pi-hashline-edit-pro 4.2.9 → 4.2.11

package/README.md

@@ -94,13 +94,13 @@ Content containing a NUL byte (`U+0000`) is rejected with `[E_BAD_SHAPE]` before
 
 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. A pending bypass overrides `strict` mode for its one resend; an aborted batch preserves a consumed bypass for retry.
+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, the result states how many lines were removed; sending the same replacement again goes through the same dedup. To apply such lines literally, turn Boundary dedup off in `/hashline-config`.
 
 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 assistant message are grouped per file into one batch. The batch unit is the message, not the turn: calls from separate messages in the same turn run solo, one after another. A solo edit commits before its result returns; a batch validates every call against the pre-batch state and commits once, during 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. Nothing commits at turn end.
+Multiple `replace` and `insert` calls on the same file in one assistant message are grouped per file into one batch. The batch unit is the message, not the turn: calls from separate messages in the same turn run solo, one after another. A solo edit commits before its result returns; a batch validates every call against the pre-batch state and commits once, during the batch's last call: earlier calls reply `In batch N` and the batch's last call shows the combined diff, with one undo reverting the whole batch. If the batch aborts, an earlier member's row renders the abort message instead of the placeholder. Nothing commits at turn end. A batch member accepts the same request shapes and auto-fixes as a solo call. A member whose boundary dedup cuts it to a noop contributes no hunk to the combined diff: the batch warning names it instead of pointing at `dedup│` rows. The `dedup│` rows in a batch diff cover its applied members only.
 Tools in one message run concurrently, so a `read` or shell `cat` issued alongside an edit can observe the pre-commit state; verify in the next message with the post-edit diff or a fresh `read`.
-Batched calls must target disjoint ranges; overlapping ranges, or any failing call, aborts the whole batch unwritten. A resolvable failure aborts its batch-mates, while an anchor that resolves nowhere cannot join a batch: same-message [resolvable-fail + resolvable-valid] on one file fails fast with `[E_OP_ABORTED]`, but the same pair split across messages runs as two solos (fail, then apply). 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-message 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.
+Batched calls must target disjoint ranges; overlapping ranges, or any failing call, aborts the whole batch unwritten. One `insert` with `direction: "before"` and one with `direction: "after"` may target the same anchor line: the pair composes into a single insertion. A batch member that fails aborts its batch-mates with `[E_OP_ABORTED]`. A call whose anchors resolve nowhere never joins a batch: it runs solo and fails with its own error (`[E_STALE_ANCHOR]`, or `[E_BAD_SHAPE]` when its request cannot be parsed), while the same-file batch in the message still commits. Calls with one stale anchor and a valid co-anchor, or with a `requirePath` path hint, join their file's batch and abort it instead of applying partially. An error that aborts a batch ends with `Aborts batch N.`; an aborted call reads `[E_OP_ABORTED] Batch N aborted: [<kind>] Call Nr <X> errored [<code>]`, naming the failing call and its error code (or `[E_OP_ABORTED] Batch N aborted.` when the failing error carries no code). 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
 
@@ -114,7 +114,7 @@ Batched calls must target disjoint ranges; overlapping ranges, or any failing ca
 
 Lines are applied literally: nothing is removed, and a line that duplicates its neighbor is kept. `replace`'s boundary anti-duplication never runs for `insert`. Inserting nothing (`lines: []`) reports a noop. To seed an empty file, read it and insert after the `anchor│` empty-line row.
 
-The same safety machinery as `replace` applies: undo is saved before the write (a failed write restores the previous undo record), line endings and BOMs survive, and an applied insert clears a pending boundary bypass.
+The same safety machinery as `replace` applies: undo is saved before the write (a failed write restores the previous undo record), and line endings and BOMs survive.
 
 ### anchor_grep
 
@@ -154,7 +154,7 @@ Output is capped at `limit` matched lines, 2000 rows, and 50KB of text, whicheve
 
 Auto-read is enabled by default. After a successful `write`, the extension reads the file and appends an `--- Auto-read (hashline anchors) ---` block, so you get fresh `anchor│content` anchors without a separate `read` call.
 
-After `replace`, `insert`, and `undo_last_change`, the result shows the post-edit diff. Inside a same-message batch, only the batch's last call shows the combined diff, headed by a `batch:` line (`batch N:` when several files batch); earlier calls reply `In batch` (`In batch N` when several files batch). The `+anchor│` and ` anchor│` rows carry the current anchors, so follow-up edits can anchor on the diff directly. The `-anchor│` rows show removed lines with their old anchors, which are stale after the edit. When the context line next to a change is blank or whitespace-only, one more context line is shown in that direction, so the change stays anchored to visible content. Call `read` when you want the full file's anchors.
+After `replace`, `insert`, and `undo_last_change`, the result shows the post-edit diff. Inside a same-message batch, only the batch's last call shows the combined diff, headed by a `batch N:` line; earlier calls reply `In batch N`. The `+anchor│` and ` anchor│` rows carry the current anchors, so follow-up edits can anchor on the diff directly. The `-anchor│` rows show removed lines with their old anchors, which are stale after the edit. When the context line next to a change is blank or whitespace-only, one more context line is shown in that direction, so the change stays anchored to visible content. Call `read` when you want the full file's anchors.
 
 Auto-read keeps the same 50KB and 2000-line budget as `read`. Change it in `/hashline-config`; both settings persist across sessions. The post-edit diff shows 1 surrounding line by default; change Diff context in `/hashline-config` (0-10, needs Auto-read) to show more or fewer.
 
