pi-hashline-edit-pro 6.2.0 → 6.3.1

package/src/hash-store.ts

@@ -161,6 +161,15 @@ function openDb(storePath: string): { db: RawDb; stmts: Prepared } {
   }
 }
 
+function addColumnIfMissing(db: RawDb, statement: string): void {
+  try {
+    db.exec(statement);
+  } catch (error) {
+    if (error instanceof Error && /duplicate column/i.test(error.message)) return;
+    throw error;
+  }
+}
+
 function buildStore(db: RawDb): { db: RawDb; stmts: Prepared } {
   db.exec("PRAGMA journal_mode = WAL");
   db.exec("PRAGMA synchronous = NORMAL");
@@ -192,18 +201,10 @@ function buildStore(db: RawDb): { db: RawDb; stmts: Prepared } {
       "updated_at INTEGER NOT NULL" +
     ")"
   );
-  try {
-    db.exec("ALTER TABLE snapshots ADD COLUMN line_checksums TEXT");
-  } catch {}
-  try {
-    db.exec("ALTER TABLE undo ADD COLUMN mode INTEGER");
-  } catch {}
-  try {
-    db.exec("ALTER TABLE undo ADD COLUMN separators TEXT");
-  } catch {}
-  try {
-    db.exec("ALTER TABLE undo ADD COLUMN result_separators TEXT");
-  } catch {}
+  addColumnIfMissing(db, "ALTER TABLE snapshots ADD COLUMN line_checksums TEXT");
+  addColumnIfMissing(db, "ALTER TABLE undo ADD COLUMN mode INTEGER");
+  addColumnIfMissing(db, "ALTER TABLE undo ADD COLUMN separators TEXT");
+  addColumnIfMissing(db, "ALTER TABLE undo ADD COLUMN result_separators TEXT");
   const versionRow = db.prepare("SELECT value FROM meta WHERE key = 'version'").get() as { value?: string } | undefined;
   if (versionRow && versionRow.value !== String(HASH_STORE_VERSION)) {
     db.exec("DELETE FROM snapshots");

package/src/hashline/resolve.ts

@@ -93,7 +93,12 @@ export function fmtMismatchWithHashes(
   const out: string[] = [];
   const hashes: string[] = [];
   const servedMap = new Map<string, string>();
-  const notFound = mismatches;
+  const seen = new Set<string>();
+  const notFound = mismatches.filter((mismatch) => {
+    if (seen.has(mismatch.ref.hash)) return false;
+    seen.add(mismatch.ref.hash);
+    return true;
+  });
   if (notFound.length > 0) {
     const refList = notFound.map((m) => `"${m.ref.hash}"`).join(", ");
     out.push(
@@ -194,7 +199,13 @@ export function stripAnchorRow(
 	return match[2]!;
 }
 
-export function resEdit(edit: HTEdit | HTPayloadEdit, warnings?: string[]): HEdit {
+export type HTextInput = {
+  text: string | string[];
+  remove_from: string;
+  remove_to: string;
+};
+
+export function resEdit(edit: HTextInput, warnings?: string[]): HEdit {
 	if (typeof edit.text === "string") {
 		assertPayloadItem(edit as unknown as Record<string, unknown>);
 		return resolveParsedEdit(edit.remove_from, edit.remove_to, parsePayloadText(edit.text), warnings);

package/src/insert.ts

@@ -3,9 +3,9 @@ import { Type } from "typebox";
 import { constants } from "node:fs";
 import { execPipeline, type ReplaceDetails, previewFromPipe, previewError } from "./replace";
 import { commitEdit } from "./commit";
-import { batchMemberFor, ensureBatchBase, executeBatchMember, noteBatchFailure } from "./batch";
+import { batchMemberFor, executeBatchMember, noteBatchFailure, registerBatchPlanner, type BatchMemberPlan, type BatchPlannerInput } from "./batch";
 import { readNormFile, type NormFile } from "./file-reader";
-import { MAX_HASH_LINES, parseHashRef, parsePayloadText, resEdit, resolveAnchorLine, type Anchor, type HEdit, type HTEdit, type StripWarningLocation } from "./hashline";
+import { MAX_HASH_LINES, parseHashRef, parsePayloadText, planEdit, preserveDeletionSeparators, resEdit, resolveAnchorLine, type Anchor, type HTEdit, type StripWarningLocation } from "./hashline";
 import type { LineEnding } from "./normalize";
 import { stripAnchorRow } from "./hashline/resolve";
 import { withAnchorSession } from "./anchor-registry";
@@ -28,7 +28,7 @@ const insertDirectionSchema = Type.Union(
 );
 const insertTextSchema = Type.String({
   description:
-    'The exact text to insert; an empty string inserts one blank line. "\\n" is one blank line, and a trailing line break sets the last line\'s ending instead of adding a blank line. Never include the anchor line.',
+    'The exact text to insert; an empty string inserts one blank line. A trailing line break sets the newline of the last line written instead of adding a blank line; a lone newline writes one blank line. Never include the anchor line.',
 });
 
 const insertPathRequiredSchema = Type.String({
@@ -97,6 +97,37 @@ function insertStripWarning(anchorLine: string | undefined, direction: "before"
   return { label: "text", indexOffset: anchorLine !== undefined && direction === "after" ? -1 : 0 };
 }
 
+function planInsertBatchMember(input: BatchPlannerInput): BatchMemberPlan {
+  const req = normReq(input.member.args);
+  assertInsertReq(req);
+  const insertWarnings = literalEscapeHints([req.text], "text");
+  const { ref, warnings: anchorWarnings } = parseInsertAnchor(req.anchor);
+  const basePreload = { normalized: input.base.content, fileHashes: input.base.hashes } as NormFile;
+  const built = buildInsertEdit(req, basePreload, ref, input.displayPath);
+  const resWarnings: string[] = [];
+  const hedit = resEdit(built.editParams, resWarnings);
+  const stripWarning = insertStripWarning(built.anchorLine, req.direction);
+  const effectiveHedit = preserveDeletionSeparators(hedit, input.base.baseLines, input.base.hashes);
+  const planned = planEdit(input.base.content, effectiveHedit, input.base.hashes, {
+    filePath: input.displayPath,
+    servedHashes: input.served,
+    signal: input.signal,
+    baseFileLines: input.base.baseLines,
+    stripWarning,
+  });
+  return {
+    hedit,
+    warnings: [...anchorWarnings, ...insertWarnings, ...resWarnings],
+    planned,
+    foldedLines: built.anchorLine === undefined ? 0 : 1,
+    direction: req.direction,
+    stripWarning,
+    contentSeparators: built.contentSeparators,
+  };
+}
+
+registerBatchPlanner("insert", planInsertBatchMember);
+
 export async function insertPreview(request: unknown, cwd: string, signal?: AbortSignal): Promise<RPreview> {
   try {
     const normalized = normReq(request);
@@ -180,12 +211,13 @@ export function buildInsertToolDef(flags: EditToolFlags = DEFAULT_EDIT_FLAGS): I
         assertInsertReq(canonical);
         const req = canonical;
         const insertWarnings: string[] = [...literalEscapeHints([req.text], "text")];
+        const member = batchMemberFor(_toolCallId);
         const targetPath = await resolveEditTargetWithRequirement({
           anchor: req.anchor,
           providedPath: req.path,
           cwd: ctx.cwd,
+          anchorTarget: member?.target,
         }).catch((error: unknown) => {
-          const member = batchMemberFor(_toolCallId);
           if (member) noteBatchFailure(member, error);
           throw error;
         });
@@ -193,40 +225,14 @@ export function buildInsertToolDef(flags: EditToolFlags = DEFAULT_EDIT_FLAGS): I
         let anchorWarnings: string[];
         try {
           ({ ref, warnings: anchorWarnings } = parseInsertAnchor(req.anchor));
-          await throwIfStrictInput([...anchorWarnings, ...insertWarnings]);
+          if (member === undefined) await throwIfStrictInput([...anchorWarnings, ...insertWarnings]);
         } catch (error) {
-          const member = batchMemberFor(_toolCallId);
           if (member) noteBatchFailure(member, error);
           throw error;
         }
         return queuedEdit(targetPath, ctx.cwd, signal, async (absolutePath, mutationTargetPath) => {
-          const member = batchMemberFor(_toolCallId);
           if (member) {
-            const base = await ensureBatchBase({ member, targetPath, mutationTargetPath, cwd: ctx.cwd, signal });
-            const basePreload = { normalized: base.content, fileHashes: base.hashes } as NormFile;
-            const built = buildInsertEdit(req, basePreload, ref, targetPath);
-            let hedit: HEdit;
-            const resWarnings: string[] = [];
-            try {
-              hedit = resEdit(built.editParams, resWarnings);
-            } catch (error) {
-              noteBatchFailure(member, error);
-              throw error;
-            }
-            return executeBatchMember({
-              kind: "insert",
-              direction: req.direction,
-              member,
-              targetPath,
-              mutationTargetPath,
-              cwd: ctx.cwd,
-              signal,
-              hedit,
-              extraWarnings: [...anchorWarnings, ...insertWarnings, ...resWarnings],
-              foldedLines: built.anchorLine === undefined ? 0 : 1,
-              stripWarning: insertStripWarning(built.anchorLine, req.direction),
-              contentSeparators: built.contentSeparators,
-            });
+            return executeBatchMember({ member, targetPath, mutationTargetPath, cwd: ctx.cwd, signal });
           }
           const preload = await readNormFile(targetPath, ctx.cwd, {
             signal,

package/src/line-endings.ts

@@ -75,9 +75,18 @@ export function separatorsForSpans(
 	spans: readonly EndingSpan[],
 	resultContent: string,
 	fallback: LineEnding,
+	baseLines?: readonly string[],
 ): LineEnding[] {
+	const consumed = new Set<number>();
+	if (baseLines !== undefined && baseSeparators.length < baseLineCount) {
+		for (const span of spans) {
+			if (span.replacementCount !== 0 || span.end !== baseLineCount - 1) continue;
+			const previous = baseLines[span.start - 1];
+			if (previous !== undefined && previous.trim().length > 0) consumed.add(span.start - 1);
+		}
+	}
 	const mapped = sourceLineMap(baseLineCount, spans).map((source) =>
-		source >= 0 && source < baseSeparators.length ? baseSeparators[source]! : "",
+		source >= 0 && source < baseSeparators.length && !consumed.has(source) ? baseSeparators[source]! : "",
 	);
 	const needed = countNewlines(resultContent);
 	const result: LineEnding[] = [];

package/src/outline/index.ts

@@ -23,6 +23,7 @@ export async function buildFileOutline(input: FileOutlineInput): Promise<Outline
 			languageName: parsed.languageName,
 			totalLines: lines.length,
 			hashes: input.hashes,
+			lines,
 			symbols: parsed.symbols,
 			...(input.maxRows !== undefined ? { maxRows: input.maxRows } : {}),
 			...(input.maxDepth !== undefined ? { maxDepth: input.maxDepth } : {}),

package/src/outline/render.ts

@@ -27,6 +27,7 @@ export interface SymbolOutlineInput {
 	languageName?: string;
 	totalLines: number;
 	hashes: string[];
+	lines: string[];
 	symbols: OutlineSymbol[];
 	maxRows?: number;
 	maxDepth?: number;
@@ -62,7 +63,8 @@ function symbolLabel(symbol: OutlineSymbol, depth: number): string {
 		? ` ${symbol.detail.length > MAX_DETAIL_CHARS ? `${symbol.detail.slice(0, MAX_DETAIL_CHARS - 3)}...` : symbol.detail}`
 		: "";
 	const children = symbol.children !== undefined && symbol.children.length > 0 ? ` (${symbol.children.length} children)` : "";
-	return `${indent}${symbol.type}${name}${detail}${children} [limit ${symbol.endLine - symbol.startLine + 1}]`;
+	const span = symbol.endLine - symbol.startLine + 1;
+	return `${indent}${symbol.type}${name}${detail}${children}${span > 1 ? ` [limit ${span}]` : ""}`;
 }
 
 export function renderSymbolOutline(input: SymbolOutlineInput): OutlineRender {
@@ -92,7 +94,9 @@ export function renderSymbolOutline(input: SymbolOutlineInput): OutlineRender {
 
 	const walk = (symbols: OutlineSymbol[], depth: number): boolean => {
 		for (const symbol of symbols) {
-			if (!addRow(symbol.startLine, symbolLabel(symbol, depth))) return false;
+			const contentLine = symbol.endLine === symbol.startLine ? input.lines[symbol.startLine - 1] : undefined;
+			const text = contentLine === undefined ? symbolLabel(symbol, depth) : clipLine(contentLine, PREVIEW_LINE_CHARS);
+			if (!addRow(symbol.startLine, text)) return false;
 			const children = symbol.children ?? [];
 			if (children.length === 0) continue;
 			if (depth >= maxDepth) {

package/src/payload-contract.ts

@@ -4,7 +4,7 @@ import { TEXT_NOT_STRING_MSG, NEW_CONTENT_NOT_STRING_MSG } from "./constants";
 
 const textSchema = Type.String({
   description:
-    'The exact text to write in place of the removed range. "" deletes the range, "\\n" is one blank line, and a trailing line break sets the last line\'s ending instead of adding a blank line.',
+    'The exact text to write in place of the removed range. "" deletes the range. A trailing line break sets the newline of the last line written instead of adding a blank line; a lone newline writes one blank line.',
 });
 
 const removeFromSchema = Type.String({
@@ -234,7 +234,7 @@ const replaceMatchOldStringSchema = Type.String({
 });
 const replaceMatchNewStringSchema = Type.String({
   description:
-    'The exact replacement for every matched occurrence. "" deletes the matches, "\\n" inserts one blank line, and a trailing line break sets the last line\'s ending instead of adding a blank line; the rest of the range is kept byte-for-byte.',
+    'The exact replacement for every matched occurrence. "" deletes the matches. A trailing line break sets the newline of the last line written instead of adding a blank line; a lone newline writes one blank line; the rest of the range is kept byte-for-byte.',
 });
 const replaceMatchPathRequiredSchema = Type.String({
   description:

package/src/read.ts

@@ -49,10 +49,11 @@ export function formatPaginationHint(
 	endLine: number,
 	totalLines: number,
 	nextOffset: number,
+	lastAnchor?: string,
 	byteLimit?: number,
 ): string {
 	const sizeSuffix = byteLimit !== undefined ? ` (${formatSize(byteLimit)} limit)` : "";
-	return `[Showing lines ${startLine}-${endLine} of ${totalLines}${sizeSuffix}. Use offset=${nextOffset} to continue.]`;
+	return `[Showing lines ${startLine}-${endLine} of ${totalLines}${sizeSuffix}. Use offset=${lastAnchor ?? nextOffset} to continue.]`;
 }
 
 export async function fmtReadPreview(
@@ -147,7 +148,7 @@ export async function fmtReadPreview(
 		let nextOffset: number | undefined;
 		if (shownRowCount > 0 && (skippedTruncation.truncated || lastShownLine < totalLines)) {
 			nextOffset = lastShownLine + 1;
-			preview += `\n\n${warning}\n${formatPaginationHint(startLine, lastShownLine, totalLines, nextOffset, skippedTruncation.truncated ? skippedTruncation.maxBytes : undefined)}`;
+			preview += `\n\n${warning}\n${formatPaginationHint(startLine, lastShownLine, totalLines, nextOffset, servedHashes.at(-1), skippedTruncation.truncated ? skippedTruncation.maxBytes : undefined)}`;
 		} else {
 			preview += `\n\n${warning}`;
 		}
@@ -175,13 +176,13 @@ export async function fmtReadPreview(
 		const endLineDisplay = startLine + truncation.outputLines - 1;
 		nextOffset = endLineDisplay + 1;
 		if (truncation.truncatedBy === "lines") {
-			preview += `\n\n${formatPaginationHint(startLine, endLineDisplay, totalLines, nextOffset)}`;
+			preview += `\n\n${formatPaginationHint(startLine, endLineDisplay, totalLines, nextOffset, servedHashes.at(-1))}`;
 		} else {
-			preview += `\n\n${formatPaginationHint(startLine, endLineDisplay, totalLines, nextOffset, truncation.maxBytes)}`;
+			preview += `\n\n${formatPaginationHint(startLine, endLineDisplay, totalLines, nextOffset, servedHashes.at(-1), truncation.maxBytes)}`;
 		}
 	} else if (endIdx < totalLines) {
 		nextOffset = endIdx + 1;
-		preview += `\n\n${formatPaginationHint(startLine, endIdx, totalLines, nextOffset)}`;
+		preview += `\n\n${formatPaginationHint(startLine, endIdx, totalLines, nextOffset, servedHashes.at(-1))}`;
 	}
 
 	return {
@@ -209,10 +210,10 @@ export function resolveReadOffset(
 	if (owner === undefined) {
 		const folded = ownersDifferingOnlyByCase(ref.hash);
 		const hint = folded.length > 0 ? ` Anchors are case-sensitive; ${folded.map((match) => `"${match.anchor}"`).join(", ")} differs only in case.` : "";
-		throw new Error(`[E_STALE_ANCHOR] "${ref.hash}" is not owned in this session.${hint} Call read() on ${resolvedPath} first.`);
+		throw new Error(`[E_STALE_ANCHOR] "${ref.hash}" is not owned in this session.${hint} Use a line number, or read again for fresh anchors.`);
 	}
 	if (owner.path !== resolvedPath) {
-		throw new Error(`[E_STALE_ANCHOR] "${ref.hash}" is owned by ${owner.path}. Call read() on ${resolvedPath} for fresh anchors.`);
+		throw new Error(`[E_STALE_ANCHOR] "${ref.hash}" is owned by ${owner.path}. Use a line number, or read ${owner.path} to use that anchor.`);
 	}
 	try {
 		return resolveAnchorLine(ref, fileLines, fileHashes, resolvedPath);
@@ -272,11 +273,15 @@ function renderReadCall(args: unknown, theme: any, context: any): Text {
 	const index = text.lastIndexOf(marker);
 	if (index < 0) return rendered;
 	const line = anchorLineOf(ref.anchor, ref.path, context?.cwd);
-	if (line === undefined && ref.limit === undefined) return rendered;
-	const lineLabel = line === undefined ? "" : ` (${line})`;
-	const limitLabel = ref.limit === undefined ? "" : ` +${ref.limit}`;
-	const suffix = theme.fg("warning", `${lineLabel}${limitLabel}`);
-	rendered.setText(`${text.slice(0, index + marker.length)}${suffix}${text.slice(index + marker.length)}`);
+	if (line === undefined) {
+		if (ref.limit === undefined) return rendered;
+		const suffix = theme.fg("warning", ` +${ref.limit}`);
+		rendered.setText(`${text.slice(0, index + marker.length)}${suffix}${text.slice(index + marker.length)}`);
+		return rendered;
+	}
+	const range = ref.limit === undefined ? `${line}` : `${line}-${line + ref.limit - 1}`;
+	const replacement = theme.fg("warning", `:${range} (${ref.anchor})`);
+	rendered.setText(`${text.slice(0, index)}${replacement}${text.slice(index + marker.length)}`);
 	return rendered;
 }
 

package/src/replace-match.ts

@@ -3,9 +3,9 @@ import { constants } from "node:fs";
 import { execPipeline, noteAnchorError, previewFromPipe, previewError, type ReplaceDetails } from "./replace";
 import { commitEdit } from "./commit";
 import { readNormFile, type NormFile } from "./file-reader";
-import { fmtRegion, MAX_HASH_LINES, parseHashRef, resEdit, resolveAnchorLine, stripAnchorRow, type Anchor, type HEdit } from "./hashline";
+import { fmtRegion, MAX_HASH_LINES, parseHashRef, planEdit, preserveDeletionSeparators, resEdit, resolveAnchorLine, stripAnchorRow, type Anchor } from "./hashline";
 import { servedForPath, withAnchorSession } from "./anchor-registry";
-import { batchMemberFor, batchServedFor, ensureBatchBase, executeBatchMember, noteBatchFailure } from "./batch";
+import { batchMemberFor, executeBatchMember, noteBatchFailure, registerBatchPlanner, type BatchMemberPlan, type BatchPlannerInput } from "./batch";
 import { loadP, loadGuide } from "./prompts";
 import {
   assertReplaceMatchReq,
@@ -109,6 +109,33 @@ export function buildReplaceMatchEdit(
   };
 }
 
+function planReplaceMatchBatchMember(input: BatchPlannerInput): BatchMemberPlan {
+  const req = normReq(input.member.args, "replace");
+  assertReplaceMatchReq(req);
+  const { refs, warnings } = parseMatchAnchors(req);
+  const hints = [...literalEscapeHints([req.old_string], "old_string"), ...literalEscapeHints([req.new_string], "new_string")];
+  const preload = { normalized: input.base.content, fileHashes: input.base.hashes } as NormFile;
+  const matchPlan = buildReplaceMatchEdit(req, refs, preload, input.displayPath, input.served);
+  const resWarnings: string[] = [];
+  const hedit = resEdit(matchPlan.editParams, resWarnings);
+  const effectiveHedit = preserveDeletionSeparators(hedit, input.base.baseLines, input.base.hashes);
+  const planned = planEdit(input.base.content, effectiveHedit, input.base.hashes, {
+    filePath: input.displayPath,
+    servedHashes: matchPlan.servedOverride ?? input.served,
+    signal: input.signal,
+    baseFileLines: input.base.baseLines,
+  });
+  return {
+    hedit,
+    warnings: [...warnings, ...hints, ...resWarnings],
+    planned,
+    foldedLines: 0,
+    ...(matchPlan.servedOverride !== undefined ? { servedOverride: matchPlan.servedOverride } : {}),
+  };
+}
+
+registerBatchPlanner("replace_match", planReplaceMatchBatchMember);
+
 export async function replaceMatchPreview(request: unknown, cwd: string, signal?: AbortSignal): Promise<RPreview> {
   try {
     const normalized = normReq(request, "replace");
@@ -173,13 +200,13 @@ export function buildReplaceMatchToolDef(flags: EditToolFlags = DEFAULT_EDIT_FLA
         const normalized = normReq(params, "replace");
         assertReplaceMatchReq(normalized);
         const req = normalized;
+        const member = batchMemberFor(_toolCallId);
         let refs: MatchRefs;
         let warnings: string[];
         try {
           ({ refs, warnings } = parseMatchAnchors(req));
-          await throwIfStrictInput(warnings);
+          if (member === undefined) await throwIfStrictInput(warnings);
         } catch (error) {
-          const member = batchMemberFor(_toolCallId);
           if (member) noteBatchFailure(member, error);
           throw error;
         }
@@ -189,53 +216,27 @@ export function buildReplaceMatchToolDef(flags: EditToolFlags = DEFAULT_EDIT_FLA
           removeTo: req.replace_to,
           providedPath: req.path,
           cwd: ctx.cwd,
+          anchorTarget: member?.target,
         }).catch((error: unknown) => {
-          const member = batchMemberFor(_toolCallId);
           if (member) noteBatchFailure(member, error);
           throw error;
         });
         return queuedEdit(targetPath, ctx.cwd, signal, async (absolutePath, mutationTargetPath) => {
-          const member = batchMemberFor(_toolCallId);
-          let preload: NormFile;
           if (member) {
-            const base = await ensureBatchBase({ member, targetPath, mutationTargetPath, cwd: ctx.cwd, signal });
-            preload = { normalized: base.content, fileHashes: base.hashes } as NormFile;
-          } else {
-            preload = await readNormFile(targetPath, ctx.cwd, {
-              signal,
-              accessMode: constants.R_OK | constants.W_OK,
-              maxLines: MAX_HASH_LINES,
-            });
+            return executeBatchMember({ member, targetPath, mutationTargetPath, cwd: ctx.cwd, signal });
           }
+          const preload = await readNormFile(targetPath, ctx.cwd, {
+            signal,
+            accessMode: constants.R_OK | constants.W_OK,
+            maxLines: MAX_HASH_LINES,
+          });
           let plan: MatchPlan;
           try {
-            plan = buildReplaceMatchEdit(req, refs, preload, targetPath, member ? batchServedFor(member) : servedForPath(preload.absolutePath));
+            plan = buildReplaceMatchEdit(req, refs, preload, targetPath, servedForPath(preload.absolutePath));
           } catch (error) {
             await noteAnchorError(mutationTargetPath, error);
-            if (member) noteBatchFailure(member, error);
             throw error;
           }
-          if (member) {
-            let hedit: HEdit;
-            const resWarnings: string[] = [];
-            try {
-              hedit = resEdit(plan.editParams, resWarnings);
-            } catch (error) {
-              noteBatchFailure(member, error);
-              throw error;
-            }
-            return executeBatchMember({
-              kind: "replace_match",
-              member,
-              targetPath,
-              mutationTargetPath,
-              cwd: ctx.cwd,
-              signal,
-              hedit,
-              extraWarnings: [...warnings, ...hints, ...resWarnings],
-              ...(plan.servedOverride !== undefined ? { servedOverride: plan.servedOverride } : {}),
-            });
-          }
           const pipe = await execPipeline(targetPath, plan.editParams, ctx.cwd, {
             accessMode: constants.R_OK | constants.W_OK,
             signal,

package/src/replace-undo.ts

@@ -184,7 +184,7 @@ export function regUndo(pi: ExtensionAPI, flags: EditToolFlags = DEFAULT_EDIT_FL
           );
 
           const currentNormalized = currentRaw === undefined ? "" : toLF(stripBOM(currentRaw).text);
-          const currentHashes = await lineHashes(currentNormalized, mutationTargetPath);
+          const currentHashes = await lineHashes(currentNormalized, mutationTargetPath, undefined, undefined, false, true);
           const diffResult = genDiff(undo.content, undo.resultContent, 0, undefined, undo.hashes, { unlimited: true });
           const linesAddedByReplace = cntDiff(diffResult.diff, "+");
           const linesRemovedByReplace = cntDiff(diffResult.diff, "-");

package/src/replace.ts

@@ -16,6 +16,7 @@ import { loadP, loadGuide } from "./prompts";
 import { type FileIdentity } from "./fs-write";
 import { applyEdit,
   lineHashes,
+  planEdit,
   resEdit,
   preserveDeletionSeparators,
   MAX_HASH_LINES,
@@ -36,7 +37,7 @@ import { resolveTarget } from "./fs-write";
 import { toCwd, toDisplayPath } from "./paths";
 import { queuedEdit, editToolBase, editRenderCallWrapper, editRenderResultWrapper, resolveEditTargetWithRequirement, throwIfStrictInput, withReplacePrompts, DEFAULT_EDIT_FLAGS, type EditToolFlags } from "./edit-common";
 import { commitEdit } from "./commit";
-import { batchMemberFor, executeBatchMember, noteBatchFailure } from "./batch";
+import { batchMemberFor, executeBatchMember, noteBatchFailure, registerBatchPlanner, type BatchMemberPlan, type BatchPlannerInput } from "./batch";
 
 export { editToolSchema, type ReqParams, assertReq };
 
@@ -126,12 +127,32 @@ function countLineChanges(
 export function buildReplaceHEdit(params: RawReqParams): { edit: HEdit; warnings: string[] } {
   const editWarnings: string[] = [];
   const anchors = { remove_from: params.remove_from, remove_to: params.remove_to };
-  const edit = typeof params.text === "string"
-    ? resEdit({ ...anchors, text: params.text }, editWarnings)
-    : resEdit({ ...anchors, text: params.text }, editWarnings);
+  const edit = resEdit({ ...anchors, text: params.text }, editWarnings);
   return { edit, warnings: editWarnings };
 }
 
+function planReplaceBatchMember(input: BatchPlannerInput): BatchMemberPlan {
+  const req = normReq(input.member.args, "remove");
+  assertReq(req);
+  const literalEscapes = literalEscapeHints([req.text], "text");
+  const built = buildReplaceHEdit(req);
+  const effectiveHedit = preserveDeletionSeparators(built.edit, input.base.baseLines, input.base.hashes);
+  const planned = planEdit(input.base.content, effectiveHedit, input.base.hashes, {
+    filePath: input.displayPath,
+    servedHashes: input.served,
+    signal: input.signal,
+    baseFileLines: input.base.baseLines,
+  });
+  return {
+    hedit: built.edit,
+    warnings: [...literalEscapes, ...built.warnings],
+    planned,
+    foldedLines: 0,
+  };
+}
+
+registerBatchPlanner("replace", planReplaceBatchMember);
+
 function withEndingOverrides(edit: HEdit, overrides: (LineEnding | undefined)[] | undefined): HEdit {
   if (overrides === undefined) return edit;
   const length = Math.max(edit.content_separators?.length ?? 0, overrides.length);
@@ -292,18 +313,18 @@ export function buildToolDef(flags: EditToolFlags = DEFAULT_EDIT_FLAGS): ToolDef
         assertReq(canonical);
         const normalizedParams = canonical;
         const literalEscapes = literalEscapeHints([normalizedParams.text], "text");
+        const member = batchMemberFor(_toolCallId);
         const targetPath = await resolveEditTargetWithRequirement({
           removeFrom: normalizedParams.remove_from,
           removeTo: normalizedParams.remove_to,
           providedPath: normalizedParams.path,
           cwd: ctx.cwd,
+          anchorTarget: member?.target,
         }).catch((error: unknown) => {
-          const member = batchMemberFor(_toolCallId);
           if (member) noteBatchFailure(member, error);
           throw error;
         });
         return queuedEdit(targetPath, ctx.cwd, signal, async (absolutePath, mutationTargetPath) => {
-          const member = batchMemberFor(_toolCallId);
           if (!member) {
             const pipe = await execPipeline(
               targetPath,
@@ -320,22 +341,12 @@ export function buildToolDef(flags: EditToolFlags = DEFAULT_EDIT_FLAGS): ToolDef
               signal,
             });
           }
-          let built: { edit: HEdit; warnings: string[] };
-          try {
-            built = buildReplaceHEdit(normalizedParams);
-          } catch (error) {
-            noteBatchFailure(member, error);
-            throw error;
-          }
           return executeBatchMember({
-            kind: "replace",
             member,
             targetPath,
             mutationTargetPath,
             cwd: ctx.cwd,
             signal,
-            hedit: built.edit,
-            extraWarnings: [...literalEscapes, ...built.warnings],
           });
         });
       }));

package/tool-prompts/copy.md

@@ -1,3 +1,3 @@
 Copy a range of lines to another position, targeted by 4-character anchors from any served anchor│content row. Give `source_from` and `source_to` as bare anchors marking the first and last line to copy in the source file, and `insert_after` as the bare anchor of the destination line after which the copy goes. The source lines stay in place, and the copied lines are written exactly as the source file holds them.
 
-A cross-file copy joins the destination file's batch. A copy always duplicates the content its source anchors were served from, so a same-message edit to the source file does not change what is copied.
+A copy always duplicates the content its source anchors were served from, so a same-message edit to the source file does not change what is copied.

package/tool-prompts/grep.md

@@ -1 +1 @@
-Search text files with ripgrep. Hits and context lines come back as `lineNumber │ anchor│content` rows, editable with replace, insert, copy, or move without a new read; the `=== path ===` header and line numbers locate the match. Patterns are regex by default; set `literal: true` to search exact text, `ignoreCase` for case-insensitive search, and `context` for surrounding rows. Avoid backreferences, nested quantifiers, and quantified alternation. Searches respect `.gitignore`, always skip `.git`, and skip binary and image files silently. A match over 500 bytes is shown as a `...` fragment around the hit, but its anchor still covers the whole line. When cut by match limit, raise `limit` (default 100); when cut by rows/bytes, refine `pattern` / narrow path.
+Search text files with ripgrep. Hits and context lines come back as `lineNumber │ anchor│content` rows, editable with replace, insert, copy, or move without a new read; the `=== path ===` header and line numbers locate the match. Patterns are regex by default; set `literal: true` to search exact text, `ignoreCase` for case-insensitive search, and `context` for surrounding rows. Backreferences and look-around are rejected by ripgrep's engine; nested quantifiers and alternation run in linear time. Searches respect `.gitignore`, always skip `.git`, and skip binary and image files silently. A match over 500 bytes is shown as a `...` fragment around the hit, but its anchor still covers the whole line. When cut by match limit, raise `limit` (default 100); when cut by rows/bytes, refine `pattern` / narrow path.

package/tool-prompts/insert-guidelines.md

@@ -1 +1 @@
-- `insert`: compare both edges of the inserted block in the post-edit diff against the request; a missing or extra `+anchor│` blank row at either boundary is the classic insert slip.
+- `insert`: a missing or extra `+anchor│` blank row at either block edge in the diff is the classic insert slip.

package/tool-prompts/insert.md

@@ -1 +1 @@
-Insert text after or before one existing line in a text file, addressed by the `anchor` field (a bare anchor from any served anchor│content row). `text` goes after the anchor line with `direction: "after"` or before it with `direction: "before"`. `text` is one string holding the exact text to insert. A trailing line break sets the last line's ending instead of adding a blank line, so a blank line next to the anchor line must be an extra break in `text`: `"x\n"` leaves the anchor line directly after `x`, and `"x\n\n"` leaves one blank line between them (`direction: "after"` mirrors this at the start of `text`).
+Insert text after or before one existing line in a text file, addressed by the `anchor` field (a bare anchor from any served anchor│content row). `text` goes after the anchor line with `direction: "after"` or before it with `direction: "before"`. `text` is one string holding the exact text to insert; a trailing line break sets the newline of the last line written instead of adding a blank line, and a leading break is an ordinary blank line.

package/tool-prompts/move.md

@@ -1,3 +1,3 @@
-Move a range of lines to another position, targeted by 4-character anchors from any served anchor│content row. Give `source_from` and `source_to` as bare anchors marking the first and last line to move in the source file, and `insert_after` as the bare anchor of the destination line after which the range goes. `insert_after` must sit outside the source range when both anchors share a file; moving a range in one file to where it already sits reports no change.
+Move a range of lines to another position, targeted by 4-character anchors from any served anchor│content row. Give `source_from` and `source_to` as bare anchors marking the first and last line to move in the source file, and `insert_after` as the bare anchor of the destination line after which the range goes. `insert_after` must sit outside the source range when both anchors share a file.
 
-A cross-file `move` whose source file also has batched edits in the message commits on its own. A batched cross-file `move` commits its source removal with the batch but shows only the destination diff; read the source file for fresh anchors.
+A cross-file `move` commits on its own when its source file also has batched edits in the message.

package/tool-prompts/read-guidelines.md

@@ -1,3 +1,3 @@
 - `read`: call again after an edit when you need anchors you lack — post-edit diff `+anchor│`/` anchor│` rows and any served `anchor│content` rows already carry fresh anchors for the changed range.
-- `read`: pass a served anchor as `offset` with `limit` to read from it without line-number math; an outline row's `[limit N]` is the span to request.
-- `read`: an outline row shows a symbol label, not the file line; edit by anchor, and read the anchor (or copy `old_string` from a served row) before `replace_match`.
+- `read`: an auto-read-all outline row shows a symbol label, or the line content for a single-line symbol; its `[limit N]` is the span to request.
+- `read`: `replace_match` needs both boundary lines served; copy `old_string` from a served row or read the lines first.

package/tool-prompts/read.md

@@ -1,3 +1,3 @@
-Read a text file and return it as `anchor│content` rows, one per line: a 4-character anchor (letters only, case-sensitive), the `│` separator, then the line content. Target lines in edits by anchor, never by content or line number. Page long files with `offset` and `limit`; when the output says truncated, continue with the hinted `offset/limit`. Images attach visually; binary, directory, and UTF-16/UTF-32 text are rejected; an empty file returns one empty row you can replace to seed content.
+Read a text file and return it as `anchor│content` rows, one per line: a 4-character anchor (letters only, case-sensitive), the `│` separator, then the line content. Target edits by anchor, never by content or line number. Page long files with `offset` and `limit`; when the output says truncated, continue from the hinted `offset`. Images attach visually; binary, directory, and UTF-16/UTF-32 text are rejected; an empty file returns one empty row you can replace to seed content.
 
-`offset` takes a 1-indexed line number or a served anchor; with an anchor, `limit` counts the lines to return after it. A stale anchor is refused with the current context rows and fresh anchors.
+`offset` takes a 1-indexed line number or a served anchor; with an anchor, `limit` counts the lines to return after it, so no line-number math is needed. A stale anchor is refused with the current context rows and fresh anchors.

package/tool-prompts/transfer-guidelines.md

@@ -1,4 +1,4 @@
-- `copy`/`move`: for a block transfer, only the source's two boundary rows and the destination line need serving; the interior transfers verbatim and the block lands in one commit. To append at the end, use the destination's last served line as `insert_after`.
+- `copy`/`move`: for a block transfer, only the source's two boundary rows and the destination line need serving; to append at the end, use the destination's last served line as `insert_after`.
 - `copy`/`move`: `insert_after` must sit outside the source range; `source_to` places the block right after itself.
 - `copy`/`move`: `source_from` and `source_to` may live in a different file than `insert_after`; an empty destination file is seeded with the copied or moved lines.
 - `move`: a batched cross-file move does not display the source file's diff; its removal commits with the batch, and the source file needs a read for fresh anchors.

package/tool-prompts/undo-last-change-guidelines.md

@@ -1,3 +1,3 @@
 - `undo_last_change`: history is one slot per file, not a stack; a second undo returns `E_UNDO_NONE`.
-- `undo_last_change`: a `write` clears the history, so undo right after a bad diff — review the diff's `-anchor│` rows first to confirm what you're restoring.
+- `undo_last_change`: a `write` clears the history, so undo before any other edit or write; the undo diff's `+anchor│` rows are the restored lines.
 - `undo_last_change`: a cross-file `move` records one undo entry per file; undo both the source and the destination to revert the whole move, because undoing one side alone leaves the moved lines duplicated or missing.