pi-hashline-edit-pro 4.3.4 → 4.3.5

package/README.md

@@ -89,7 +89,7 @@ Single line: use the same anchor for `remove_from` and `remove_to`. `replace_fro
 
 The request is checked before any file I/O, so a bad request never touches the file.
 
-Common copy-paste slips are fixed automatically: a leftover `anchor│` prefix in `replacement_lines` or the anchor fields (a prefix of 4 to 5 characters before `│`, for example `ab12│`), diff-preview rows pasted into the replacement, and a boundary line pasted twice are reported as warnings, while a reversed range, a JSON-array wrapper, and embedded newlines are corrected silently. New lines that re-include a block adjacent to the range are stripped when that block is unique in the file. The whole run is stripped as one unit, so re-including an unchanged block next to the range never duplicates it. Boundary dedup has three modes in `/hashline-config`: `on` strips with a warning, `off` applies edits literally, and `strict` rejects the edit with `[E_BOUNDARY_STRICT]` when any replacement line would be stripped.
+Common copy-paste slips are fixed automatically: a leftover `anchor│` prefix in `replacement_lines` or the anchor fields (a prefix of 4 to 5 letters before `│`, for example `abde│`), diff-preview rows pasted into the replacement, and a boundary line pasted twice are reported as warnings, while a reversed range, a JSON-array wrapper, and embedded newlines are corrected silently. New lines that re-include a block adjacent to the range are stripped when that block is unique in the file. The whole run is stripped as one unit, so re-including an unchanged block next to the range never duplicates it. Boundary dedup has three modes in `/hashline-config`: `on` strips with a warning, `off` applies edits literally, and `strict` rejects the edit with `[E_BOUNDARY_STRICT]` when any replacement line would be stripped.
 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 `replace`'s `replacement_lines` and `insert`'s `lines`.
 
 Every line in the removed range must match what was last shown to you. The extension records the `anchor│content` rows it serves (`read` output, `anchor_grep` output, the auto-read block after `write`, the `+anchor│` and ` anchor│` rows of post-edit diffs, the current-range rows of `[E_RANGE_STALE]` feedback, and the context rows of stale-anchor feedback) and verifies the whole range against that record before writing. A line that changed on disk since it was shown, or an anchor that is not owned in this session, refuses the edit with `[E_RANGE_STALE]` or `[E_STALE_ANCHOR]` and returns the current range with fresh anchors, so the retry needs no `read`. An owned anchor enters the served record when its row is shown (after a restart, restored ownership counts as shown), so a file with no owned anchors cannot be edited by anchor at all; call `read` first. An owned line that was never shown — for example beyond an auto-read preview's truncation cap — is refused with `[E_RANGE_STALE]` and returns the current range, so the retry still needs no `read`.
@@ -233,7 +233,7 @@ Codes starting with `E_` are errors: nothing was written — except `File was wr
 | --- | --- |
 | `[E_BAD_SHAPE]` | Request envelope or edit item has unknown, missing, or wrongly-typed fields (for example `replacement_lines` must be an array of strings, one element per line), or content contains a NUL byte (`U+0000`), which would make the file binary. |
 | `[W_BAD_SHAPE]` | Auto-corrected request slip reported as a warning (for example stringified array text that could not be parsed and was kept as one literal line). |
-| `[E_BAD_REF]` | An anchor in `remove_from`/`remove_to` is not a bare 4-char anchor. |
+| `[E_BAD_REF]` | An anchor in `remove_from`/`remove_to` is not a bare 4-character anchor (the anchor table is letters only). |
 | `[W_BAD_REF]` | A pasted `anchor│` or diff-preview marker was stripped from an anchor field with a warning. |
 | `[E_STALE_ANCHOR]` | An anchor is not owned in this session (it was never shown to you, or its line was edited or the file was rewritten); call `read` for fresh anchors. |
 | `[W_INVALID_PATCH]` | A `replacement_lines` element is a diff-preview row (`+anchor│`, `-anchor│`, `-    │`). The marker is stripped automatically with a warning. |
