pi-hashline-edit-pro 6.4.2 → 6.4.4

package/README.md

@@ -159,7 +159,7 @@ The extension registers eight tools: `read`, `replace`, `replace_match`, `insert
 
 ### read
 
-`read` returns a text file with every line prefixed by `anchor│content`. The anchor is the line's address. `offset` accepts a 1-indexed line number or a served anchor; with an anchor, `limit` counts the lines to return after it. Anchor offsets are stable across edits and return the same editable rows.
+`read` returns a text file with every line prefixed by `anchor│content`. The anchor is the line's address. `offset` accepts a 1-indexed line number or a served anchor; with an anchor, `limit` counts the lines to return starting at that anchor row. Anchor offsets are stable across edits and return the same editable rows.
 
 | Parameter | Description |
 | --- | --- |
@@ -207,7 +207,7 @@ A deletion keeps blank lines at the edges of the removed range, so the separator
 
 The extension checks the request before any file I/O, so a bad request never touches the file.
 
-Auto-fixable slips fall into two groups. Fixed silently: a reversed range, embedded newlines, and a legacy array payload (a single-element array that holds stringified array text, even with a trailing JS method call, for example `[…].map(s => s)`, is unwrapped). Fixed with a warning: a leftover `anchor│` prefix in `text` or the anchor fields (a prefix of 4 to 5 letters before `│`, for example `abde│`), and diff-preview rows pasted into the replacement.
+Auto-fixable slips fall into two groups. Fixed silently: embedded newlines and a legacy array payload (a single-element array that holds stringified array text, even with a trailing JS method call, for example `[…].map(s => s)`, is unwrapped). Fixed with a warning or a hint: a reversed `remove_from`/`remove_to` range is applied in document order with an `[H_RANGE_REVERSED]` hint; a leftover `anchor│` prefix in `text` or the anchor fields (a prefix of 4 to 5 letters before `│`, for example `abde│`) and diff-preview rows pasted into the replacement are stripped with a warning.
 
 Content containing a NUL byte (`U+0000`) is rejected with `[E_BAD_SHAPE]` before any file I/O: writing it would make the file binary, so use an empty replacement to delete. This applies to the `text` field of both `replace` and `insert`.
 
@@ -219,13 +219,13 @@ After a successful edit, the diff is capped at 50KB. A row over 50KB is shown as
 
 ### replace_match
 
-`replace_match` changes part of a line (or a range of lines) without retyping the rest. `replace_from` and `replace_to` are bare anchors marking the first and last line of the range; use the same anchor for a single line. `old_string` is the exact text to find inside that range, and `new_string` replaces every occurrence of it; every other character stays untouched. Send `old_string` as only the fragment that changes — never include text that `new_string` leaves unchanged — and use `replace` with the same anchors when the change covers whole lines or the whole range. That makes it the tool for a change the request quotes as a substring: a whole-line `replace` has to reproduce the rest of the line, so a slipped character becomes a wrong byte, while `replace_match` leaves everything the request did not name untouched. It is enabled by default; turn Replace match off in `/hashline-config` to remove the tool.
+`replace_match` changes part of a line (or a range of lines) without retyping the rest. `replace_from` and `replace_to` are bare anchors marking the first and last line of the range; use the same anchor for a single line. `old_string` is the exact text to find inside that range, and `new_string` replaces every occurrence of it; every other character stays untouched. Send `old_string` as only the fragment that changes — never include text that `new_string` leaves unchanged — and use `replace` with the same anchors when the change covers whole lines or the whole range; if `old_string` is everything on the line except indentation and trailing punctuation, that is a whole-line change. That makes it the tool for a change the request quotes as a substring: a whole-line `replace` has to reproduce the rest of the line, so a slipped character becomes a wrong byte, while `replace_match` leaves everything the request did not name untouched. It is enabled by default; turn Replace match off in `/hashline-config` to remove the tool.
 
 `remove_from` and `remove_to` are accepted as aliases for `replace_from` and `replace_to`.
 
 `old_string` is matched against the range's text (LF line breaks, no final terminator) and every non-overlapping occurrence is replaced, left to right. A missing match is refused with `[E_SUBSTRING_NOT_FOUND]` and the current `anchor│content` rows, so the retry needs no `read`. The two boundary anchors are verified against what was last shown; lines strictly inside the range are matched against the file as it currently stands on disk.
 
-`replace_match` reports `[W_REPLACE_MATCH_WHOLE_RANGE]` when `old_string` is the entire selected range, `[W_REPLACE_MATCH_RETYPE]` when `old_string` retypes a long run of text that `new_string` leaves unchanged, and `[W_REPLACE_MATCH_MULTI]` when `old_string` matched more than one occurrence. In strict-input mode the first two are refused with `[E_BAD_SHAPE]`.
+`replace_match` reports `[W_REPLACE_MATCH_WHOLE_RANGE]` when `old_string` is the entire selected range, and `[W_REPLACE_MATCH_RETYPE]` when `old_string` retypes a long run of text that `new_string` leaves unchanged. Both are refused in strict-input mode with `[E_BAD_SHAPE]`.
 
 In a same-message batch it joins the other calls on its file: the batch validates everything against the pre-batch state and commits once, with one undo. A missing `old_string` fails that call on its own and is left out of the batch; the rest of the batch still commits. The post-edit diff carries fresh anchors, and the edit is undoable with `undo_last_change`.
 
@@ -465,7 +465,6 @@ Full reference:
 | `[W_BARE_HASH_PREFIX]` | A `text` line starts with an `anchor│` prefix. The prefix is stripped automatically with a warning. |
 | `[W_REPLACE_MATCH_WHOLE_RANGE]` | `replace_match` `old_string` is the entire selected range. The anchors already identify it; use `replace` with the same anchors, or send only the changed fragment. Refused in strict-input mode. |
 | `[W_REPLACE_MATCH_RETYPE]` | `replace_match` `old_string` retypes a long run of text that `new_string` leaves unchanged. Send only the fragment that changes; refused in strict-input mode. |
-| `[W_REPLACE_MATCH_MULTI]` | `replace_match` `old_string` matched more than one occurrence in the range and every one was replaced. Narrow the range or send a longer fragment if you meant only one. |
 | `[W_ANCHOR_RECLAIMED]` | The session's anchor quota was exhausted, so all anchors of the listed files (the least recently read or edited) were freed to make room. Read those files again before editing them. |
 | `[H_LITERAL_ESCAPE]` | A payload field contains literal escaped text such as `\uXXXX`, `\n`, `\t`, `\r`, or `\"` (one hint per distinct escape, up to three). The file receives those backslash characters as written, because escapes in the tool call are decoded once when the call is parsed (`\uXXXX` → the character), so a doubled escape (`\\uXXXX`) lands literally. The hint is one line: `text: "\u200b" written as literal text (Kq3f│ col 31); resend with U+200B if unintended.` names the field, the escape, and up to three affected anchors with their columns, then the fix; when more than three rows carry it, it gives `on 10 rows; undo_last_change + resend with U+200B if unintended.` instead of the anchor list. |
 | `[H_UNICODE_LOST]` | The new text is missing an invisible or look-alike character (for example `U+200B`, `U+2060`, `U+00A0`, or a smart quote) that a replaced row has, or that a context row sharing a long run with an inserted line has. The edit applied as sent; the one-line hint names the character, its column, and the reference anchor, for example `[H_UNICODE_LOST] U+2060 missing at col 31; Kq3f│ has it; resend with U+2060 if unintended.` When another look-alike character (including `U+FFFD`) takes its place, the hint reports the substitute with `[H_UNICODE_SWAPPED]` wording. |
