pi-hashline-edit-pro 2.7.0 → 2.7.2

package/src/grep.ts

@@ -1,20 +1,21 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { formatSize, DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, type TruncationResult } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 import { readdir, stat } from "fs/promises";
 import { dirname, join, relative } from "path";
 import { loadFileKindAndText } from "./file-kind";
 import { readNormFile } from "./file-reader";
-import { MAX_HASH_LINES, HASH_SEP } from "./hashline";
+import { MAX_HASH_LINES, fmtRow, HASH_LEN, HASH_SEP } from "./hashline";
+import { MAX_GREP_LINE_BYTES } from "./constants";
 import { toCwd } from "./paths";
 import { loadP, loadGuide } from "./prompts";
 import { normReq } from "./replace-normalize";
 import { recordServedSafe } from "./served";
-import { abortIf, errCode, isRec, makePrepareArguments, rejectUnknownFields, visLines } from "./utils";
+import { abortIf, errCode, isRec, makePrepareArguments, rejectUnknownFields, truncateToBytes, visLines } from "./utils";
 
 const GREP_KS = new Set(["pattern", "path", "glob", "context", "ignoreCase", "literal", "limit"]);
 const SKIP_DIRS = new Set(["node_modules", ".git", ".tmp", "coverage"]);
 const MAX_SCAN_FILES = 4000;
