pi-hashline-edit-pro 4.2.5 → 4.2.7

package/src/grep.ts

@@ -12,7 +12,7 @@ import { toCwd } from "./paths";
 import { loadP, loadGuide } from "./prompts";
 import { normReq } from "./payload-contract";
 import { abortIf, errCode, isRec, makePrepareArguments, rejectUnknownFields, truncateToBytes, visLines } from "./utils";
-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";
 import { expandHint, getResultText, reuseText, type CallT, type FgT } from "./replace-render";
@@ -553,172 +553,174 @@ export function regGrep(pi: ExtensionAPI): void {
     },
 
     async execute(_toolCallId, params, signal, _onUpdate, ctx) {
-      const canonical = normReq(params);
-      assertGrepReq(canonical);
-      const req = canonical;
-      const context = req.context ?? 0;
-      const limit = req.limit ?? 100;
-      const base = req.path ? toCwd(req.path, ctx.cwd) : ctx.cwd;
-      abortIf(signal);
-      let baseStat;
-      try {
-        baseStat = await stat(base);
-      } catch (error) {
-        if (errCode(error) === "ENOENT") {
-          throw new Error(`[E_NOT_FOUND] File not found: ${req.path ?? ctx.cwd}`);
-        }
-        throw new Error(`[E_ACCESS] Cannot access path: ${req.path ?? ctx.cwd}`);
-      }
-      const globRoot = baseStat.isFile() ? dirname(base) : base;
-      const globRegex = req.glob === undefined ? undefined : globToRegex(req.glob);
-      const validatedRegex = buildRegex(req.pattern, req.literal === true, req.ignoreCase === true);
-      const rgPath = await resolveRgPath();
-      const hits: FileHit[] = [];
-      let matches = 0;
-      let limitTruncated = false;
-      let rowTruncated = false;
-      let rowCount = 0;
-      let byteCount = 0;
-      let totalRows = 0;
-      let totalBytes = 0;
-      let truncatedBy: "lines" | "bytes" | null = null;
-      let linesReplaced = 0;
-      let countOnly = false;
-      let poolSkipped = 0;
-      const makeGrepReader = (allocation: "real" | "shadow") => async (absPath: string) => {
+      return withAnchorSession(ctx, async () => {
+        const canonical = normReq(params);
+        assertGrepReq(canonical);
+        const req = canonical;
+        const context = req.context ?? 0;
+        const limit = req.limit ?? 100;
+        const base = req.path ? toCwd(req.path, ctx.cwd) : ctx.cwd;
+        abortIf(signal);
+        let baseStat;
         try {
-          return await tryReadNormFile(absPath, ctx.cwd, { maxLines: MAX_HASH_LINES, noPersist: true, allocation, signal });
+          baseStat = await stat(base);
         } catch (error) {
-          if (!isPoolExhaustedError(error)) throw error;
-          poolSkipped += 1;
-          return undefined;
+          if (errCode(error) === "ENOENT") {
+            throw new Error(`[E_NOT_FOUND] File not found: ${req.path ?? ctx.cwd}`);
+          }
+          throw new Error(`[E_ACCESS] Cannot access path: ${req.path ?? ctx.cwd}`);
         }
-      };
-      const readGrepFile = makeGrepReader("real");
-      const readGrepFileShadow = makeGrepReader("shadow");
-      const rgMatches = await collectRgMatches(rgPath, req.pattern, base, req, signal);
-      const sortedFiles = [...rgMatches.keys()].sort(cmp);
-      for (let f = 0; f < sortedFiles.length; f++) {
-        abortIf(signal);
-        const absPath = sortedFiles[f]!;
-        const allNums = rgMatches.get(absPath) ?? [];
-        const totalForFile = allNums.length;
-        const sortedNums = [...allNums].sort((a, b) => a - b);
-        const indices = sortedNums.map((n) => n - 1).filter((n) => n >= 0);
-        if (countOnly) {
+        const globRoot = baseStat.isFile() ? dirname(base) : base;
+        const globRegex = req.glob === undefined ? undefined : globToRegex(req.glob);
+        const validatedRegex = buildRegex(req.pattern, req.literal === true, req.ignoreCase === true);
+        const rgPath = await resolveRgPath();
+        const hits: FileHit[] = [];
+        let matches = 0;
+        let limitTruncated = false;
+        let rowTruncated = false;
+        let rowCount = 0;
+        let byteCount = 0;
+        let totalRows = 0;
+        let totalBytes = 0;
+        let truncatedBy: "lines" | "bytes" | null = null;
+        let linesReplaced = 0;
+        let countOnly = false;
+        let poolSkipped = 0;
+        const makeGrepReader = (allocation: "real" | "shadow") => async (absPath: string) => {
+          try {
+            return await tryReadNormFile(absPath, ctx.cwd, { maxLines: MAX_HASH_LINES, noPersist: true, allocation, signal });
+          } catch (error) {
+            if (!isPoolExhaustedError(error)) throw error;
+            poolSkipped += 1;
+            return undefined;
+          }
+        };
+        const readGrepFile = makeGrepReader("real");
+        const readGrepFileShadow = makeGrepReader("shadow");
+        const rgMatches = await collectRgMatches(rgPath, req.pattern, base, req, signal);
+        const sortedFiles = [...rgMatches.keys()].sort(cmp);
+        for (let f = 0; f < sortedFiles.length; f++) {
+          abortIf(signal);
+          const absPath = sortedFiles[f]!;
+          const allNums = rgMatches.get(absPath) ?? [];
+          const totalForFile = allNums.length;
+          const sortedNums = [...allNums].sort((a, b) => a - b);
+          const indices = sortedNums.map((n) => n - 1).filter((n) => n >= 0);
+          if (countOnly) {
+            if (globRegex) {
+              const displayPath = relative(ctx.cwd, absPath).replace(/\\/g, "/");
+              const globPath = relative(globRoot, absPath).replace(/\\/g, "/");
+              if (!globRegex.test(globPath) && !globRegex.test(displayPath)) continue;
+            }
+            const norm = await readGrepFileShadow(absPath);
+            if (!norm) continue;
+            const hit = makeHitFromIndices(norm, relative(ctx.cwd, absPath).replace(/\\/g, "/"), indices, context, validatedRegex, totalForFile, indices.length);
+            const display = displayRowsForHit(hit);
+            totalRows += display.length;
+            for (const r of display) totalBytes += Buffer.byteLength(r, "utf-8") + 1;
+            const remainingCountOnly = limit - matches;
+            if (remainingCountOnly > 0) {
+              const add = Math.min(hit.matchCount, remainingCountOnly);
+              matches += add;
+              if (hit.matchCount > remainingCountOnly) limitTruncated = true;
+            } else {
+              limitTruncated = true;
+            }
+            continue;
+          }
+          const remaining = limit - matches;
+          if (remaining <= 0) {
+            limitTruncated = true;
+            break;
+          }
           if (globRegex) {
             const displayPath = relative(ctx.cwd, absPath).replace(/\\/g, "/");
             const globPath = relative(globRoot, absPath).replace(/\\/g, "/");
             if (!globRegex.test(globPath) && !globRegex.test(displayPath)) continue;
           }
-          const norm = await readGrepFileShadow(absPath);
+          const norm = await readGrepFile(absPath);
           if (!norm) continue;
-          const hit = makeHitFromIndices(norm, relative(ctx.cwd, absPath).replace(/\\/g, "/"), indices, context, validatedRegex, totalForFile, indices.length);
+          const hit = makeHitFromIndices(norm, relative(ctx.cwd, absPath).replace(/\\/g, "/"), indices, context, validatedRegex, totalForFile, Math.min(totalForFile, remaining));
+          if (!hit) continue;
           const display = displayRowsForHit(hit);
-          totalRows += display.length;
-          for (const r of display) totalBytes += Buffer.byteLength(r, "utf-8") + 1;
-          const remainingCountOnly = limit - matches;
-          if (remainingCountOnly > 0) {
-            const add = Math.min(hit.matchCount, remainingCountOnly);
-            matches += add;
-            if (hit.matchCount > remainingCountOnly) limitTruncated = true;
-          } else {
-            limitTruncated = true;
+          const keptRows: string[] = [];
+          const keptHashes: string[] = [];
+          const keptLineNumbers: number[] = [];
+          const keptFragmented: boolean[] = [];
+          for (let i = 0; i < display.length; i++) {
+            const row = display[i]!;
+            const rowBytes = Buffer.byteLength(row, "utf-8") + 1;
+            if (rowCount >= DEFAULT_MAX_LINES || byteCount + rowBytes > DEFAULT_MAX_BYTES) {
+              rowTruncated = true;
+              if (truncatedBy === null) truncatedBy = byteCount + rowBytes > DEFAULT_MAX_BYTES ? "bytes" : "lines";
+              for (let j = i; j < display.length; j++) {
+                totalRows += 1;
+                totalBytes += Buffer.byteLength(display[j]!, "utf-8") + 1;
+              }
+              break;
+            }
+            keptRows.push(row);
+            keptHashes.push(hit.hashes[i]!);
+            keptLineNumbers.push(hit.lineNumbers[i]!);
+            keptFragmented.push(hit.fragmented[i]!);
+            if (hit.fragmented[i]) linesReplaced += 1;
+            rowCount += 1;
+            byteCount += rowBytes;
+            totalRows += 1;
+            totalBytes += rowBytes;
           }
-          continue;
-        }
-        const remaining = limit - matches;
-        if (remaining <= 0) {
-          limitTruncated = true;
-          break;
+          if (hit.totalMatchCount > hit.matchCount) limitTruncated = true;
+          matches += hit.matchCount;
+          const displayHit: FileHit = { ...hit, rows: keptRows, hashes: keptHashes, lineNumbers: keptLineNumbers, fragmented: keptFragmented };
+          hits.push(displayHit);
+          if (rowTruncated) countOnly = true;
         }
-        if (globRegex) {
-          const displayPath = relative(ctx.cwd, absPath).replace(/\\/g, "/");
-          const globPath = relative(globRoot, absPath).replace(/\\/g, "/");
-          if (!globRegex.test(globPath) && !globRegex.test(displayPath)) continue;
+        hits.sort((a, b) => cmp(a.displayPath, b.displayPath));
+        for (const hit of hits) {
+          markServedScoped(hit.path, buildServedMap(hit.fileHashes, hit.fileLines, hit.hashes), new Set(hit.fileHashes));
         }
-        const norm = await readGrepFile(absPath);
-        if (!norm) continue;
-        const hit = makeHitFromIndices(norm, relative(ctx.cwd, absPath).replace(/\\/g, "/"), indices, context, validatedRegex, totalForFile, Math.min(totalForFile, remaining));
-        if (!hit) continue;
-        const display = displayRowsForHit(hit);
-        const keptRows: string[] = [];
-        const keptHashes: string[] = [];
-        const keptLineNumbers: number[] = [];
-        const keptFragmented: boolean[] = [];
-        for (let i = 0; i < display.length; i++) {
-          const row = display[i]!;
-          const rowBytes = Buffer.byteLength(row, "utf-8") + 1;
-          if (rowCount >= DEFAULT_MAX_LINES || byteCount + rowBytes > DEFAULT_MAX_BYTES) {
-            rowTruncated = true;
-            if (truncatedBy === null) truncatedBy = byteCount + rowBytes > DEFAULT_MAX_BYTES ? "bytes" : "lines";
-            for (let j = i; j < display.length; j++) {
-              totalRows += 1;
-              totalBytes += Buffer.byteLength(display[j]!, "utf-8") + 1;
+        const blocks = hits
+          .map((hit) => `=== ${hit.displayPath} ===\n${hit.rows.join("\n")}`)
+          .join("\n");
+        const notes: string[] = [];
+        if (rowTruncated) notes.push(`[grep: output truncated at ${DEFAULT_MAX_LINES} rows or ${formatSize(DEFAULT_MAX_BYTES)}; refine the pattern to see more.]`);
+        if (limitTruncated) notes.push(`[grep: showing first ${limit} matches; increase limit to see more.]`);
+        if (linesReplaced > 0) notes.push(`[grep: ${linesReplaced} line(s) exceed ${formatSize(MAX_GREP_LINE_BYTES)} and are shown as truncated fragments; use read to see the full lines.]`);
+        if (poolSkipped > 0) notes.push(`[grep: ${poolSkipped} file(s) skipped because the session's anchor pool is exhausted; narrow the search.]`);
+        const truncated = limitTruncated || rowTruncated;
+        const truncation: TruncationResult | undefined = rowTruncated
+          ? {
+              content: blocks,
+              truncated: true,
+              truncatedBy,
+              totalLines: totalRows,
+              totalBytes,
+              outputLines: rowCount,
+              outputBytes: byteCount,
+              lastLinePartial: false,
+              firstLineExceedsLimit: false,
+              maxLines: DEFAULT_MAX_LINES,
+              maxBytes: DEFAULT_MAX_BYTES,
             }
-            break;
-          }
-          keptRows.push(row);
-          keptHashes.push(hit.hashes[i]!);
-          keptLineNumbers.push(hit.lineNumbers[i]!);
-          keptFragmented.push(hit.fragmented[i]!);
-          if (hit.fragmented[i]) linesReplaced += 1;
-          rowCount += 1;
-          byteCount += rowBytes;
-          totalRows += 1;
-          totalBytes += rowBytes;
-        }
-        if (hit.totalMatchCount > hit.matchCount) limitTruncated = true;
-        matches += hit.matchCount;
-        const displayHit: FileHit = { ...hit, rows: keptRows, hashes: keptHashes, lineNumbers: keptLineNumbers, fragmented: keptFragmented };
-        hits.push(displayHit);
-        if (rowTruncated) countOnly = true;
-      }
-      hits.sort((a, b) => cmp(a.displayPath, b.displayPath));
-      for (const hit of hits) {
-        markServedScoped(hit.path, buildServedMap(hit.fileHashes, hit.fileLines, hit.hashes), new Set(hit.fileHashes));
-      }
-      const blocks = hits
-        .map((hit) => `=== ${hit.displayPath} ===\n${hit.rows.join("\n")}`)
-        .join("\n");
-      const notes: string[] = [];
-      if (rowTruncated) notes.push(`[grep: output truncated at ${DEFAULT_MAX_LINES} rows or ${formatSize(DEFAULT_MAX_BYTES)}; refine the pattern to see more.]`);
-      if (limitTruncated) notes.push(`[grep: showing first ${limit} matches; increase limit to see more.]`);
-      if (linesReplaced > 0) notes.push(`[grep: ${linesReplaced} line(s) exceed ${formatSize(MAX_GREP_LINE_BYTES)} and are shown as truncated fragments; use read to see the full lines.]`);
-      if (poolSkipped > 0) notes.push(`[grep: ${poolSkipped} file(s) skipped because the session's anchor pool is exhausted; narrow the search.]`);
-      const truncated = limitTruncated || rowTruncated;
-      const truncation: TruncationResult | undefined = rowTruncated
-        ? {
-            content: blocks,
-            truncated: true,
-            truncatedBy,
-            totalLines: totalRows,
-            totalBytes,
-            outputLines: rowCount,
-            outputBytes: byteCount,
-            lastLinePartial: false,
-            firstLineExceedsLimit: false,
-            maxLines: DEFAULT_MAX_LINES,
-            maxBytes: DEFAULT_MAX_BYTES,
-          }
-        : undefined;
-      const text = blocks.length > 0
-        ? `${blocks}${notes.length > 0 ? `\n${notes.join("\n")}` : ""}`
-        : notes.length > 0
-          ? `No matches found.\n${notes.join("\n")}`
-          : "No matches found.";
-      return {
-        content: [{ type: "text", text }],
-        details: {
-          ...(truncation ? { truncation } : {}),
-          ...(linesReplaced > 0 ? { linesTruncated: true as const } : {}),
-          metrics: {
-            matches,
-            files: hits.length,
-            truncated,
+          : undefined;
+        const text = blocks.length > 0
+          ? `${blocks}${notes.length > 0 ? `\n${notes.join("\n")}` : ""}`
+          : notes.length > 0
+            ? `No matches found.\n${notes.join("\n")}`
+            : "No matches found.";
+        return {
+          content: [{ type: "text", text }],
+          details: {
+            ...(truncation ? { truncation } : {}),
+            ...(linesReplaced > 0 ? { linesTruncated: true as const } : {}),
+            metrics: {
+              matches,
+              files: hits.length,
+              truncated,
+            },
           },
-        },
-      };
+        };
+      });
     },
   });
 }

package/src/hash-store.ts

@@ -39,10 +39,81 @@ interface RawDb {
   close(): void;
   readonly isOpen: boolean;
 }
-export type SqliteEngine = "node:sqlite";
-const sqliteEngine: SqliteEngine = "node:sqlite";
-const { DatabaseSync } = await import("node:sqlite");
-const openDbFn = (path: string): RawDb => new DatabaseSync(path, { timeout: HASH_STORE_BUSY_TIMEOUT }) as unknown as RawDb;
+export type SqliteEngine = "node:sqlite" | "bun:sqlite";
+
+interface BunStatementLike {
+  get(...params: SqlParams): unknown;
+  all(...params: SqlParams): unknown[];
+  run(...params: SqlParams): unknown;
+}
+
+interface BunDbLike {
+  exec(sql: string): void;
+  prepare(sql: string): BunStatementLike;
+  close(): void;
+}
+
+function wrapBunDatabase(mod: { Database: new (path: string) => BunDbLike }): (path: string) => RawDb {
+  return (path) => {
+    const db = new mod.Database(path);
+    db.exec(`PRAGMA busy_timeout = ${HASH_STORE_BUSY_TIMEOUT}`);
+    let closed = false;
+    return {
+      exec: (sql) => db.exec(sql),
+      prepare: (sql) => {
+        const stmt = db.prepare(sql);
+        return {
+          get: (...params) => stmt.get(...params) ?? undefined,
+          all: (...params) => stmt.all(...params),
+          run: (...params) => stmt.run(...params),
+        };
+      },
+      close: () => {
+        if (!closed) {
+          closed = true;
+          db.close();
+        }
+      },
+      get isOpen() {
+        return !closed;
+      },
+    };
+  };
+}
+
+async function loadNodeEngine(): Promise<{ engine: SqliteEngine; open: (path: string) => RawDb }> {
+  const { DatabaseSync } = await import("node:sqlite");
+  return {
+    engine: "node:sqlite",
+    open: (path) => new DatabaseSync(path, { timeout: HASH_STORE_BUSY_TIMEOUT }) as unknown as RawDb,
+  };
+}
+
+async function loadBunEngine(): Promise<{ engine: SqliteEngine; open: (path: string) => RawDb }> {
+  const specifier = "bun:sqlite";
+  const mod = await import(specifier) as { Database: new (path: string) => BunDbLike };
+  return { engine: "bun:sqlite", open: wrapBunDatabase(mod) };
+}
+
+const isBunRuntime = typeof process !== "undefined" && typeof (process.versions as Record<string, string | undefined>).bun === "string";
+
+async function selectSqliteEngine(): Promise<{ engine: SqliteEngine; open: (path: string) => RawDb }> {
+  const candidates = isBunRuntime ? [loadBunEngine, loadNodeEngine] : [loadNodeEngine, loadBunEngine];
+  let lastError: unknown;
+  for (const candidate of candidates) {
+    try {
+      return await candidate();
+    } catch (error) {
+      lastError = error;
+    }
+  }
+  const detail = lastError instanceof Error ? lastError.message : String(lastError);
+  throw new Error(`[E_STORE_UNAVAILABLE] No SQLite runtime available (node:sqlite and bun:sqlite both failed to load): ${detail}`);
+}
+
+const selectedEngine = await selectSqliteEngine();
+const sqliteEngine: SqliteEngine = selectedEngine.engine;
+const openDbFn = selectedEngine.open;
 
 interface Prepared {
   get: (...params: SqlParams) => Record<string, unknown> | undefined;

package/src/hashline/resolve.ts

@@ -1,4 +1,4 @@
-import { abortIf, rejectUnknownFields, firstNonEmptyIndex, lastNonEmptyIndex, clipLine, getCached } from "../utils";
+import { abortIf, rejectUnknownFields, firstNonEmptyIndex, lastNonEmptyIndex, clipLine, getCached, decodeStringArray, assertNoNul } from "../utils";
 import { parseHashRef, parseText, type Anchor } from "./parse";
 import { HASH_SEP, stripRowPrefix, canon } from "./hash";
 import { HASH_RUN } from "./alphabet";
@@ -171,7 +171,8 @@ export function stripAnchorRow(
 export function resEdit(edit: HTEdit, warnings?: string[]): HEdit {
   assertItem(edit as Record<string, unknown>);
 
-  const replaceLines = parseText(edit.replacement_lines, warnings);
+  const replaceLines = parseText(decodeStringArray(edit.replacement_lines, warnings) ?? edit.replacement_lines, warnings);
+  assertNoNul(replaceLines);
   const bounds = [edit.remove_from, edit.remove_to].map((ref) => {
     return stripAnchorRow(ref.trim(), "remove_from/remove_to entry", warnings);
   }) as [string, string];

package/src/insert.ts

@@ -7,6 +7,7 @@ import { batchMemberFor, ensureBatchBase, executeBatchMember, noteBatchFailure,
 import { readNormFile, type NormFile } from "./file-reader";
 import { MAX_HASH_LINES, parseHashRef, resEdit, resolveAnchorLine, type Anchor, type HEdit } from "./hashline";
 import { stripAnchorRow } from "./hashline/resolve";
+import { withAnchorSession } from "./anchor-registry";
 import { loadP, loadGuide } from "./prompts";
 import { assertInsertReq, normReq, type InsertReq } from "./payload-contract";
 import { decodeStringArray, isRec, splitLines } from "./utils";
@@ -95,11 +96,8 @@ export async function insertPreview(request: unknown, cwd: string, signal?: Abor
     const normalized = normReq(request);
     const previewFixes: string[] = [];
     if (isRec(normalized)) {
-      const expanded = decodeStringArray(normalized.lines);
-      if (expanded) {
-        previewFixes.push('[W_BAD_SHAPE] Unwrapped JSON array syntax from a lines element.');
-        normalized.lines = expanded;
-      }
+      const expanded = decodeStringArray(normalized.lines, previewFixes, "lines");
+      if (expanded) normalized.lines = expanded;
     }
     assertInsertReq(normalized);
     const previewReq = normalized as InsertReq;
@@ -175,87 +173,86 @@ export function buildInsertToolDef(flags: EditToolFlags = DEFAULT_EDIT_FLAGS): I
     renderCall: editRenderCallWrapper(insertPreview, getInsertInput, "insert"),
     renderResult: editRenderResultWrapper,
     async execute(_toolCallId, params, signal, _onUpdate, ctx) {
-      const canonical = normReq(params);
-      const insertWarnings: string[] = [];
-      if (isRec(canonical)) {
-        const expanded = decodeStringArray(canonical.lines);
-        if (expanded) {
-          insertWarnings.push('[W_BAD_SHAPE] Unwrapped JSON array syntax from a lines element.');
-          canonical.lines = expanded;
+      return withAnchorSession(ctx, async () => {
+        const canonical = normReq(params);
+        const insertWarnings: string[] = [];
+        if (isRec(canonical)) {
+          const expanded = decodeStringArray(canonical.lines, insertWarnings, "lines");
+          if (expanded) canonical.lines = expanded;
         }
-      }
-      assertInsertReq(canonical);
-      const req = canonical;
-      const targetPath = await resolveEditTargetWithRequirement({
-        anchor: req.anchor,
-        providedPath: req.path,
-        cwd: ctx.cwd,
-      }).catch((error: unknown) => {
-        const member = batchMemberFor(_toolCallId);
-        if (member) noteBatchFailure(member, error);
-        else suffixPoisonCause(_toolCallId, error);
-        throw error;
-      });
-      let ref: Anchor;
-      let anchorWarnings: string[];
-      try {
-        ({ ref, warnings: anchorWarnings } = parseInsertAnchor(req.anchor));
-        await throwIfStrictInput([...anchorWarnings, ...insertWarnings]);
-      } catch (error) {
-        const member = batchMemberFor(_toolCallId);
-        if (member) noteBatchFailure(member, error);
-        throw error;
-      }
-      return queuedEdit(targetPath, ctx.cwd, signal, async (absolutePath, mutationTargetPath) => {
-        const member = batchMemberFor(_toolCallId);
-        if (member) {
-          const base = await ensureBatchBase({ member, targetPath, mutationTargetPath, cwd: ctx.cwd, signal });
-          const basePreload = { normalized: base.content, fileHashes: base.hashes } as NormFile;
-          const built = buildInsertEdit(req, basePreload, ref, targetPath);
-          let hedit: HEdit;
-          const resWarnings: string[] = [];
-          try {
-            hedit = resEdit(built.editParams, resWarnings);
-          } catch (error) {
-            noteBatchFailure(member, error);
-            throw error;
+        assertInsertReq(canonical);
+        const req = canonical;
+        const targetPath = await resolveEditTargetWithRequirement({
+          anchor: req.anchor,
+          providedPath: req.path,
+          cwd: ctx.cwd,
+        }).catch((error: unknown) => {
+          const member = batchMemberFor(_toolCallId);
+          if (member) noteBatchFailure(member, error);
+          else suffixPoisonCause(_toolCallId, error);
+          throw error;
+        });
+        let ref: Anchor;
+        let anchorWarnings: string[];
+        try {
+          ({ ref, warnings: anchorWarnings } = parseInsertAnchor(req.anchor));
+          await throwIfStrictInput([...anchorWarnings, ...insertWarnings]);
+        } catch (error) {
+          const member = batchMemberFor(_toolCallId);
+          if (member) noteBatchFailure(member, error);
+          throw error;
+        }
+        return queuedEdit(targetPath, ctx.cwd, signal, async (absolutePath, mutationTargetPath) => {
+          const member = batchMemberFor(_toolCallId);
+          if (member) {
+            const base = await ensureBatchBase({ member, targetPath, mutationTargetPath, cwd: ctx.cwd, signal });
+            const basePreload = { normalized: base.content, fileHashes: base.hashes } as NormFile;
+            const built = buildInsertEdit(req, basePreload, ref, targetPath);
+            let hedit: HEdit;
+            const resWarnings: string[] = [];
+            try {
+              hedit = resEdit(built.editParams, resWarnings);
+            } catch (error) {
+              noteBatchFailure(member, error);
+              throw error;
+            }
+            return executeBatchMember({
+              kind: "insert",
+              member,
+              targetPath,
+              mutationTargetPath,
+              cwd: ctx.cwd,
+              signal,
+              hedit,
+              extraWarnings: [...anchorWarnings, ...insertWarnings, ...resWarnings],
+              skipBoundaryDedup: true,
+              strictBoundaryDedup: false,
+              foldedLines: built.anchorLine === undefined ? 0 : 1,
+            });
           }
-          return executeBatchMember({
-            kind: "insert",
-            member,
-            targetPath,
-            mutationTargetPath,
-            cwd: ctx.cwd,
+          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, targetPath);
+          const pipe = await execPipeline(targetPath, editParams, ctx.cwd, {
+            accessMode: constants.R_OK | constants.W_OK,
             signal,
-            hedit,
-            extraWarnings: [...anchorWarnings, ...insertWarnings, ...resWarnings],
+            preloadedNorm: preload,
             skipBoundaryDedup: true,
-            strictBoundaryDedup: false,
-            foldedLines: built.anchorLine === undefined ? 0 : 1,
           });
-        }
-        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, 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: pipe.path,
-          absolutePath,
-          mutationTargetPath,
-          signal,
-          verb: "inserted",
-          noopNoun: "Insertion",
-          foldedAnchorLines: anchorLine === undefined ? 0 : 1,
-          prefixWarnings: [...anchorWarnings, ...insertWarnings],
-          onApplied: () => clearBoundaryBypass(mutationTargetPath),
+          return commitEdit(pipe, {
+            path: pipe.path,
+            absolutePath,
+            mutationTargetPath,
+            signal,
+            verb: "inserted",
+            noopNoun: "Insertion",
+            foldedAnchorLines: anchorLine === undefined ? 0 : 1,
+            prefixWarnings: [...anchorWarnings, ...insertWarnings],
+            onApplied: () => clearBoundaryBypass(mutationTargetPath),
+          });
         });
       });
     },

package/src/payload-contract.ts

@@ -1,5 +1,5 @@
 import { Type } from "typebox";
-import { isRec, normalizeAnchors, normalizeFilePath, rejectUnknownFields } from "./utils";
+import { isRec, normalizeAnchors, normalizeFilePath, rejectUnknownFields, assertNoNul } from "./utils";
 
 const replacementLinesSchema = Type.Array(
   Type.String({
@@ -74,6 +74,7 @@ export function assertReq(request: unknown): asserts request is ReqParams {
       '[E_BAD_SHAPE] Edit request requires "remove_from", "remove_to", and "replacement_lines" (array of strings, one per line; use [] to delete).',
     );
   }
+  assertNoNul(request.replacement_lines);
 }
 
 export function normReq(input: unknown): unknown {
@@ -136,4 +137,5 @@ export function assertInsertReq(request: unknown): asserts request is InsertReq
   if (!Array.isArray(request.lines) || request.lines.some((line) => typeof line !== "string")) {
     throw new Error('[E_BAD_SHAPE] Insert request requires "lines" as an array of strings, one element per line.');
   }
+  assertNoNul(request.lines);
 }