pi-hashline-edit-pro 6.1.2 → 6.3.0

package/src/read.ts

@@ -1,6 +1,8 @@
+import { realpathSync } from "node:fs";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import {
 	createReadTool,
+	createReadToolDefinition,
 	formatSize,
 	truncateHead,
 	DEFAULT_MAX_BYTES,
@@ -11,23 +13,21 @@ import { Type } from "typebox";
 import { loadFileKindAndText } from "./file-kind";
 import { MAX_OVERSIZED_WARNING_LINES } from "./constants";
 import { readNormFile, safeSnapId } from "./file-reader";
-import { lineHashes, fmtRegion, fmtRow, HASH_SEP, MAX_HASH_LINES } from "./hashline";
+import { lineHashes, fmtRegion, fmtRow, HASH_SEP, MAX_HASH_LINES, parseHashRef, resolveAnchorLine, AnchorMismatchError } from "./hashline";
 import { toCwd } from "./paths";
-import { abortIf, makePrepareArguments, numberedRead, visLines, splitLines } from "./utils";
+import { abortIf, isRec, makePrepareArguments, numberedRead, visLines, splitLines } from "./utils";
 import { loadP, loadGuide } from "./prompts";
 import { withReadPrompts, DEFAULT_EDIT_FLAGS, type EditToolFlags } from "./edit-common";
 import { valAccess } from "./validation";
-import { readConfig } from "./config";
-import { resolveTarget } from "./fs-write";
-import { withAnchorSession, servedForPath, sessionKeyFor, formatAnchorReclaimNotice, takeReclaimedPaths } from "./anchor-registry";
+import { withAnchorSession, adoptAnchors, ownerOf, ownersDifferingOnlyByCase, formatAnchorReclaimNotice, takeReclaimedPaths } from "./anchor-registry";
 import { serveRows } from "./served";
-import { getAutoReadAllSnapshot } from "./auto-read-all-state";
+import { snapshotCache } from "./hash-store/cache";
 import { Text } from "@earendil-works/pi-tui";
 import { anchoredLine, readResultSchema, withStructuredErrors, type AnchoredLine, type ReadResult } from "./structured";
-const R_DESC = loadP("../prompts/read.md");
-const R_SNIPPET = loadP("../prompts/read-snippet.md");
+const R_DESC = loadP("../tool-prompts/read.md");
+const R_SNIPPET = loadP("../tool-prompts/read-snippet.md");
 function readGuide(): string[] {
-  return loadGuide("../prompts/read-guidelines.md");
+  return loadGuide("../tool-prompts/read-guidelines.md");
 }
 function normPosInt(
 	value: number | undefined,
@@ -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 {
@@ -196,6 +197,94 @@ export async function fmtReadPreview(
 	};
 }
 
+export function resolveReadOffset(
+	offset: number | string | undefined,
+	fileLines: string[],
+	fileHashes: string[],
+	resolvedPath: string,
+): number | undefined {
+	if (offset === undefined || typeof offset === "number") return offset;
+	if (/^\d+$/.test(offset)) return Number(offset);
+	const ref = parseHashRef(offset);
+	const owner = ownerOf(ref.hash);
+	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} 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}. Use a line number, or read ${owner.path} to use that anchor.`);
+	}
+	try {
+		return resolveAnchorLine(ref, fileLines, fileHashes, resolvedPath);
+	} catch (error) {
+		if (error instanceof AnchorMismatchError) adoptAnchors(resolvedPath, error.feedbackMap);
+		throw error;
+	}
+}
+
+const builtinReadRenderCall = createReadToolDefinition(process.cwd()).renderCall as
+	(args: unknown, theme: any, context: any) => Text;
+
+function normalizeReadCallArgs(args: unknown): unknown {
+	if (!isRec(args)) return args;
+	const normalized: Record<string, unknown> = { ...args };
+	for (const key of ["offset", "limit"]) {
+		const value = normalized[key];
+		if (typeof value === "string" && /^\d+$/.test(value)) normalized[key] = Number(value);
+	}
+	return normalized;
+}
+
+function anchorRefOf(args: unknown): { anchor: string; limit: number | undefined; path: string | undefined } | undefined {
+	if (!isRec(args)) return undefined;
+	const { offset, limit, path } = args;
+	if (typeof offset !== "string" || offset.length === 0 || /^\d+$/.test(offset)) return undefined;
+	const validLimit = typeof limit === "number" && Number.isInteger(limit) && limit >= 1 ? limit : undefined;
+	if (limit !== undefined && validLimit === undefined) return undefined;
+	return { anchor: offset, limit: validLimit, path: typeof path === "string" ? path : undefined };
+}
+
+function cachedHashes(path: string): string[] | undefined {
+	const cached = snapshotCache.get(path);
+	if (cached !== undefined) return cached.hashes;
+	try {
+		return snapshotCache.get(realpathSync(path))?.hashes;
+	} catch {
+		return undefined;
+	}
+}
+
+function anchorLineOf(anchor: string, path: string | undefined, cwd: unknown): number | undefined {
+	if (path === undefined || typeof cwd !== "string") return undefined;
+	const hashes = cachedHashes(toCwd(path, cwd));
+	if (hashes === undefined) return undefined;
+	const index = hashes.indexOf(anchor);
+	return index < 0 ? undefined : index + 1;
+}
+
+function renderReadCall(args: unknown, theme: any, context: any): Text {
+	const normalized = normalizeReadCallArgs(args);
+	const rendered = builtinReadRenderCall(normalized, theme, context);
+	const ref = anchorRefOf(normalized);
+	if (ref === undefined) return rendered;
+	const marker = `:${ref.anchor}`;
+	const text = (rendered as unknown as { text: string }).text;
+	const index = text.lastIndexOf(marker);
+	if (index < 0) return rendered;
+	const line = anchorLineOf(ref.anchor, ref.path, context?.cwd);
+	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;
+}
+
 export function regRead(pi: ExtensionAPI, flags: EditToolFlags = DEFAULT_EDIT_FLAGS): void {
   const prompted = withReadPrompts({ description: R_DESC, snippet: R_SNIPPET, guidelines: readGuide() }, flags);
   pi.registerTool({
@@ -210,20 +299,26 @@ export function regRead(pi: ExtensionAPI, flags: EditToolFlags = DEFAULT_EDIT_FL
 				description: "Path to the file to read (relative or absolute)",
 			}),
 			offset: Type.Optional(
-				Type.Integer({
-					minimum: 1,
-					description: "Line number to start reading from (1-indexed)",
-				}),
+				Type.Union([
+					Type.Integer({
+						minimum: 1,
+						description: "Line number to start reading from (1-indexed)",
+					}),
+					Type.String({
+						description: "4-char anchor of a served line to start reading from",
+					}),
+				], { description: "Line number (1-indexed) or a served anchor to start reading from" }),
 			),
 			limit: Type.Optional(
 				Type.Integer({
 					minimum: 1,
-					description: "Maximum number of lines to read",
+					description: "Maximum number of lines to read from offset",
 				}),
 			),
 		}),
 		outputSchema: readResultSchema,
 		executionMode: "sequential",
+		renderCall: renderReadCall,
 		renderResult(result, { isPartial, expanded }, theme, context) {
 			if (isPartial) return new Text((theme as unknown as { fg: (a:string,b:string)=>string }).fg("warning", "Reading..."), 0, 0);
 			const raw = (result.content?.[0] as { text?: string } | undefined)?.text;
@@ -243,22 +338,6 @@ export function regRead(pi: ExtensionAPI, flags: EditToolFlags = DEFAULT_EDIT_FL
 
 				abortIf(signal);
 				await valAccess(absolutePath, rawPath);
-                const autoReadAllMode = (await readConfig()).autoReadAll ?? "off";
-                if (autoReadAllMode !== "off") {
-                  const canonical = await resolveTarget(absolutePath).catch(() => undefined);
-                  if (canonical !== undefined) {
-                    const stored = getAutoReadAllSnapshot(sessionKeyFor(ctx), canonical);
-                    if (stored !== undefined) {
-                      const current = await safeSnapId(canonical, "auto-read-all guard");
-                      if (current !== undefined && current === stored) {
-                        const served = servedForPath(canonical);
-                        if (served !== undefined && served.size > 0) {
-                          throw new Error(`[E_AUTO_READ_ALL] ${rawPath} is unchanged since this session's start-of-session auto-read, so the attached content is still exact. Read succeeds on files that have changed since the full auto read.`);
-                        }
-                      }
-                    }
-                  }
-                }
 
 				abortIf(signal);
 				const file = await loadFileKindAndText(absolutePath, { maxLines: MAX_HASH_LINES, displayPath: rawPath });