-const MAX_SHOWN_ROWS = 2000;
 
 export interface GrepReq {
   pattern: string;
@@ -92,6 +93,42 @@ interface FileHit {
   hashes: string[];
   matchCount: number;
   totalMatchCount: number;
+  fragmented: boolean[];
+}
+
+const GREP_ROW_OVERHEAD_BYTES = HASH_LEN + Buffer.byteLength(HASH_SEP, "utf-8");
+const GREP_ROW_CONTENT_BYTES = MAX_GREP_LINE_BYTES - GREP_ROW_OVERHEAD_BYTES;
+
+function snapCharBoundaries(line: string, start: number, end: number): [number, number] {
+  let s = start;
+  let e = end;
+  if (s > 0 && s < line.length) {
+    const c = line.charCodeAt(s);
+    if (c >= 0xdc00 && c <= 0xdfff && line.charCodeAt(s - 1) >= 0xd800 && line.charCodeAt(s - 1) <= 0xdbff) s -= 1;
+  }
+  if (e > 0 && e < line.length) {
+    const c = line.charCodeAt(e - 1);
+    if (c >= 0xd800 && c <= 0xdbff && line.charCodeAt(e) >= 0xdc00 && line.charCodeAt(e) <= 0xdfff) e += 1;
+  }
+  return [s, e];
+}
+
+function grepMatchFragment(line: string, regex: RegExp): string {
+  const m = regex.exec(line);
+  const matchStart = m?.index ?? 0;
+  const matchLen = m?.[0].length ?? 0;
+  const budget = GREP_ROW_CONTENT_BYTES - 6;
+  const half = Math.floor((budget - Math.min(matchLen, budget)) / 2);
+  const [start, end] = snapCharBoundaries(line, Math.max(0, matchStart - half), Math.min(line.length, matchStart + matchLen + half));
+  const content = truncateToBytes(line.slice(start, end), budget);
+  const lead = start > 0 ? "..." : "";
+  const tail = end < line.length ? "..." : "";
+  return truncateToBytes(`${lead}${content}${tail}`, GREP_ROW_CONTENT_BYTES);
+}
+
+function grepHeadFragment(line: string): string {
+  const head = truncateToBytes(line, GREP_ROW_CONTENT_BYTES - 3);
+  return head.length < line.length ? `${head}...` : head;
 }
 
 interface ScanState {
@@ -155,7 +192,7 @@ async function searchFile(
   if (file.kind !== "text") return undefined;
   let norm;
   try {
-    norm = await readNormFile(absPath, cwd, { maxLines: MAX_HASH_LINES, preloadedFile: file });
+    norm = await readNormFile(absPath, cwd, { maxLines: MAX_HASH_LINES, preloadedFile: file, noPersist: true });
   } catch (error) {
     if (isSkipableLoadError(error)) return undefined;
     throw error;
@@ -172,11 +209,24 @@ async function searchFile(
     for (let j = Math.max(0, i - context); j <= Math.min(lines.length - 1, i + context); j++) shown.add(j);
   }
   const sorted = [...shown].sort((a, b) => a - b);
+  const matchSet = new Set(matchLines);
   const rows: string[] = [];
   const hashes: string[] = [];
+  const fragmented: boolean[] = [];
   for (const idx of sorted) {
-    rows.push(`${norm.fileHashes[idx]}${HASH_SEP}${lines[idx]}`);
-    hashes.push(norm.fileHashes[idx]!);
+    const hash = norm.fileHashes[idx]!;
+    const line = lines[idx]!;
+    const row = fmtRow(hash, line);
+    if (Buffer.byteLength(row, "utf-8") > MAX_GREP_LINE_BYTES) {
+      const content = matchSet.has(idx) ? grepMatchFragment(line, regex) : grepHeadFragment(line);
+      rows.push(fmtRow(hash, content));
+      hashes.push(hash);
+      fragmented.push(true);
+    } else {
+      rows.push(row);
+      hashes.push(hash);
+      fragmented.push(false);
+    }
   }
   return {
     path: norm.absolutePath,
@@ -186,6 +236,7 @@ async function searchFile(
     hashes,
     matchCount: keptMatches.length,
     totalMatchCount: matchLines.length,
+    fragmented,
   };
 }
 
@@ -274,8 +325,29 @@ export function regGrep(pi: ExtensionAPI): void {
       let limitTruncated = false;
       let rowTruncated = false;
       let rowCount = 0;
-      for (const absPath of files) {
+      let byteCount = 0;
+      let totalRows = 0;
+      let totalBytes = 0;
+      let truncatedBy: "lines" | "bytes" | null = null;
+      let linesReplaced = 0;
+      let countOnly = false;
+      for (let f = 0; f < files.length; f++) {
         abortIf(signal);
+        const absPath = files[f]!;
+        if (countOnly) {
+          const hit = await searchFile(absPath, globRoot, ctx.cwd, regex, globRegex, context, Number.MAX_SAFE_INTEGER);
+          if (!hit) continue;
+          totalRows += hit.rows.length;
+          for (const row of hit.rows) totalBytes += Buffer.byteLength(row, "utf-8") + 1;
+          const remaining = limit - matches;
+          if (remaining > 0) {
+            matches += Math.min(hit.matchCount, remaining);
+            if (hit.matchCount > remaining) limitTruncated = true;
+          } else {
+            limitTruncated = true;
+          }
+          continue;
+        }
         const remaining = limit - matches;
         if (remaining <= 0) {
           limitTruncated = true;
@@ -283,18 +355,32 @@ export function regGrep(pi: ExtensionAPI): void {
         }
         const hit = await searchFile(absPath, globRoot, ctx.cwd, regex, globRegex, context, remaining);
         if (!hit) continue;
-        const rowBudget = MAX_SHOWN_ROWS - rowCount;
-        if (rowBudget <= 0) {
-          rowTruncated = true;
-          break;
+        const keptRows: string[] = [];
+        const keptHashes: string[] = [];
+        for (let i = 0; i < hit.rows.length; i++) {
+          const row = hit.rows[i]!;
+          const rowBytes = Buffer.byteLength(row, "utf-8") + 1;
+          if (rowCount >= DEFAULT_MAX_LINES || byteCount + rowBytes > DEFAULT_MAX_BYTES) {
+            rowTruncated = true;
+            if (truncatedBy === null) truncatedBy = byteCount + rowBytes > DEFAULT_MAX_BYTES ? "bytes" : "lines";
+            for (let j = i; j < hit.rows.length; j++) {
+              totalRows += 1;
+              totalBytes += Buffer.byteLength(hit.rows[j]!, "utf-8") + 1;
+            }
+            break;
+          }
+          keptRows.push(row);
+          keptHashes.push(hit.hashes[i]);
+          if (hit.fragmented[i]) linesReplaced += 1;
+          rowCount += 1;
+          byteCount += rowBytes;
+          totalRows += 1;
+          totalBytes += rowBytes;
         }
-        const keptRows = hit.rows.slice(0, rowBudget);
-        const keptHashes = hit.hashes.slice(0, rowBudget);
-        rowCount += keptRows.length;
         if (hit.totalMatchCount > hit.matchCount) limitTruncated = true;
-        if (keptRows.length < hit.rows.length) rowTruncated = true;
         matches += hit.matchCount;
         hits.push({ ...hit, rows: keptRows, hashes: keptHashes });
+        if (rowTruncated) countOnly = true;
       }
       for (const hit of hits) {
         await recordServedSafe(hit.path, hit.hashes, "grep", new Set(hit.fileHashes));
@@ -303,14 +389,32 @@ export function regGrep(pi: ExtensionAPI): void {
         .map((hit) => `=== ${hit.displayPath} ===\n${hit.rows.join("\n")}`)
         .join("\n");
       const notes: string[] = [];
-      if (rowTruncated) notes.push(`[grep: output truncated at ${MAX_SHOWN_ROWS} rows; refine the pattern to see more.]`);
+      if (rowTruncated) notes.push(`[grep: output truncated at ${DEFAULT_MAX_LINES} rows or ${formatSize(DEFAULT_MAX_BYTES)}; refine the pattern to see more.]`);
       if (limitTruncated) notes.push(`[grep: showing first ${limit} matches; increase limit to see more.]`);
       if (state.stopped) notes.push(`[grep: scan cap of ${MAX_SCAN_FILES} files reached; results may be incomplete.]`);
+      if (linesReplaced > 0) notes.push(`[grep: ${linesReplaced} line(s) exceed ${formatSize(MAX_GREP_LINE_BYTES)} and are shown as truncated fragments; use read to see the full lines.]`);
       const truncated = limitTruncated || rowTruncated;
+      const truncation: TruncationResult | undefined = rowTruncated
+        ? {
+            content: blocks,
+            truncated: true,
+            truncatedBy,
+            totalLines: totalRows,
+            totalBytes,
+            outputLines: rowCount,
+            outputBytes: byteCount,
+            lastLinePartial: false,
+            firstLineExceedsLimit: false,
+            maxLines: DEFAULT_MAX_LINES,
+            maxBytes: DEFAULT_MAX_BYTES,
+          }
+        : undefined;
       const text = blocks.length > 0 ? `${blocks}${notes.length > 0 ? `\n${notes.join("\n")}` : ""}` : "No matches found.";
       return {
         content: [{ type: "text", text }],
         details: {
+          ...(truncation ? { truncation } : {}),
+          ...(linesReplaced > 0 ? { linesTruncated: true as const } : {}),
           metrics: {
             matches,
             files: hits.length,

package/src/hash-store.ts

@@ -66,6 +66,7 @@ interface Prepared {
   get: (...params: SqlParams) => Record<string, unknown> | undefined;
   allPaths: (...params: SqlParams) => Record<string, unknown>[];
   allHashes: (...params: SqlParams) => Record<string, unknown>[];
+  allServed: (...params: SqlParams) => Record<string, unknown>[];
   deleteOne: (...params: SqlParams) => void;
   upsert: (...params: SqlParams) => void;
   undoUpsert: (...params: SqlParams) => void;
@@ -118,6 +119,14 @@ export function parseHashList(raw: string, onInvalid: () => void): string[] | un
   return parsed;
 }
 
+export function parseStoredHashes(
+  row: Record<string, unknown> | undefined,
+  onInvalid: () => void,
+): string[] | undefined {
+  if (!row) return undefined;
+  return parseHashList(row.hashes as string, onInvalid);
+}
+
 function isValidSnapshot(value: unknown): value is LegacySnapshot {
   if (typeof value !== "object" || value === null) return false;
   const v = value as Record<string, unknown>;
@@ -174,6 +183,14 @@ function openDbWithBusyRetry(storePath: string): { db: RawDb; stmts: Prepared }
   return withBusyRetry(() => openDb(storePath));
 }
 
+function retriedWrite(
+  stmt: { run(...params: SqlParams): unknown },
+): (...params: SqlParams) => void {
+  return (...params) => {
+    withBusyRetry(() => { stmt.run(...params); });
+  };
+}
+
 let cachedDb: { path: string; db: RawDb; stmts: Prepared } | null = null;
 let opening: { path: string; promise: Promise<HashStore> } | null = null;
 let exitHandlerRegistered = false;
@@ -238,6 +255,7 @@ function buildStore(
   if (versionRow && versionRow.value !== String(HASH_STORE_VERSION)) {
     db.exec("DELETE FROM snapshots");
     db.exec("DELETE FROM undo");
+    db.exec("DELETE FROM served");
   }
   db.prepare(
     "INSERT INTO meta (key, value) VALUES ('version', ?) " +
@@ -246,6 +264,7 @@ function buildStore(
   const getStmt = db.prepare("SELECT hashes FROM snapshots WHERE path = ? AND checksum = ? AND line_count = ?");
   const allStmt = db.prepare("SELECT path FROM snapshots UNION SELECT path FROM undo UNION SELECT path FROM served");
   const allHashesStmt = db.prepare("SELECT path, hashes FROM snapshots");
+  const allServedStmt = db.prepare("SELECT path, hashes FROM served");
   const delStmt = db.prepare("DELETE FROM snapshots WHERE path = ?");
   const upsertStmt = db.prepare(
     "INSERT INTO snapshots (path, checksum, line_count, hashes, updated_at) VALUES (?, ?, ?, ?, ?) " +
@@ -269,14 +288,15 @@ function buildStore(
     get: (...params) => getStmt.get(...params) as Record<string, unknown> | undefined,
     allPaths: (...params) => allStmt.all(...params) as Record<string, unknown>[],
     allHashes: (...params) => allHashesStmt.all(...params) as Record<string, unknown>[],
-    deleteOne: (...params) => { withBusyRetry(() => { delStmt.run(...params); }); },
-    upsert: (...params) => { withBusyRetry(() => { upsertStmt.run(...params); }); },
-    undoUpsert: (...params) => { withBusyRetry(() => { undoUpsertStmt.run(...params); }); },
+    allServed: (...params) => allServedStmt.all(...params) as Record<string, unknown>[],
+    deleteOne: retriedWrite(delStmt),
+    upsert: retriedWrite(upsertStmt),
+    undoUpsert: retriedWrite(undoUpsertStmt),
     undoGet: (...params) => undoGetStmt.get(...params) as Record<string, unknown> | undefined,
-    undoDelete: (...params) => { withBusyRetry(() => { undoDelStmt.run(...params); }); },
+    undoDelete: retriedWrite(undoDelStmt),
     servedGet: (...params) => servedGetStmt.get(...params) as Record<string, unknown> | undefined,
-    servedUpsert: (...params) => { withBusyRetry(() => { servedUpsertStmt.run(...params); }); },
-    servedDelete: (...params) => { withBusyRetry(() => { servedDelStmt.run(...params); }); },
+    servedUpsert: retriedWrite(servedUpsertStmt),
+    servedDelete: retriedWrite(servedDelStmt),
   };
   return { db, stmts };
 }
@@ -489,8 +509,7 @@ export function getSnapshot(
     return cached.hashes.slice();
   }
   const row = store.stmts.get(path, checksum, lineCount);
-  if (!row) return undefined;
-  const parsed = parseHashList(row.hashes as string, () => {
+  const parsed = parseStoredHashes(row, () => {
     if (deleteCorrupt) store.stmts.deleteOne(path);
     snapshotCache.delete(path);
   });
@@ -525,7 +544,7 @@ export function upsertUndo(store: HashStore, path: string, entry: UndoRecord): v
 export function getUndoEntry(store: HashStore, path: string): UndoRecord | undefined {
   const row = store.stmts.undoGet(path);
   if (!row) return undefined;
-  const parsed = parseHashList(row.hashes as string, () => store.stmts.undoDelete(path));
+  const parsed = parseStoredHashes(row, () => store.stmts.undoDelete(path));
   if (!parsed) return undefined;
   return {
     content: row.content as string,
@@ -551,7 +570,11 @@ async function statMissing(rows: { path: string }[]): Promise<string[]> {
         try {
           await stat(row.path);
           return undefined;
-        } catch {
+        } catch (error: unknown) {
+          if (errCode(error) !== "ENOENT") {
+            console.error("Failed to stat hash store path:", row.path, error);
+            return undefined;
+          }
           return row.path;
         }
       }),
@@ -571,14 +594,15 @@ export async function pruneMissing(store: HashStore): Promise<void> {
     for (const path of missing) {
       store.stmts.deleteOne(path);
       snapshotCache.delete(path);
-      store.stmts.undoDelete(path);
       store.stmts.servedDelete(path);
     }
   });
 }
 
-export function findSnapshotPaths(store: HashStore, hashes: string[]): string[] {
-  const rows = store.stmts.allHashes() as { path: string; hashes: string }[];
+function matchPathsByHashes(
+  rows: { path: string; hashes: string }[],
+  hashes: string[],
+): string[] {
   const matches: string[] = [];
   for (const row of rows) {
     try {
@@ -591,3 +615,11 @@ export function findSnapshotPaths(store: HashStore, hashes: string[]): string[]
   }
   return matches;
 }
+
+export function findSnapshotPaths(store: HashStore, hashes: string[]): string[] {
+  return matchPathsByHashes(store.stmts.allHashes() as { path: string; hashes: string }[], hashes);
+}
+
+export function findServedPaths(store: HashStore, hashes: string[]): string[] {
+  return matchPathsByHashes(store.stmts.allServed() as { path: string; hashes: string }[], hashes);
+}

package/src/hashline/apply.ts

@@ -1,5 +1,5 @@
 import { abortIf, splitLines } from "../utils";
-import { _lineHashesPure, HASH_SEP } from "./hash";
+import { _lineHashesPure } from "./hash";
 import {
 	valEdit,
 	stripBarePrefixes,
@@ -268,20 +268,7 @@ export function applyEdit(
 	};
 }
 
-export function fmtRegion(
-	hashes: string[],
-	lines: string[],
-): string {
-	if (hashes.length !== lines.length) {
-		throw new Error(
-			`fmtRegion: hashes.length (${hashes.length}) must match lines.length (${lines.length}).`,
-		);
-	}
-	return lines
-		.map((line, index) => `${hashes[index]}${HASH_SEP}${line}`)
-		.join("\n");
-}
-
+export { fmtRegion, fmtRow } from "./resolve";
 export function changedRange(
 	original: string,
 	result: string,

package/src/hashline/hash.ts

@@ -1,4 +1,5 @@
-import { splitLines } from "../utils";
+import { splitLines, truncateToBytes } from "../utils";
+import { MAX_HASH_SOURCE_BYTES } from "../constants";
 import {
   loadHashStore,
   type HashStore,
@@ -47,10 +48,38 @@ export const HL_PREFIX_MINUS_RE = new RegExp(
 
 export const HL_BARE_PREFIX_RE = new RegExp(`^\\s*(${HASH_RUN})│`);
 
+export type RowPrefixKind = "bare" | "plus" | "minus";
+
+export type StrippedRow = {
+	text: string;
+	kind: RowPrefixKind | null;
+	hash: string | undefined;
+};
+
+export function stripRowPrefix(line: string): StrippedRow {
+	const bare = line.match(HL_BARE_PREFIX_RE);
+	if (bare) {
+		return { text: line.slice(bare[0].length), kind: "bare", hash: bare[1] };
+	}
+	const plus = line.match(HL_PREFIX_PLUS_RE);
+	if (plus) {
+		return { text: line.slice(plus[0].length), kind: "plus", hash: plus[1] };
+	}
+	const minus = line.match(HL_PREFIX_MINUS_RE);
+	if (minus) {
+		return { text: line.slice(minus[0].length), kind: "minus", hash: minus[1] };
+	}
+	return { text: line, kind: null, hash: undefined };
+}
+
 export function canon(line: string): string {
 	return line.replace(/\r/g, "").trimEnd();
 }
 
+export function hashSource(line: string): string {
+	return truncateToBytes(canon(line), MAX_HASH_SOURCE_BYTES);
+}
+
 const BITSET_WORDS = Math.ceil(HASH_SPACE / 32);
 
 function getBit(bits: Uint32Array, idx: number): boolean {
@@ -93,7 +122,7 @@ export function _lineHashesPure(content: string): string[] {
   const hint = { value: 0 };
 
   for (let i = 0; i < lines.length; i++) {
-    const c = canon(lines[i]!);
+    const c = hashSource(lines[i]!);
     const baseIdx = (xxh32(c) >>> 14) % HASH_SPACE;
     hashes[i] = assignHash(used, baseIdx, hint);
   }
@@ -231,7 +260,7 @@ function mapStableHashes(
 
   const newByContent = new Map<string, number[]>();
   for (let i = 0; i < newLines.length; i++) {
-    const key = canon(newLines[i]!);
+    const key = hashSource(newLines[i]!);
     const list = newByContent.get(key);
     if (list) list.push(i);
     else newByContent.set(key, [i]);
@@ -246,7 +275,7 @@ function mapStableHashes(
   };
 
   for (const entry of survivors) {
-    const candidates = newByContent.get(canon(oldLines[entry.index]!));
+    const candidates = newByContent.get(hashSource(oldLines[entry.index]!));
     if (!candidates || candidates.length === 0) continue;
     const target = entry.index > spanEnd ? entry.index + shiftAfterSpan : entry.index;
     const pos = nearestNew(candidates, target);
@@ -277,7 +306,7 @@ function mapStableHashes(
 
   for (let i = 0; i < newLines.length; i++) {
     if (newHashes[i]) continue;
-    const c = canon(newLines[i]!);
+    const c = hashSource(newLines[i]!);
     const baseIdx = (xxh32(c) >>> 14) % HASH_SPACE;
     newHashes[i] = assignHash(used, baseIdx, hint);
   }

package/src/hashline/index.ts

@@ -11,6 +11,7 @@ export {
 	_lineHashesPure,
 	initHasher,
 	canon,
+	hashSource,
 } from "./hash";
 
 export {
@@ -43,5 +44,6 @@ export {
 	buildIdx,
 	applyEdit,
 	fmtRegion,
+	fmtRow,
 	changedRange,
 } from "./apply";

package/src/hashline/parse.ts

@@ -14,11 +14,11 @@ function diagRef(ref: string): string {
 	}
 
 	if (/^\d+/.test(trimmed)) {
-		return `[E_BAD_REF] Invalid anchor. Use the hash alone (e.g. "aB3"): no line numbers or trailing content.`;
+		return `[E_BAD_REF] Invalid anchor. Use the anchor alone (e.g. "aB3"): no line numbers or trailing content.`;
 	}
 
 	if (trimmed.includes("│")) {
-		return `[E_BAD_REF] Invalid anchor "${trimmed}": use only the 3-char hash, drop everything from "│" onward.`;
+		return `[E_BAD_REF] Invalid anchor "${trimmed}": use only the 3-char anchor, drop everything from "│" onward.`;
 	}
 
 	return `[E_BAD_REF] Invalid anchor "${trimmed}". Expected a 3-char alphanumeric anchor (e.g. "aB3").`;

package/src/hashline/resolve.ts

@@ -1,12 +1,11 @@
 import { abortIf, rejectUnknownFields, firstNonEmptyIndex, lastNonEmptyIndex, clipLine } from "../utils";
-import { HASH_SEP, HASH_RUN, HL_BARE_PREFIX_RE, HL_PREFIX_PLUS_RE, HL_PREFIX_MINUS_RE, canon } from "./hash";
+import { HASH_SEP, HASH_RUN, stripRowPrefix, canon } from "./hash";
 import { parseHashRef, parseText, type Anchor } from "./parse";
 import { NEW_CONTENT_NOT_ARRAY_MSG, MAX_RANGE_STALE_LINES } from "../constants";
 
 export type RAnchor = {
 	line: number;
 	hash: string;
-	hashMatched: boolean;
 };
 
 export type HEdit = { content_lines: string[]; hash_bounds: [Anchor, Anchor] };
@@ -56,7 +55,6 @@ function resAnchorFromMap(
 		return {
 			line: hashMatches[0]!,
 			hash: ref.hash,
-			hashMatched: true,
 		};
 	}
 	return { ref, kind: "ambiguous", candidates: hashMatches };
@@ -74,6 +72,19 @@ function assertAligned(
 	}
 }
 
+export function fmtRow(hash: string, line: string): string {
+	return `${hash}${HASH_SEP}${line}`;
+}
+
+export function fmtRegion(hashes: string[], lines: string[]): string {
+	if (hashes.length !== lines.length) {
+		throw new Error(
+			`fmtRegion: hashes.length (${hashes.length}) must match lines.length (${lines.length}).`,
+		);
+	}
+	return lines.map((line, index) => fmtRow(hashes[index]!, line)).join("\n");
+}
+
 export function fmtMismatchWithHashes(
   mismatches: HMismatch[],
   fileLines: string[],
@@ -141,12 +152,12 @@ function assertItem(edit: Record<string, unknown>): void {
 
   if ("remove_from" in edit && typeof edit.remove_from !== "string") {
     throw new Error(
-      `[E_BAD_SHAPE] Field "remove_from" must be an anchor string (3-char hash).`,
+      `[E_BAD_SHAPE] Field "remove_from" must be an anchor string (3-char anchor).`,
     );
   }
   if ("remove_to" in edit && typeof edit.remove_to !== "string") {
     throw new Error(
-      `[E_BAD_SHAPE] Field "remove_to" must be an anchor string (3-char hash).`,
+      `[E_BAD_SHAPE] Field "remove_to" must be an anchor string (3-char anchor).`,
     );
   }
   if (!("replacement_lines" in edit)) {
@@ -157,7 +168,7 @@ function assertItem(edit: Record<string, unknown>): void {
   }
   if (typeof edit.remove_from !== "string" || typeof edit.remove_to !== "string") {
     throw new Error(
-      `[E_BAD_SHAPE] The edit requires "remove_from" and "remove_to" anchor strings (3-char hashes from read output).`,
+      `[E_BAD_SHAPE] The edit requires "remove_from" and "remove_to" anchor strings (3-char anchors from read output).`,
     );
   }
 }
@@ -176,7 +187,7 @@ export function stripAnchorRow(
 			? "diff-preview marker"
 			: match[1] === "-"
 				? 'leading "-" marker'
-				: '"HASH│" prefix';
+				: '"anchor│" prefix';
 	warnings?.push(`[E_BAD_REF] Stripped ${marker} from ${entryLabel} "${trimmed}".`);
 	return match[2]!;
 }
@@ -213,10 +224,10 @@ export function stripBarePrefixes(
 	const fileHashSet = new Set(fileHashes);
 	const stripped: { lineIndex: number; matched: boolean }[] = [];
 	const contentLines = edit.content_lines.map((line, lineIndex) => {
-		const match = line.match(HL_BARE_PREFIX_RE);
-		if (!match) return line;
-		stripped.push({ lineIndex, matched: fileHashSet.has(match[1]!) });
-		return line.slice(match[0].length);
+		const result = stripRowPrefix(line);
+		if (result.kind !== "bare") return line;
+		stripped.push({ lineIndex, matched: fileHashSet.has(result.hash ?? "") });
+		return result.text;
 	});
 	if (stripped.length === 0) return edit;
 	const locations = stripped
@@ -228,7 +239,7 @@ export function stripBarePrefixes(
 			? " Verify it was pasted from read output."
 			: "";
 	warnings.push(
-		`[E_BARE_HASH_PREFIX] Stripped "HASH│" prefix from ${locations}.${guidance}`
+		`[E_BARE_HASH_PREFIX] Stripped "anchor│" prefix from ${locations}.${guidance}`
 	);
 	return { ...edit, content_lines: contentLines };
 }
@@ -239,17 +250,10 @@ export function stripDiffPrefixes(
 ): HEdit {
 	const stripped: number[] = [];
 	const contentLines = edit.content_lines.map((line, lineIndex) => {
-		const plus = line.match(HL_PREFIX_PLUS_RE);
-		if (plus) {
-			stripped.push(lineIndex);
-			return line.slice(plus[0].length);
-		}
-		const minus = line.match(HL_PREFIX_MINUS_RE);
-		if (minus) {
-			stripped.push(lineIndex);
-			return line.slice(minus[0].length);
-		}
-		return line;
+		const result = stripRowPrefix(line);
+		if (result.kind !== "plus" && result.kind !== "minus") return line;
+		stripped.push(lineIndex);
+		return result.text;
 	});
 	if (stripped.length === 0) return edit;
 	const locations = stripped.map((i) => `replacement_lines line ${i + 1}`).join(", ");
@@ -502,12 +506,10 @@ export function resolveAnchorLine(
 }
 
 export class RangeStaleError extends Error {
-  readonly firstMismatchLine: number;
   readonly rangeHashes: string[];
-  constructor(message: string, firstMismatchLine: number, rangeHashes: string[]) {
+  constructor(message: string, rangeHashes: string[]) {
     super(message);
     this.name = "RangeStaleError";
-    this.firstMismatchLine = firstMismatchLine;
     this.rangeHashes = rangeHashes;
   }
 }
@@ -544,7 +546,7 @@ export function assertRangeServed(
   for (let line = startLine; line < startLine + shownLength; line++) {
     const hash = fileHashes[line - 1]!;
     shownHashes.push(hash);
-    rows.push(`${hash}${HASH_SEP}${fileLines[line - 1]}`);
+    rows.push(fmtRow(hash, clipLine(fileLines[line - 1])));
   }
   const location = filePath ? ` in ${filePath}` : "";
   const first = mismatchLines[0]!;
@@ -558,7 +560,7 @@ export function assertRangeServed(
       : "";
   const message =
     `[E_RANGE_STALE] ${mismatchText} what was shown. Nothing was modified. Current range with fresh anchors:\n\n${rows.join("\n")}${capHint}`;
-  throw new RangeStaleError(message, first, shownHashes);
+  throw new RangeStaleError(message, shownHashes);
 }
 
 export { warnUnicodeEsc };

package/src/insert.ts

@@ -34,7 +34,7 @@ export function assertInsertReq(request: unknown): asserts request is InsertReq
     throw new Error('[E_BAD_SHAPE] Insert request requires a non-empty "path" string.');
   }
   if (typeof request.anchor !== "string" || request.anchor.length === 0) {
-    throw new Error('[E_BAD_SHAPE] Insert request requires an "anchor" string (3-char hash from read output).');
+    throw new Error('[E_BAD_SHAPE] Insert request requires an "anchor" string (3-char anchor from read output).');
   }
   if (request.direction !== "before" && request.direction !== "after") {
     throw new Error('[E_BAD_SHAPE] Insert request "direction" must be "before" or "after".');
@@ -52,7 +52,7 @@ const insertToolSchema = Type.Object(
     }),
     anchor: Type.String({
       description:
-        'Bare 3-char HASH only (e.g. "aB3"): copy just the hash from the leftmost column of a read row like `aB3│content`; never the line content. A pasted diff row like `+aB3│x` or a `HASH│` prefix is stripped automatically with a warning. The anchored line is preserved; the new lines go after or before it.',
+        'Bare 3-char anchor only (e.g. "aB3"): copy just the anchor from the leftmost column of a read row like `aB3│content`; never the line content. A pasted diff row like `+aB3│x` or an `anchor│` prefix is stripped automatically with a warning. The anchored line is preserved; the new lines go after or before it.',
     }),
     direction: Type.Union(
       [