pi-hashline-edit-pro 3.0.3 → 4.0.0

package/src/hashline/apply.ts

@@ -167,7 +167,10 @@ export function applyEdit(
 	abortIf(signal);
 
 	const lineIndex = buildIdx(content);
-	const fileHashes = precomputedHashes ?? _lineHashesPure(content);
+	if (precomputedHashes === undefined) {
+		throw new Error("[E_BAD_SHAPE] applyEdit requires the file's allocated anchors; derive them via lineHashes(content, path) first.");
+	}
+	const fileHashes = precomputedHashes;
 	const warnings: string[] = [];
 
 	const rangeFixed = swapReversedRanges(edit, fileHashes, warnings);

package/src/hashline/hash.ts

@@ -1,13 +1,9 @@
 import { splitLines, truncateToBytes, getCached } from "../utils";
 import { MAX_HASH_SOURCE_BYTES } from "../constants";
-import {
-  loadHashStore,
-  type HashStore,
-  getSnapshot,
-  persistSnapshot,
-} from "../hash-store";
+import { loadHashStore, type HashStore } from "../hash-store";
+import { allocateFileAnchors } from "../anchor-registry";
 import { xxh32, initHasher } from "./hasher";
-import { HASH_LEN, ANCHOR_COUNT, anchorAt, anchorIndex, HASH_CLASS, HASH_RUN } from "./alphabet";
+import { HASH_LEN, ANCHOR_COUNT, anchorAt, HASH_CLASS, HASH_RUN } from "./alphabet";
 export { initHasher, HASH_LEN, HASH_CLASS, HASH_RUN };
 
 export const ANCHOR_LEN = HASH_LEN;
@@ -17,7 +13,8 @@ export const HASH_SEP = "│";
 export const HASH_SPACE = ANCHOR_COUNT;
 export const MAX_HASH_LINES = HASH_SPACE;
 
-export const HASH_PROBE_STRIDE = 571;
+export const HASH_PROBE_STRIDE = 836286;
+
 
 function hashAt(idx: number): string {
   return anchorAt(idx);
@@ -117,179 +114,19 @@ export function _lineHashesPure(content: string): string[] {
 export async function lineHashes(
   content: string,
   path?: string,
-  previous?: { content: string; hashes: string[]; removedHashes?: Set<string> },
+  previous?: { content: string; hashes: string[]; spans?: { start: number; end: number; replacementCount: number }[] },
   store?: HashStore,
   persist?: boolean,
+  shadow?: boolean,
 ): Promise<string[]> {
   await initHasher();
   if (!path) {
     return _lineHashesPure(content);
   }
-
-  const hashStore = store ?? await loadHashStore();
-
-  if (previous) {
-    const newHashes = mapStableHashes(
-      previous.content, previous.hashes,
-      content,
-      previous.removedHashes,
-    );
-    if (persist !== false) {
-      try {
-        persistSnapshot(hashStore, path, content, newHashes);
-      } catch (error) {
-        console.error("Failed to persist hash snapshot:", error);
-      }
-    }
-    return newHashes;
-  }
-
-  let cached: string[] | undefined;
-  try {
-    cached = getSnapshot(hashStore, path, content, persist !== false);
-  } catch (error) {
-    console.error("Failed to read hash store snapshot:", error);
-  }
-  if (cached) {
-    return cached;
-  }
-
-  const newHashes = _lineHashesPure(content);
-  if (persist !== false) {
-    try {
-      persistSnapshot(hashStore, path, content, newHashes);
-    } catch (error) {
-      console.error("Failed to persist hash snapshot:", error);
-    }
-  }
-  return newHashes;
-}
-
-function hashToIndex(hash: string): number {
-  return anchorIndex(hash);
-}
-
-function nearestNew(
-  candidates: number[],
-  target: number,
-): number {
-  let lo = 0;
-  let hi = candidates.length;
-  while (lo < hi) {
-    const mid = (lo + hi) >>> 1;
-    if (candidates[mid]! < target) lo = mid + 1;
-    else hi = mid;
-  }
-  const left = lo - 1;
-  const right = lo;
-  if (
-    left >= 0 &&
-    (right >= candidates.length ||
-      target - candidates[left]! <= candidates[right]! - target)
-  ) {
-    return left;
-  }
-  return right < candidates.length ? right : -1;
+  return allocateFileAnchors(store ?? (await loadHashStore()), path, content, {
+    persist,
+    shadow,
+    previous,
+  });
 }
 
-function mapStableHashes(
-  oldContent: string,
-  oldHashes: string[],
-  newContent: string,
-  removedHashes?: Set<string>,
-): string[] {
-  const oldLines = splitLines(oldContent);
-  const newLines = splitLines(newContent);
-  const newHashes = new Array<string>(newLines.length);
-  const used = new Uint32Array(BITSET_WORDS);
-  const hint = { value: 0 };
-  const hashSourceCache = new Map<string, string>();
-  const removed = removedHashes ?? new Set<string>();
-
-  const oldHashIndex = new Map<string, number>();
-  for (let i = 0; i < oldHashes.length; i++) {
-    const hash = oldHashes[i]!;
-    oldHashIndex.set(hash, i);
-    const idx = hashToIndex(hash);
-    if (idx >= 0) setBit(used, idx);
-  }
-
-  const removedIndexes = new Set<number>();
-  for (const hash of removed) {
-    const idx = oldHashIndex.get(hash);
-    if (idx !== undefined) removedIndexes.add(idx);
-  }
-
-  let spanStart = oldLines.length;
-  let spanEnd = -1;
-  for (const idx of removedIndexes) {
-    if (idx < spanStart) spanStart = idx;
-    if (idx > spanEnd) spanEnd = idx;
-  }
-  const spanLen = spanEnd >= spanStart ? spanEnd - spanStart + 1 : 0;
-  const replacementLen = newLines.length - oldLines.length + spanLen;
-  const shiftAfterSpan = spanEnd >= spanStart ? replacementLen - spanLen : 0;
-
-  const survivors: { index: number; hash: string }[] = [];
-  const removedEntries: { index: number; hash: string }[] = [];
-  for (let i = 0; i < oldLines.length; i++) {
-    const entry = { index: i, hash: oldHashes[i]! };
-    if (removedIndexes.has(i)) removedEntries.push(entry);
-    else survivors.push(entry);
-  }
-
-  const newByContent = new Map<string, number[]>();
-  for (let i = 0; i < newLines.length; i++) {
-    const key = getCached(hashSourceCache, newLines[i]!, hashSource);
-    const list = newByContent.get(key);
-    if (list) list.push(i);
-    else newByContent.set(key, [i]);
-  }
-
-  const markUsed = (hash: string): void => {
-    const idx = hashToIndex(hash);
-    if (idx >= 0) {
-      setBit(used, idx);
-      if (idx + HASH_PROBE_STRIDE > hint.value) hint.value = idx + HASH_PROBE_STRIDE;
-    }
-  };
-
-  for (const entry of survivors) {
-    const candidates = newByContent.get(getCached(hashSourceCache, oldLines[entry.index]!, hashSource));
-    if (!candidates || candidates.length === 0) continue;
-    const target = entry.index > spanEnd ? entry.index + shiftAfterSpan : entry.index;
-    const pos = nearestNew(candidates, target);
-    if (pos < 0) continue;
-    const newIdx = candidates.splice(pos, 1)[0]!;
-    newHashes[newIdx] = entry.hash;
-    markUsed(entry.hash);
-  }
-
-  const removedByContent = new Map<string, { hashes: string[]; pos: number }>();
-  for (const entry of removedEntries) {
-    const key = oldLines[entry.index]!;
-    let queue = removedByContent.get(key);
-    if (!queue) {
-      queue = { hashes: [], pos: 0 };
-      removedByContent.set(key, queue);
-    }
-    queue.hashes.push(entry.hash);
-  }
-
-  for (let i = 0; i < newLines.length; i++) {
-    if (newHashes[i]) continue;
-    const queue = removedByContent.get(newLines[i]!);
-    if (!queue || queue.pos >= queue.hashes.length) continue;
-    newHashes[i] = queue.hashes[queue.pos]!;
-    queue.pos += 1;
-  }
-
-  for (let i = 0; i < newLines.length; i++) {
-    if (newHashes[i]) continue;
-    const c = getCached(hashSourceCache, newLines[i]!, hashSource);
-    const baseIdx = (xxh32(c) >>> 14) % HASH_SPACE;
-    newHashes[i] = assignHash(used, baseIdx, hint);
-  }
-
-  return newHashes;
-}

package/src/hashline/parse.ts

@@ -63,14 +63,14 @@ function unwrapJsonEnvelope(line: string, warnings?: string[]): string {
     const parsed: unknown = JSON.parse(withoutDot);
     if (Array.isArray(parsed) && parsed.length === 1 && typeof parsed[0] === "string") {
       warnings?.push(
-        '[E_BAD_SHAPE] Unwrapped JSON array syntax from a replacement_lines element.',
+        '[W_BAD_SHAPE] Unwrapped JSON array syntax from a replacement_lines element.',
       );
       return parsed[0];
     }
     return line;
   } catch {
     warnings?.push(
-      '[E_BAD_SHAPE] Unwrapped JSON array syntax from a replacement_lines element.',
+      '[W_BAD_SHAPE] Unwrapped JSON array syntax from a replacement_lines element.',
     );
     return match[1]!;
   }
@@ -85,12 +85,12 @@ export function parseText(edit: string[], warnings?: string[]): string[] {
   for (const line of edit) {
     const unwrapped = unwrapJsonEnvelope(line, warnings);
     const normalized = unwrapped.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
-    if (normalized !== unwrapped) split = true;
+    if (normalized.includes("\n")) split = true;
     out.push(...normalized.split("\n"));
   }
   if (split) {
     warnings?.push(
-      "[E_BAD_SHAPE] replacement_lines contained embedded newlines; split into one line each.",
+      "[W_BAD_SHAPE] replacement_lines contained embedded newlines; split into one line each.",
     );
   }
   return out;

package/src/hashline/resolve.ts

@@ -3,6 +3,7 @@ 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";
 import { contentChecksum } from "./hasher";
+import { hashSource } from "./hash";
 
 export type RAnchor = {
 	line: number;
@@ -17,8 +18,7 @@ export type RHEdit = {
 
 interface HMismatch {
 	ref: Anchor;
-	kind: "not_found" | "ambiguous";
-	candidates?: number[];
+	kind: "not_found";
 	context?: RAnchor;
 }
 
@@ -52,13 +52,10 @@ function resAnchorFromMap(
 	if (!hashMatches || hashMatches.length === 0) {
 		return { ref, kind: "not_found" };
 	}
-	if (hashMatches.length === 1) {
-		return {
-			line: hashMatches[0]!,
-			hash: ref.hash,
-		};
-	}
-	return { ref, kind: "ambiguous", candidates: hashMatches };
+	return {
+		line: hashMatches[0]!,
+		hash: ref.hash,
+	};
 }
 
 function assertAligned(
@@ -96,10 +93,9 @@ export function fmtMismatchWithHashes(
   const out: string[] = [];
   const hashes: string[] = [];
   const servedMap = new Map<string, string>();
-  const notFound = mismatches.filter((m) => m.kind === "not_found");
-  const ambiguous = mismatches.filter((m) => m.kind === "ambiguous");
-  const refList = notFound.map((m) => `"${m.ref.hash}"`).join(", ");
+  const notFound = mismatches;
   if (notFound.length > 0) {
+    const refList = notFound.map((m) => `"${m.ref.hash}"`).join(", ");
     out.push(
       `[E_STALE_ANCHOR] ${notFound.length} stale anchor${notFound.length > 1 ? "s" : ""}${filePath ? ` in ${filePath}` : ""}: ${refList}. The file changed since read. Call read() for fresh anchors.`
     );
@@ -113,41 +109,13 @@ export function fmtMismatchWithHashes(
         const h = fileHashes[ln - 1]!;
         const c = fileLines[ln - 1] ?? "";
         hashes.push(h);
-        servedMap.set(h, contentChecksum(c));
+        servedMap.set(h, contentChecksum(hashSource(c)));
         rows.push(`    ${ln}: ${h}│${clipLine(c)}`);
       }
       out.push("");
       out.push(`  Current context around resolved anchor "${ctx.hash}" (line ${ctx.line}):\n${rows.join("\n")}`);
     }
   }
-  if (ambiguous.length > 0) {
-    if (out.length > 0) out.push("");
-    out.push(
-      `[E_AMBIGUOUS_ANCHOR] ${ambiguous.length} ambiguous anchor${ambiguous.length > 1 ? "s" : ""}${filePath ? ` in ${filePath}` : ""}. Call read() for fresh anchors.`
-    );
-    for (const m of ambiguous) {
-      const sample = (m.candidates ?? []).slice(0, 5);
-      const more =
-        (m.candidates?.length ?? 0) > sample.length
-          ? `, ... (+${(m.candidates?.length ?? 0) - sample.length} more)`
-          : "";
-      for (const line of sample) {
-        const h = fileHashes[line - 1]!;
-        const c = fileLines[line - 1] ?? "";
-        hashes.push(h);
-        servedMap.set(h, contentChecksum(c));
-      }
-      const lines = sample
-        .map((line) => {
-          const content = clipLine(fileLines[line - 1] ?? "");
-          return `    ${line}: ${fileHashes[line - 1]}│${content}`;
-        })
-        .join("\n");
-        out.push(
-          `  Hash "${m.ref.hash}" matches lines ${sample.join(", ")}${more}.\n${lines}`,
-        );
-    }
-  }
   return { text: out.join("\n"), hashes, servedMap };
 }
 
@@ -195,7 +163,7 @@ export function stripAnchorRow(
 			: match[1] === "-"
 				? 'leading "-" marker'
 				: '"anchor│" prefix';
-	warnings?.push(`[E_BAD_REF] Stripped ${marker} from ${entryLabel} "${clipLine(trimmed, 48)}".`);
+  warnings?.push(`[W_BAD_REF] Stripped ${marker} from ${entryLabel} "${clipLine(trimmed, 48)}".`);
 	return match[2]!;
 }
 
@@ -241,7 +209,7 @@ export function stripBarePrefixes(
 		.map((s) => `replacement_lines line ${s.lineIndex + 1}`)
 		.join(", ");
 	warnings.push(
-		`[E_BARE_HASH_PREFIX] Stripped "anchor│" prefix from ${locations}.`
+    `[W_BARE_HASH_PREFIX] Stripped "anchor│" prefix from ${locations}.`
 	);
 	return { ...edit, content_lines: contentLines };
 }
@@ -260,7 +228,7 @@ export function stripDiffPrefixes(
 	if (stripped.length === 0) return edit;
 	const locations = stripped.map((i) => `replacement_lines line ${i + 1}`).join(", ");
 	warnings.push(
-		`[E_INVALID_PATCH] Stripped diff-preview marker from ${locations}.`
+    `[W_INVALID_PATCH] Stripped diff-preview marker from ${locations}.`
 	);
 	return { ...edit, content_lines: contentLines };
 }
@@ -285,7 +253,7 @@ export function swapReversedRanges(
 		return edit;
 	}
 	warnings.push(
-		`[E_BAD_OP] Swapped reversed remove_from/remove_to.`
+    `[W_BAD_OP] Swapped reversed remove_from/remove_to.`
 	);
 	return { ...edit, hash_bounds: [endRef, startRef] as [Anchor, Anchor] };
 }
@@ -545,7 +513,7 @@ export function assertRangeServed(
     const hash = fileHashes[line - 1]!;
     const content = fileLines[line - 1]!;
     const servedContent = served?.get(hash);
-    if (servedContent === undefined || servedContent !== contentChecksum(content)) mismatchLines.push(line);
+    if (servedContent === undefined || servedContent !== contentChecksum(hashSource(content))) mismatchLines.push(line);
   }
   if (mismatchLines.length === 0) return;
   const rangeLength = endLine - startLine + 1;
@@ -557,7 +525,7 @@ export function assertRangeServed(
     const hash = fileHashes[line - 1]!;
     const content = fileLines[line - 1]!;
     shownHashes.push(hash);
-    shownMap.set(hash, contentChecksum(content));
+    shownMap.set(hash, contentChecksum(hashSource(content)));
     rows.push(fmtRow(hash, clipLine(content)));
   }
   const location = filePath ? ` in ${filePath}` : "";

package/src/insert.ts

@@ -10,14 +10,13 @@ import { loadP, loadGuide } from "./prompts";
 import { normReq } from "./payload-contract";
 import { decodeStringArray, isRec, rejectUnknownFields, splitLines } from "./utils";
 import { clearBoundaryBypass } from "./boundary-bypass";
-import { resolveInsertPath } from "./missing-path";
+import { resolveEditTarget } from "./edit-common";
 import type { RPreview, RRState } from "./replace-render";
 import { queuedEdit, editToolBase, editRenderCallWrapper, editRenderResultWrapper } from "./edit-common";
 
-const INSERT_KS = new Set(["path", "anchor", "direction", "lines"]);
+const INSERT_KS = new Set(["anchor", "direction", "lines"]);
 
 export interface InsertReq {
-  path: string;
   anchor: string;
   direction: "before" | "after";
   lines: string[];
@@ -28,9 +27,6 @@ export function assertInsertReq(request: unknown): asserts request is InsertReq
     throw new Error("[E_BAD_SHAPE] Insert request must be an object.");
   }
   rejectUnknownFields(request, INSERT_KS, "Insert request");
-  if (typeof request.path !== "string" || request.path.length === 0) {
-    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 (4-char anchor from read output).');
   }
@@ -44,15 +40,9 @@ export function assertInsertReq(request: unknown): asserts request is InsertReq
 
 const insertToolSchema = Type.Object(
   {
-    path: Type.Optional(
-      Type.String({
-        description:
-          "Path to edit; always provide it explicitly — it is only auto-resolved from the anchors as a fallback.",
-      }),
-    ),
     anchor: Type.String({
       description:
-        'Bare 4-char anchor from a read row like `Hasu│content`, never the content. A pasted `+Hasu│x` diff row or `anchor│` prefix is stripped with a warning. The anchor line is preserved; lines go after or before it.',
+        'Bare 4-char anchor from a read row (the text before the `│` separator), never the row content. A pasted diff row or `anchor│` prefix is stripped with a warning. The anchor line is preserved; lines go after or before it.',
     }),
     direction: Type.Union(
       [
@@ -86,12 +76,12 @@ function buildInsertEdit(
   req: InsertReq,
   preload: NormFile,
   ref: Anchor,
+  path: string,
 ): { editParams: ReqParams; anchorLine: string | undefined } {
   const fileLines = splitLines(preload.normalized);
-  const line = resolveAnchorLine(ref, fileLines, preload.fileHashes, req.path);
+  const line = resolveAnchorLine(ref, fileLines, preload.fileHashes, path);
   const anchorLine = preload.normalized.length === 0 ? undefined : fileLines[line - 1];
   const editParams: ReqParams = {
-    path: req.path,
     remove_from: ref.hash,
     remove_to: ref.hash,
     replacement_lines:
@@ -111,20 +101,17 @@ export async function insertPreview(request: unknown, cwd: string, signal?: Abor
       const expanded = decodeStringArray(normalized.lines);
       if (expanded) normalized.lines = expanded;
     }
-    if (isRec(normalized)) {
-      const resolution = await resolveInsertPath(normalized);
-      if (resolution) normalized.path = resolution.path;
-    }
     assertInsertReq(normalized);
     const { ref } = parseInsertAnchor(normalized.anchor);
-    const preload = await readNormFile(normalized.path, cwd, {
+    const targetPath = resolveEditTarget(normalized.anchor);
+    const preload = await readNormFile(targetPath, cwd, {
       accessMode: constants.R_OK,
       maxLines: MAX_HASH_LINES,
       noPersist: true,
       signal,
     });
-    const { editParams } = buildInsertEdit(normalized, preload, ref);
-    const pipe = await execPipeline(editParams, cwd, {
+    const { editParams } = buildInsertEdit(normalized, preload, ref, targetPath);
+    const pipe = await execPipeline(targetPath, editParams, cwd, {
       accessMode: constants.R_OK,
       noPersist: true,
       preloadedNorm: preload,
@@ -181,38 +168,36 @@ export function buildInsertToolDef(): InsertToolDef {
       if (isRec(canonical)) {
         const expanded = decodeStringArray(canonical.lines);
         if (expanded) {
-          insertWarnings.push('[E_BAD_SHAPE] Unwrapped JSON array syntax from a lines element.');
+          insertWarnings.push('[W_BAD_SHAPE] Unwrapped JSON array syntax from a lines element.');
           canonical.lines = expanded;
         }
       }
-      const resolution = isRec(canonical) ? await resolveInsertPath(canonical) : undefined;
-      if (resolution && isRec(canonical)) canonical.path = resolution.path;
       assertInsertReq(canonical);
       const req = canonical;
-      const path = req.path;
+      const targetPath = resolveEditTarget(req.anchor);
       const { ref, warnings: anchorWarnings } = parseInsertAnchor(req.anchor);
-      return queuedEdit(path, ctx.cwd, signal, async (absolutePath, mutationTargetPath) => {
-        const preload = await readNormFile(path, ctx.cwd, {
+      return queuedEdit(targetPath, ctx.cwd, signal, async (absolutePath, mutationTargetPath) => {
+        const preload = await readNormFile(targetPath, ctx.cwd, {
           signal,
           accessMode: constants.R_OK | constants.W_OK,
           maxLines: MAX_HASH_LINES,
         });
-        const { editParams, anchorLine } = buildInsertEdit(req, preload, ref);
-        const pipe = await execPipeline(editParams, ctx.cwd, {
+        const { editParams, anchorLine } = buildInsertEdit(req, preload, ref, targetPath);
+        const pipe = await execPipeline(targetPath, editParams, ctx.cwd, {
           accessMode: constants.R_OK | constants.W_OK,
           signal,
           preloadedNorm: preload,
           skipBoundaryDedup: true,
         });
         return commitEdit(pipe, {
-          path,
+          path: pipe.path,
           absolutePath,
           mutationTargetPath,
           signal,
           verb: "inserted",
           noopNoun: "Insertion",
           foldedAnchorLines: anchorLine === undefined ? 0 : 1,
-          prefixWarnings: [...(resolution ? [resolution.warning] : []), ...anchorWarnings, ...insertWarnings],
+          prefixWarnings: [...anchorWarnings, ...insertWarnings],
           onApplied: () => clearBoundaryBypass(mutationTargetPath),
         });
       });

package/src/paths.ts

@@ -31,6 +31,10 @@ export function legacyHashStorePath(): string {
   return join(configDir(), "hash-store.json");
 }
 
+export function sessionClaimsDir(): string {
+  return join(configDir(), "sessions");
+}
+
 export function hashStoreDir(): string {
   return dirname(hashStorePath());
 }

package/src/payload-contract.ts

@@ -1,5 +1,5 @@
 import { Type } from "typebox";
-import { isRec, normalizeFilePath, rejectUnknownFields } from "./utils";
+import { isRec, normalizeAnchors, normalizeFilePath, rejectUnknownFields } from "./utils";
 
 const replacementLinesSchema = Type.Array(
   Type.String({
@@ -14,22 +14,16 @@ const replacementLinesSchema = Type.Array(
 
 const removeFromSchema = Type.String({
   description:
-    "Bare 4-char anchor from a read row like `Hasu│content` (the leftmost column), never the row content. Marks the FIRST line to remove (inclusive)",
+    "Bare 4-char anchor from a read row (the text before the `│` separator), never the row content. Marks the FIRST line to remove (inclusive)",
 });
 
 const removeToSchema = Type.String({
   description:
-    "Bare 4-char anchor from a read row like `Hasu│content` (the leftmost column), never the row content. Marks the LAST line to remove (inclusive)",
+    "Bare 4-char anchor from a read row (the text before the `│` separator), never the row content. Marks the LAST line to remove (inclusive)",
 });
 
 export const editToolSchema = Type.Object(
   {
-    path: Type.Optional(
-      Type.String({
-        description:
-          "Path to edit; always provide it explicitly — it is only auto-resolved from the anchors as a fallback.",
-      }),
-    ),
     remove_from: removeFromSchema,
     remove_to: removeToSchema,
     replacement_lines: replacementLinesSchema,
@@ -38,22 +32,18 @@ export const editToolSchema = Type.Object(
 );
 
 export type ReqParams = {
-  path: string;
   remove_from: string;
   remove_to: string;
   replacement_lines: string[];
 };
 
-const ROOT_KS = new Set(["path", "remove_from", "remove_to", "replacement_lines"]);
+const ROOT_KS = new Set(["remove_from", "remove_to", "replacement_lines"]);
 
 export function assertReq(request: unknown): asserts request is ReqParams {
   if (!isRec(request)) {
     throw new Error("[E_BAD_SHAPE] Edit request must be an object.");
   }
   rejectUnknownFields(request, ROOT_KS, "Edit request");
-  if (typeof request.path !== "string" || request.path.length === 0) {
-    throw new Error('[E_BAD_SHAPE] Edit request requires a non-empty "path" string.');
-  }
   if (
     typeof request.remove_from !== "string" ||
     typeof request.remove_to !== "string" ||
@@ -72,6 +62,7 @@ export function normReq(input: unknown): unknown {
   }
   const record: Record<string, unknown> = { ...input };
   normalizeFilePath(record);
+  normalizeAnchors(record);
   return record;
 }
 

package/src/read.ts

@@ -14,11 +14,11 @@ import { readNormFile, safeSnapId } from "./file-reader";
 import { lineHashes, fmtRegion, fmtRow, HASH_SEP, MAX_HASH_LINES } from "./hashline";
 import { toCwd } from "./paths";
 import { abortIf, makePrepareArguments, numberedRead, visLines, splitLines } from "./utils";
-import { recordServedSafe, buildServedMap } from "./served";
 import { loadP, loadGuide } from "./prompts";
 import { valAccess } from "./validation";
+import { markServed as markServedScoped } from "./anchor-registry";
+import { buildServedMap } from "./served";
 import { Text } from "@earendil-works/pi-tui";
-
 const R_DESC = loadP("../prompts/read.md");
 
 const R_SNIPPET = loadP("../prompts/read-snippet.md");
@@ -227,6 +227,7 @@ export function regRead(pi: ExtensionAPI): void {
       const { normalized, fileHashes, hadUtf8DecodeErrors, absolutePath: resolvedPath } = await readNormFile(
         rawPath, ctx.cwd, { signal, preloadedFile: file, maxLines: MAX_HASH_LINES },
       );
+			const fileLines = splitLines(normalized);
 			const preview = await fmtReadPreview(
 				normalized,
 				{
@@ -236,9 +237,7 @@ export function regRead(pi: ExtensionAPI): void {
 				fileHashes,
 				resolvedPath,
 			);
-			const fileLines = splitLines(normalized);
-			const servedMap = buildServedMap(fileHashes, fileLines, preview.servedHashes);
-			await recordServedSafe(resolvedPath, servedMap, "read", new Set(fileHashes));
+			markServedScoped(resolvedPath, buildServedMap(fileHashes, fileLines, preview.servedHashes), new Set(fileHashes));
 			const snapshotId = await safeSnapId(absolutePath, "read");
 			const previewText =
 				hadUtf8DecodeErrors