@@ -199,7 +199,7 @@ The table is curated for tokenizers, not for humans. Every anchor is the concate
 
 Each line also carries a content checksum. The line is canonicalized (carriage returns stripped, trailing whitespace trimmed) and hashed with [xxhash-wasm](https://github.com/jungomi/xxhash-wasm). The canonicalization keeps the checksum stable across editor-save cycles that add or remove trailing whitespace. A line over 500 bytes is hashed from its first 500 bytes.
 
-Allocated anchors live in a persistent per-file snapshot (`~/.config/pi-hashline-edit-pro/hash-store.sqlite`) keyed by content checksum, so resume-after-restart and cross-session edits reuse ownership instead of minting duplicates. Each session also appends an ownership log (`allocate`/`free`/`clear` events) to a sidecar file under `~/.config/pi-hashline-edit-pro/sessions/`; the fold of that log is the session's source of truth, sidecars whose session file is gone are garbage-collected at startup, and the in-memory ownership of a session is released when that session shuts down and rebuilt from its sidecar on next use.
+Allocated anchors live in a persistent per-file snapshot (`~/.config/pi-hashline-edit-pro/hash-store.sqlite`) keyed by content checksum, so resume-after-restart and cross-session edits reuse ownership instead of minting duplicates. Each session also appends an ownership log (`allocate`/`free`/`clear` events) to a sidecar file under `~/.config/pi-hashline-edit-pro/sessions/`; the fold of that log is the session's source of truth, sidecars whose session file is gone are garbage-collected at startup (never the sidecar of a session that is currently loaded in this process), and the in-memory ownership of a session is released when that session shuts down and rebuilt from its sidecar on next use.
 
 When a range is edited, the mapping between old and new content is computed per span: lines whose content is unchanged keep their allocated anchors, anchors of removed lines are freed, and every genuinely new line is minted a fresh anchor. Anchors are never assigned by matching content; only positional survival across an edit preserves one.
 
@@ -233,15 +233,14 @@ Codes starting with `E_` are errors: nothing was written — except `File was wr
 | `[E_UNDO_STALE]` | `undo_last_change` refused: the file was modified after the last edit. The undo record is kept until the file matches the edited state again or a new edit replaces it. |
 | `[E_UNDO_UNAVAILABLE]` | Undo history could not be persisted to the hash store; the edit was refused and the file was left unchanged. |
 | `[E_RANGE_STALE]` | A line in the replaced range no longer matches what was last shown (the file changed on disk, or the line was never shown). The edit was refused; the current range is returned with fresh anchors. |
-| `[W_BOUNDARY_BYPASS]` | The boundary anti-duplication was turned off for one replace call (an identical replacement had previously been cut to a noop); the duplicate lines were applied literally. The dedup is restored for the next call. |
 | `[E_BOUNDARY_STRICT]` | Strict boundary dedup rejected the edit because replacement lines re-include edge lines; resend without those lines. |
 | `[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 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. 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. |
+| `[E_BATCH_OVERLAP]` | Batched `replace`/`insert` calls target overlapping ranges; the whole batch was refused. One `before` plus one `after` insert on the same anchor line is not an overlap. Retry with disjoint ranges. |
+| `[E_OP_ABORTED]` | An edit aborted (a same-message batch member failed, or the file changed or was deleted after the edit started). Nothing was written. Fix the sibling failure and retry the batch, otherwise call `read` for fresh anchors and retry. The abort names the failing call and its error code when one is known. |
 | `[E_UNSAFE_REGEX]` | A grep regex can trigger excessive backtracking; simplify it or search with `literal: true`. |
 
 ## Troubleshooting

package/index.ts

@@ -22,7 +22,6 @@ import {
 import { loadHashStore, persistSnapshot, pruneMissing } from "./src/hash-store";
 import { initRegistry, gcRegistrySidecars, clearRegistry, freeAnchors, markServed as markServedScoped, sessionKeyFor, withAnchorSession, releaseRegistrySession } from "./src/anchor-registry";
 import { buildServedMap } from "./src/served";
-import { clearBoundaryBypass } from "./src/boundary-bypass";
 import { finalizeTurn, planAssistantMessage } from "./src/batch";
 import { currentEditFlags } from "./src/edit-common";
 import { HashlineConfigOverlay } from "./src/config-ui";
@@ -167,7 +166,6 @@ export default function (pi: ExtensionAPI): void {
           resolvedPath = (await resolveInCwd(writtenPath, ctx.cwd)).resolved;
           freeAnchors(resolvedPath);
           await clearUndo(resolvedPath);
-          clearBoundaryBypass(resolvedPath);
         } catch (error) {
           console.error("Failed to clear undo after write:", error);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hashline-edit-pro",
-  "version": "4.2.9",
+  "version": "4.2.11",
   "type": "module",
   "description": "Hash-anchored read/replace/insert/grep tools for pi-coding-agent. Every line gets a unique 4-char tokenizer-friendly anchor that stays stable across edits; stale or ambiguous anchors are rejected, never fuzzy-matched. Undo persists across restarts.",
   "main": "index.ts",

package/prompts/insert-guidelines.md

@@ -1,2 +1,3 @@
 - `insert`: the anchor must have been shown by `read`, a post-edit diff (`+anchor│`/` anchor│`), or any served `anchor│content` row. Empty file: `read` shows one `anchor│` row — insert `after` it.
-- `insert`: same-file calls in one message join the file's batch: earlier calls reply `In batch` (`In batch N` when several files batch), the last call shows the combined diff.
+- `insert`: same-file calls in one message join the file's batch: earlier calls reply `In batch N`, the last call shows the combined diff.
+- `insert`: a batch may pair one `before` and one `after` on the same anchor line; the pair composes into a single insertion. Any other same-line pair is an overlap.

package/prompts/replace.md

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

package/src/anchor-registry.ts

@@ -1,5 +1,5 @@
 import { chmod, mkdir, open, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
-import { appendFileSync, chmodSync } from "node:fs";
+import { appendFileSync, chmodSync, statSync } from "node:fs";
 import { join } from "node:path";
 import { createHash } from "node:crypto";
 import { AsyncLocalStorage } from "node:async_hooks";
@@ -163,6 +163,7 @@ export const SIDECAR_HEADER_BYTES = 64 * 1024;
 const SIDECAR_HEADER_CHUNK = 4096;
 let currentKey: string | undefined;
 const sidecarByKey = new Map<string, string>();
+const sessionFileByKey = new Map<string, string>();
 const pendingInits = new Map<string, Promise<void>>();
 const loadTokens = new Map<string, object>();
 const registries = new Map<string, SessionState>();
@@ -368,6 +369,7 @@ async function ensureRegistryForKey(key: string, sessionFile: string | undefined
       registries.set(key, newSessionState(key));
       return;
     }
+    sessionFileByKey.set(key, sessionFile);
     await loadRegistryState(key, sessionFile, token);
   })();
   pendingInits.set(key, promise);
@@ -423,12 +425,27 @@ function current(): SessionState | undefined {
   return registries.get(key);
 }
 
+function sidecarNeedsSessionRecord(sidecar: string): boolean {
+  try {
+    return statSync(sidecar).size === 0;
+  } catch {
+    return true;
+  }
+}
+
+function ensureSidecarSessionRecord(key: string, sidecar: string): void {
+  const sessionFile = sessionFileByKey.get(key);
+  if (sessionFile === undefined || !sidecarNeedsSessionRecord(sidecar)) return;
+  appendEvent({ kind: "session", sessionFile } satisfies RegistryEvent);
+}
+
 function appendEvent(event: RegistryEvent): void {
   const key = activeKey();
   if (!key) return;
   const sidecar = sidecarByKey.get(key);
   if (!sidecar) return;
   try {
+    if (event.kind !== "session") ensureSidecarSessionRecord(key, sidecar);
     appendFileSync(sidecar, JSON.stringify(event) + "\n", "utf-8");
     if (process.platform !== "win32") {
       try { chmodSync(sidecar, 0o600); } catch (error) { if (errCode(error) !== "ENOENT") console.error("Failed to secure anchor registry sidecar:", error); }
@@ -880,6 +897,7 @@ export function adoptAnchors(path: string, entries: Map<string, string>): void {
 export function resetRegistryForTests(): void {
   currentKey = undefined;
   sidecarByKey.clear();
+  sessionFileByKey.clear();
   pendingInits.clear();
   loadTokens.clear();
   registries.clear();
@@ -924,9 +942,17 @@ export function releaseRegistrySession(key: string): void {
   if (currentKey === key) currentKey = undefined;
   pendingInits.delete(key);
   sidecarByKey.delete(key);
+  sessionFileByKey.delete(key);
   registries.delete(key);
 }
 
+function isClaimedSidecar(sidecar: string): boolean {
+  for (const claimed of sidecarByKey.values()) {
+    if (claimed === sidecar) return true;
+  }
+  return false;
+}
+
 export async function gcRegistrySidecars(): Promise<void> {
   let names: string[];
   try {
@@ -948,6 +974,7 @@ export async function gcRegistrySidecars(): Promise<void> {
     }
     if (!name.endsWith(SIDECAR_SUFFIX)) continue;
     const sidecar = join(sessionClaimsDir(), name);
+    if (isClaimedSidecar(sidecar)) continue;
     try {
       const sessionFile = await readSidecarSessionFile(sidecar);
       if (sessionFile === undefined) continue;

package/src/batch.ts

@@ -2,7 +2,7 @@ import { readFile } from "node:fs/promises";
 import { constants } from "node:fs";
 import { relative } from "node:path";
 import { readConfig, getDiffContextLines } from "./config";
-import { resolveEditTarget, throwIfStrictInput, tryResolveEditTarget } from "./edit-common";
+import { throwIfStrictInput, tryResolveEditTarget } from "./edit-common";
 import { readNormFile, safeSnapId } from "./file-reader";
 import { resolveInCwd, writeAtomic, type FileIdentity } from "./fs-write";
 import {
@@ -16,8 +16,7 @@ import {
   type HEdit,
   type PlannedEdit,
 } from "./hashline";
-import { clearBoundaryBypass, markBoundaryNoop } from "./boundary-bypass";
-import { boundaryDedupWarning } from "./commit";
+import { boundaryDedupNoopWarning, boundaryDedupWarning, dedupRowsFromFixes } from "./commit";
 import { adoptAnchors, markServed, servedForPath } from "./anchor-registry";
 import { restoreEndings, stripBOM, toLF, type LineEnding } from "./normalize";
 import { assertInsertReq, assertReq, normReq } from "./payload-contract";
@@ -56,6 +55,7 @@ interface BatchBase {
 export interface BatchPiece {
   order: number;
   kind: BatchKind;
+  direction?: "before" | "after";
   start: number;
   end: number;
   fromHash: string;
@@ -63,14 +63,15 @@ export interface BatchPiece {
   newLines: string[];
   warnings: string[];
   autoFixes: number;
+  dedupAbove: string[];
+  dedupBelow: string[];
   noop: boolean;
-  noopPayload?: string;
   foldedLines: number;
-  bypassConsumed?: boolean;
 }
 
 export interface BatchMemberInput {
   kind: BatchKind;
+  direction?: "before" | "after";
   member: PlannedMember;
   targetPath: string;
   mutationTargetPath: string;
@@ -80,9 +81,13 @@ export interface BatchMemberInput {
   extraWarnings: string[];
   skipBoundaryDedup: boolean;
   strictBoundaryDedup: boolean;
-  noopPayload?: string;
   foldedLines?: number;
-  bypassConsumed?: boolean;
+}
+
+interface BatchFailure {
+  kind: BatchKind;
+  order: number;
+  code?: string;
 }
 
 interface BatchState {
@@ -100,7 +105,7 @@ interface BatchState {
   failures: number;
   failed: boolean;
   firstError?: unknown;
-  poisonedBy?: string;
+  failure?: BatchFailure;
   warnings: string[];
 }
 
@@ -119,6 +124,30 @@ const MAX_TRACKED_BATCHES = 256;
 const plan = new Map<string, PlannedMember>();
 const batches = new Map<number, BatchState>();
 let nextBatchKey = 1;
+const abortedMembers = new Map<string, { display: number; message: string }>();
+const ABORTED_MEMBERS_LIMIT = 1024;
+
+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 });
+  }
+  while (abortedMembers.size > ABORTED_MEMBERS_LIMIT) {
+    const oldest = abortedMembers.keys().next().value;
+    if (oldest === undefined) break;
+    abortedMembers.delete(oldest);
+  }
+}
+
+export function abortedBatchMessageFor(toolCallId: string): string | undefined {
+  const marked = abortedMembers.get(toolCallId);
+  if (marked !== undefined) return marked.message;
+  const member = plan.get(toolCallId);
+  if (!member) return undefined;
+  const runtime = batches.get(member.batchKey);
+  return runtime?.failed ? abortedBatchMessage(runtime) : undefined;
+}
 
 export function batchMemberFor(toolCallId: string): PlannedMember | undefined {
   return plan.get(toolCallId);
@@ -127,6 +156,7 @@ export function batchMemberFor(toolCallId: string): PlannedMember | undefined {
 export function resetBatchStateForTests(): void {
   plan.clear();
   batches.clear();
+  abortedMembers.clear();
   nextBatchKey = 1;
 }
 
@@ -154,18 +184,6 @@ function anchorTargetFor(args: unknown): string | 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;
@@ -245,22 +263,10 @@ export async function planAssistantMessage(message: unknown, cwd: string): Promi
   } else {
     finalGroups.push(...multi);
   }
-  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,
@@ -270,9 +276,8 @@ export async function planAssistantMessage(message: unknown, cwd: string): Promi
       pieces: [],
       applied: 0,
       noops: 0,
-      failures: poisoned ? 1 : 0,
-      failed: poisoned,
-      ...(matchingPoison ? { firstError: matchingPoison.error, poisonedBy: matchingPoison.callId } : {}),
+      failures: 0,
+      failed: false,
       warnings: [],
     });
     group.forEach((item, index) => {
@@ -309,7 +314,7 @@ function batchVerb(runtime: BatchState): string {
   return "replaced";
 }
 function batchHeader(member: PlannedMember): string {
-  return member.total > 1 ? `batch ${member.display}:` : "batch:";
+  return `batch ${member.display}:`;
 }
 
 function formatBatchLines(start: number, end: number): string {
@@ -337,7 +342,7 @@ function batchPlaceholder(member: PlannedMember, piece: BatchPiece, snapshotId:
     content: [
       {
         type: "text",
-        text: member.total > 1 ? `In batch ${member.display}` : "In batch",
+        text: `In batch ${member.display}`,
       },
     ],
     details: {
@@ -357,12 +362,15 @@ export function withAbortSuffix(message: string, display: number): string {
   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);
-  }
+
+const ERROR_CODE_RE = /\[(E_[A-Z0-9_]+)\]/;
+
+function errorCodeOf(error: unknown): string | undefined {
+  if (!(error instanceof Error)) return undefined;
+  const code = ERROR_CODE_RE.exec(error.message)?.[1];
+  return code === "E_OP_ABORTED" ? undefined : code;
 }
+
 export function noteBatchFailure(member: PlannedMember, error: unknown): void {
   const runtime = batches.get(member.batchKey);
   if (!runtime) return;
@@ -371,18 +379,39 @@ export function noteBatchFailure(member: PlannedMember, error: unknown): void {
   if (!runtime.failed) {
     runtime.failed = true;
     runtime.firstError = error;
+    const code = errorCodeOf(error);
+    runtime.failure = { kind: member.kind, order: member.order, ...(code !== undefined ? { code } : {}) };
   }
+  markBatchMembersAborted(runtime);
 }
 
-function batchAbortedError(runtime: BatchState, input?: BatchMemberInput): Error {
-  restoreBatchBypasses(runtime, input);
-  return new Error(`[E_OP_ABORTED] Batch ${runtime.display} aborted.`);
+function firstFailureCause(runtime: BatchState): string | undefined {
+  const error = runtime.firstError;
+  if (!(error instanceof Error)) return undefined;
+  const suffix = ` Aborts batch ${runtime.display}.`;
+  const message = error.message.endsWith(suffix) ? error.message.slice(0, -suffix.length) : error.message;
+  const firstLine = message.split("\n")[0]?.trim() ?? "";
+  if (firstLine.length === 0) return undefined;
+  if (!firstLine.endsWith(":")) return firstLine;
+  const sentenceEnd = firstLine.lastIndexOf(". ");
+  return sentenceEnd >= 0 ? firstLine.slice(0, sentenceEnd + 1) : firstLine.slice(0, -1);
 }
-function restoreBatchBypasses(runtime: BatchState, input?: BatchMemberInput): void {
-  for (const piece of runtime.pieces) {
-    if (piece.bypassConsumed && piece.noopPayload) markBoundaryNoop(runtime.target, piece.noopPayload);
+
+function abortedBatchMessage(runtime: BatchState): string {
+  const failure = runtime.failure;
+  if (failure?.code !== undefined) {
+    return `[E_OP_ABORTED] Batch ${runtime.display} aborted: [${failure.kind}] Call Nr ${failure.order} errored [${failure.code}]`;
   }
-  if (input?.bypassConsumed && input.noopPayload) markBoundaryNoop(input.mutationTargetPath, input.noopPayload);
+  const cause = firstFailureCause(runtime);
+  return cause ? `[E_OP_ABORTED] Batch ${runtime.display} aborted: ${cause}` : `[E_OP_ABORTED] Batch ${runtime.display} aborted.`;
+}
+
+function batchAbortedError(runtime: BatchState): Error {
+  discardBatchState(runtime);
+  return new Error(abortedBatchMessage(runtime));
+}
+function discardBatchState(runtime: BatchState): void {
+  markBatchMembersAborted(runtime);
 }
 
 export async function ensureBatchBase(input: {
@@ -426,7 +455,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, input);
+  if (runtime.failed) throw batchAbortedError(runtime);
   let base: BatchBase;
   try {
     base = await ensureBatchBase({
@@ -438,13 +467,13 @@ export async function executeBatchMember(input: BatchMemberInput): Promise<TResu
     });
   } catch (error) {
     noteBatchFailure(input.member, error);
-    restoreBatchBypasses(runtime, input);
+    discardBatchState(runtime);
     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);
+    discardBatchState(runtime);
     throw error;
   }
   const displayPath = runtime.paths?.displayPath ?? input.targetPath;
@@ -464,11 +493,11 @@ 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);
+      discardBatchState(runtime);
       throw indexed;
     }
     noteBatchFailure(input.member, error);
-    restoreBatchBypasses(runtime, input);
+    discardBatchState(runtime);
     throw error;
   }
   const start = planned.resolved.hash_bounds[0].line;
@@ -477,21 +506,23 @@ export async function executeBatchMember(input: BatchMemberInput): Promise<TResu
   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;
+  const fixes = planned.autoFixes ?? [];
+  const dedupRows = dedupRowsFromFixes(fixes);
   const piece: BatchPiece = {
     order: input.member.order,
     kind: input.kind,
+    ...(input.direction !== undefined ? { direction: input.direction } : {}),
     start,
     end,
     fromHash: input.hedit.hash_bounds[0].hash,
     toHash: input.hedit.hash_bounds[1].hash,
     newLines: [...newLines],
     warnings: [...input.extraWarnings, ...planned.warnings],
-    autoFixes,
+    autoFixes: fixes.length,
+    dedupAbove: dedupRows.above,
+    dedupBelow: dedupRows.below,
     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;
@@ -512,46 +543,100 @@ function composeBatchLines(baseContent: string, pieces: BatchPiece[]): string {
   return composed;
 }
 
+function mergeInsertPairs(pieces: BatchPiece[]): BatchPiece[] {
+  const byAnchor = new Map<number, BatchPiece[]>();
+  for (const piece of pieces) {
+    if (piece.kind !== "insert" || piece.start !== piece.end || piece.foldedLines === 0) continue;
+    const group = byAnchor.get(piece.start) ?? [];
+    group.push(piece);
+    byAnchor.set(piece.start, group);
+  }
+  const partnerOf = new Map<BatchPiece, BatchPiece>();
+  for (const group of byAnchor.values()) {
+    if (group.length !== 2) continue;
+    const [first, second] = group;
+    if (first.direction === undefined || second.direction === undefined || first.direction === second.direction) continue;
+    partnerOf.set(first, second);
+    partnerOf.set(second, first);
+  }
+  const merged: BatchPiece[] = [];
+  const consumed = new Set<BatchPiece>();
+  for (const piece of pieces) {
+    if (consumed.has(piece)) continue;
+    const partner = partnerOf.get(piece);
+    if (partner === undefined) {
+      merged.push(piece);
+      continue;
+    }
+    consumed.add(piece);
+    consumed.add(partner);
+    const before = piece.direction === "before" ? piece : partner;
+    const after = piece.direction === "before" ? partner : piece;
+    merged.push({
+      ...before,
+      order: Math.min(before.order, after.order),
+      newLines: [...before.newLines, ...after.newLines.slice(1)],
+      warnings: [...before.warnings, ...after.warnings],
+      autoFixes: before.autoFixes + after.autoFixes,
+      dedupAbove: [...before.dedupAbove, ...after.dedupAbove],
+      dedupBelow: [...before.dedupBelow, ...after.dedupBelow],
+      foldedLines: before.foldedLines + after.foldedLines - 1,
+    });
+  }
+  return merged;
+}
+
+function dedupCutNoops(pieces: BatchPiece[]): BatchPiece[] {
+  return pieces.filter((piece) => piece.noop && piece.autoFixes > 0).sort((a, b) => a.order - b.order);
+}
+
+function dedupCutNoopWarning(noops: BatchPiece[]): string {
+  return boundaryDedupNoopWarning(noops.map((piece) => piece.order), noops.reduce((sum, piece) => sum + piece.autoFixes, 0));
+}
+
 async function finishBatch(member: PlannedMember, signal?: AbortSignal): Promise<TResult> {
   const runtime = batches.get(member.batchKey);
   if (!runtime || !runtime.base || !runtime.paths) throw new Error(`[E_STALE_ANCHOR] Batch ${member.display} is no longer tracked. Call read for fresh anchors.`);
   const base = runtime.base;
   const paths = runtime.paths;
   if (runtime.failed) throw batchAbortedError(runtime);
+  const executedOrders = new Set(runtime.pieces.map((piece) => piece.order));
   for (const id of runtime.memberIds) {
     const planned = plan.get(id);
     if (!planned) continue;
+    if (executedOrders.has(planned.order)) continue;
     try {
       const normalized = normReq(planned.args);
       if (planned.kind === "replace") assertReq(normalized);
       else assertInsertReq(normalized);
     } catch (error) {
-      noteBatchFailure(member, error);
+      noteBatchFailure(planned, error);
       throw batchAbortedError(runtime);
     }
   }
   const appliedPieces = runtime.pieces.filter((piece) => !piece.noop);
   if (appliedPieces.length === 0) {
-    for (const piece of runtime.pieces) {
-      if (piece.autoFixes > 0 && piece.noopPayload !== undefined) markBoundaryNoop(runtime.target, piece.noopPayload);
-    }
+    const dedupNoops = dedupCutNoops(runtime.pieces);
     const snapshotId = await safeSnapId(paths.absolutePath, "noop edit");
-    return combinedNoop(paths.displayPath, member, runtime, snapshotId);
+    return combinedNoop(paths.displayPath, member, runtime, snapshotId, dedupNoops);
   }
-  const ordered = [...appliedPieces].sort((a, b) => a.start - b.start);
+  const effectivePieces = mergeInsertPairs(appliedPieces);
+  const ordered = [...effectivePieces].sort((a, b) => a.start - b.start);
   for (let i = 1; i < ordered.length; i++) {
     const prev = ordered[i - 1]!;
     const current = ordered[i]!;
     if (current.start <= prev.end) {
-      restoreBatchBypasses(runtime);
+      discardBatchState(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 composed = composeBatchLines(base.content, effectivePieces);
   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);
+  const dedupTotal = effectivePieces.reduce((sum, piece) => sum + piece.autoFixes, 0);
   if (dedupTotal > 0) warnings.push(boundaryDedupWarning(dedupTotal));
+  const dedupNoops = dedupCutNoops(runtime.pieces);
+  if (dedupNoops.length > 0) warnings.push(dedupCutNoopWarning(dedupNoops));
   try {
     await throwIfStrictInput(dedupeWarnings(warnings));
     assertNotEmpty(base.content, composed);
@@ -561,13 +646,13 @@ async function finishBatch(member: PlannedMember, signal?: AbortSignal): Promise
       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);
+    discardBatchState(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");
-    return combinedNoop(paths.displayPath, member, runtime, snapshotId);
+    return combinedNoop(paths.displayPath, member, runtime, snapshotId, dedupNoops);
   }
   abortIf(signal);
   let currentRaw: string;
@@ -575,14 +660,14 @@ async function finishBatch(member: PlannedMember, signal?: AbortSignal): Promise
     currentRaw = await readFile(runtime.target, "utf-8");
   } catch (error) {
     if (errCode(error) !== "ENOENT") throw error;
-    restoreBatchBypasses(runtime);
+    discardBatchState(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) {
-    restoreBatchBypasses(runtime);
+    discardBatchState(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 }));
+  const preflightSpans = effectivePieces.map((piece) => ({ start: piece.start - 1, end: piece.end - 1, replacementCount: piece.newLines.length }));
   try {
     await lineHashes(composed, runtime.target, {
       content: base.content,
@@ -590,7 +675,7 @@ async function finishBatch(member: PlannedMember, signal?: AbortSignal): Promise
       spans: preflightSpans,
     }, undefined, false, true);
   } catch (error) {
-    restoreBatchBypasses(runtime);
+    discardBatchState(runtime);
     if (error instanceof Error) error.message = withAbortSuffix(error.message, runtime.display);
     throw error;
   }
@@ -602,7 +687,7 @@ async function finishBatch(member: PlannedMember, signal?: AbortSignal): Promise
     resultContent: composed,
   });
   if (!undo.persisted) {
-    restoreBatchBypasses(runtime);
+    discardBatchState(runtime);
     throw new Error(`[E_UNDO_UNAVAILABLE] Could not persist undo history for ${paths.displayPath}. Aborts batch ${runtime.display}.`);
   }
   try {
@@ -610,13 +695,12 @@ async function finishBatch(member: PlannedMember, signal?: AbortSignal): Promise
     await writeAtomic(paths.absolutePath, base.bom + restoreEndings(composed, base.ending), base.identity);
   } catch (error) {
     await undo.restore();
-    restoreBatchBypasses(runtime);
+    discardBatchState(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 spans = effectivePieces.map((piece) => ({ start: piece.start - 1, end: piece.end - 1, replacementCount: piece.newLines.length, dedupAbove: piece.dedupAbove, dedupBelow: piece.dedupBelow }));
   let resultHashes: string[];
   try {
     resultHashes = await lineHashes(composed, runtime.target, {
@@ -636,6 +720,8 @@ async function finishBatch(member: PlannedMember, signal?: AbortSignal): Promise
     const gross = Math.max(0, piece.newLines.length - piece.autoFixes);
     added += piece.kind === "insert" ? Math.max(0, gross - piece.foldedLines) : gross;
   }
+  const dedupAboveRows = ordered.flatMap((piece) => piece.dedupAbove);
+  const dedupBelowRows = ordered.flatMap((piece) => piece.dedupBelow);
   const header = batchHeader(member);
   const changed = buildChanged(
     {
@@ -654,8 +740,8 @@ async function finishBatch(member: PlannedMember, signal?: AbortSignal): Promise
         addedLines: added,
         removedLines: removed,
       },
-      boundaryDedupAbove: [],
-      boundaryDedupBelow: [],
+      boundaryDedupAbove: dedupAboveRows,
+      boundaryDedupBelow: dedupBelowRows,
       spans,
     },
     batchVerb(runtime),
@@ -674,8 +760,10 @@ async function finishBatch(member: PlannedMember, signal?: AbortSignal): Promise
   return changed;
 }
 
-async function combinedNoop(path: string, member: PlannedMember, runtime: BatchState, snapshotId: string | undefined): Promise<TResult> {
+async function combinedNoop(path: string, member: PlannedMember, runtime: BatchState, snapshotId: string | undefined, dedupNoops: BatchPiece[]): Promise<TResult> {
   const executed = runtime.applied + runtime.noops;
+  const warnings = [...runtime.warnings];
+  if (dedupNoops.length > 0) warnings.push(dedupCutNoopWarning(dedupNoops));
   const noop = buildNoop(
     {
       path,
@@ -687,7 +775,7 @@ async function combinedNoop(path: string, member: PlannedMember, runtime: BatchS
         addedLines: 0,
         removedLines: 0,
       },
-      warnings: dedupeWarnings(runtime.warnings),
+      warnings: dedupeWarnings(warnings),
       boundaryRemovedLines: 0,
     },
     "Batch",

package/src/commit.ts

@@ -9,7 +9,7 @@ import { getDiffContextLines } from "./config";
 import { safeSnapId } from "./file-reader";
 import { writeAtomic } from "./fs-write";
 import { servedHashesFromDiff, buildServedMap } from "./served";
-import { lineHashes } from "./hashline";
+import { lineHashes, type AutoFix } from "./hashline";
 import { hashSpan } from "./replace";
 import { restoreEndings, stripBOM, toLF } from "./normalize";
 import { markServed as markServedScoped } from "./anchor-registry";
@@ -22,10 +22,7 @@ export interface CommitMeta {
   verb?: string;
   noopNoun?: string;
   prefixWarnings?: string[];
-  appliedWarnings?: string[];
   foldedAnchorLines?: number;
-  onApplied?: () => void;
-  onNoopDedup?: () => void;
 }
 
 export function boundaryDedupWarning(count: number): string {
@@ -34,6 +31,21 @@ export function boundaryDedupWarning(count: number): string {
   return `Boundary dedup: ${noun} not added again (see ${DEDUP_ANCHOR}${HASH_SEP} ${row}).`;
 }
 
+export function boundaryDedupNoopWarning(orders: number[], removedLines: number): string {
+  const noun = removedLines === 1 ? "1 line" : `${removedLines} lines`;
+  if (orders.length === 1) {
+    return `Boundary dedup: edit #${orders[0]!} produced no change (${noun} not added again).`;
+  }
+  return `Boundary dedup: edits ${orders.map((order) => `#${order}`).join(", ")} produced no change (${noun} not added again).`;
+}
+
+export function dedupRowsFromFixes(fixes: AutoFix[]): { removedTexts: string[]; above: string[]; below: string[] } {
+  const sorted = [...fixes].sort((a, b) => a.removedLineIndex - b.removedLineIndex);
+  const above = sorted.filter((fix) => fix.kind === "leading" || fix.kind === "last-new-before").map((fix) => fix.removedLine);
+  const below = sorted.filter((fix) => fix.kind === "trailing" || fix.kind === "first-new-after").map((fix) => fix.removedLine);
+  return { removedTexts: sorted.map((fix) => fix.removedLine), above, below };
+}
+
 export async function commitEdit(pipe: PipelineResult, meta: CommitMeta): Promise<TResult> {
   const { path, absolutePath, mutationTargetPath, signal } = meta;
   const warnings = [...(meta.prefixWarnings ?? []), ...pipe.warnings];
@@ -41,7 +53,6 @@ export async function commitEdit(pipe: PipelineResult, meta: CommitMeta): Promis
 
   if (pipe.result === pipe.originalNormalized) {
     const noopSnapshotId = await safeSnapId(absolutePath, "noop edit");
-    if (pipe.hadBoundaryDedup) meta.onNoopDedup?.();
     return buildNoop(
       {
         path,
@@ -60,7 +71,6 @@ export async function commitEdit(pipe: PipelineResult, meta: CommitMeta): Promis
     );
   }
 
-  warnings.push(...(meta.appliedWarnings ?? []));
   if (pipe.hadUtf8DecodeErrors) {
     warnings.push(
       "Non-UTF-8 bytes were shown as U+FFFD; this edit rewrote the file as UTF-8.",
@@ -110,7 +120,6 @@ export async function commitEdit(pipe: PipelineResult, meta: CommitMeta): Promis
     await undo.restore();
     throw error;
   }
-  meta.onApplied?.();
   const updatedSnapshotId = await safeSnapId(absolutePath, "post-edit");
 
   const editMeta: RMeta = {

package/src/insert.ts

@@ -3,7 +3,7 @@ import { Type } from "typebox";
 import { constants } from "node:fs";
 import { execPipeline, type ReqParams, type ReplaceDetails, previewFromPipe, previewError } from "./replace";
 import { commitEdit } from "./commit";
-import { batchMemberFor, ensureBatchBase, executeBatchMember, noteBatchFailure, suffixPoisonCause } from "./batch";
+import { batchMemberFor, ensureBatchBase, executeBatchMember, noteBatchFailure } from "./batch";
 import { readNormFile, type NormFile } from "./file-reader";
 import { MAX_HASH_LINES, parseHashRef, resEdit, resolveAnchorLine, type Anchor, type HEdit } from "./hashline";
 import { stripAnchorRow } from "./hashline/resolve";
@@ -11,7 +11,6 @@ import { withAnchorSession } from "./anchor-registry";
 import { loadP, loadGuide } from "./prompts";
 import { assertInsertReq, normReq, type InsertReq } from "./payload-contract";
 import { decodeStringArray, isRec, splitLines } from "./utils";
-import { clearBoundaryBypass } from "./boundary-bypass";
 import { queuedEdit, editToolBase, editRenderCallWrapper, editRenderResultWrapper, resolveEditTargetWithRequirement, throwIfStrictInput, withInsertPrompts, DEFAULT_EDIT_FLAGS, type EditToolFlags } from "./edit-common";
 import type { RPreview, RRState } from "./replace-render";
 export { assertInsertReq, type InsertReq };
@@ -189,7 +188,6 @@ export function buildInsertToolDef(flags: EditToolFlags = DEFAULT_EDIT_FLAGS): I
         }).catch((error: unknown) => {
           const member = batchMemberFor(_toolCallId);
           if (member) noteBatchFailure(member, error);
-          else suffixPoisonCause(_toolCallId, error);
           throw error;
         });
         let ref: Anchor;
@@ -218,6 +216,7 @@ export function buildInsertToolDef(flags: EditToolFlags = DEFAULT_EDIT_FLAGS): I
             }
             return executeBatchMember({
               kind: "insert",
+              direction: req.direction,
               member,
               targetPath,
               mutationTargetPath,
@@ -251,7 +250,6 @@ export function buildInsertToolDef(flags: EditToolFlags = DEFAULT_EDIT_FLAGS): I
             noopNoun: "Insertion",
             foldedAnchorLines: anchorLine === undefined ? 0 : 1,
             prefixWarnings: [...anchorWarnings, ...insertWarnings],
-            onApplied: () => clearBoundaryBypass(mutationTargetPath),
           });
         });
       });

package/src/replace-diff.ts

@@ -6,7 +6,7 @@ import {
   HASH_SEP,
   changedRange,
 } from "./hashline";
-import { MAX_DIFF_INPUT_BYTES } from "./constants";
+import { MAX_DIFF_INPUT_BYTES, DEDUP_ANCHOR } from "./constants";
 import { splitLines } from "./utils";
 import {
   detectEnding,
@@ -22,6 +22,8 @@ export interface DiffSpan {
   start: number;
   end: number;
   replacementCount: number;
+  dedupAbove?: string[];
+  dedupBelow?: string[];
 }
 
 interface PlacedSpan {
@@ -29,6 +31,16 @@ interface PlacedSpan {
   oldEnd: number;
   newStart: number;
   newEnd: number;
+  dedupAbove?: string[];
+  dedupBelow?: string[];
+}
+
+export function fmtDedupRow(line: string): string {
+  const row = `${DEDUP_ANCHOR}${HASH_SEP}${line}`;
+  if (Buffer.byteLength(row, "utf-8") <= DEFAULT_MAX_BYTES) return row;
+  const size = formatSize(Buffer.byteLength(row, "utf-8"));
+  const limit = formatSize(DEFAULT_MAX_BYTES);
+  return `${DEDUP_ANCHOR}${HASH_SEP}[Row is ${size}, exceeds ${limit}; content not shown. Use read to see the full line.]`;
 }
 
 function fmtDiffLine(
@@ -155,7 +167,7 @@ function placeSpans(
     if (span.replacementCount === 0) {
       if (newEnd !== newStart - 1) return undefined;
     } else if (newEnd >= newLen) return undefined;
-    placed.push({ oldStart: span.start, oldEnd: span.end, newStart, newEnd });
+    placed.push({ oldStart: span.start, oldEnd: span.end, newStart, newEnd, dedupAbove: span.dedupAbove, dedupBelow: span.dedupBelow });
     offset += span.replacementCount - spanLen;
     removedSum += spanLen;
     addedSum += span.replacementCount;
@@ -184,7 +196,7 @@ function trimPlacedSpans(
       newEnd -= 1;
     }
     if (oldStart > oldEnd && newStart > newEnd) continue;
-    out.push({ oldStart, oldEnd, newStart, newEnd });
+    out.push({ oldStart, oldEnd, newStart, newEnd, dedupAbove: span.dedupAbove, dedupBelow: span.dedupBelow });
   }
   return out;
 }
@@ -198,7 +210,7 @@ function genSpanDiff(
   maxLineBytes: number,
   maxBytes: number,
   spans: DiffSpan[],
-): { diff: string; firstChangedLine: number | undefined; lineNumbers: (number | undefined)[] } | undefined {
+): { diff: string; firstChangedLine: number | undefined; lineNumbers: (number | undefined)[]; dedupEmitted: boolean } | undefined {
   const oldLines = splitLines(oldContent);
   const newLines = splitLines(newContent);
   if (oldHashes.length !== oldLines.length || newHashes.length !== newLines.length) return undefined;
@@ -220,6 +232,7 @@ function genSpanDiff(
     return undefined;
   }
   const output: string[] = [];
+  let dedupEmitted = false;
   const lineNumbers: (number | undefined)[] = [];
   let firstChangedLine: number | undefined;
   let outBytes = 0;
@@ -310,12 +323,24 @@ function genSpanDiff(
     emitGap(newPos, gapLen, spanIdx === 0 ? "leading" : "middle");
     if (stopped) break;
     if (firstChangedLine === undefined) firstChangedLine = span.newStart + 1;
+    for (const dedup of span.dedupAbove ?? []) {
+      if (stopped) break;
+      dedupEmitted = true;
+      output.push(fmtDedupRow(dedup));
+      lineNumbers.push(undefined);
+    }
     for (let oldIdx = span.oldStart; oldIdx <= span.oldEnd && !stopped; oldIdx++) {
       emitRow("-", oldLines[oldIdx]!, oldHashes[oldIdx], oldIdx + 1);
     }
     for (let newIdx = span.newStart; newIdx <= span.newEnd && !stopped; newIdx++) {
       emitRow("+", newLines[newIdx]!, newHashes[newIdx], newIdx + 1);
     }
+    for (const dedup of span.dedupBelow ?? []) {
+      if (stopped) break;
+      dedupEmitted = true;
+      output.push(fmtDedupRow(dedup));
+      lineNumbers.push(undefined);
+    }
     oldPos = span.oldEnd + 1;
     newPos = span.newEnd + 1;
   }
@@ -329,7 +354,7 @@ function genSpanDiff(
     output.push(`[diff truncated at ${formatSize(maxBytes)}; use read to see the rest.]`);
     lineNumbers.push(undefined);
   }
-  return { diff: output.join("\n"), firstChangedLine, lineNumbers };
+  return { diff: output.join("\n"), firstChangedLine, lineNumbers, dedupEmitted };
 }
 
 function overDiffInputLimit(oldContent: string, newContent: string): boolean {
@@ -344,14 +369,14 @@ export function genDiff(
   oldContentHashes?: string[],
   limits?: DiffLimits,
   spans?: DiffSpan[],
-): { diff: string; firstChangedLine: number | undefined; lineNumbers: (number|undefined)[] } {
+): { diff: string; firstChangedLine: number | undefined; lineNumbers: (number|undefined)[]; spanDedupEmitted?: boolean } {
   const maxLineBytes = limits?.unlimited ? Number.POSITIVE_INFINITY : (limits?.maxLineBytes ?? DEFAULT_MAX_BYTES);
   const maxBytes = limits?.unlimited ? Number.POSITIVE_INFINITY : (limits?.maxBytes ?? DEFAULT_MAX_BYTES);
   if (spans && newContentHashes && oldContentHashes) {
     const anchored = genSpanDiff(oldContent, newContent, contextLines, newContentHashes, oldContentHashes, maxLineBytes, maxBytes, spans);
     if (anchored) {
       const diff = disambiguateDuplicateAnchors(anchored.diff);
-      return { diff, firstChangedLine: anchored.firstChangedLine, lineNumbers: anchored.lineNumbers };
+      return { diff, firstChangedLine: anchored.firstChangedLine, lineNumbers: anchored.lineNumbers, ...(anchored.dedupEmitted ? { spanDedupEmitted: true as const } : {}) };
     }
   }
   if (!limits?.unlimited && overDiffInputLimit(oldContent, newContent)) {

package/src/replace-render.ts

@@ -1,6 +1,7 @@
 import { Markdown, Text } from "@earendil-works/pi-tui";
 import { keyHint, type Theme } from "@earendil-works/pi-coding-agent";
 import type { ReplaceDetails } from "./replace";
+import { abortedBatchMessageFor } from "./batch";
 import { withLineNumbers } from "./utils";
 import { isDedupRow } from "./replace-response";
 import { getPreviewInput } from "./payload-contract";
@@ -66,6 +67,21 @@ export function fmtResult(diff: string, theme: FgT): string {
 	return colorLines(diff.split("\n"), theme).join("\n");
 }
 
+export function highlightBatchRefs(text: string, theme: FgT): string {
+	const pattern = /\b([Bb]atch \d+)\b/g;
+	const sections: string[] = [];
+	let cursor = 0;
+	for (;;) {
+		const match = pattern.exec(text);
+		if (!match) break;
+		if (match.index > cursor) sections.push(theme.fg("error", text.slice(cursor, match.index)));
+		sections.push(theme.fg("warning", match[0]));
+		cursor = match.index + match[0].length;
+	}
+	if (cursor < text.length) sections.push(theme.fg("error", text.slice(cursor)));
+	return sections.join("");
+}
+
 export function fmtCall(
   args: { path?: string; remove_from?: string; remove_to?: string; anchor?: string } | undefined,
   state: RRState,
@@ -144,6 +160,14 @@ function extractSummary(text: string | undefined): string | undefined {
 	return summary.length > 0 ? summary : 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 } {
+	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) };
+}
+
 export function buildAppliedText(
 	text: string | undefined,
 	details: ReplaceDetails | undefined,
@@ -154,8 +178,9 @@ export function buildAppliedText(
 	const summary = extractSummary(text);
 	if (summary) sections.push(summary);
 	if (details?.diff) {
-		const rawDiff = details.diffLineNumbers ? toNumberedDiff(details.diff, details.diffLineNumbers) : details.diff;
-		const diffLines = details.diff.split("\n");
+		const { header, body, lineNumbers } = splitBatchHeader(details.diff, details.diffLineNumbers);
+		const rawDiff = lineNumbers ? toNumberedDiff(body, lineNumbers) : body;
+		const diffLines = body.split("\n");
 		const diffSection = expanded
 			? fmtResult(rawDiff, theme)
 			: fmtPreview(rawDiff, false, theme);
@@ -163,7 +188,7 @@ export function buildAppliedText(
 			!expanded && diffLines.length > RESULT_PREVIEW_LINES
 				? ` (${expandHint()})`
 				: "";
-		sections.push(`${diffSection}${hint}`);
+		sections.push(header !== undefined ? `${theme.fg("warning", header)}\n${diffSection}${hint}` : `${diffSection}${hint}`);
 	}
 	const warnings = details?.warnings?.length ? `Warnings:\n${details.warnings.join("\n")}` : extractWarnings(text);
 	if (warnings) sections.push(warnings);
@@ -343,9 +368,17 @@ export function renderEditResult(
 		renderState.preview = undefined;
 		renderState.previewGeneration = (renderState.previewGeneration ?? 0) + 1;
 	}
+	const batch = result.details?.batch;
+	if (batch && batch.last === false) {
+		const abortedMessage = typeof context?.toolCallId === "string" ? abortedBatchMessageFor(context.toolCallId) : undefined;
+		if (abortedMessage !== undefined) {
+			return reuseText(context, `\n${highlightBatchRefs(abortedMessage, theme)}`);
+		}
+		return reuseText(context, theme.fg("warning", `In batch ${batch.id}`));
+	}
 	if (context.isError) {
 		return renderedText
-			? reuseText(context, `\n${theme.fg("error", renderedText)}`)
+			? reuseText(context, `\n${highlightBatchRefs(renderedText, theme)}`)
 			: new Text("", 0, 0);
 	}
 	if (isApplied(result.details)) {

package/src/replace-response.ts

@@ -1,8 +1,7 @@
-import { formatSize, DEFAULT_MAX_BYTES } from "@earendil-works/pi-coding-agent";
 import type { NEdit } from "./hashline";
 import { HASH_SEP } from "./hashline";
 import type { ReplaceDetails } from "./replace";
-import { genDiff, genPatch, type DiffSpan } from "./replace-diff";
+import { genDiff, genPatch, fmtDedupRow, type DiffSpan } from "./replace-diff";
 import { visLines, clipLine } from "./utils";
 import { DEDUP_ANCHOR } from "./constants";
 
@@ -106,7 +105,7 @@ export function buildNoop(input: NoopInput, noopNoun = "Replacement"): TResult {
 		: "The edit produced identical content.";
 	const dedupNote =
 		boundaryRemovedLines !== undefined && boundaryRemovedLines > 0
-			? `\nBoundary dedup removed ${boundaryRemovedLines} line(s); resend the same edit to apply it literally.`
+			? `\nBoundary dedup removed ${boundaryRemovedLines} line(s) that duplicated adjacent lines.`
 			: "";
 
 	const text = `No changes made to ${path}\nClassification: noop\n${noopDetailsText}${dedupNote}${warnBlock(warnings)}`;
@@ -131,13 +130,7 @@ export function buildNoop(input: NoopInput, noopNoun = "Replacement"): TResult {
 		},
 	};
 }
-export function fmtDedupRow(line: string): string {
-  const row = `${DEDUP_ANCHOR}${HASH_SEP}${line}`;
-  if (Buffer.byteLength(row, "utf-8") <= DEFAULT_MAX_BYTES) return row;
-  const size = formatSize(Buffer.byteLength(row, "utf-8"));
-  const limit = formatSize(DEFAULT_MAX_BYTES);
-  return `${DEDUP_ANCHOR}${HASH_SEP}[Row is ${size}, exceeds ${limit}; content not shown. Use read to see the full line.]`;
-}
+export { fmtDedupRow };
 
 export function isDedupRow(line: string): boolean {
   return line.startsWith(`${DEDUP_ANCHOR}${HASH_SEP}`);
@@ -175,7 +168,9 @@ export function buildChanged(input: SuccessInput, verb = "replaced", diffContext
   const { path, result, warnings, snapshotId, originalNormalized, originalHashes, editMeta, resultHashes, boundaryDedupAbove, boundaryDedupBelow, spans } = input;
   const resultLines = visLines(result);
   const baseDiff = genDiff(originalNormalized, result, diffContextLines, resultHashes, originalHashes, undefined, spans);
-  const diffResult = withDedupRows(baseDiff.diff, baseDiff.lineNumbers, boundaryDedupAbove, boundaryDedupBelow);
+  const diffResult = baseDiff.spanDedupEmitted
+    ? baseDiff
+    : withDedupRows(baseDiff.diff, baseDiff.lineNumbers, boundaryDedupAbove, boundaryDedupBelow);
   const addedLines = editMeta.addedLines;
   const removedLines = editMeta.removedLines;
   const warningsBlock = warnBlock(warnings);

package/src/replace-undo.ts

@@ -172,7 +172,7 @@ export function regUndo(pi: ExtensionAPI): void {
               content: [
                 {
                   type: "text",
-                  text: `[E_UNDO_STALE] Cannot undo last change on ${path}: the file was modified after the edit, so nothing was reverted. The current content already contains your applied edit plus that external change and is most likely the correct state. Do not modify the file to make an undo possible and do not revert your own edit. The undo record is kept. Call read() to verify the current state, then stop.`
+                  text: `[E_UNDO_STALE] Cannot undo last change on ${path}: the file was modified after the edit, so nothing was reverted and the file was left untouched. The undo record is kept. Do not edit the file to force the undo. Call read() to inspect the current state.`
                 },
               ],
               isError: true,

package/src/replace.ts

@@ -32,10 +32,9 @@ import { loadHashStore, type HashStore } from "./hash-store";
 import { adoptAnchors, servedForPath, withAnchorSession } from "./anchor-registry";
 import { resolveTarget } from "./fs-write";
 import { toCwd } from "./paths";
-import { noopPayloadKey, markBoundaryNoop, consumeBoundaryBypass, clearBoundaryBypass } from "./boundary-bypass";
 import { queuedEdit, editToolBase, editRenderCallWrapper, editRenderResultWrapper, resolveEditTargetWithRequirement, throwIfStrictInput, getBoundaryDedupMode, withReplacePrompts, DEFAULT_EDIT_FLAGS, type EditToolFlags } from "./edit-common";
-import { commitEdit } from "./commit";
-import { batchMemberFor, executeBatchMember, noteBatchFailure, suffixPoisonCause } from "./batch";
+import { commitEdit, dedupRowsFromFixes } from "./commit";
+import { batchMemberFor, executeBatchMember, noteBatchFailure } from "./batch";
 
 export { editToolSchema, type ReqParams, assertReq };
 
@@ -67,7 +66,6 @@ export interface PipelineResult {
   resultHashes: string[];
   totalAddedLines: number;
   totalRemovedLines: number;
-  hadBoundaryDedup: boolean;
   boundaryRemovedLines: number;
   boundaryRemovedLineTexts: string[];
   boundaryDedupAbove: string[];
@@ -180,9 +178,7 @@ export async function execPipeline(
     edit, originalHashes, isNoop, anchorResult.autoFixes?.length ?? 0,
   );
 
-  const sortedFixes = [...(anchorResult.autoFixes ?? [])].sort((a, b) => a.removedLineIndex - b.removedLineIndex);
-  const aboveFixes = sortedFixes.filter((fix) => fix.kind === "leading" || fix.kind === "last-new-before");
-  const belowFixes = sortedFixes.filter((fix) => fix.kind === "trailing" || fix.kind === "first-new-after");
+  const sortedFixes = dedupRowsFromFixes(anchorResult.autoFixes ?? []);
   const pipeSpan = isNoop ? undefined : hashSpan(originalHashes, edit.hash_bounds[0].hash, edit.hash_bounds[1].hash);
   const pipeResultCount = splitLines(result).length;
   const pipeSpans = pipeSpan ? [{ start: pipeSpan[0], end: pipeSpan[1], replacementCount: pipeResultCount - (originalHashes.length - (pipeSpan[1] - pipeSpan[0] + 1)) }] : undefined;
@@ -201,11 +197,10 @@ export async function execPipeline(
     originalHashes,
     totalAddedLines,
     totalRemovedLines,
-    hadBoundaryDedup: (anchorResult.autoFixes?.length ?? 0) > 0,
     boundaryRemovedLines: anchorResult.autoFixes?.length ?? 0,
-    boundaryRemovedLineTexts: sortedFixes.map((fix) => fix.removedLine),
-    boundaryDedupAbove: aboveFixes.map((fix) => fix.removedLine),
-    boundaryDedupBelow: belowFixes.map((fix) => fix.removedLine),
+    boundaryRemovedLineTexts: sortedFixes.removedTexts,
+    boundaryDedupAbove: sortedFixes.above,
+    boundaryDedupBelow: sortedFixes.below,
     identity,
     ...(pipeSpans ? { spans: pipeSpans } : {}),
   };
@@ -287,54 +282,34 @@ export function buildToolDef(flags: EditToolFlags = DEFAULT_EDIT_FLAGS): ToolDef
         }).catch((error: unknown) => {
           const member = batchMemberFor(_toolCallId);
           if (member) noteBatchFailure(member, error);
-          else suffixPoisonCause(_toolCallId, error);
           throw error;
         });
         return queuedEdit(targetPath, ctx.cwd, signal, async (absolutePath, mutationTargetPath) => {
           const dedupMode = await getBoundaryDedupMode();
-          const dedupOn = dedupMode !== "off";
-          const noopPayload = noopPayloadKey(mutationTargetPath, normalizedParams.remove_from, normalizedParams.remove_to, normalizedParams.replacement_lines);
-          const boundaryBypass = dedupOn ? consumeBoundaryBypass(mutationTargetPath, noopPayload) : false;
-          const strictBoundaryDedup = dedupMode === "strict" && !boundaryBypass;
+          const strictBoundaryDedup = dedupMode === "strict";
           const member = batchMemberFor(_toolCallId);
           if (!member) {
-            try {
-              const pipe = await execPipeline(
-                targetPath,
-                normalizedParams,
-                ctx.cwd,
-                { accessMode: constants.R_OK | constants.W_OK, signal, skipBoundaryDedup: boundaryBypass },
-              );
-              const appliedWarnings = boundaryBypass
-                ? ["[W_BOUNDARY_BYPASS] Boundary dedup was off for this call and is back on."]
-                : [];
-              return await commitEdit(pipe, {
-                path: pipe.path,
-                absolutePath,
-                mutationTargetPath,
-                editAnchors: [normalizedParams.remove_from, normalizedParams.remove_to],
-                signal,
-                appliedWarnings,
-                onApplied: () => { if (dedupOn) clearBoundaryBypass(mutationTargetPath); },
-                onNoopDedup: dedupOn ? () => markBoundaryNoop(mutationTargetPath, noopPayload) : undefined,
-              });
-            } catch (error) {
-              const detail = error instanceof Error ? error.message : String(error);
-              if (boundaryBypass && !detail.includes("File was written;")) markBoundaryNoop(mutationTargetPath, noopPayload);
-              throw error;
-            }
+            const pipe = await execPipeline(
+              targetPath,
+              normalizedParams,
+              ctx.cwd,
+              { accessMode: constants.R_OK | constants.W_OK, signal },
+            );
+            return await commitEdit(pipe, {
+              path: pipe.path,
+              absolutePath,
+              mutationTargetPath,
+              editAnchors: [normalizedParams.remove_from, normalizedParams.remove_to],
+              signal,
+            });
           }
           let built: { edit: HEdit; warnings: string[] };
           try {
             built = buildReplaceHEdit(normalizedParams);
           } catch (error) {
             noteBatchFailure(member, error);
-            if (boundaryBypass) markBoundaryNoop(mutationTargetPath, noopPayload);
             throw error;
           }
-          const appliedWarnings = boundaryBypass
-            ? ["[W_BOUNDARY_BYPASS] Boundary dedup was off for this call and is back on."]
-            : [];
           return executeBatchMember({
             kind: "replace",
             member,
@@ -343,11 +318,9 @@ export function buildToolDef(flags: EditToolFlags = DEFAULT_EDIT_FLAGS): ToolDef
             cwd: ctx.cwd,
             signal,
             hedit: built.edit,
-            extraWarnings: [...built.warnings, ...appliedWarnings],
-            skipBoundaryDedup: boundaryBypass,
+            extraWarnings: built.warnings,
+            skipBoundaryDedup: false,
             strictBoundaryDedup,
-            noopPayload,
-            bypassConsumed: boundaryBypass,
           });
         });
       });

package/src/boundary-bypass.ts

@@ -1,51 +0,0 @@
-import { parseText } from "./hashline/parse";
-import { ANCHOR_ROW_RE } from "./hashline/resolve";
-import { stripRowPrefix } from "./hashline/hash";
-
-function canonRef(ref: string): string {
-  const trimmed = ref.trim();
-  const match = trimmed.match(ANCHOR_ROW_RE);
-  return match ? match[2]! : trimmed;
-}
-
-function canonLines(lines: string[]): string[] {
-  return parseText(lines).map((line) => stripRowPrefix(line).text);
-}
-
-const boundaryBypassTracker = new Map<string, string>();
-const BOUNDARY_BYPASS_LIMIT = 256;
-
-export function noopPayloadKey(
-  absolutePath: string,
-  removeFrom: string,
-  removeTo: string,
-  replacementLines: string[],
-): string {
-  return JSON.stringify([
-    absolutePath,
-    canonRef(removeFrom),
-    canonRef(removeTo),
-    canonLines(replacementLines),
-  ]);
-}
-
-export function markBoundaryNoop(absolutePath: string, payload: string): void {
-  boundaryBypassTracker.delete(absolutePath);
-  boundaryBypassTracker.set(absolutePath, payload);
-  if (boundaryBypassTracker.size > BOUNDARY_BYPASS_LIMIT) {
-    const oldest = boundaryBypassTracker.keys().next().value;
-    if (oldest !== undefined) boundaryBypassTracker.delete(oldest);
-  }
-}
-
-export function consumeBoundaryBypass(absolutePath: string, payload: string): boolean {
-  if (boundaryBypassTracker.get(absolutePath) === payload) {
-    boundaryBypassTracker.delete(absolutePath);
-    return true;
-  }
-  return false;
-}
-
-export function clearBoundaryBypass(absolutePath: string): void {
-  boundaryBypassTracker.delete(absolutePath);
-}