@@ -474,6 +473,7 @@ Full reference:
 | `[H_INDENT_MISMATCH]` | The new line has fewer leading whitespace characters than a structurally similar row (a reference row near the anchor line for an insert, or the replaced line). The edit applied as sent; the one-line hint names both counts and the reference anchor, for example `[H_INDENT_MISMATCH] new line has 0 leading whitespace characters; Kq3f│ has 2.` Copied or moved blocks are not checked, because their indentation comes from the source lines. |
 | `[H_SEPARATOR_MOVED]` | An insert landed its text directly against the anchor line, and the blank line that separated the anchor from its neighbor was displaced to the other side of the inserted text. The edit applied as sent; the one-line hint names the anchor and which side lost the blank line, for example `[H_SEPARATOR_MOVED] blank separator above Kq3f│ was displaced; add a blank line before Kq3f│ if unintended.` |
 | `[H_SEPARATOR_LOST]` | A pure deletion removed a run of blank lines that sat between two content lines. The edit applied as sent; the one-line hint names the two surviving anchors and the removed count, for example `[H_SEPARATOR_LOST] deletion removed 2 blank lines between Aaaa│ and Dddd│.` |
+| `[H_RANGE_REVERSED]` | The `remove_from` anchor resolved to a line after `remove_to`. The call applied the range in document order; the one-line hint names the line range used. |
 | `[E_NOT_FOUND]` | The path does not exist. |
 | `[E_ACCESS]` | The file is not readable or writable. |
 | `[E_NOT_TEXT]` | The path is a directory, binary file, image, or UTF-16/UTF-32 encoded text; hashline editing only supports text files. |

