pi-hashline-edit-pro 4.2.6 → 4.2.7

package/src/read.ts

@@ -17,7 +17,7 @@ import { abortIf, makePrepareArguments, numberedRead, visLines, splitLines } fro
 import { loadP, loadGuide } from "./prompts";
 import { withReadPrompts, DEFAULT_EDIT_FLAGS, type EditToolFlags } from "./edit-common";
 import { valAccess } from "./validation";
-import { markServed as markServedScoped } from "./anchor-registry";
+import { markServed as markServedScoped, withAnchorSession } from "./anchor-registry";
 import { buildServedMap } from "./served";
 import { Text } from "@earendil-works/pi-tui";
 const R_DESC = loadP("../prompts/read.md");
@@ -204,62 +204,64 @@ export function regRead(pi: ExtensionAPI, flags: EditToolFlags = DEFAULT_EDIT_FL
 		},
 
 		async execute(_toolCallId, params, signal, _onUpdate, ctx) {
-			const rawPath = params.path;
-			const absolutePath = toCwd(rawPath, ctx.cwd);
+			return withAnchorSession(ctx, async () => {
+				const rawPath = params.path;
+				const absolutePath = toCwd(rawPath, ctx.cwd);
 
-			abortIf(signal);
-			await valAccess(absolutePath, rawPath);
+				abortIf(signal);
+				await valAccess(absolutePath, rawPath);
 
-			abortIf(signal);
-			const file = await loadFileKindAndText(absolutePath, { maxLines: MAX_HASH_LINES, displayPath: rawPath });
-			if (file.kind === "image") {
-				const builtinRead = createReadTool(ctx.cwd);
-				const executeBuiltinRead = builtinRead.execute as unknown as (
-					toolCallId: string,
-					input: typeof params,
-					abortSignal: typeof signal,
-					onUpdate: typeof _onUpdate,
-					context: typeof ctx,
-				) => ReturnType<typeof builtinRead.execute>;
-				return executeBuiltinRead(_toolCallId, params, signal, _onUpdate, ctx);
-			}
-      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,
-				{
-					offset: params.offset,
-					limit: params.limit,
-				},
-				fileHashes,
-				resolvedPath,
-			);
-			markServedScoped(resolvedPath, buildServedMap(fileHashes, fileLines, preview.servedHashes), new Set(fileHashes));
-			const snapshotId = await safeSnapId(absolutePath, "read");
-			const previewText =
-				hadUtf8DecodeErrors
-					? `${preview.text}\n\n[Non-UTF-8 bytes shown as U+FFFD; editing rewrites the file as UTF-8.]`
-					: preview.text;
+				abortIf(signal);
+				const file = await loadFileKindAndText(absolutePath, { maxLines: MAX_HASH_LINES, displayPath: rawPath });
+				if (file.kind === "image") {
+					const builtinRead = createReadTool(ctx.cwd);
+					const executeBuiltinRead = builtinRead.execute as unknown as (
+						toolCallId: string,
+						input: typeof params,
+						abortSignal: typeof signal,
+						onUpdate: typeof _onUpdate,
+						context: typeof ctx,
+					) => ReturnType<typeof builtinRead.execute>;
+					return executeBuiltinRead(_toolCallId, params, signal, _onUpdate, ctx);
+				}
+	      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,
+					{
+						offset: params.offset,
+						limit: params.limit,
+					},
+					fileHashes,
+					resolvedPath,
+				);
+				markServedScoped(resolvedPath, buildServedMap(fileHashes, fileLines, preview.servedHashes), new Set(fileHashes));
+				const snapshotId = await safeSnapId(absolutePath, "read");
+				const previewText =
+					hadUtf8DecodeErrors
+						? `${preview.text}\n\n[Non-UTF-8 bytes shown as U+FFFD; editing rewrites the file as UTF-8.]`
+						: preview.text;
 
-			return {
-				content: [{ type: "text", text: previewText }],
-				details: {
-					truncation: preview.truncation,
-					snapshotId,
-					offset: params.offset ?? 1,
-					...(preview.nextOffset !== undefined
-						? { nextOffset: preview.nextOffset }
-						: {}),
-					metrics: {
-						truncated: !!preview.truncation,
+				return {
+					content: [{ type: "text", text: previewText }],
+					details: {
+						truncation: preview.truncation,
+						snapshotId,
+						offset: params.offset ?? 1,
 						...(preview.nextOffset !== undefined
-							? { next_offset: preview.nextOffset }
+							? { nextOffset: preview.nextOffset }
 							: {}),
+						metrics: {
+							truncated: !!preview.truncation,
+							...(preview.nextOffset !== undefined
+								? { next_offset: preview.nextOffset }
+								: {}),
+						},
 					},
-				},
-			};
+				};
+			});
 		},
 	});
 }

