pi-hashline-edit-pro 2.7.2 → 2.8.1

package/src/replace-undo.ts

@@ -1,16 +1,17 @@
-import { readFile } from "fs/promises";
+import { constants } from "fs";
+import { open } from "fs/promises";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { withFileMutationQueue } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
-import { loadHashStore, upsertSnapshot, upsertUndo, getUndoEntry, deleteUndo, type UndoRecord } from "./hash-store";
+import { loadHashStore, persistSnapshot, upsertUndo, getUndoEntry, deleteUndo, type UndoRecord } from "./hash-store";
 import { recordServedDiff } from "./served";
-import { contentChecksum } from "./hashline/hasher";
-import { resolveTarget, writeAtomic } from "./fs-write";
-import { toCwd } from "./paths";
-import { toLF, stripBOM, genDiff, genPatch, restoreEndings, type LineEnding } from "./replace-diff";
-import { cntDiff, splitLines, errCode, makePrepareArguments } from "./utils";
+import { resolveInCwd, writeAtomic, type FileIdentity } from "./fs-write";
+import { toLF, stripBOM, restoreEndings, type LineEnding } from "./normalize";
+import { genDiff, genPatch } from "./replace-diff";
+import { cntDiff, errCode, makePrepareArguments } from "./utils";
 import { loadP, loadGuide } from "./prompts";
 import { buildMetrics } from "./replace-response";
+import { renderEditResult } from "./replace-render";
 import { changedRange, lineHashes } from "./hashline";
 export interface UndoEntry {
   content: string;
@@ -98,11 +99,13 @@ export function regUndo(pi: ExtensionAPI): void {
         description: "Path to the file to undo",
       }),
     }),
-
+    executionMode: "sequential",
+    renderResult(result, opts, theme, context) {
+      return renderEditResult(result as never, opts as { isPartial: boolean; expanded?: boolean }, theme as never, context as never);
+    },
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
       const path = params.path;