@@ -279,12 +358,10 @@ export function regRead(pi: ExtensionAPI, flags: EditToolFlags = DEFAULT_EDIT_FL
 	        rawPath, ctx.cwd, { signal, preloadedFile: file, maxLines: MAX_HASH_LINES },
 	      );
 				const fileLines = splitLines(normalized);
+				const offset = resolveReadOffset(params.offset, fileLines, fileHashes, resolvedPath);
 				const preview = await fmtReadPreview(
 					normalized,
-					{
-						offset: params.offset,
-						limit: params.limit,
-					},
+					{ offset, limit: params.limit },
 					fileHashes,
 					resolvedPath,
 				);
@@ -315,12 +392,12 @@ export function regRead(pi: ExtensionAPI, flags: EditToolFlags = DEFAULT_EDIT_FL
 					details: {
 						truncation: preview.truncation,
 						snapshotId,
-						offset: params.offset ?? 1,
+						offset: preview.startLine,
 						...(preview.nextOffset !== undefined
 							? { nextOffset: preview.nextOffset }
 							: {}),
 						metrics: {
-							truncated: !!preview.truncation,
+							truncated: preview.truncation !== undefined,
 							...(preview.nextOffset !== undefined
 								? { next_offset: preview.nextOffset }
 								: {}),

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");
@@ -148,9 +175,9 @@ type ReplaceMatchToolDef = ToolDefinition<any, ReplaceDetails, RRState> & { rend
 
 export function buildReplaceMatchToolDef(flags: EditToolFlags = DEFAULT_EDIT_FLAGS): ReplaceMatchToolDef {
   const prompted = withReplaceMatchPrompts({
-    description: loadP("../prompts/replace-match.md"),
-    snippet: loadP("../prompts/replace-match-snippet.md"),
-    guidelines: loadGuide("../prompts/replace-match-guidelines.md"),
+    description: loadP("../tool-prompts/replace-match.md"),
+    snippet: loadP("../tool-prompts/replace-match-snippet.md"),
+    guidelines: loadGuide("../tool-prompts/replace-match-guidelines.md"),
   }, flags);
   return {
     name: "replace_match",
@@ -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

@@ -113,9 +113,9 @@ function fallbackFileMode(): number {
 
 export function regUndo(pi: ExtensionAPI, flags: EditToolFlags = DEFAULT_EDIT_FLAGS): void {
   const prompted = withUndoPrompts({
-    description: loadP("../prompts/undo-last-change.md"),
-    snippet: loadP("../prompts/undo-last-change-snippet.md"),
-    guidelines: loadGuide("../prompts/undo-last-change-guidelines.md"),
+    description: loadP("../tool-prompts/undo-last-change.md"),
+    snippet: loadP("../tool-prompts/undo-last-change-snippet.md"),
+    guidelines: loadGuide("../tool-prompts/undo-last-change-guidelines.md"),
   }, flags);
   pi.registerTool({
     name: "undo_last_change",
@@ -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);
@@ -269,9 +290,9 @@ type ToolDef = ToolDefinition<
 
 export function buildToolDef(flags: EditToolFlags = DEFAULT_EDIT_FLAGS): ToolDef {
   const prompted = withReplacePrompts({
-    description: loadP("../prompts/replace.md"),
-    snippet: loadP("../prompts/replace-snippet.md"),
-    guidelines: loadGuide("../prompts/replace-guidelines.md"),
+    description: loadP("../tool-prompts/replace.md"),
+    snippet: loadP("../tool-prompts/replace-snippet.md"),
+    guidelines: loadGuide("../tool-prompts/replace-guidelines.md"),
   }, flags);
   const parameters = buildEditToolSchema(flags.requirePath);
   return {
@@ -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

@@ -0,0 +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, 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`.

package/{prompts → tool-prompts}/read.md

@@ -1 +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.
+
+`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.

package/prompts/read-guidelines.md

@@ -1 +0,0 @@
-- `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.

package/src/auto-read-all-state.ts

@@ -1,27 +0,0 @@
-const completeSnapshots = new Map<string, Map<string, string>>();
-
-function scopeFor(sessionKey: string | undefined): string {
-  return sessionKey ?? "";
-}
-
-export function recordAutoReadAllComplete(sessionKey: string | undefined, absolutePath: string, snapshotId: string): void {
-  const scope = scopeFor(sessionKey);
-  let snapshots = completeSnapshots.get(scope);
-  if (!snapshots) {
-    snapshots = new Map();
-    completeSnapshots.set(scope, snapshots);
-  }
-  snapshots.set(absolutePath, snapshotId);
-}
-
-export function getAutoReadAllSnapshot(sessionKey: string | undefined, absolutePath: string): string | undefined {
-  return completeSnapshots.get(scopeFor(sessionKey))?.get(absolutePath);
-}
-
-export function clearAutoReadAllComplete(sessionKey: string | undefined): void {
-  completeSnapshots.delete(scopeFor(sessionKey));
-}
-
-export function clearAllAutoReadAllComplete(): void {
-  completeSnapshots.clear();
-}