package/src/replace-diff.ts

@@ -332,6 +332,10 @@ function genSpanDiff(
   return { diff: output.join("\n"), firstChangedLine, lineNumbers };
 }
 
+function overDiffInputLimit(oldContent: string, newContent: string): boolean {
+  return Buffer.byteLength(oldContent, "utf-8") + Buffer.byteLength(newContent, "utf-8") > MAX_DIFF_INPUT_BYTES;
+}
+
 export function genDiff(
   oldContent: string,
   newContent: string,
@@ -350,7 +354,7 @@ export function genDiff(
       return { diff, firstChangedLine: anchored.firstChangedLine, lineNumbers: anchored.lineNumbers };
     }
   }
-  if (!limits?.unlimited && Buffer.byteLength(oldContent, "utf-8") + Buffer.byteLength(newContent, "utf-8") > MAX_DIFF_INPUT_BYTES) {
+  if (!limits?.unlimited && overDiffInputLimit(oldContent, newContent)) {
     const guardedRange = changedRange(oldContent, newContent);
     const guardNote = `[diff truncated at ${formatSize(maxBytes)}; use read to see the rest.]`;
     if (!guardedRange || !newContentHashes) {
@@ -580,6 +584,9 @@ export function genPatch(
   const patchOpts: Record<string, unknown> = { context: 4 };
   const ho = (Diff as unknown as Record<string, unknown>).FILE_HEADERS_ONLY;
   if (ho !== undefined) patchOpts.headerOptions = ho;
+  if (!limits?.unlimited && overDiffInputLimit(oldContent, newContent)) {
+    return { patch: "", truncated: true };
+  }
   const full = (Diff.createTwoFilesPatch(path, path, oldContent, newContent, undefined, undefined, patchOpts as never) as unknown as string) ?? "";
   const maxLineBytes = limits?.unlimited ? Number.POSITIVE_INFINITY : (limits?.maxLineBytes ?? DEFAULT_MAX_BYTES);
   const maxBytes = limits?.unlimited ? Number.POSITIVE_INFINITY : (limits?.maxBytes ?? DEFAULT_MAX_BYTES);

package/src/replace-undo.ts

@@ -7,7 +7,7 @@ import { loadHashStore, persistSnapshot, upsertUndo, getUndoEntry, deleteUndo, t
 import { servedHashesFromDiff, buildServedMap } from "./served";
 import { contentChecksum } from "./hashline/hasher";
 import { hashSource } from "./hashline";
-import { markServed as markServedScoped, freeAnchors, adoptAnchors } from "./anchor-registry";
+import { markServed as markServedScoped, freeAnchors, adoptAnchors, withAnchorSession } from "./anchor-registry";
 import { resolveInCwd, writeAtomic, type FileIdentity } from "./fs-write";
 import { toLF, stripBOM, restoreEndings, type LineEnding } from "./normalize";
 import { genDiff, genPatch, spansFromHashes } from "./replace-diff";
@@ -114,52 +114,20 @@ export function regUndo(pi: ExtensionAPI): void {
       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;
-      if (typeof path !== "string" || path.length === 0) {
-        throw new Error('[E_BAD_SHAPE] Undo request requires a non-empty "path" string.');
-      }
-      const { resolved: mutationTargetPath } = await resolveInCwd(path, ctx.cwd);
-
-      const undo = await getUndo(mutationTargetPath);
-      if (!undo) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: `No undo history for ${path}.`,
-            },
-          ],
-          isError: true,
-          details: {},
-        };
-      }
-
-      return withFileMutationQueue(mutationTargetPath, async () => {
-        let currentRaw: string | undefined;
-        let currentIdentity: FileIdentity | undefined;
-        try {
-          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;
+      return withAnchorSession(ctx, async () => {
+        const path = params.path;
+        if (typeof path !== "string" || path.length === 0) {
+          throw new Error('[E_BAD_SHAPE] Undo request requires a non-empty "path" string.');
         }
+        const { resolved: mutationTargetPath } = await resolveInCwd(path, ctx.cwd);
 
-        if (
-          currentRaw !== undefined &&
-          currentRaw !== undo.bom + restoreEndings(undo.resultContent, undo.originalEnding)
-        ) {
+        const undo = await getUndo(mutationTargetPath);
+        if (!undo) {
           return {
             content: [
               {
                 type: "text",
-                text: `[E_UNDO_STALE] Cannot undo last change on ${path}: the file was modified after the edit, so nothing was reverted. The current content already contains your applied edit plus that external change and is most likely the correct state. Do not modify the file to make an undo possible and do not revert your own edit. The undo record is kept. Call read() to verify the current state, then stop.`
+                text: `No undo history for ${path}.`,
               },
             ],
             isError: true,
@@ -167,82 +135,116 @@ export function regUndo(pi: ExtensionAPI): void {
           };
         }
 
-        await writeAtomic(
-          mutationTargetPath,
-          undo.bom + restoreEndings(undo.content, undo.originalEnding),
-          currentIdentity,
-        );
+        return withFileMutationQueue(mutationTargetPath, async () => {
+          let currentRaw: string | undefined;
+          let currentIdentity: FileIdentity | undefined;
+          try {
+            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;
+          }
 
-        const currentNormalized = currentRaw === undefined ? "" : toLF(stripBOM(currentRaw).text);
-        const currentHashes = await lineHashes(currentNormalized, mutationTargetPath);
-        const diffResult = genDiff(undo.content, undo.resultContent, 0, undefined, undo.hashes, { unlimited: true });
-        const linesAddedByReplace = cntDiff(diffResult.diff, "+");
-        const linesRemovedByReplace = cntDiff(diffResult.diff, "-");
-        const restoredRange = changedRange(currentNormalized, undo.content);
-        const undoSpans = spansFromHashes(currentHashes, undo.hashes);
-        const undoDiffResult = genDiff(currentNormalized, undo.content, await getDiffContextLines(), undo.hashes, currentHashes, undefined, undoSpans);
-        const undoDiff = undoDiffResult.diff;
+          if (
+            currentRaw !== undefined &&
+            currentRaw !== undo.bom + restoreEndings(undo.resultContent, undo.originalEnding)
+          ) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `[E_UNDO_STALE] Cannot undo last change on ${path}: the file was modified after the edit, so nothing was reverted. The current content already contains your applied edit plus that external change and is most likely the correct state. Do not modify the file to make an undo possible and do not revert your own edit. The undo record is kept. Call read() to verify the current state, then stop.`
+                },
+              ],
+              isError: true,
+              details: {},
+            };
+          }
 
-        try {
-          const store = await loadHashStore();
-          const undoLines = splitLines(undo.content);
-          persistSnapshot(store, mutationTargetPath, undo.content, undo.hashes, undoLines.map((line) => contentChecksum(hashSource(line))));
-          freeAnchors(mutationTargetPath);
-          adoptAnchors(
+          await writeAtomic(
             mutationTargetPath,
-            new Map(undoLines.map((line, i) => [undo.hashes[i]!, contentChecksum(hashSource(line))])),
+            undo.bom + restoreEndings(undo.content, undo.originalEnding),
+            currentIdentity,
           );
-          markServedScoped(
-            mutationTargetPath,
-            buildServedMap(undo.hashes, undoLines, servedHashesFromDiff(undoDiff)),
-            new Set(undo.hashes),
-          );
-        } catch (error) {
-          console.error("Failed to restore hash store snapshot after undo:", error);
-        }
 
-        await clearUndo(mutationTargetPath);
+          const currentNormalized = currentRaw === undefined ? "" : toLF(stripBOM(currentRaw).text);
+          const currentHashes = await lineHashes(currentNormalized, mutationTargetPath);
+          const diffResult = genDiff(undo.content, undo.resultContent, 0, undefined, undo.hashes, { unlimited: true });
+          const linesAddedByReplace = cntDiff(diffResult.diff, "+");
+          const linesRemovedByReplace = cntDiff(diffResult.diff, "-");
+          const restoredRange = changedRange(currentNormalized, undo.content);
+          const undoSpans = spansFromHashes(currentHashes, undo.hashes);
+          const undoDiffResult = genDiff(currentNormalized, undo.content, await getDiffContextLines(), undo.hashes, currentHashes, undefined, undoSpans);
+          const undoDiff = undoDiffResult.diff;
 
-        const parts: string[] = [
-          `Undone last change on ${path}.`,
-        ];
-        if (currentRaw === undefined) {
-          parts.push("The file was deleted; restored it from undo history.");
-        }
-        if (linesAddedByReplace > 0 || linesRemovedByReplace > 0) {
+          try {
+            const store = await loadHashStore();
+            const undoLines = splitLines(undo.content);
+            persistSnapshot(store, mutationTargetPath, undo.content, undo.hashes, undoLines.map((line) => contentChecksum(hashSource(line))));
+            freeAnchors(mutationTargetPath);
+            adoptAnchors(
+              mutationTargetPath,
+              new Map(undoLines.map((line, i) => [undo.hashes[i]!, contentChecksum(hashSource(line))])),
+            );
+            markServedScoped(
+              mutationTargetPath,
+              buildServedMap(undo.hashes, undoLines, servedHashesFromDiff(undoDiff)),
+              new Set(undo.hashes),
+            );
+          } catch (error) {
+            console.error("Failed to restore hash store snapshot after undo:", error);
+          }
+
+          await clearUndo(mutationTargetPath);
+
+          const parts: string[] = [
+            `Undone last change on ${path}.`,
+          ];
+          if (currentRaw === undefined) {
+            parts.push("The file was deleted; restored it from undo history.");
+          }
+          if (linesAddedByReplace > 0 || linesRemovedByReplace > 0) {
+            parts.push(
+              `Removed ${linesAddedByReplace} line(s), restored ${linesRemovedByReplace} line(s).`,
+            );
+          }
           parts.push(
-            `Removed ${linesAddedByReplace} line(s), restored ${linesRemovedByReplace} line(s).`,
+            "Call read for fresh anchors.",
           );
-        }
-        parts.push(
-          "Call read for fresh anchors.",
-        );
 
-        const patchResult = genPatch(path, currentNormalized, undo.content);
-        return {
-          content: [
-            {
-              type: "text",
-              text: parts.join("\n"),
+          const patchResult = genPatch(path, currentNormalized, undo.content);
+          return {
+            content: [
+              {
+                type: "text",
+                text: parts.join("\n"),
+              },
+            ],
+            details: {
+              diff: undoDiff,
+              diffLineNumbers: undoDiffResult.lineNumbers,
+              patch: patchResult.patch,
+              ...(patchResult.truncated ? { patchTruncated: true as const } : {}),
+              metrics: buildMetrics({
+                classification: "applied",
+                editsAttempted: 1,
+                noopEditsCount: 0,
+                warningsCount: 0,
+                firstChangedLine: restoredRange?.firstChangedLine,
+                lastChangedLine: restoredRange?.lastChangedLine,
+                addedLines: linesRemovedByReplace,
+                removedLines: linesAddedByReplace,
+              }),
             },
-          ],
-          details: {
-            diff: undoDiff,
-            diffLineNumbers: undoDiffResult.lineNumbers,
-            patch: patchResult.patch,
-            ...(patchResult.truncated ? { patchTruncated: true as const } : {}),
-            metrics: buildMetrics({
-              classification: "applied",
-              editsAttempted: 1,
-              noopEditsCount: 0,
-              warningsCount: 0,
-              firstChangedLine: restoredRange?.firstChangedLine,
-              lastChangedLine: restoredRange?.lastChangedLine,
-              addedLines: linesRemovedByReplace,
-              removedLines: linesAddedByReplace,
-            }),
-          },
-        };
+          };
+        });
       });
     },
   });

package/src/replace.ts

@@ -29,7 +29,7 @@ import {
   type RRState,
 } from "./replace-render";
 import { loadHashStore, type HashStore } from "./hash-store";
-import { adoptAnchors, servedForPath } from "./anchor-registry";
+import { adoptAnchors, servedForPath, withAnchorSession } from "./anchor-registry";
 import { resolveTarget } from "./fs-write";
 import { toCwd } from "./paths";
 import { noopPayloadKey, markBoundaryNoop, consumeBoundaryBypass, clearBoundaryBypass } from "./boundary-bypass";
@@ -275,78 +275,80 @@ export function buildToolDef(flags: EditToolFlags = DEFAULT_EDIT_FLAGS): ToolDef
     renderCall: editRenderCallWrapper(compPreview),
     renderResult: editRenderResultWrapper,
     async execute(_toolCallId, params, signal, _onUpdate, ctx) {
-      const canonical = normReq(params);
-      assertReq(canonical);
-      const normalizedParams = canonical;
-      const targetPath = await resolveEditTargetWithRequirement({
-        removeFrom: normalizedParams.remove_from,
-        removeTo: normalizedParams.remove_to,
-        providedPath: normalizedParams.path,
-        cwd: ctx.cwd,
-      }).catch((error: unknown) => {
-        const member = batchMemberFor(_toolCallId);
-        if (member) noteBatchFailure(member, error);
-        else suffixPoisonCause(_toolCallId, error);
-        throw error;
-      });
-      return queuedEdit(targetPath, ctx.cwd, signal, async (absolutePath, mutationTargetPath) => {
-        const dedupMode = await getBoundaryDedupMode();
-        const dedupOn = dedupMode !== "off";
-        const noopPayload = noopPayloadKey(mutationTargetPath, normalizedParams.remove_from, normalizedParams.remove_to, normalizedParams.replacement_lines);
-        const boundaryBypass = dedupOn ? consumeBoundaryBypass(mutationTargetPath, noopPayload) : false;
-        const strictBoundaryDedup = dedupMode === "strict" && !boundaryBypass;
-        const member = batchMemberFor(_toolCallId);
-        if (!member) {
+      return withAnchorSession(ctx, async () => {
+        const canonical = normReq(params);
+        assertReq(canonical);
+        const normalizedParams = canonical;
+        const targetPath = await resolveEditTargetWithRequirement({
+          removeFrom: normalizedParams.remove_from,
+          removeTo: normalizedParams.remove_to,
+          providedPath: normalizedParams.path,
+          cwd: ctx.cwd,
+        }).catch((error: unknown) => {
+          const member = batchMemberFor(_toolCallId);
+          if (member) noteBatchFailure(member, error);
+          else suffixPoisonCause(_toolCallId, error);
+          throw error;
+        });
+        return queuedEdit(targetPath, ctx.cwd, signal, async (absolutePath, mutationTargetPath) => {
+          const dedupMode = await getBoundaryDedupMode();
+          const dedupOn = dedupMode !== "off";
+          const noopPayload = noopPayloadKey(mutationTargetPath, normalizedParams.remove_from, normalizedParams.remove_to, normalizedParams.replacement_lines);
+          const boundaryBypass = dedupOn ? consumeBoundaryBypass(mutationTargetPath, noopPayload) : false;
+          const strictBoundaryDedup = dedupMode === "strict" && !boundaryBypass;
+          const member = batchMemberFor(_toolCallId);
+          if (!member) {
+            try {
+              const pipe = await execPipeline(
+                targetPath,
+                normalizedParams,
+                ctx.cwd,
+                { accessMode: constants.R_OK | constants.W_OK, signal, skipBoundaryDedup: boundaryBypass },
+              );
+              const appliedWarnings = boundaryBypass
+                ? ["[W_BOUNDARY_BYPASS] Boundary dedup was off for this call and is back on."]
+                : [];
+              return await commitEdit(pipe, {
+                path: pipe.path,
+                absolutePath,
+                mutationTargetPath,
+                editAnchors: [normalizedParams.remove_from, normalizedParams.remove_to],
+                signal,
+                appliedWarnings,
+                onApplied: () => { if (dedupOn) clearBoundaryBypass(mutationTargetPath); },
+                onNoopDedup: dedupOn ? () => markBoundaryNoop(mutationTargetPath, noopPayload) : undefined,
+              });
+            } catch (error) {
+              const detail = error instanceof Error ? error.message : String(error);
+              if (boundaryBypass && !detail.includes("File was written;")) markBoundaryNoop(mutationTargetPath, noopPayload);
+              throw error;
+            }
+          }
+          let built: { edit: HEdit; warnings: string[] };
           try {
-            const pipe = await execPipeline(
-              targetPath,
-              normalizedParams,
-              ctx.cwd,
-              { accessMode: constants.R_OK | constants.W_OK, signal, skipBoundaryDedup: boundaryBypass },
-            );
-            const appliedWarnings = boundaryBypass
-              ? ["[W_BOUNDARY_BYPASS] Boundary dedup was off for this call and is back on."]
-              : [];
-            return await commitEdit(pipe, {
-              path: pipe.path,
-              absolutePath,
-              mutationTargetPath,
-              editAnchors: [normalizedParams.remove_from, normalizedParams.remove_to],
-              signal,
-              appliedWarnings,
-              onApplied: () => { if (dedupOn) clearBoundaryBypass(mutationTargetPath); },
-              onNoopDedup: dedupOn ? () => markBoundaryNoop(mutationTargetPath, noopPayload) : undefined,
-            });
+            built = buildReplaceHEdit(normalizedParams);
           } catch (error) {
-            const detail = error instanceof Error ? error.message : String(error);
-            if (boundaryBypass && !detail.includes("File was written;")) markBoundaryNoop(mutationTargetPath, noopPayload);
+            noteBatchFailure(member, error);
+            if (boundaryBypass) markBoundaryNoop(mutationTargetPath, noopPayload);
             throw error;
           }
-        }
-        let built: { edit: HEdit; warnings: string[] };
-        try {
-          built = buildReplaceHEdit(normalizedParams);
-        } catch (error) {
-          noteBatchFailure(member, error);
-          if (boundaryBypass) markBoundaryNoop(mutationTargetPath, noopPayload);
-          throw error;
-        }
-        const appliedWarnings = boundaryBypass
-          ? ["[W_BOUNDARY_BYPASS] Boundary dedup was off for this call and is back on."]
-          : [];
-        return executeBatchMember({
-          kind: "replace",
-          member,
-          targetPath,
-          mutationTargetPath,
-          cwd: ctx.cwd,
-          signal,
-          hedit: built.edit,
-          extraWarnings: [...built.warnings, ...appliedWarnings],
-          skipBoundaryDedup: boundaryBypass,
-          strictBoundaryDedup,
-          noopPayload,
-          bypassConsumed: boundaryBypass,
+          const appliedWarnings = boundaryBypass
+            ? ["[W_BOUNDARY_BYPASS] Boundary dedup was off for this call and is back on."]
+            : [];
+          return executeBatchMember({
+            kind: "replace",
+            member,
+            targetPath,
+            mutationTargetPath,
+            cwd: ctx.cwd,
+            signal,
+            hedit: built.edit,
+            extraWarnings: [...built.warnings, ...appliedWarnings],
+            skipBoundaryDedup: boundaryBypass,
+            strictBoundaryDedup,
+            noopPayload,
+            bypassConsumed: boundaryBypass,
+          });
         });
       });
     },

package/src/utils.ts

@@ -1,3 +1,5 @@
+import { NUL_CONTENT_MSG } from "./constants";
+
 export function isRec(value: unknown): value is Record<string, unknown> {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -74,6 +76,10 @@ export function abortIf(signal?: AbortSignal): void {
   if (signal?.aborted) throw new Error("Operation aborted");
 }
 
+export function assertNoNul(lines: string[]): void {
+  if (lines.some((line) => line.includes("\0"))) throw new Error(NUL_CONTENT_MSG);
+}
+
 export function errCode(error: unknown): string | undefined {
 	if (error instanceof Error) {
 		return (error as NodeJS.ErrnoException).code;

package/src/write-hook.ts

@@ -1,7 +1,7 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { HASH_CLASS } from "./hashline/alphabet";
 import { HASH_SEP } from "./hashline/hash";
-import { servedForPath } from "./anchor-registry";
+import { servedForPath, withAnchorSession } from "./anchor-registry";
 import { resolveInCwd } from "./fs-write";
 import { abortIf, splitLines, isRec, normalizeFilePath } from "./utils";
 
@@ -35,7 +35,7 @@ export async function servedHashEchoDenial(rawPath: string, content: string, cwd
 }
 
 export function registerWriteHook(pi: ExtensionAPI): void {
-  pi.on("tool_call", async (event, ctx) => {
+  pi.on("tool_call", async (event, ctx) => withAnchorSession(ctx, async () => {
     if (event.toolName !== "write") return;
     const input = event.input as Record<string, unknown> | undefined;
     if (!input || !isRec(input)) return;
@@ -53,5 +53,5 @@ export function registerWriteHook(pi: ExtensionAPI): void {
       console.error("write hook failed:", error);
     }
     return;
-  });
+  }));
 }