pi-hashline-edit-pro 4.2.10 → 4.3.0

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,14 +16,13 @@ import {
   type HEdit,
   type PlannedEdit,
 } from "./hashline";
-import { clearBoundaryBypass, markBoundaryNoop } from "./boundary-bypass";
-import { boundaryDedupWarning } from "./commit";
-import { adoptAnchors, markServed, servedForPath } from "./anchor-registry";
+import { boundaryDedupNoopWarning, boundaryDedupWarning, dedupRowsFromFixes } from "./commit";
+import { adoptAnchors, servedForPath } from "./anchor-registry";
 import { restoreEndings, stripBOM, toLF, type LineEnding } from "./normalize";
 import { assertInsertReq, assertReq, normReq } from "./payload-contract";
 import { saveUndo } from "./replace-undo";
 import { buildChanged, buildNoop, type RMetrics, type TResult } from "./replace-response";
-import { buildServedMap, servedHashesFromDiff } from "./served";
+import { serveRows, servedHashesFromDiff } from "./served";
 import { abortIf, assertLineLimit, errCode, isRec, splitLines } from "./utils";
 import { MAX_BYTES } from "./constants";
 
@@ -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),
@@ -664,7 +750,7 @@ async function finishBatch(member: PlannedMember, signal?: AbortSignal): Promise
   changed.details.diff = `${header}\n${changed.details.diff}`;
   changed.details.diffLineNumbers?.unshift(undefined);
   try {
-    markServed(runtime.target, buildServedMap(resultHashes, splitLines(composed), servedHashesFromDiff(changed.details.diff)), new Set(resultHashes));
+    serveRows(runtime.target, resultHashes, splitLines(composed), servedHashesFromDiff(changed.details.diff));
   } catch (error) {
     console.error("Failed to mark batch diff served:", error);
   }
@@ -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

@@ -8,11 +8,10 @@ import { saveUndo } from "./replace-undo";
 import { getDiffContextLines } from "./config";
 import { safeSnapId } from "./file-reader";
 import { writeAtomic } from "./fs-write";
-import { servedHashesFromDiff, buildServedMap } from "./served";
-import { lineHashes } from "./hashline";
-import { hashSpan } from "./replace";
+import { servedHashesFromDiff, serveRows } from "./served";
+import { lineHashes, type AutoFix } from "./hashline";
+import { spanForEdit } from "./replace";
 import { restoreEndings, stripBOM, toLF } from "./normalize";
-import { markServed as markServedScoped } from "./anchor-registry";
 export interface CommitMeta {
   editAnchors?: [string, string];
   path: string;
@@ -22,10 +21,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 +30,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 +52,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 +70,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 +119,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 = {
@@ -122,18 +130,14 @@ export async function commitEdit(pipe: PipelineResult, meta: CommitMeta): Promis
     removedLines: pipe.totalRemovedLines,
   };
 
-  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 span = meta.editAnchors ? spanForEdit(pipe.originalHashes, meta.editAnchors[0], meta.editAnchors[1], pipe.result) : undefined;
   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,
-      });
+    resultHashes = await lineHashes(pipe.result, mutationTargetPath, {
+      content: pipe.originalNormalized,
+      hashes: pipe.originalHashes,
+      spans: span ? [span] : 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.`);
@@ -149,15 +153,11 @@ export async function commitEdit(pipe: PipelineResult, meta: CommitMeta): Promis
     editMeta,
     boundaryDedupAbove: pipe.boundaryDedupAbove,
     boundaryDedupBelow: pipe.boundaryDedupBelow,
-    ...(span ? { spans: [{ start: span[0], end: span[1], replacementCount }] } : {}),
+    ...(span ? { spans: [span] } : {}),
   };
   const changed = buildChanged(successInput, meta.verb, await getDiffContextLines());
   if (changed.details.diff) {
-    markServedScoped(
-      mutationTargetPath,
-      buildServedMap(resultHashes, splitLines(pipe.result), servedHashesFromDiff(changed.details.diff)),
-      new Set(resultHashes),
-    );
+    serveRows(mutationTargetPath, resultHashes, splitLines(pipe.result), servedHashesFromDiff(changed.details.diff));
   }
   return changed;
 }

package/src/config-ui.ts

@@ -2,7 +2,7 @@ import { Key, matchesKey, visibleWidth } from "@earendil-works/pi-tui";
 import type { Theme } from "@earendil-works/pi-coding-agent";
 import { readConfig, type Config } from "./config";
 
-export type ConfigToggleKey = "autoRead" | "anchorGrepEnabled" | "requirePath" | "strictInput" | "boundaryDedupMode" | "diffContextLines";
+export type ConfigToggleKey = "autoRead" | "autoReadAll" | "anchorGrepEnabled" | "requirePath" | "strictInput" | "boundaryDedupMode" | "diffContextLines";
 
 export interface ConfigRow {
   key: ConfigToggleKey;
@@ -18,6 +18,7 @@ export interface ConfigRow {
 export function configRows(config: Config): ConfigRow[] {
   return [
     { key: "autoRead", label: "Auto-read", hint: "Anchors after write + post-edit diffs", enabled: config.autoRead !== false },
+    { key: "autoReadAll", label: "Auto-read all", hint: "Attach every non-ignored file with anchors on the first turn", enabled: config.autoReadAll === true },
     { key: "diffContextLines", label: "Diff context", hint: "Surrounding lines in post-edit diffs (needs Auto-read)", enabled: config.autoRead !== false, value: config.diffContextLines ?? 1, disabled: config.autoRead === false },
     { key: "anchorGrepEnabled", label: "Anchor grep", hint: "anchor_grep tool (builtin grep off while on)", enabled: config.anchorGrepEnabled === true },
     { key: "requirePath", label: "Require path", hint: "replace + insert need path (RPC visibility)", enabled: config.requirePath === true },