-      const absolutePath = toCwd(path, ctx.cwd);
-      const mutationTargetPath = await resolveTarget(absolutePath);
+      const { resolved: mutationTargetPath } = await resolveInCwd(path, ctx.cwd);
 
       const undo = await getUndo(mutationTargetPath);
       if (!undo) {
@@ -120,8 +123,17 @@ export function regUndo(pi: ExtensionAPI): void {
 
       return withFileMutationQueue(mutationTargetPath, async () => {
         let currentRaw: string | undefined;
+        let currentIdentity: FileIdentity | undefined;
         try {
-          currentRaw = await readFile(mutationTargetPath, "utf-8");
+          const noFollow = process.platform === "win32" ? 0 : constants.O_NOFOLLOW;
+          const handle = await open(mutationTargetPath, constants.O_RDONLY | noFollow);
+          try {
+            const { dev, ino } = await handle.stat();
+            currentIdentity = { dev, ino };
+            currentRaw = await handle.readFile("utf-8");
+          } finally {
+            await handle.close();
+          }
         } catch (error) {
           if (errCode(error) !== "ENOENT") throw error;
         }
@@ -145,6 +157,7 @@ export function regUndo(pi: ExtensionAPI): void {
         await writeAtomic(
           mutationTargetPath,
           undo.bom + restoreEndings(undo.content, undo.originalEnding),
+          currentIdentity,
         );
 
         const currentNormalized = currentRaw === undefined ? "" : toLF(stripBOM(currentRaw).text);
@@ -153,11 +166,12 @@ export function regUndo(pi: ExtensionAPI): void {
         const linesAddedByReplace = cntDiff(diffResult.diff, "+");
         const linesRemovedByReplace = cntDiff(diffResult.diff, "-");
         const restoredRange = changedRange(currentNormalized, undo.content);
-        const undoDiff = genDiff(currentNormalized, undo.content, 1, undo.hashes, currentHashes).diff;
+        const undoDiffResult = genDiff(currentNormalized, undo.content, 1, undo.hashes, currentHashes);
+        const undoDiff = undoDiffResult.diff;
 
         try {
           const store = await loadHashStore();
-          upsertSnapshot(store, mutationTargetPath, contentChecksum(undo.content), splitLines(undo.content).length, undo.hashes);
+          persistSnapshot(store, mutationTargetPath, undo.content, undo.hashes);
           recordServedDiff(store, mutationTargetPath, undoDiff, new Set(undo.hashes));
         } catch (error) {
           console.error("Failed to restore hash store snapshot after undo:", error);
@@ -190,6 +204,7 @@ export function regUndo(pi: ExtensionAPI): void {
           ],
           details: {
             diff: undoDiff,
+            diffLineNumbers: undoDiffResult.lineNumbers,
             patch: patchResult.patch,
             ...(patchResult.truncated ? { patchTruncated: true as const } : {}),
             metrics: buildMetrics({

package/src/replace.ts

@@ -2,17 +2,16 @@ import type {
   ExtensionAPI,
   ToolDefinition,
 } from "@earendil-works/pi-coding-agent";
-import { withFileMutationQueue } from "@earendil-works/pi-coding-agent";
-import { Type } from "typebox";
 import { constants } from "fs";
 import {
   genDiff,
   type LineEnding,
 } from "./replace-diff";
 import { readNormFile, type NormFile } from "./file-reader";
-import { normReq } from "./replace-normalize";
-import { isRec, rejectUnknownFields, abortIf, makePrepareArguments } from "./utils";
-import { resolveTarget } from "./fs-write";
+import { editToolSchema, type ReqParams, assertReq, normReq } from "./payload-contract";
+import { isRec } from "./utils";
+import { loadP, loadGuide } from "./prompts";
+import { type FileIdentity } from "./fs-write";
 import { applyEdit,
   lineHashes,
   resEdit,
@@ -23,54 +22,18 @@ import { applyEdit,
   type HEdit,
   type NEdit,
 } from "./hashline";
-import { toCwd } from "./paths";
+import { commitEdit } from "./commit";
 import type { RMetrics } from "./replace-response";
 import {
-  makeRenderCall,
-  renderEditResult,
   type RPreview,
   type RRState,
 } from "./replace-render";
-import { loadP, loadGuide } from "./prompts";
 import { loadHashStore, findSnapshotPaths, findServedPaths, type HashStore } from "./hash-store";
 import { getServed, recordServedSafe } from "./served";
 import { noopPayloadKey, markBoundaryNoop, consumeBoundaryBypass, clearBoundaryBypass } from "./boundary-bypass";
-import { commitEdit } from "./commit";
-
-const replacementLinesSchema = Type.Array(
-  Type.String({
-    description:
-      "One replacement line. Each element is exactly one line; do not embed \\n inside an element: use separate elements.",
-  }),
-  {
-    description:
-      "Replacement lines as an array of strings, one element per line. Use [] to delete the range."
-  }
-);
+import { queuedEdit, editToolBase, editRenderCallWrapper, editRenderResultWrapper } from "./edit-common";
 
-const removeFromSchema = Type.String({
-  description: "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. Marks the FIRST line to remove (inclusive)",
-});
-
-const removeToSchema = Type.String({
-  description: "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. Marks the LAST line to remove (inclusive)",
-});
-
-export const editToolSchema = Type.Object(
-  {
-    path: Type.Optional(Type.String({ description: "Path to edit. Required: always provide it explicitly; it is only auto-resolved from the anchors as a fallback when omitted by mistake." })),
-    remove_from: removeFromSchema,
-    remove_to: removeToSchema,
-    replacement_lines: replacementLinesSchema,
-  },
-  { additionalProperties: false },
-);
-export type ReqParams = {
-  path: string;
-  remove_from: string;
-  remove_to: string;
-  replacement_lines: string[];
-};
+export { editToolSchema, type ReqParams, assertReq };
 
 export type ReplaceDetails = {
   diff: string;
@@ -80,6 +43,7 @@ export type ReplaceDetails = {
   snapshotId?: string;
   classification?: "noop";
   metrics?: RMetrics;
+  diffLineNumbers?: (number|undefined)[];
 };
 
 export interface PipelineResult {
@@ -99,33 +63,7 @@ export interface PipelineResult {
   totalRemovedLines: number;
   hadBoundaryDedup: boolean;
   boundaryRemovedLines: number;
-}
-
-const ROOT_KS = new Set(["path", "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" ||
-    !Array.isArray(request.replacement_lines) ||
-    request.replacement_lines.some((line) => typeof line !== "string")
-  ) {
-    throw new Error(
-      '[E_BAD_SHAPE] Edit request requires "remove_from", "remove_to", and "replacement_lines" (array of strings, one per line; use [] to delete).',
-    );
-  }
+  identity: FileIdentity;
 }
 
 async function resolveMissingPath(
@@ -173,21 +111,26 @@ export interface ExecPipelineOptions {
   preloadedNorm?: NormFile;
 }
 
+function hashSpan(hashes: string[], from: string, to: string): [number, number] | undefined {
+  const a = hashes.indexOf(from);
+  const b = hashes.indexOf(to);
+  if (a < 0 || b < 0) return undefined;
+  return [Math.min(a, b), Math.max(a, b)];
+}
+async function noteAnchorError(absolutePath: string, error: unknown, scopeHashes: string[], noPersist?: boolean): Promise<void> {
+  if (noPersist === true) return;
+  if (error instanceof RangeStaleError) await recordServedSafe(absolutePath, error.rangeHashes, "range-stale feedback", new Set(scopeHashes));
+  else if (error instanceof AnchorMismatchError) await recordServedSafe(absolutePath, error.feedbackHashes, "anchor-mismatch feedback", new Set(scopeHashes));
+}
+
 function collectRemovedHashes(
   edit: HEdit,
   originalHashes: string[],
 ): Set<string> {
+  const span = hashSpan(originalHashes, edit.hash_bounds[0].hash, edit.hash_bounds[1].hash);
   const removedHashes = new Set<string>();
-  const startHash = edit.hash_bounds[0].hash;
-  const endHash = edit.hash_bounds[1].hash;
-  const startLine = originalHashes.indexOf(startHash);
-  const endLine = originalHashes.indexOf(endHash);
-  if (startLine >= 0 && endLine >= 0) {
-    const firstLine = Math.min(startLine, endLine);
-    const lastLine = Math.max(startLine, endLine);
-    for (let i = firstLine; i <= lastLine; i++) {
-      removedHashes.add(originalHashes[i]!);
-    }
+  if (span) {
+    for (let i = span[0]; i <= span[1]; i++) removedHashes.add(originalHashes[i]!);
   }
   return removedHashes;
 }
@@ -199,12 +142,8 @@ function countLineChanges(
   removedAutoFixes: number,
 ): { totalAddedLines: number; totalRemovedLines: number } {
   if (isNoop) return { totalAddedLines: 0, totalRemovedLines: 0 };
-  let totalRemovedLines = 0;
-  const startLine = originalHashes.indexOf(edit.hash_bounds[0].hash);
-  const endLine = originalHashes.indexOf(edit.hash_bounds[1].hash);
-  if (startLine >= 0 && endLine >= 0) {
-    totalRemovedLines = Math.abs(endLine - startLine) + 1;
-  }
+  const span = hashSpan(originalHashes, edit.hash_bounds[0].hash, edit.hash_bounds[1].hash);
+  const totalRemovedLines = span ? span[1] - span[0] + 1 : 0;
   return {
     totalAddedLines: Math.max(0, edit.content_lines.length - removedAutoFixes),
     totalRemovedLines,
@@ -230,7 +169,7 @@ export async function execPipeline(
   );
 
   const hashStore = options?.store ?? await loadHashStore();
-  const { normalized: originalNormalized, bom, originalEnding, fileHashes: originalHashes, hadUtf8DecodeErrors, absolutePath } = await readNormFile(
+  const { normalized: originalNormalized, bom, originalEnding, fileHashes: originalHashes, hadUtf8DecodeErrors, absolutePath, identity } = await readNormFile(
     path, cwd, { signal: options?.signal, accessMode: options?.accessMode, maxLines: MAX_HASH_LINES, store: hashStore, noPersist: options?.noPersist, preloadedNorm: options?.preloadedNorm },
   );
 
@@ -247,13 +186,7 @@ export async function execPipeline(
       options?.skipBoundaryDedup,
     );
   } catch (error) {
-    if (options?.noPersist !== true) {
-      if (error instanceof RangeStaleError) {
-        await recordServedSafe(absolutePath, error.rangeHashes, "range-stale feedback", new Set(originalHashes));
-      } else if (error instanceof AnchorMismatchError) {
-        await recordServedSafe(absolutePath, error.feedbackHashes, "anchor-mismatch feedback", new Set(originalHashes));
-      }
-    }
+    await noteAnchorError(absolutePath, error, originalHashes, options?.noPersist);
     throw error;
   }
 
@@ -293,9 +226,21 @@ export async function execPipeline(
     totalRemovedLines,
     hadBoundaryDedup: (anchorResult.autoFixes?.length ?? 0) > 0,
     boundaryRemovedLines: anchorResult.autoFixes?.length ?? 0,
+    identity,
   };
 }
 
+export function previewFromPipe(pipe: PipelineResult): RPreview {
+  if (pipe.originalNormalized === pipe.result) {
+    return {
+      error: `No changes made to ${pipe.path}. The edit produced identical content.`,
+    };
+  }
+  return { diff: genDiff(pipe.originalNormalized, pipe.result, 4, pipe.resultHashes, pipe.originalHashes).diff };
+}
+export function previewError(error: unknown): RPreview {
+  return { error: error instanceof Error ? error.message : String(error) };
+}
 export async function compPreview(
   request: unknown,
   cwd: string,
@@ -303,20 +248,14 @@ export async function compPreview(
   try {
     const normalized = normReq(request);
     assertReq(normalized);
-    const { path, originalNormalized, result, resultHashes, originalHashes } = await execPipeline(
+    const pipe = await execPipeline(
       normalized,
       cwd,
       { accessMode: constants.R_OK, noPersist: true },
     );
-    if (originalNormalized === result) {
-      return {
-        error: `No changes made to ${path}. The edit produced identical content.`,
-      };
-    }
-
-    return { diff: genDiff(originalNormalized, result, 4, resultHashes, originalHashes).diff };
+    return previewFromPipe(pipe);
   } catch (error: unknown) {
-    return { error: error instanceof Error ? error.message : String(error) };
+    return previewError(error);
   }
 }
 
@@ -326,12 +265,10 @@ type ToolDef = ToolDefinition<
   RRState
 > & { renderShell?: "default" | "self" };
 
-
 export function buildToolDef(): ToolDef {
   const E_DESC = loadP("../prompts/replace.md");
   const E_SNIPPET = loadP("../prompts/replace-snippet.md");
   const E_GUIDE = loadGuide("../prompts/replace-guidelines.md");
-
   const parameters = editToolSchema;
   return {
     name: "replace",
@@ -340,21 +277,9 @@ export function buildToolDef(): ToolDef {
     parameters,
     promptSnippet: E_SNIPPET,
     promptGuidelines: E_GUIDE,
-    prepareArguments: makePrepareArguments(),
-    renderShell: "default",
-    renderCall: makeRenderCall(compPreview),
-    renderResult(result, { isPartial }, theme, context) {
-      return renderEditResult(
-        result as {
-          content?: Array<{ type: string; text?: string }>;
-          details?: ReplaceDetails;
-        },
-        isPartial,
-        theme,
-        context,
-      );
-    },
-
+    ...editToolBase,
+    renderCall: editRenderCallWrapper(compPreview),
+    renderResult: editRenderResultWrapper,
     async execute(_toolCallId, params, signal, _onUpdate, ctx) {
       const canonical = normReq(params);
       const resolution = isRec(canonical) ? await resolveMissingPath(canonical) : undefined;
@@ -362,15 +287,11 @@ export function buildToolDef(): ToolDef {
         canonical.path = resolution.path;
       }
       assertReq(canonical);
-
       const normalizedParams = canonical;
       const path = normalizedParams.path;
-      const absolutePath = toCwd(path, ctx.cwd);
-      const mutationTargetPath = await resolveTarget(absolutePath);
-      const noopPayload = noopPayloadKey(mutationTargetPath, normalizedParams.remove_from, normalizedParams.remove_to, normalizedParams.replacement_lines);
-      const boundaryBypass = consumeBoundaryBypass(mutationTargetPath, noopPayload);
-      return withFileMutationQueue(mutationTargetPath, async () => {
-        abortIf(signal);
+      return queuedEdit(path, ctx.cwd, signal, async (absolutePath, mutationTargetPath) => {
+        const noopPayload = noopPayloadKey(mutationTargetPath, normalizedParams.remove_from, normalizedParams.remove_to, normalizedParams.replacement_lines);
+        const boundaryBypass = consumeBoundaryBypass(mutationTargetPath, noopPayload);
         const pipe = await execPipeline(
           normalizedParams,
           ctx.cwd,

package/src/served.ts

@@ -1,4 +1,4 @@
-import { loadHashStore, parseStoredHashes, type HashStore } from "./hash-store";
+import { loadHashStore, parseStoredHashes, STORE_NOT_OPEN_MESSAGE, withStore, type HashStore } from "./hash-store";
 import { HASH_CLASS } from "./hashline/alphabet";
 
 const SERVED_DIFF_ROW_RE = new RegExp(`^[+ ](${HASH_CLASS})│`);
@@ -19,14 +19,14 @@ export function getServed(store: HashStore, path: string): Set<string> | undefin
   return new Set(parsed);
 }
 
-export function recordServed(
+function computeUpdate(
   store: HashStore,
   path: string,
   hashes: string[],
   scope?: ReadonlySet<string>,
-): void {
+): Set<string> | undefined {
   const existing = getServed(store, path);
-  if (!existing && hashes.length === 0) return;
+  if (!existing && hashes.length === 0) return undefined;
   const set = existing ?? new Set<string>();
   let changed = false;
   if (scope) {
@@ -43,7 +43,28 @@ export function recordServed(
       changed = true;
     }
   }
-  if (!changed) return;
+  if (!changed) return undefined;
+  return set;
+}
+
+export function recordServed(
+  store: HashStore,
+  path: string,
+  hashes: string[],
+  scope?: ReadonlySet<string>,
+): void {
+  try {
+    withStore(() => {
+      const set = computeUpdate(store, path, hashes, scope);
+      if (!set) return;
+      store.stmts.servedUpsert(path, JSON.stringify([...set]), Date.now());
+    });
+    return;
+  } catch (error) {
+    if (!(error instanceof Error && error.message === STORE_NOT_OPEN_MESSAGE)) throw error;
+  }
+  const set = computeUpdate(store, path, hashes, scope);
+  if (!set) return;
   store.stmts.servedUpsert(path, JSON.stringify([...set]), Date.now());
 }
 

package/src/utils.ts

@@ -106,7 +106,65 @@ export function truncateToBytes(s: string, maxBytes: number): string {
 	return out;
 }
 
+export function getCached<K, V>(map: Map<K, V>, key: K, compute: (key: K) => V): V {
+	if (map.has(key)) return map.get(key)!;
+	const v = compute(key);
+	map.set(key, v);
+	return v;
+}
+
+export function isHashRow(line: string): boolean {
+	return /^[A-Za-z0-9]{3}│/.test(line);
+}
+
+function gutterWidth(max: number, fallback: number): number {
+	return String(max || fallback).length;
+}
+
+function formatGutter(n: number, width: number): string {
+	return String(n).padStart(width) + " │ ";
+}
+
+function blankGutter(width: number): string {
+	return " ".repeat(width) + " │ ";
+}
+
+export function numberedRead(text: string, offset: number): string {
+	const lines = text.split("\n");
+	const hashLines = lines.filter(isHashRow).length;
+	const max = hashLines > 0 ? offset + hashLines - 1 : offset;
+	const width = gutterWidth(max, offset);
+	let n = offset;
+	return lines.map((line) => {
+		if (!isHashRow(line)) return line;
+		const prefix = formatGutter(n++, width);
+		return prefix + line;
+	}).join("\n");
+}
+
+export function withLineNumbers(text: string, numbers: (number|undefined)[]): string {
+	const lines = text.split("\n");
+	const nums = numbers ?? [];
+	const max = nums.reduce<number>((m, n) => n !== undefined && n > m ? n : m, 0);
+	const width = gutterWidth(max, lines.length);
+	return lines.map((line, i) => {
+		const n = nums[i];
+		const prefix = n !== undefined ? formatGutter(n, width) : blankGutter(width);
+		return prefix + line;
+	}).join("\n");
+}
 export function clipLine(line: string, maxLen = 200): string {
 	const flat = line.replace(/\n/g, "\\n");
 	return flat.length > maxLen ? `${flat.slice(0, maxLen)}...` : flat;
 }
+export function assertLineLimit(content: string, displayPath: string, limit: number): void {
+	const count = splitLines(content).length;
+	if (count > limit) throw new Error(formatLineLimit(displayPath, limit, count));
+}
+export function lineLimitMoreThanMessage(displayPath: string, limit: number): string {
+	return formatLineLimit(displayPath, limit, undefined);
+}
+function formatLineLimit(displayPath: string, limit: number, count: number | undefined): string {
+	const detail = count === undefined ? `has more than ${limit}` : `has ${count}`;
+	return `[E_FILE_TOO_LARGE] ${displayPath} ${detail} lines, exceeding the ${limit}-line hashline limit. For very large files, use write.`;
+}

package/src/validation.ts

@@ -1,6 +1,7 @@
 import { constants } from "fs";
 import { access as fsAccess } from "fs/promises";
 import type { LFile } from "./file-kind";
+import type { FileIdentity } from "./fs-write";
 import { errCode } from "./utils";
 
 export async function valAccess(
@@ -26,7 +27,7 @@ export async function valAccess(
 	}
 }
 
-export function valKind(file: LFile, path: string): asserts file is { kind: "text"; text: string; hadUtf8DecodeErrors?: true } {
+export function valKind(file: LFile, path: string): asserts file is { kind: "text"; text: string; identity?: FileIdentity; hadUtf8DecodeErrors?: true } {
 	if (file.kind === "directory") {
 		throw new Error(`[E_NOT_TEXT] Path is a directory: ${path}. Use ls to inspect directories.`);
 	}
@@ -42,4 +43,3 @@ export function valKind(file: LFile, path: string): asserts file is { kind: "tex
 		);
 	}
 }
-

package/src/write-hook.ts

@@ -0,0 +1,59 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { HASH_CLASS } from "./hashline/alphabet";
+import { HASH_SEP } from "./hashline/hash";
+import { loadHashStore } from "./hash-store";
+import { getServed } from "./served";
+import { resolveInCwd } from "./fs-write";
+import { abortIf, splitLines, isRec, normalizeFilePath } from "./utils";
+
+const HASH_ECHO_RE = new RegExp(`^(${HASH_CLASS})${HASH_SEP}`);
+
+function searchEcho(lines: string[], served: ReadonlySet<string>): { line: number; hash: string } | undefined {
+  for (let i = 0; i < lines.length; i++) {
+    const match = HASH_ECHO_RE.exec(lines[i]!);
+    if (match && served.has(match[1]!)) return { line: i + 1, hash: match[1]! };
+  }
+  return undefined;
+}
+
+export function findServedHashEcho(content: string, served: ReadonlySet<string>): { line: number; hash: string } | undefined {
+  return searchEcho(splitLines(content), served);
+}
+
+export function findEditHashEcho(lines: string[], served: ReadonlySet<string>): { line: number; hash: string } | undefined {
+  return searchEcho(lines, served);
+}
+
+export async function servedHashEchoDenial(rawPath: string, content: string, cwd: string, signal?: AbortSignal): Promise<string | undefined> {
+  abortIf(signal);
+  const { resolved } = await resolveInCwd(rawPath, cwd);
+  abortIf(signal);
+  const store = await loadHashStore();
+  const served = getServed(store, resolved);
+  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. Nothing was written.`;
+}
+
+export function registerWriteHook(pi: ExtensionAPI): void {
+  pi.on("tool_call", async (event, ctx) => {
+    if (event.toolName !== "write") return;
+    const input = event.input as Record<string, unknown> | undefined;
+    if (!input || !isRec(input)) return;
+    const normalized = { ...input };
+    normalizeFilePath(normalized);
+    const rawPath = normalized.path as unknown;
+    const content = normalized.content as unknown;
+    if (typeof rawPath !== "string" || typeof content !== "string") return;
+    const signal = ctx.signal;
+    try {
+      const reason = await servedHashEchoDenial(rawPath, content, ctx.cwd, signal);
+      if (reason !== undefined) return { block: true, reason };
+    } catch (error) {
+      if (signal?.aborted) throw error;
+      console.error("write hook failed:", error);
+    }
+    return;
+  });
+}

package/src/replace-normalize.ts

@@ -1,13 +0,0 @@
-import { isRec, normalizeFilePath } from "./utils";
-
-export function normReq(input: unknown): unknown {
-  if (!isRec(input)) {
-    return input;
-  }
-
-  const record: Record<string, unknown> = { ...input };
-
-  normalizeFilePath(record);
-
-  return record;
-}