pi-hashline-edit-pro 6.2.0 → 6.3.0

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";
@@ -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/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/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`: 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, and a row without one is a single line shown as its content.
+- `read`: an outline row shows a symbol label, or the line content for a single-line symbol; edit by anchor, and read the anchor (or copy `old_string` from a served row) before `replace_match`.