package/index.ts

@@ -33,7 +33,7 @@ import {
   setDisableOnModelsFromText,
 } from "./src/config";
 import { loadHashStore, pruneMissing } from "./src/hash-store";
-import { initRegistry, gcRegistrySidecars, clearRegistry, freeAnchors, sessionKeyFor, withAnchorSession, releaseRegistrySession, formatAnchorReclaimNotice, takeReclaimedPaths } from "./src/anchor-registry";
+import { type AnchorSessionContext, initRegistry, gcRegistrySidecars, clearRegistry, freeAnchors, freeAnchorsForPaths, sessionKeyFor, withAnchorSession, releaseRegistrySession, formatAnchorReclaimNotice, takeReclaimedPaths } from "./src/anchor-registry";
 import { serveRows } from "./src/served";
 import { finalizeTurn, planAssistantMessage } from "./src/batch";
 import { currentEditFlags } from "./src/edit-common";
@@ -72,6 +72,7 @@ export default function (pi: ExtensionAPI): void {
   let grepFlavorCwd: string | undefined;
   const baseAnchorTools = new Set<string>();
   let gateApplied = false;
+  const pendingRegistrySessionKeys: Array<string | undefined> = [];
 
   async function refreshEditTools(): Promise<void> {
     try {
@@ -144,7 +145,12 @@ export default function (pi: ExtensionAPI): void {
     pi.setActiveTools([...new Set([...base, ...enabled])]);
   }
 
-  pi.on("session_start", async (_event, ctx) => withAnchorSession(ctx, async () => {
+  async function withRegistrySession<T>(ctx: AnchorSessionContext | undefined, fn: () => Promise<T> | T): Promise<T> {
+    pendingRegistrySessionKeys.push(sessionKeyFor(ctx));
+    return withAnchorSession(ctx, fn);
+  }
+
+  pi.on("session_start", async (_event, ctx) => withRegistrySession(ctx, async () => {
     const active = pi.getActiveTools();
     baseAnchorTools.clear();
     for (const tool of ANCHOR_TOOL_NAMES) {
@@ -154,8 +160,7 @@ export default function (pi: ExtensionAPI): void {
     await initHasher();
     loadHashStore()
       .then(async store => {
-        const missing = await pruneMissing(store);
-        for (const path of missing) freeAnchors(path);
+        freeAnchorsForPaths(await pruneMissing(store));
       })
       .catch(err => {
         console.error("Failed to load hash store:", err);
@@ -192,9 +197,9 @@ export default function (pi: ExtensionAPI): void {
     }
   }));
 
-  pi.on("session_shutdown", async (_event, ctx) => {
+  pi.on("session_shutdown", async () => {
     try {
-      const key = sessionKeyFor(ctx);
+      const key = pendingRegistrySessionKeys.shift();
       if (key !== undefined) releaseRegistrySession(key);
     } catch (error) {
       console.error("Failed to release anchor registry session:", error);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hashline-edit-pro",
-  "version": "6.4.2",
+  "version": "6.4.4",
   "type": "module",
   "description": "Hash-anchored read/replace/insert/grep tools for pi-coding-agent. Every line gets a unique 4-char tokenizer-friendly anchor that stays stable across edits; stale or ambiguous anchors are rejected, never fuzzy-matched. Undo persists across restarts.",
   "main": "index.ts",

package/src/anchor-registry.ts

@@ -512,7 +512,7 @@ function hasOwnedPath(state: SessionState, path: string): boolean {
 
 function evictPath(state: SessionState, path: string): string[] {
 	const anchors: string[] = [];
-	for (const [anchor, entry] of [...state.owned]) {
+	for (const [anchor, entry] of state.owned) {
 		if (entry.path === path) {
 			anchors.push(anchor);
 			state.owned.delete(anchor);
@@ -617,6 +617,28 @@ export function freeAnchors(path: string, anchors?: string[]): void {
 	}
 }
 
+export function freeAnchorsForPaths(paths: Iterable<string>): void {
+	const state = current();
+	if (!state) return;
+	const targets = new Set(paths);
+	if (targets.size === 0) return;
+	const freedByPath = new Map<string, string[]>();
+	for (const [anchor, entry] of state.owned) {
+		if (!targets.has(entry.path)) continue;
+		state.owned.delete(anchor);
+		const freed = freedByPath.get(entry.path);
+		if (freed === undefined) freedByPath.set(entry.path, [anchor]);
+		else freed.push(anchor);
+	}
+	for (const path of targets) {
+		state.served.delete(path);
+		state.lastUsedAt.delete(path);
+	}
+	for (const [path, anchors] of freedByPath) {
+		appendEvent({ kind: "free", path, anchors });
+	}
+}
+
 export function clearRegistry(): void {
 	const state = current();
 	if (!state) return;

package/src/edit-common.ts

@@ -47,7 +47,7 @@ export async function currentEditFlags(codemode = false): Promise<EditToolFlags>
 
 function preferenceGuideline(flags: EditToolFlags): string {
   const tools = gatedEditOps(["read", "replace", "replace_match", "insert", "copy", "move", "undo_last_change"], flags);
-  return `Prefer the hashline tools for every file read and edit: ${joinOps(tools, { backtick: true })}.`;
+  return `Remember to use the hashline tools for every file read and edit: ${joinOps(tools, { backtick: true })}.`;
 }
 
 const SHARED_EDIT_OPS = ["replace", "replace_match", "insert", "copy", "move"];

package/src/hash-store.ts

@@ -128,7 +128,7 @@ function requireEngine(): EngineSelection {
 interface Prepared {
   get: (...params: SqlParams) => Record<string, unknown> | undefined;
   getState: (...params: SqlParams) => Record<string, unknown> | undefined;
-  allPaths: (...params: SqlParams) => Record<string, unknown>[];
+  snapshotPaths: (...params: SqlParams) => Record<string, unknown>[];
   deleteOne: (...params: SqlParams) => void;
   upsert: (...params: SqlParams) => void;
   undoUpsert: (...params: SqlParams) => void;
@@ -226,7 +226,7 @@ function buildStore(db: RawDb): { db: RawDb; stmts: Prepared } {
   ).run(String(HASH_STORE_VERSION));
   const getStmt = db.prepare("SELECT hashes FROM snapshots WHERE path = ? AND checksum = ? AND line_count = ?");
   const getStateStmt = db.prepare("SELECT checksum, hashes, line_checksums FROM snapshots WHERE path = ?");
-  const allStmt = db.prepare("SELECT path FROM snapshots UNION SELECT path FROM undo");
+  const snapshotPathsStmt = db.prepare("SELECT path FROM snapshots");
   const delStmt = db.prepare("DELETE FROM snapshots WHERE path = ?");
   const upsertStmt = db.prepare(
     "INSERT INTO snapshots (path, checksum, line_count, hashes, line_checksums, updated_at) VALUES (?, ?, ?, ?, ?, ?) " +
@@ -245,7 +245,7 @@ function buildStore(db: RawDb): { db: RawDb; stmts: Prepared } {
   const stmts: Prepared = {
     get: (...params) => getStmt.get(...params) as Record<string, unknown> | undefined,
     getState: (...params) => getStateStmt.get(...params) as Record<string, unknown> | undefined,
-    allPaths: (...params) => withBusyRetry(() => allStmt.all(...params) as Record<string, unknown>[]),
+    snapshotPaths: (...params) => withBusyRetry(() => snapshotPathsStmt.all(...params) as Record<string, unknown>[]),
     deleteOne: retriedWrite(delStmt),
     upsert: retriedWrite(upsertStmt),
     undoUpsert: retriedWrite(undoUpsertStmt),
@@ -640,7 +640,7 @@ async function statMissing(rows: { path: string }[]): Promise<string[]> {
 }
 
 export async function pruneMissing(store: HashStore): Promise<string[]> {
-  const rows = store.stmts.allPaths() as { path: string }[];
+  const rows = store.stmts.snapshotPaths() as { path: string }[];
   const missing = await statMissing(rows);
   if (missing.length === 0) return [];
   withStore(() => {

package/src/hashline/apply.ts

@@ -166,7 +166,7 @@ export function planEdit(
   const fileHashes = precomputedHashes;
   const warnings: string[] = [];
 
-  const rangeFixed = swapReversedRanges(edit, fileHashes);
+  const rangeFixed = swapReversedRanges(edit, fileHashes, warnings);
   const prefixFixed = stripDiffPrefixes(
     stripBarePrefixes(rangeFixed, warnings, options?.stripWarning),
     warnings,

package/src/hashline/resolve.ts

@@ -265,6 +265,7 @@ export function stripDiffPrefixes(edit: HEdit, warnings: string[], location: Str
 export function swapReversedRanges(
 	edit: HEdit,
 	fileHashes: string[],
+	warnings?: string[],
 ): HEdit {
 	const lineByHash = new Map<string, number>();
 	for (let i = 0; i < fileHashes.length; i++) {
@@ -280,6 +281,7 @@ export function swapReversedRanges(
 	) {
 		return edit;
 	}
+	warnings?.push(`[H_RANGE_REVERSED] "remove_from" refers to line ${startLine} after "remove_to" (line ${endLine}); lines ${endLine}-${startLine} were replaced in document order.`);
 	return { ...edit, hash_bounds: [endRef, startRef] as [Anchor, Anchor] };
 }
 

package/src/payload-contract.ts

@@ -234,7 +234,7 @@ const replaceMatchToSchema = Type.String({
 });
 const replaceMatchOldStringSchema = Type.String({
   description:
-    "The exact text to find inside the selected line(s), copied from the served row: only the fragment that changes, never text that `new_string` leaves unchanged. Every occurrence inside the range is replaced; the text around each match is left untouched. Matching uses LF line breaks and excludes the last line's terminator. For a whole-line or whole-range rewrite use `replace` with the same anchors.",
+    "The exact text to find inside the selected line(s), copied from the served row: only the fragment that changes, never text that `new_string` leaves unchanged. If `old_string` is everything on the line except indentation and trailing punctuation, that is a whole-line match: use `replace` instead. Every occurrence inside the range is replaced; the text around each match is left untouched. Matching uses LF line breaks and excludes the last line's terminator.",
 });
 const replaceMatchNewStringSchema = Type.String({
   description:

package/src/replace-match.ts

@@ -4,7 +4,7 @@ import * as Diff from "diff";
 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, planEdit, preserveDeletionSeparators, resEdit, resolveAnchorLine, stripAnchorRow, type Anchor } from "./hashline";
+import { fmtRegion, MAX_HASH_LINES, parseHashRef, parsePayloadText, planEdit, preserveDeletionSeparators, resEdit, resolveAnchorLine, stripAnchorRow, type Anchor } from "./hashline";
 import { servedForPath, withAnchorSession } from "./anchor-registry";
 import { batchMemberFor, executeBatchMember, noteBatchFailure, registerBatchPlanner, type BatchMemberPlan, type BatchPlannerInput } from "./batch";
 import { loadP, loadGuidelines } from "./prompts";
@@ -16,9 +16,9 @@ import {
   type ReplaceMatchReq,
 } from "./payload-contract";
 import { literalEscapeHints, makePrepareArguments, splitLines } from "./utils";
-import { toLF } from "./normalize";
+import { toLF, type LineEnding } from "./normalize";
 import { isFidelitySensitiveChar } from "./edit-fidelity";
-import { countNewlines } from "./line-endings";
+import { countNewlines, splitWithEndings } from "./line-endings";
 import { MAX_RANGE_STALE_LINES } from "./constants";
 import {
   assertBoundaryLinesServed,
@@ -44,6 +44,7 @@ interface MatchRefs {
 export interface MatchPlan {
   editParams: { remove_from: string; remove_to: string; text: string };
   warnings: string[];
+  contentSeparators: (LineEnding | undefined)[];
   servedOverride?: ReadonlyMap<string, string>;
 }
 
@@ -51,18 +52,46 @@ function formatMatchRange(start: number, end: number): string {
   return start === end ? `line ${start}` : `lines ${start}-${end}`;
 }
 
-function replaceAllOccurrences(text: string, oldText: string, newText: string): { text: string; count: number } {
-  let out = "";
+function replaceAllOccurrences(
+  text: string,
+  oldText: string,
+  newText: string,
+): { text: string; separators: (LineEnding | undefined)[]; count: number } {
+  const parts: string[] = [];
+  const inserted: Array<{ start: number; end: number }> = [];
+  let length = 0;
+  const append = (chunk: string, fromNewText: boolean): void => {
+    if (fromNewText) inserted.push({ start: length, end: length + chunk.length });
+    parts.push(chunk);
+    length += chunk.length;
+  };
   let cursor = 0;
   let count = 0;
   for (;;) {
     const found = text.indexOf(oldText, cursor);
     if (found < 0) break;
-    out += text.slice(cursor, found) + newText;
+    append(text.slice(cursor, found), false);
+    append(newText, true);
     cursor = found + oldText.length;
     count += 1;
   }
-  return count === 0 ? { text, count: 0 } : { text: out + text.slice(cursor), count };
+  if (count === 0) return { text, separators: [], count: 0 };
+  append(text.slice(cursor), false);
+  const replacement = parts.join("");
+  const parsed = splitWithEndings(replacement);
+  const separators: (LineEnding | undefined)[] = [];
+  let offset = 0;
+  let insertedIndex = 0;
+  for (let index = 0; index < parsed.lines.length; index++) {
+    offset += parsed.lines[index]!.length;
+    const ending = parsed.endings[index];
+    if (ending === undefined) continue;
+    while (insertedIndex < inserted.length && inserted[insertedIndex]!.end <= offset) insertedIndex += 1;
+    const fromNewText = insertedIndex < inserted.length && offset >= inserted[insertedIndex]!.start && offset < inserted[insertedIndex]!.end;
+    separators.push(fromNewText ? ending : undefined);
+    offset += ending.length;
+  }
+  return { text: replacement, separators, count };
 }
 
 const RETYPE_DIFF_MAX_CHARS = 20_000;
@@ -150,10 +179,6 @@ function wholeRangeWarning(oldText: string, rangeText: string, lineCount: number
   return `[W_REPLACE_MATCH_WHOLE_RANGE] "old_string" is the entire selected range (${formatMatchRange(start, end)}); the anchors already identify it. Use replace with remove_from "${startHash}", remove_to "${endHash}" and the new text, or send only the fragment that changes.`;
 }
 
-function multiMatchWarning(count: number, start: number, end: number, displayPath: string): string {
-  return `[W_REPLACE_MATCH_MULTI] "old_string" matched ${count} occurrences in ${formatMatchRange(start, end)} of ${displayPath}; every one was replaced. Narrow the range or send a longer fragment if you meant only one.`;
-}
-
 function describeChar(char: string | undefined): string {
   if (char === undefined) return "the end of the text";
   const codePoint = char.codePointAt(0)!;
@@ -210,10 +235,11 @@ export function buildReplaceMatchEdit(
   const rangeText = `${rangeLines.join("\n")}${rangeLines[rangeLines.length - 1] === "" ? "\n" : ""}`;
   const oldText = toLF(req.old_string);
   const newText = toLF(req.new_string);
-  const { text: replacement, count } = replaceAllOccurrences(rangeText, oldText, req.new_string);
+  const { text: replacement, separators: replacementSeparators, count } = replaceAllOccurrences(rangeText, oldText, req.new_string);
   if (count === 0) {
     throw new Error(notFoundMessage(displayPath, start, end, preload.fileHashes, fileLines, rangeText, oldText));
   }
+  const contentSeparators = parsePayloadText(replacement).lines.map((_, index) => replacementSeparators[index]);
   const startRef = fromLine <= toLine ? refs.from : refs.to;
   const endRef = fromLine <= toLine ? refs.to : refs.from;
   const servedOverride = trustRangeServed(fileLines, preload.fileHashes, served, start, end);
@@ -225,7 +251,6 @@ export function buildReplaceMatchEdit(
     const wholeRange = wholeRangeWarning(oldText, rangeText, rangeLines.length, start, end, startRef.hash, endRef.hash);
     if (wholeRange !== undefined) warnings.push(wholeRange);
   }
-  if (count > 1) warnings.push(multiMatchWarning(count, start, end, displayPath));
   return {
     editParams: {
       remove_from: startRef.hash,
@@ -233,6 +258,7 @@ export function buildReplaceMatchEdit(
       text: replacement,
     },
     warnings,
+    contentSeparators,
     ...(servedOverride !== undefined ? { servedOverride } : {}),
   };
 }
@@ -256,6 +282,7 @@ function planReplaceMatchBatchMember(input: BatchPlannerInput): BatchMemberPlan
   return {
     hedit,
     warnings: [...warnings, ...hints, ...resWarnings, ...matchPlan.warnings],
+    contentSeparators: matchPlan.contentSeparators,
     planned,
     foldedLines: 0,
     ...(matchPlan.servedOverride !== undefined ? { servedOverride: matchPlan.servedOverride } : {}),
@@ -291,6 +318,7 @@ export async function replaceMatchPreview(request: unknown, cwd: string, signal?
       noPersist: true,
       preloadedNorm: preload,
       served: plan.servedOverride,
+      endingOverrides: plan.contentSeparators,
       signal,
     });
     return previewFromPipe(pipe);
@@ -372,6 +400,7 @@ export function buildReplaceMatchToolDef(flags: EditToolFlags = DEFAULT_EDIT_FLA
             signal,
             preloadedNorm: preload,
             served: plan.servedOverride,
+            endingOverrides: plan.contentSeparators,
           });
           return commitEdit(pipe, {
             path: pipe.path,

package/src/replace.ts

@@ -158,9 +158,11 @@ function withEndingOverrides(edit: HEdit, overrides: (LineEnding | undefined)[]
   const length = Math.max(edit.content_separators?.length ?? 0, overrides.length);
   const separators: (LineEnding | undefined)[] = new Array(length);
   for (let index = 0; index < length; index++) {
-    separators[index] = overrides[index] ?? edit.content_separators?.[index];
+    separators[index] = index < overrides.length ? overrides[index] : edit.content_separators?.[index];
+  }
+  if (separators.every((ending) => ending === undefined)) {
+    return edit.content_separators === undefined ? edit : { ...edit, content_separators: undefined };
   }
-  if (separators.every((ending) => ending === undefined)) return edit;
   return { ...edit, content_separators: separators };
 }
 

package/tool-prompts/read.md

@@ -1 +1 @@
-Read a text file as `anchor│content` rows: a 4-character anchor (letters only, case-sensitive), `│`, then the line. Target edits by anchor, never by content or line number. `offset` takes a 1-indexed line number or a served anchor; with an anchor, `limit` counts lines after it — no line-number math. Page long files with `offset` and `limit`; when output says truncated, continue from the hinted `offset`. A stale anchor is refused with the current rows and fresh anchors. 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 as `anchor│content` rows: a 4-character anchor (letters only, case-sensitive), `│`, then the line. Target edits by anchor, never by content or line number. `offset` takes a 1-indexed line number or a served anchor; with an anchor, `limit` counts lines from that anchor row onward — no line-number math. Page long files with `offset` and `limit`; when output says truncated, continue from the hinted `offset`. A stale anchor is refused with the current rows and fresh anchors. 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.

package/tool-prompts/replace-match-guidelines.md

@@ -1,3 +1,3 @@
-- `replace_match`: `old_string` is only the fragment of the line that changes — never the whole line or range, and never text that `new_string` leaves unchanged; every occurrence inside the range is replaced, so scope the range with anchors when only some occurrences should change.
-- `replace_match`: when the same changed fragment appears on every matching line in a range, anchor the first and last matching lines so one call replaces them all instead of one call per line.
-- `replace_match`: when the change covers whole lines or the whole range, use `replace` with the same anchors and the new text.
+- `replace_match`: `old_string` is only the fragment that changes — never text that `new_string` leaves unchanged; every occurrence inside the range is replaced, so scope the range when only some lines should change.
+- `replace_match`: if `old_string` is everything on the line except indentation and trailing punctuation, that match is the whole line — use `replace`. A shorter fragment repeated on several lines (a value, a name) is the intended multi-line use.
+- `replace_match`: when the change covers whole lines or the whole range, use `replace` with the same anchors and the exact text.

package/tool-prompts/replace-match.md

@@ -1,3 +1,3 @@
-Replace part of a line (or a range of lines) without retyping the rest. `replace_from`/`replace_to` are bare anchors from served `anchor│content` rows marking the range's first and last line (the same anchor for one line), and `old_string` is the exact text to find inside that range. Send only the smallest fragment that contains the change — never text that `new_string` leaves unchanged; for a whole-line or whole-range rewrite use `replace` with the same anchors instead. `remove_from`/`remove_to` are accepted as aliases.
+Replace part of a line (or a range of lines) without retyping the rest. `replace_from`/`replace_to` are bare anchors from served `anchor│content` rows marking the range's first and last line (the same anchor for one line), and `old_string` is the exact text to find inside that range. Send only the fragment that changes — never text that `new_string` leaves unchanged. If `old_string` is everything on the line except indentation and trailing punctuation, that is a whole-line rewrite: use `replace` with the same anchors. The same short fragment on several lines (a value, a name) may be replaced in one call. `remove_from`/`remove_to` are accepted as aliases.
 
 The two boundary anchors must still match what was last shown; lines strictly inside the range are matched against the file as it is on disk.