@@ -249,7 +249,7 @@ Codes starting with `E_` are errors: nothing was written — except `File was wr
 | `[E_FILE_TOO_LARGE]` | The file exceeds the 1,353,139-line hashline limit or the 100MB size limit. |
 | `[E_REGISTRY]` | The anchor registry was not initialized; a serve or edit ran outside an initialized session. |
 | `[E_STORE_UNAVAILABLE]` | No SQLite runtime could be loaded: the host exposes neither `node:sqlite` (Node 22.19+) nor `bun:sqlite`. The pi release binary's bundled Bun lacks `node:sqlite`; run pi under Node or a Bun build that ships SQLite. |
-| `[E_WRITE_HASH_ECHO]` | A `write` `content` line begins with an `anchor│` that was served for this file (any line position). The write is refused, file byte-identical; retry with bare content (remove the copied anchors). |
+| `[E_WRITE_HASH_ECHO]` | A `write` `content` line reproduces a served row for this file (a bare `anchor│` read row, a `+anchor│`, ` anchor│`, or `-anchor│` diff row, or a `lineNumber │ anchor│content` grep row). The write is refused, file byte-identical; retry with bare content (remove the copied anchors). |
 | `[E_PATH_CHANGED]` | A write target changed identity after it was read; the write was refused to avoid following a swapped symlink or overwriting a replacement file. |
 | `[E_BATCH_OVERLAP]` | Batched `replace`/`insert` calls target overlapping ranges; the whole batch was refused. One `before` plus one `after` insert on the same anchor line is not an overlap. Retry with disjoint ranges. |
 | `[E_OP_ABORTED]` | An edit aborted (a same-message batch member failed, or the file changed or was deleted after the edit started). Nothing was written. Fix the sibling failure and retry the batch, otherwise call `read` for fresh anchors and retry. The abort names the failing call and its error code when one is known. |

package/index.ts

@@ -7,6 +7,7 @@ import { regGrep } from "./src/grep";
 import { regUndo, clearUndo } from "./src/replace-undo";
 import { regRead, fmtReadPreview } from "./src/read";
 import { buildAutoReadAllInjection, autoReadAllBudget } from "./src/auto-read-all";
+import { clearAutoReadAllComplete } from "./src/auto-read-all-state";
 import type { RMetrics } from "./src/replace-response";
 import type { ReplaceDetails } from "./src/replace";
 import { extractWarnings } from "./src/replace-render";
@@ -103,6 +104,7 @@ export default function (pi: ExtensionAPI): void {
   pi.on("session_shutdown", async (_event, ctx) => {
     try {
       const key = sessionKeyFor(ctx);
+      clearAutoReadAllComplete(key);
       if (key !== undefined) releaseRegistrySession(key);
     } catch (error) {
       console.error("Failed to release anchor registry session:", error);
@@ -113,7 +115,7 @@ export default function (pi: ExtensionAPI): void {
     if (autoReadAll === "off" || autoReadAllInjected) return;
     autoReadAllInjected = true;
     try {
-      const injection = await buildAutoReadAllInjection(ctx.cwd, autoReadAllBudget(ctx.model), autoReadAll, autoReadAllIgnore);
+      const injection = await buildAutoReadAllInjection(ctx.cwd, autoReadAllBudget(ctx.model), autoReadAll, autoReadAllIgnore, sessionKeyFor(ctx));
       if (!injection) return;
       if (ctx.hasUI) ctx.ui.notify(`Auto-read all: attached ${injection.files} file(s) with anchors`, "info");
       return { message: { customType: AUTO_READ_ALL_CUSTOM_TYPE, content: injection.text, display: false } };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hashline-edit-pro",
-  "version": "4.3.4",
+  "version": "4.3.5",
   "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/prompts/read.md

@@ -1 +1 @@
-Read a text file and return it as `anchor│content` rows, one per line: a 4-character alphanumeric anchor, the `│` separator, then the line content. Target lines in replace and insert by anchor, never by content or line number. Page long files with `offset` and `limit`; when the output says truncated, continue with the hinted `offset/limit`. Images attach visually; binary, directory, and UTF-16/UTF-32 text are rejected; an empty file returns one empty row you can replace to seed content.
+Read a text file and return it as `anchor│content` rows, one per line: a 4-character anchor (letters only), the `│` separator, then the line content. Target lines in replace and insert 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.

package/src/anchor-registry.ts

@@ -659,6 +659,7 @@ export function alignOwnershipWithSpans(
   const state = options?.shadow ? shadowStateFrom(current()!) : current()!;
   const freed: { anchor: string; checksum: string }[] = [];
   const minted: MintedAt[] = [];
+  const reused = new Set<string>();
   const log = (event: RegistryEvent): void => {
     if (!options?.shadow) appendEvent(event);
   };
@@ -671,14 +672,12 @@ export function alignOwnershipWithSpans(
     const start = span.start + offset;
     const end = span.end + offset;
     const spanLength = end - start + 1;
-    const spanFreed: { anchor: string; checksum: string }[] = [];
     for (let i = start; i <= end; i++) {
       const anchor = anchors[i]!;
       if (state.owned.has(anchor)) {
         state.owned.delete(anchor);
         const checksum = prevChecksums[i - offset] ?? "";
-        spanFreed.push({ anchor, checksum });
-        freed.push(spanFreed[spanFreed.length - 1]!);
+        freed.push({ anchor, checksum });
       }
     }
     const replacement: (string | undefined)[] = new Array(span.replacementCount);
@@ -690,10 +689,7 @@ export function alignOwnershipWithSpans(
         (!state.owned.has(positional) || state.owned.get(positional)!.path === path)
       ) {
         replacement[k] = positional;
-        const freedAt = freed.findIndex((candidate) => candidate.anchor === positional);
-        if (freedAt >= 0) freed.splice(freedAt, 1);
-        const pooledAt = spanFreed.findIndex((candidate) => candidate.anchor === positional);
-        if (pooledAt >= 0) spanFreed.splice(pooledAt, 1);
+        reused.add(positional);
       }
     }
     for (let k = 0; k < span.replacementCount; k++) {
@@ -714,8 +710,9 @@ export function alignOwnershipWithSpans(
   }
   const rows: [string, string][] = minted.map((m) => [m.anchor, m.checksum]);
   if (rows.length > 0) log({ kind: "allocate", path, rows });
-  if (freed.length > 0) log({ kind: "free", path, anchors: freed.map((f) => f.anchor) });
-  return { anchors, freed: freed.map((f) => f.anchor), minted: minted.map((m) => m.anchor) };
+  const retained = freed.filter((candidate) => !reused.has(candidate.anchor));
+  if (retained.length > 0) log({ kind: "free", path, anchors: retained.map((f) => f.anchor) });
+  return { anchors, freed: retained.map((f) => f.anchor), minted: minted.map((m) => m.anchor) };
 }
 
 export function alignOwnership(

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

@@ -1,13 +1,27 @@
-const completeSnapshots = new Map<string, string>();
-export function recordAutoReadAllComplete(absolutePath: string, snapshotId: string): void {
-  completeSnapshots.set(absolutePath, snapshotId);
+const completeSnapshots = new Map<string, Map<string, string>>();
+
+function scopeFor(sessionKey: string | undefined): string {
+  return sessionKey ?? "";
 }
-export function getAutoReadAllSnapshot(absolutePath: string): string | undefined {
-  return completeSnapshots.get(absolutePath);
+
+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 invalidateAutoReadAllComplete(absolutePath: string): void {
-  completeSnapshots.delete(absolutePath);
+
+export function getAutoReadAllSnapshot(sessionKey: string | undefined, absolutePath: string): string | undefined {
+  return completeSnapshots.get(scopeFor(sessionKey))?.get(absolutePath);
 }
-export function clearAutoReadAllComplete(): void {
+
+export function clearAutoReadAllComplete(sessionKey: string | undefined): void {
+  completeSnapshots.delete(scopeFor(sessionKey));
+}
+
+export function clearAllAutoReadAllComplete(): void {
   completeSnapshots.clear();
 }

package/src/auto-read-all.ts

@@ -419,7 +419,7 @@ function buildFooter(attached: number, discovery: AutoReadAllDiscovery, omitted:
   return `[hashline auto-read-all: ${attached} file(s) attached from ${discovery.source}; ${summary}${omissionNote}]`;
 }
 
-export async function buildAutoReadAllInjection(cwd: string, budgetBytes: number, mode: AutoReadAllMode = "on", ignoreDirs: readonly string[] = []): Promise<AutoReadAllInjection | undefined> {
+export async function buildAutoReadAllInjection(cwd: string, budgetBytes: number, mode: AutoReadAllMode = "on", ignoreDirs: readonly string[] = [], sessionKey?: string): Promise<AutoReadAllInjection | undefined> {
   const discovery = await discoverAutoReadAllFiles(cwd, mode, ignoreDirs);
   if (discovery.files.length === 0) return undefined;
   const sections: AutoReadAllSection[] = [];
@@ -439,7 +439,7 @@ export async function buildAutoReadAllInjection(cwd: string, budgetBytes: number
     }
     sections.push(section);
     const snapshotId = await safeSnapId(section.absolutePath, "auto-read-all");
-    if (snapshotId !== undefined) recordAutoReadAllComplete(section.absolutePath, snapshotId);
+    if (snapshotId !== undefined) recordAutoReadAllComplete(sessionKey, section.absolutePath, snapshotId);
     bytes += sectionBytes;
     completeFiles += 1;
   }

package/src/grep.ts

@@ -3,11 +3,12 @@ import { formatSize, DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, type TruncationResult
 import { Type } from "typebox";
 import { stat } from "node:fs/promises";
 import { dirname, isAbsolute, join, win32 } from "node:path";
+import { pathToFileURL } from "node:url";
 import { spawn, spawnSync } from "node:child_process";
 import { createInterface } from "node:readline";
 import { tryReadNormFile } from "./file-reader";
 import { globToRegex } from "./glob";
-import { MAX_HASH_LINES, fmtRow, HASH_LEN, HASH_SEP } from "./hashline";
+import { MAX_HASH_LINES, fmtRow, HASH_LEN, HASH_SEP, HASH_CLASS } from "./hashline";
 import { ANCHOR_POOL_EXHAUSTED_PREFIX, MAX_GREP_LINE_BYTES } from "./constants";
 import { toCwd, toDisplayPath } from "./paths";
 import { loadP, loadGuide } from "./prompts";
@@ -276,10 +277,9 @@ export async function resolveRgPath(): Promise<string> {
     const { createRequire } = await import("node:module");
     const require = createRequire(import.meta.url);
     const pkgPath = require.resolve("@earendil-works/pi-coding-agent/package.json");
-    const { dirname } = await import("node:path");
     const piDir = dirname(pkgPath);
     const toolsManagerPath = join(piDir, "dist/utils/tools-manager.js");
-    const mod = await import("file://" + toolsManagerPath);
+    const mod = await import(pathToFileURL(toolsManagerPath).href);
     if (mod.ensureTool) {
       const p = await mod.ensureTool("rg", true);
       if (p) { cachedRgPath = p; return p; }
@@ -468,7 +468,7 @@ function highlightMatches(text: string, regex: RegExp, theme: FgT): string {
   return out + text.slice(last);
 }
 
-const ANCHORED_ROW_RE = /^[A-Za-z0-9]{4}│/;
+const ANCHORED_ROW_RE = new RegExp(`^${HASH_CLASS}${HASH_SEP}`);
 
 function highlightHitRow(row: string, highlight: RegExp, theme: FgT): string {
   const anchored = row.match(ANCHORED_ROW_RE);

package/src/hash-store.ts

@@ -117,7 +117,6 @@ interface Prepared {
   get: (...params: SqlParams) => Record<string, unknown> | undefined;
   getState: (...params: SqlParams) => Record<string, unknown> | undefined;
   allPaths: (...params: SqlParams) => Record<string, unknown>[];
-  allHashes: (...params: SqlParams) => Record<string, unknown>[];
   deleteOne: (...params: SqlParams) => void;
   upsert: (...params: SqlParams) => void;
   undoUpsert: (...params: SqlParams) => void;
@@ -205,7 +204,6 @@ function buildStore(db: RawDb): { db: RawDb; stmts: Prepared } {
   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 allHashesStmt = db.prepare("SELECT path, hashes 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 (?, ?, ?, ?, ?, ?) " +
@@ -224,8 +222,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) => allStmt.all(...params) as Record<string, unknown>[],
-    allHashes: (...params) => allHashesStmt.all(...params) as Record<string, unknown>[],
+    allPaths: (...params) => withBusyRetry(() => allStmt.all(...params) as Record<string, unknown>[]),
     deleteOne: retriedWrite(delStmt),
     upsert: retriedWrite(upsertStmt),
     undoUpsert: retriedWrite(undoUpsertStmt),

package/src/hashline/alphabet.ts

@@ -6,13 +6,13 @@ if (typeof rawAnchors !== "string" || rawAnchors.length === 0 || rawAnchors.leng
 const TABLE: string = rawAnchors;
 export const HASH_LEN = 4;
 export const ANCHOR_COUNT = TABLE.length / HASH_LEN;
-const ALNUM = "A-Za-z0-9";
+const LETTERS = "A-Za-z";
 
-export const ALPH_RE = new RegExp(`^[${ALNUM}]+$`);
+export const ALPH_RE = new RegExp(`^[${LETTERS}]+$`);
 
-export const HASH_CLASS = `[${ALNUM}]{${HASH_LEN}}`;
+export const HASH_CLASS = `[${LETTERS}]{${HASH_LEN}}`;
 
-export const HASH_RUN = `[${ALNUM}]{${HASH_LEN},${HASH_LEN + 1}}`;
+export const HASH_RUN = `[${LETTERS}]{${HASH_LEN},${HASH_LEN + 1}}`;
 
 export const HASH_RE = new RegExp(`^${HASH_CLASS}$`);
 

package/src/hashline/parse.ts

@@ -13,7 +13,7 @@ function diagRef(ref: string): string {
 	const trimmed = ref.trim();
 
 	if (!trimmed.length) {
-		return `[E_BAD_REF] Invalid anchor. Expected a 4-char alphanumeric anchor (e.g. "Hasu").`;
+		return `[E_BAD_REF] Invalid anchor. Expected a 4-character anchor (letters only, e.g. "Hasu").`;
 	}
 
 	if (/^\d+/.test(trimmed)) {
@@ -29,13 +29,13 @@ function diagRef(ref: string): string {
 		const firstHash = firstMatch?.[0] ?? "Hasu";
 		const lastHash = lastMatch?.[0] ?? "Hasu";
 		const preview = first.slice(0, 60);
-		return `[E_BAD_REF] Invalid anchor — remove_from and remove_to must each be a single bare 4-char hash (e.g. "Hasu"), not a block with HASH│content. Received ${lines.length} lines starting "${preview}…" — use only the first hash "${firstHash}" as remove_from and "${lastHash}" as remove_to, and put the new content (without HASH│) in replacement_lines.`;
+		return `[E_BAD_REF] Invalid anchor — remove_from and remove_to must each be a single bare 4-character anchor (letters only, e.g. "Hasu"), not a block with HASH│content. Received ${lines.length} lines starting "${preview}…" — use only the first hash "${firstHash}" as remove_from and "${lastHash}" as remove_to, and put the new content (without HASH│) in replacement_lines.`;
 	}
 	if (trimmed.includes("│")) {
-		return `[E_BAD_REF] Invalid anchor "${trimmed}": use only the 4-char anchor, drop everything from "│" onward.`;
+		return `[E_BAD_REF] Invalid anchor "${trimmed}": use only the 4-character anchor, drop everything from "│" onward.`;
 	}
 
-	return `[E_BAD_REF] Invalid anchor "${trimmed}". Expected a 4-char alphanumeric anchor (e.g. "Hasu").`;
+	return `[E_BAD_REF] Invalid anchor "${trimmed}". Expected a 4-character anchor (letters only, e.g. "Hasu").`;
 }
 
 function parseRef(ref: string): Anchor {

package/src/read.ts

@@ -19,7 +19,7 @@ import { withReadPrompts, DEFAULT_EDIT_FLAGS, type EditToolFlags } from "./edit-
 import { valAccess } from "./validation";
 import { readConfig } from "./config";
 import { resolveTarget } from "./fs-write";
-import { withAnchorSession, servedForPath } from "./anchor-registry";
+import { withAnchorSession, servedForPath, sessionKeyFor } from "./anchor-registry";
 import { serveRows } from "./served";
 import { getAutoReadAllSnapshot } from "./auto-read-all-state";
 import { Text } from "@earendil-works/pi-tui";
@@ -217,7 +217,7 @@ export function regRead(pi: ExtensionAPI, flags: EditToolFlags = DEFAULT_EDIT_FL
                 if (autoReadAllMode !== "off") {
                   const canonical = await resolveTarget(absolutePath).catch(() => undefined);
                   if (canonical !== undefined) {
-                    const stored = getAutoReadAllSnapshot(canonical);
+                    const stored = getAutoReadAllSnapshot(sessionKeyFor(ctx), canonical);
                     if (stored !== undefined) {
                       const current = await safeSnapId(canonical, "auto-read-all guard");
                       if (current !== undefined && current === stored) {

package/src/replace-diff.ts

@@ -4,6 +4,7 @@ import {
   _lineHashesPure,
   ANCHOR_LEN,
   HASH_SEP,
+  HASH_CLASS,
   changedRange,
 } from "./hashline";
 import { MAX_DIFF_INPUT_BYTES, DEDUP_ANCHOR } from "./constants";
@@ -111,7 +112,7 @@ export function spansFromHashes(oldHashes: string[], newHashes: string[]): DiffS
   return spans;
 }
 
-const ANCHORED_DIFF_ROW_RE = /^([+ -])([A-Za-z0-9]{4})│/;
+const ANCHORED_DIFF_ROW_RE = new RegExp(`^([+ -])(${HASH_CLASS})│`);
 
 export function disambiguateDuplicateAnchors(diff: string): string {
   if (!diff.includes("│")) return diff;

package/src/utils.ts

@@ -1,4 +1,5 @@
 import { NUL_CONTENT_MSG } from "./constants";
+import { HASH_CLASS } from "./hashline/alphabet";
 
 export function isRec(value: unknown): value is Record<string, unknown> {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -141,8 +142,10 @@ export function getCached<K, V>(map: Map<K, V>, key: K, compute: (key: K) => V):
 	return v;
 }
 
+const HASH_ROW_RE = new RegExp(`^${HASH_CLASS}│`);
+
 export function isHashRow(line: string): boolean {
-	return /^[A-Za-z0-9]{4}│/.test(line);
+	return HASH_ROW_RE.test(line);
 }
 
 export function gutterWidth(max: number, fallback: number): number {

package/src/write-hook.ts

@@ -5,7 +5,7 @@ import { servedForPath, withAnchorSession } from "./anchor-registry";
 import { resolveInCwd } from "./fs-write";
 import { abortIf, splitLines, isRec, normalizeFilePath } from "./utils";
 
-const HASH_ECHO_RE = new RegExp(`^(${HASH_CLASS})${HASH_SEP}`);
+const HASH_ECHO_RE = new RegExp(`^(?: *[0-9]+ ${HASH_SEP} )?[+ -]?(${HASH_CLASS})${HASH_SEP}`);
 
 function searchEcho(lines: string[], served: ReadonlyMap<string, string> | ReadonlySet<string>): { line: number; hash: string } | undefined {
   for (let i = 0; i < lines.length; i++) {
@@ -27,7 +27,7 @@ export async function servedHashEchoDenial(rawPath: string, content: string, cwd
   if (!served || served.size === 0) return undefined;
   const echo = findServedHashEcho(content, served);
   if (!echo) return undefined;
-  return `[E_WRITE_HASH_ECHO] Refused write to ${rawPath}: line ${echo.line} begins with the exact ${echo.hash}${HASH_SEP} anchor served for this file. Remove the copied anchors and retry.`;
+  return `[E_WRITE_HASH_ECHO] Refused write to ${rawPath}: line ${echo.line} contains the copied ${echo.hash}${HASH_SEP} anchor served for this file. Remove the copied anchors and retry.`;
 }
 
 export function registerWriteHook(pi: ExtensionAPI): void {