pi-hashline-edit-pro 4.2.11 → 4.3.0

package/src/hashline/parse.ts

@@ -55,43 +55,30 @@ export const parseHashRef = parseRef;
 
 const JSON_ENVELOPE_RE = /^\s*\["(.*)"\]\.\s*$/;
 
-function unwrapJsonEnvelope(line: string, warnings?: string[]): string {
+function unwrapJsonEnvelope(line: string): string {
   const match = line.match(JSON_ENVELOPE_RE);
   if (!match) return line;
   const withoutDot = line.trim().slice(0, -1);
   try {
     const parsed: unknown = JSON.parse(withoutDot);
     if (Array.isArray(parsed) && parsed.length === 1 && typeof parsed[0] === "string") {
-      warnings?.push(
-        '[W_BAD_SHAPE] Unwrapped JSON array syntax from a replacement_lines element.',
-      );
       return parsed[0];
     }
     return line;
   } catch {
-    warnings?.push(
-      '[W_BAD_SHAPE] Unwrapped JSON array syntax from a replacement_lines element.',
-    );
     return match[1]!;
   }
 }
 
-export function parseText(edit: string[], warnings?: string[]): string[] {
+export function parseText(edit: string[]): string[] {
   if (!Array.isArray(edit) || edit.some((line) => typeof line !== "string")) {
     throw new Error(NEW_CONTENT_NOT_ARRAY_MSG);
   }
   const out: string[] = [];
-  let split = false;
   for (const line of edit) {
-    const unwrapped = unwrapJsonEnvelope(line, warnings);
+    const unwrapped = unwrapJsonEnvelope(line);
     const normalized = unwrapped.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
-    if (normalized.includes("\n")) split = true;
     out.push(...normalized.split("\n"));
   }
-  if (split) {
-    warnings?.push(
-      "[W_BAD_SHAPE] replacement_lines contained embedded newlines; split into one line each.",
-    );
-  }
   return out;
 }

package/src/hashline/resolve.ts

@@ -1,10 +1,8 @@
 import { abortIf, rejectUnknownFields, firstNonEmptyIndex, lastNonEmptyIndex, clipLine, getCached, decodeStringArray, assertNoNul } from "../utils";
 import { parseHashRef, parseText, type Anchor } from "./parse";
-import { HASH_SEP, stripRowPrefix, canon } from "./hash";
+import { HASH_SEP, stripRowPrefix, canon, lineChecksum, type RowPrefixKind } from "./hash";
 import { HASH_RUN } from "./alphabet";
 import { NEW_CONTENT_NOT_ARRAY_MSG, MAX_RANGE_STALE_LINES } from "../constants";
-import { contentChecksum } from "./hasher";
-import { hashSource } from "./hash";
 
 export type RAnchor = {
 	line: number;
@@ -110,7 +108,7 @@ export function fmtMismatchWithHashes(
         const h = fileHashes[ln - 1]!;
         const c = fileLines[ln - 1] ?? "";
         hashes.push(h);
-        servedMap.set(h, contentChecksum(hashSource(c)));
+        servedMap.set(h, lineChecksum(c));
         rows.push(`    ${ln}: ${h}│${clipLine(c)}`);
       }
       out.push("");
@@ -171,7 +169,7 @@ export function stripAnchorRow(
 export function resEdit(edit: HTEdit, warnings?: string[]): HEdit {
   assertItem(edit as Record<string, unknown>);
 
-  const replaceLines = parseText(decodeStringArray(edit.replacement_lines, warnings) ?? edit.replacement_lines, warnings);
+  const replaceLines = parseText(decodeStringArray(edit.replacement_lines, warnings) ?? edit.replacement_lines);
   assertNoNul(replaceLines);
   const bounds = [edit.remove_from, edit.remove_to].map((ref) => {
     return stripAnchorRow(ref.trim(), "remove_from/remove_to entry", warnings);
@@ -193,52 +191,37 @@ function warnUnicodeEsc(
   }
 }
 
-export function stripBarePrefixes(
-	edit: HEdit,
-	fileHashes: string[],
-	warnings: string[],
-): HEdit {
-	const fileHashSet = new Set(fileHashes);
-	const stripped: { lineIndex: number; matched: boolean }[] = [];
-	const contentLines = edit.content_lines.map((line, lineIndex) => {
-		const result = stripRowPrefix(line);
-		if (result.kind !== "bare") return line;
-		stripped.push({ lineIndex, matched: fileHashSet.has(result.hash ?? "") });
-		return result.text;
-	});
-	if (stripped.length === 0) return edit;
-	const locations = stripped
-		.map((s) => `replacement_lines line ${s.lineIndex + 1}`)
-		.join(", ");
-	warnings.push(
-    `[W_BARE_HASH_PREFIX] Stripped "anchor│" prefix from ${locations}.`
-	);
-	return { ...edit, content_lines: contentLines };
-}
-
-export function stripDiffPrefixes(
+function stripRowPrefixes(
 	edit: HEdit,
 	warnings: string[],
+	kinds: RowPrefixKind[],
+	code: string,
+	marker: string,
 ): HEdit {
 	const stripped: number[] = [];
 	const contentLines = edit.content_lines.map((line, lineIndex) => {
 		const result = stripRowPrefix(line);
-		if (result.kind !== "plus" && result.kind !== "minus") return line;
+		if (result.kind === null || !kinds.includes(result.kind)) return line;
 		stripped.push(lineIndex);
 		return result.text;
 	});
 	if (stripped.length === 0) return edit;
 	const locations = stripped.map((i) => `replacement_lines line ${i + 1}`).join(", ");
-	warnings.push(
-    `[W_INVALID_PATCH] Stripped diff-preview marker from ${locations}.`
-	);
+	warnings.push(`${code} Stripped ${marker} from ${locations}.`);
 	return { ...edit, content_lines: contentLines };
 }
 
+export function stripBarePrefixes(edit: HEdit, warnings: string[]): HEdit {
+	return stripRowPrefixes(edit, warnings, ["bare"], "[W_BARE_HASH_PREFIX]", '"anchor│" prefix');
+}
+
+export function stripDiffPrefixes(edit: HEdit, warnings: string[]): HEdit {
+	return stripRowPrefixes(edit, warnings, ["plus", "minus"], "[W_INVALID_PATCH]", "diff-preview marker");
+}
+
 export function swapReversedRanges(
 	edit: HEdit,
 	fileHashes: string[],
-	warnings: string[],
 ): HEdit {
 	const lineByHash = new Map<string, number>();
 	for (let i = 0; i < fileHashes.length; i++) {
@@ -254,9 +237,6 @@ export function swapReversedRanges(
 	) {
 		return edit;
 	}
-	warnings.push(
-    `[W_BAD_OP] Swapped reversed remove_from/remove_to.`
-	);
 	return { ...edit, hash_bounds: [endRef, startRef] as [Anchor, Anchor] };
 }
 
@@ -515,7 +495,7 @@ export function assertRangeServed(
     const hash = fileHashes[line - 1]!;
     const content = fileLines[line - 1]!;
     const servedContent = served?.get(hash);
-    if (servedContent === undefined || servedContent !== contentChecksum(hashSource(content))) mismatchLines.push(line);
+    if (servedContent === undefined || servedContent !== lineChecksum(content)) mismatchLines.push(line);
   }
   if (mismatchLines.length === 0) return;
   const rangeLength = endLine - startLine + 1;
@@ -527,7 +507,7 @@ export function assertRangeServed(
     const hash = fileHashes[line - 1]!;
     const content = fileLines[line - 1]!;
     shownHashes.push(hash);
-    shownMap.set(hash, contentChecksum(hashSource(content)));
+    shownMap.set(hash, lineChecksum(content));
     rows.push(fmtRow(hash, clipLine(content)));
   }
   const location = filePath ? ` in ${filePath}` : "";

package/src/payload-contract.ts

@@ -1,5 +1,5 @@
 import { Type } from "typebox";
-import { isRec, normalizeAnchors, normalizeFilePath, rejectUnknownFields, assertNoNul } from "./utils";
+import { isRec, normalizeRequest, rejectUnknownFields, assertNoNul } from "./utils";
 
 const replacementLinesSchema = Type.Array(
   Type.String({
@@ -77,20 +77,12 @@ export function assertReq(request: unknown): asserts request is ReqParams {
   assertNoNul(request.replacement_lines);
 }
 
-export function normReq(input: unknown): unknown {
-  if (!isRec(input)) {
-    return input;
-  }
-  const record: Record<string, unknown> = { ...input };
-  normalizeFilePath(record);
-  normalizeAnchors(record);
-  return record;
-}
+export { normalizeRequest as normReq } from "./utils";
 
 export function getPreviewInput(args: unknown): { path?: string; remove_from: string; remove_to: string; replacement_lines: string[] } | null {
   let normalized: unknown;
   try {
-    normalized = normReq(args);
+    normalized = normalizeRequest(args);
   } catch {
     return null;
   }

package/src/read.ts

@@ -17,8 +17,8 @@ import { abortIf, makePrepareArguments, numberedRead, visLines, splitLines } fro
 import { loadP, loadGuide } from "./prompts";
 import { withReadPrompts, DEFAULT_EDIT_FLAGS, type EditToolFlags } from "./edit-common";
 import { valAccess } from "./validation";
-import { markServed as markServedScoped, withAnchorSession } from "./anchor-registry";
-import { buildServedMap } from "./served";
+import { withAnchorSession } from "./anchor-registry";
+import { serveRows } from "./served";
 import { Text } from "@earendil-works/pi-tui";
 const R_DESC = loadP("../prompts/read.md");
 const R_SNIPPET = loadP("../prompts/read-snippet.md");
@@ -237,7 +237,7 @@ export function regRead(pi: ExtensionAPI, flags: EditToolFlags = DEFAULT_EDIT_FL
 					fileHashes,
 					resolvedPath,
 				);
-				markServedScoped(resolvedPath, buildServedMap(fileHashes, fileLines, preview.servedHashes), new Set(fileHashes));
+				serveRows(resolvedPath, fileHashes, fileLines, preview.servedHashes);
 				const snapshotId = await safeSnapId(absolutePath, "read");
 				const previewText =
 					hadUtf8DecodeErrors

package/src/replace-diff.ts

@@ -201,6 +201,74 @@ function trimPlacedSpans(
   return out;
 }
 
+function createRowEmitter(
+  output: string[],
+  lineNumbers: (number | undefined)[],
+  maxLineBytes: number,
+  maxBytes: number,
+): {
+  readonly stopped: boolean;
+  readonly truncated: boolean;
+  emitPlain(line: string, num?: number): void;
+  emitRow(prefix: " " | "+" | "-", line: string, hash: string | undefined, num?: number): void;
+  emitDedup(line: string): boolean;
+} {
+  let outBytes = 0;
+  let stopped = false;
+  let truncated = false;
+  const emitPlain = (line: string, num?: number): void => {
+    if (stopped) return;
+    const lineBytes = Buffer.byteLength(line, "utf-8") + 1;
+    if (outBytes + lineBytes > maxBytes) {
+      stopped = true;
+      truncated = true;
+      return;
+    }
+    outBytes += lineBytes;
+    output.push(line);
+    lineNumbers.push(num);
+  };
+  const emitRow = (prefix: " " | "+" | "-", line: string, hash: string | undefined, num?: number): void => {
+    if (stopped) return;
+    const full = fmtDiffLine(prefix, line, hash);
+    const rowBytes = Buffer.byteLength(full, "utf-8");
+    if (rowBytes > maxLineBytes) {
+      const marker = `[Row is ${formatSize(rowBytes)}, exceeds ${formatSize(maxLineBytes)}; content not shown. Use read to see the full line.]`;
+      emitPlain(fmtDiffLine(prefix, marker, hash), num);
+      return;
+    }
+    if (outBytes + rowBytes + 1 > maxBytes) {
+      stopped = true;
+      truncated = true;
+      return;
+    }
+    outBytes += rowBytes + 1;
+    output.push(full);
+    lineNumbers.push(num);
+  };
+  const emitDedup = (line: string): boolean => {
+    if (stopped) return false;
+    const row = fmtDedupRow(line);
+    const rowBytes = Buffer.byteLength(row, "utf-8") + 1;
+    if (outBytes + rowBytes > maxBytes) {
+      stopped = true;
+      truncated = true;
+      return false;
+    }
+    outBytes += rowBytes;
+    output.push(row);
+    lineNumbers.push(undefined);
+    return true;
+  };
+  return {
+    get stopped() { return stopped; },
+    get truncated() { return truncated; },
+    emitPlain,
+    emitRow,
+    emitDedup,
+  };
+}
+
 function genSpanDiff(
   oldContent: string,
   newContent: string,
@@ -235,50 +303,18 @@ function genSpanDiff(
   let dedupEmitted = false;
   const lineNumbers: (number | undefined)[] = [];
   let firstChangedLine: number | undefined;
-  let outBytes = 0;
-  let stopped = false;
-  let diffTruncated = false;
-  const emitPlain = (line: string, num?: number): void => {
-    if (stopped) return;
-    const lineBytes = Buffer.byteLength(line, "utf-8") + 1;
-    if (outBytes + lineBytes > maxBytes) {
-      stopped = true;
-      diffTruncated = true;
-      return;
-    }
-    outBytes += lineBytes;
-    output.push(line);
-    lineNumbers.push(num);
-  };
-  const emitRow = (prefix: " " | "+" | "-", line: string, hash: string | undefined, num?: number): void => {
-    if (stopped) return;
-    const full = fmtDiffLine(prefix, line, hash);
-    const rowBytes = Buffer.byteLength(full, "utf-8");
-    if (rowBytes > maxLineBytes) {
-      const marker = `[Row is ${formatSize(rowBytes)}, exceeds ${formatSize(maxLineBytes)}; content not shown. Use read to see the full line.]`;
-      emitPlain(fmtDiffLine(prefix, marker, hash), num);
-      return;
-    }
-    if (outBytes + rowBytes + 1 > maxBytes) {
-      stopped = true;
-      diffTruncated = true;
-      return;
-    }
-    outBytes += rowBytes + 1;
-    output.push(full);
-    lineNumbers.push(num);
-  };
+  const em = createRowEmitter(output, lineNumbers, maxLineBytes, maxBytes);
   const emitGap = (gapStartNew: number, gapLen: number, position: "leading" | "middle" | "trailing"): void => {
-    if (stopped || gapLen <= 0) return;
+    if (em.stopped || gapLen <= 0) return;
     if (position === "leading") {
       let count = contextLines;
       if (contextLines > 0 && gapLen > count && isBlankLine(newLines[gapStartNew + gapLen - 1]!)) count += 1;
       count = Math.min(count, gapLen);
       const skipStart = gapLen - count;
-      if (skipStart > 0) emitPlain(" ...", undefined);
-      for (let k = gapLen - count; k < gapLen && !stopped; k++) {
+      if (skipStart > 0) em.emitPlain(" ...", undefined);
+      for (let k = gapLen - count; k < gapLen && !em.stopped; k++) {
         const newIdx = gapStartNew + k;
-        emitRow(" ", newLines[newIdx]!, newHashes[newIdx], newIdx + 1);
+        em.emitRow(" ", newLines[newIdx]!, newHashes[newIdx], newIdx + 1);
       }
       return;
     }
@@ -286,11 +322,11 @@ function genSpanDiff(
       let count = contextLines;
       if (contextLines > 0 && gapLen > count && isBlankLine(newLines[gapStartNew]!)) count += 1;
       count = Math.min(count, gapLen);
-      for (let k = 0; k < count && !stopped; k++) {
+      for (let k = 0; k < count && !em.stopped; k++) {
         const newIdx = gapStartNew + k;
-        emitRow(" ", newLines[newIdx]!, newHashes[newIdx], newIdx + 1);
+        em.emitRow(" ", newLines[newIdx]!, newHashes[newIdx], newIdx + 1);
       }
-      if (gapLen > count) emitPlain(" ...", undefined);
+      if (gapLen > count) em.emitPlain(" ...", undefined);
       return;
     }
     let headCount = contextLines;
@@ -299,56 +335,52 @@ function genSpanDiff(
     if (contextLines > 0 && gapLen - tailCount > headCount && isBlankLine(newLines[gapStartNew + gapLen - tailCount]!)) tailCount += 1;
     const middleLen = gapLen - headCount - tailCount;
     if (middleLen <= 0) {
-      for (let k = 0; k < gapLen && !stopped; k++) {
+      for (let k = 0; k < gapLen && !em.stopped; k++) {
         const newIdx = gapStartNew + k;
-        emitRow(" ", newLines[newIdx]!, newHashes[newIdx], newIdx + 1);
+        em.emitRow(" ", newLines[newIdx]!, newHashes[newIdx], newIdx + 1);
       }
       return;
     }
-    for (let k = 0; k < headCount && !stopped; k++) {
+    for (let k = 0; k < headCount && !em.stopped; k++) {
       const newIdx = gapStartNew + k;
-      emitRow(" ", newLines[newIdx]!, newHashes[newIdx], newIdx + 1);
+      em.emitRow(" ", newLines[newIdx]!, newHashes[newIdx], newIdx + 1);
     }
-    if (!stopped) emitPlain(" ...", undefined);
-    for (let k = gapLen - tailCount; k < gapLen && !stopped; k++) {
+    if (!em.stopped) em.emitPlain(" ...", undefined);
+    for (let k = gapLen - tailCount; k < gapLen && !em.stopped; k++) {
       const newIdx = gapStartNew + k;
-      emitRow(" ", newLines[newIdx]!, newHashes[newIdx], newIdx + 1);
+      em.emitRow(" ", newLines[newIdx]!, newHashes[newIdx], newIdx + 1);
     }
   };
   oldPos = 0;
   newPos = 0;
-  for (let spanIdx = 0; spanIdx < ordered.length && !stopped; spanIdx++) {
+  for (let spanIdx = 0; spanIdx < ordered.length && !em.stopped; spanIdx++) {
     const span = ordered[spanIdx]!;
     const gapLen = span.oldStart - oldPos;
     emitGap(newPos, gapLen, spanIdx === 0 ? "leading" : "middle");
-    if (stopped) break;
+    if (em.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);
+      if (em.stopped) break;
+      if (em.emitDedup(dedup)) dedupEmitted = true;
     }
-    for (let oldIdx = span.oldStart; oldIdx <= span.oldEnd && !stopped; oldIdx++) {
-      emitRow("-", oldLines[oldIdx]!, oldHashes[oldIdx], oldIdx + 1);
+    for (let oldIdx = span.oldStart; oldIdx <= span.oldEnd && !em.stopped; oldIdx++) {
+      em.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 (let newIdx = span.newStart; newIdx <= span.newEnd && !em.stopped; newIdx++) {
+      em.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);
+      if (em.stopped) break;
+      if (em.emitDedup(dedup)) dedupEmitted = true;
     }
     oldPos = span.oldEnd + 1;
     newPos = span.newEnd + 1;
   }
-  if (!stopped) {
+  if (!em.stopped) {
     const trailingLen = oldLines.length - oldPos;
     emitGap(newPos, trailingLen, "trailing");
   }
-  if (diffTruncated) {
+  if (em.truncated) {
     output.push(" ...");
     lineNumbers.push(undefined);
     output.push(`[diff truncated at ${formatSize(maxBytes)}; use read to see the rest.]`);
@@ -441,45 +473,12 @@ export function genDiff(
   let oldLineNum = 1;
   let lastWasChange = false;
   let firstChangedLine: number | undefined;
-  let outBytes = 0;
-  let stopped = false;
-  let diffTruncated = false;
   const lineNumbers: (number|undefined)[] = [];
 
-  const emitPlain = (line: string, num?: number): void => {
-    if (stopped) return;
-    const lineBytes = Buffer.byteLength(line, "utf-8") + 1;
-    if (outBytes + lineBytes > maxBytes) {
-      stopped = true;
-      diffTruncated = true;
-      return;
-    }
-    outBytes += lineBytes;
-    output.push(line);
-    lineNumbers.push(num);
-  };
-
-  const emitRow = (prefix: " " | "+" | "-", line: string, hash: string | undefined, num?: number): void => {
-    if (stopped) return;
-    const full = fmtDiffLine(prefix, line, hash);
-    const rowBytes = Buffer.byteLength(full, "utf-8");
-    if (rowBytes > maxLineBytes) {
-      const marker = `[Row is ${formatSize(rowBytes)}, exceeds ${formatSize(maxLineBytes)}; content not shown. Use read to see the full line.]`;
-      emitPlain(fmtDiffLine(prefix, marker, hash), num);
-      return;
-    }
-    if (outBytes + rowBytes + 1 > maxBytes) {
-      stopped = true;
-      diffTruncated = true;
-      return;
-    }
-    outBytes += rowBytes + 1;
-    output.push(full);
-    lineNumbers.push(num);
-  };
+  const em = createRowEmitter(output, lineNumbers, maxLineBytes, maxBytes);
 
   for (let i = 0; i < parts.length; i++) {
-    if (stopped) break;
+    if (em.stopped) break;
     const part = parts[i]!;
     const raw = part.value.split("\n");
     if (raw[raw.length - 1] === "") raw.pop();
@@ -488,18 +487,18 @@ export function genDiff(
     if (part.added || part.removed) {
       if (firstChangedLine === undefined) firstChangedLine = newLineNum;
       for (let k = 0; k < displayLines.length; k++) {
-        if (stopped) break;
+        if (em.stopped) break;
         if (part.added) {
           const hash = effectiveNewHashes[newLineNum - 1];
-          emitRow("+", displayLines[k]!, hash, newLineNum);
+          em.emitRow("+", displayLines[k]!, hash, newLineNum);
           newLineNum++;
         } else {
           const hash = oldContentHashes?.[oldLineNum - 1];
-          emitRow("-", displayLines[k]!, hash, oldLineNum);
+          em.emitRow("-", displayLines[k]!, hash, oldLineNum);
           oldLineNum++;
         }
       }
-      if (stopped) break;
+      if (em.stopped) break;
       lastWasChange = true;
       continue;
     }
@@ -562,25 +561,25 @@ export function genDiff(
       }
 
       if (skipStart > 0) {
-        emitPlain(" ...", undefined);
+        em.emitPlain(" ...", undefined);
         newLineNum += skipStart;
         oldLineNum += skipStart;
       }
       for (const line of linesToShow) {
-        if (stopped) break;
+        if (em.stopped) break;
         if (isEllipsisMarker(line)) {
-          emitPlain(" ...", undefined);
+          em.emitPlain(" ...", undefined);
           newLineNum += skipMiddle;
           oldLineNum += skipMiddle;
           continue;
         }
         const hash = effectiveNewHashes[newLineNum - 1];
-        emitRow(" ", line, hash, newLineNum);
+        em.emitRow(" ", line, hash, newLineNum);
         newLineNum++;
         oldLineNum++;
       }
       if (skipTail > 0) {
-        emitPlain(" ...", undefined);
+        em.emitPlain(" ...", undefined);
       }
     } else {
       newLineNum += displayLines.length;
@@ -589,7 +588,7 @@ export function genDiff(
     lastWasChange = false;
   }
 
-  if (diffTruncated) {
+  if (em.truncated) {
     output.push(" ...");
     lineNumbers.push(undefined);
     output.push(`[diff truncated at ${formatSize(maxBytes)}; use read to see the rest.]`);

package/src/replace-response.ts

@@ -1,3 +1,4 @@
+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";
@@ -140,9 +141,42 @@ export function isChangeRow(line: string): boolean {
   return line.startsWith("+") || line.startsWith("-");
 }
 
-export function withDedupRows(diff: string, lineNumbers: (number | undefined)[], above: string[] | undefined, below: string[] | undefined): { diff: string; lineNumbers: (number | undefined)[] } {
-  const top = (above ?? []).map(fmtDedupRow);
-  const bottom = (below ?? []).map(fmtDedupRow);
+function capDedupRows(rows: string[], budget: number): { rows: string[]; bytes: number; omitted: number } {
+  const kept: string[] = [];
+  let bytes = 0;
+  for (const row of rows) {
+    const rowBytes = Buffer.byteLength(row, "utf-8") + 1;
+    if (bytes + rowBytes > budget) break;
+    kept.push(row);
+    bytes += rowBytes;
+  }
+  return { rows: kept, bytes, omitted: rows.length - kept.length };
+}
+
+function dedupOmissionNote(omitted: number, maxBytes: number): string {
+  return fmtDedupRow(`[${omitted} line(s) not shown again; output capped at ${formatSize(maxBytes)}.]`);
+}
+
+export function withDedupRows(diff: string, lineNumbers: (number | undefined)[], above: string[] | undefined, below: string[] | undefined, maxBytes = DEFAULT_MAX_BYTES): { diff: string; lineNumbers: (number | undefined)[] } {
+  const topAll = (above ?? []).map(fmtDedupRow);
+  const bottomAll = (below ?? []).map(fmtDedupRow);
+  if (topAll.length === 0 && bottomAll.length === 0) return { diff, lineNumbers };
+  const usedBytes = Buffer.byteLength(diff, "utf-8");
+  const fullBudget = Math.max(0, maxBytes - usedBytes);
+  const initialTop = capDedupRows(topAll, fullBudget);
+  const initialBottom = capDedupRows(bottomAll, Math.max(0, fullBudget - initialTop.bytes));
+  const anyOmitted = initialTop.omitted + initialBottom.omitted > 0;
+  const reserved = anyOmitted ? Buffer.byteLength(dedupOmissionNote(topAll.length + bottomAll.length, maxBytes), "utf-8") + 1 : 0;
+  const budget = Math.max(0, fullBudget - reserved);
+  const topCapped = anyOmitted ? capDedupRows(topAll, budget) : initialTop;
+  const bottomCapped = anyOmitted ? capDedupRows(bottomAll, Math.max(0, budget - topCapped.bytes)) : initialBottom;
+  const top = topCapped.rows;
+  const bottom = [...bottomCapped.rows];
+  const omitted = topCapped.omitted + bottomCapped.omitted;
+  if (omitted > 0) {
+    const note = dedupOmissionNote(omitted, maxBytes);
+    if (usedBytes + topCapped.bytes + bottomCapped.bytes + Buffer.byteLength(note, "utf-8") + 1 <= maxBytes) bottom.push(note);
+  }
   if (top.length === 0 && bottom.length === 0) return { diff, lineNumbers };
   if (diff.length === 0) return { diff: [...top, ...bottom].join("\n"), lineNumbers: [...lineNumbers, ...[...top, ...bottom].map(() => undefined)] };
   const lines = diff.split("\n");

package/src/replace-undo.ts

@@ -4,10 +4,9 @@ import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { withFileMutationQueue } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 import { loadHashStore, persistSnapshot, upsertUndo, getUndoEntry, deleteUndo, type UndoRecord } from "./hash-store";
-import { servedHashesFromDiff, buildServedMap } from "./served";
-import { contentChecksum } from "./hashline/hasher";
-import { hashSource } from "./hashline";
-import { markServed as markServedScoped, freeAnchors, adoptAnchors, withAnchorSession } from "./anchor-registry";
+import { servedHashesFromDiff, serveRows } from "./served";
+import { lineChecksum } from "./hashline";
+import { freeAnchors, adoptAnchors, withAnchorSession } from "./anchor-registry";
 import { resolveInCwd, writeAtomic, type FileIdentity } from "./fs-write";
 import { toLF, stripBOM, restoreEndings, type LineEnding } from "./normalize";
 import { genDiff, genPatch, spansFromHashes } from "./replace-diff";
@@ -200,16 +199,17 @@ export function regUndo(pi: ExtensionAPI): void {
           try {
             const store = await loadHashStore();
             const undoLines = splitLines(undo.content);
-            persistSnapshot(store, mutationTargetPath, undo.content, undo.hashes, undoLines.map((line) => contentChecksum(hashSource(line))));
+            persistSnapshot(store, mutationTargetPath, undo.content, undo.hashes, undoLines.map(lineChecksum));
             freeAnchors(mutationTargetPath);
             adoptAnchors(
               mutationTargetPath,
-              new Map(undoLines.map((line, i) => [undo.hashes[i]!, contentChecksum(hashSource(line))])),
+              new Map(undoLines.map((line, i) => [undo.hashes[i]!, lineChecksum(line)])),
             );
-            markServedScoped(
+            serveRows(
               mutationTargetPath,
-              buildServedMap(undo.hashes, undoLines, servedHashesFromDiff(undoDiff)),
-              new Set(undo.hashes),
+              undo.hashes,
+              undoLines,
+              servedHashesFromDiff(undoDiff),
             );
           } catch (error) {
             console.error("Failed to restore hash store snapshot after undo:", error);