pi-hashline-edit-pro 4.1.0 → 4.2.0

package/src/config.ts

@@ -3,12 +3,14 @@ import { configPath } from "./paths";
 import { errCode, isRec } from "./utils";
 import { writeAtomic } from "./fs-write";
 
+export type BoundaryDedupMode = "on" | "off" | "strict";
+
 export interface Config {
   autoRead: boolean;
   anchorGrepEnabled: boolean;
   requirePath?: boolean;
   strictInput?: boolean;
-  boundaryDedupEnabled?: boolean;
+  boundaryDedupMode?: BoundaryDedupMode;
 }
 
 const DEFAULT_CONFIG: Config = {
@@ -16,9 +18,18 @@ const DEFAULT_CONFIG: Config = {
   anchorGrepEnabled: true,
   requirePath: false,
   strictInput: false,
-  boundaryDedupEnabled: true
+  boundaryDedupMode: "on"
 };
 
+const BOUNDARY_DEDUP_MODES: BoundaryDedupMode[] = ["on", "strict", "off"];
+
+function parseBoundaryDedupMode(mode: unknown, legacy: unknown): BoundaryDedupMode {
+  if (mode === "on" || mode === "strict" || mode === "off") return mode;
+  if (legacy === true) return "on";
+  if (legacy === false) return "off";
+  return DEFAULT_CONFIG.boundaryDedupMode ?? "on";
+}
+
 function parseConfig(content: string): Config {
   const parsed = JSON.parse(content) as unknown;
   const autoRead = isRec(parsed) ? parsed.autoRead : undefined;
@@ -28,13 +39,14 @@ function parseConfig(content: string): Config {
   const anchorGrepEnabled = isRec(parsed) ? parsed.anchorGrepEnabled : undefined;
   const requirePath = isRec(parsed) ? parsed.requirePath : undefined;
   const strictInput = isRec(parsed) ? parsed.strictInput : undefined;
-  const boundaryDedupEnabled = isRec(parsed) ? parsed.boundaryDedupEnabled : undefined;
+  const boundaryDedupMode = isRec(parsed) ? parsed.boundaryDedupMode : undefined;
+  const legacyBoundaryDedup = isRec(parsed) ? parsed.boundaryDedupEnabled : undefined;
   return {
     autoRead,
     anchorGrepEnabled: typeof anchorGrepEnabled === "boolean" ? anchorGrepEnabled : DEFAULT_CONFIG.anchorGrepEnabled,
     requirePath: typeof requirePath === "boolean" ? requirePath : DEFAULT_CONFIG.requirePath,
     strictInput: typeof strictInput === "boolean" ? strictInput : DEFAULT_CONFIG.strictInput,
-    boundaryDedupEnabled: typeof boundaryDedupEnabled === "boolean" ? boundaryDedupEnabled : DEFAULT_CONFIG.boundaryDedupEnabled,
+    boundaryDedupMode: parseBoundaryDedupMode(boundaryDedupMode, legacyBoundaryDedup),
   };
 }
 
@@ -83,10 +95,11 @@ export async function toggleStrictInput(): Promise<boolean> {
   return config.strictInput === true;
 }
 
-export async function toggleBoundaryDedup(): Promise<boolean> {
+export async function cycleBoundaryDedupMode(): Promise<BoundaryDedupMode> {
   const config = await readConfig();
-  const enabled = config.boundaryDedupEnabled !== false;
-  config.boundaryDedupEnabled = !enabled;
+  const current = config.boundaryDedupMode ?? "on";
+  const next = BOUNDARY_DEDUP_MODES[(BOUNDARY_DEDUP_MODES.indexOf(current) + 1) % BOUNDARY_DEDUP_MODES.length] ?? "on";
+  config.boundaryDedupMode = next;
   await writeConfig(config);
-  return !enabled;
+  return next;
 }

package/src/edit-common.ts

@@ -3,7 +3,7 @@ import { resolveInCwd } from "./fs-write";
 import { abortIf, makePrepareArguments } from "./utils";
 import { ownerOf } from "./anchor-registry";
 import { parseHashRef, stripAnchorRow } from "./hashline";
-import { readConfig } from "./config";
+import { readConfig, type BoundaryDedupMode } from "./config";
 import { makeRenderCall, renderEditResult, type RPreview, type FgT } from "./replace-render";
 import type { ReplaceDetails } from "./replace";
 export const editPrepare = makePrepareArguments();
@@ -11,14 +11,14 @@ export const editPrepare = makePrepareArguments();
 export interface EditToolFlags {
   requirePath: boolean;
   strictInput: boolean;
-  boundaryDedupEnabled: boolean;
+  boundaryDedupMode: BoundaryDedupMode;
   autoRead: boolean;
 }
 
 export const DEFAULT_EDIT_FLAGS: EditToolFlags = {
   requirePath: false,
   strictInput: false,
-  boundaryDedupEnabled: true,
+  boundaryDedupMode: "on",
   autoRead: true
 };
 
@@ -27,7 +27,7 @@ export async function currentEditFlags(): Promise<EditToolFlags> {
   return {
     requirePath: config.requirePath === true,
     strictInput: config.strictInput === true,
-    boundaryDedupEnabled: config.boundaryDedupEnabled !== false,
+    boundaryDedupMode: config.boundaryDedupMode ?? "on",
     autoRead: config.autoRead !== false
   };
 }
@@ -38,7 +38,7 @@ export function withReplacePrompts(base: { description: string; snippet: string;
   let guidelines = [...base.guidelines];
   if (!flags.autoRead) {
     description = description.replace(" Anchor follow-up edits on the `+anchor│` and ` anchor│` rows of the post-edit diff instead of re-reading.", "");
-    guidelines = guidelines.map((guideline) => guideline.includes("post-edit diff") ? "`replace`: one edit per turn; verify each result before the next edit on that file." : guideline);
+    guidelines = guidelines.map((guideline) => guideline.includes("post-edit diff") ? "`replace`: one batch per file per turn; verify each result before the next edit on that file." : guideline);
   }
   const descriptionParts = [description];
   if (flags.requirePath) {
@@ -50,9 +50,12 @@ export function withReplacePrompts(base: { description: string; snippet: string;
     descriptionParts.push("Strict-input mode is on: auto-fixable slips are rejected instead of fixed with warnings.");
     guidelines.push("`replace`: strict-input is on: auto-fixable slips are rejected instead of fixed.");
   }
-  if (!flags.boundaryDedupEnabled) {
+  if (flags.boundaryDedupMode === "off") {
     descriptionParts.push("Boundary dedup is off: edits apply literally.");
     guidelines.push("`replace`: boundary dedup is off: edits apply literally.");
+  } else if (flags.boundaryDedupMode === "strict") {
+    descriptionParts.push("Boundary dedup is strict: edits that re-include edge lines are rejected instead of stripped.");
+    guidelines.push("`replace`: boundary dedup is strict: edits that re-include edge lines are rejected instead of stripped.");
   }
   return { description: descriptionParts.join(" "), snippet: snippetParts.join(""), guidelines };
 }
@@ -116,10 +119,10 @@ export interface PathRequirementInput {
 export async function resolveEditTargetWithRequirement(input: PathRequirementInput): Promise<string> {
   const { requirePath } = await readConfig();
   if (!requirePath && input.providedPath !== undefined) {
-    throw new Error("[E_BAD_SHAPE] Edit request contains unknown or unsupported fields: path. Path resolution is anchor-only; enable require-path in /hashline-config to require it.");
+    throw new Error("[E_BAD_SHAPE] Edit request contains unknown or unsupported fields: path. Path resolution is anchor-only; retry without `path`.");
   }
   if (requirePath && (typeof input.providedPath !== "string" || input.providedPath.length === 0)) {
-    throw new Error('[E_BAD_SHAPE] Edit request requires a non-empty "path" string when require-path mode is on (disable it in /hashline-config).');
+    throw new Error('[E_BAD_SHAPE] Edit request requires a non-empty "path" string when require-path mode is on. Provide `path` matching the file the anchors were served for.');
   }
   const anchorTarget = typeof input.anchor === "string"
     ? resolveEditTarget(input.anchor)
@@ -138,13 +141,12 @@ export async function throwIfStrictInput(warnings: string[]): Promise<void> {
   if (fixes.length === 0) return;
   const { strictInput } = await readConfig();
   if (strictInput === true) {
-    throw new Error(`[E_BAD_SHAPE] Strict-input mode rejects auto-fixable input (disable it in /hashline-config):\n${fixes.join("\n")}`);
+    throw new Error(`[E_BAD_SHAPE] Strict-input mode rejects auto-fixable input:\n${fixes.join("\n")}`);
   }
 }
 
-export async function isBoundaryDedupEnabled(): Promise<boolean> {
-  const { boundaryDedupEnabled } = await readConfig();
-  return boundaryDedupEnabled !== false;
+export async function getBoundaryDedupMode(): Promise<BoundaryDedupMode> {
+  return (await readConfig()).boundaryDedupMode ?? "on";
 }
 
 export function editRenderCallWrapper(

package/src/grep.ts

@@ -677,7 +677,7 @@ export function regGrep(pi: ExtensionAPI): void {
       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; free anchors with /clear-anchors or narrow the search.]`);
+      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
         ? {

package/src/hashline/apply.ts

@@ -1,4 +1,4 @@
-import { abortIf, splitLines } from "../utils";
+import { abortIf, clipLine, splitLines } from "../utils";
 import { _lineHashesPure } from "./hash";
 import {
 	valEdit,
@@ -52,7 +52,7 @@ type NoopSpan = {
 	loc: string;
 	currentContent: string;
 };
-function assertNotEmpty(originalContent: string, result: string): void {
+export function assertNotEmpty(originalContent: string, result: string): void {
 	if (originalContent.length > 0 && result.length === 0) {
 		throw new Error(
 			"[E_WOULD_EMPTY] A replace cannot empty a non-empty file. Use `write` to clear the file."
@@ -148,6 +148,122 @@ function assemble(
 	return content.slice(0, span.start) + span.replacement + content.slice(span.end);
 }
 
+export interface PlannedEdit {
+  resolved: RHEdit;
+  warnings: string[];
+  autoFixes?: AutoFix[];
+}
+
+
+function throwStrictBoundaryDedup(edit: HEdit, boundaryDups: BDup[], resolved: RHEdit): never {
+  const startLine = resolved.hash_bounds[0].line;
+  const endLine = resolved.hash_bounds[1].line;
+  const range = startLine === endLine ? `line ${startLine}` : `lines ${startLine}-${endLine}`;
+  const seen = new Set<number>();
+  for (const dup of boundaryDups) seen.add(dup.replacementLineIndex);
+  const removed = [...seen].sort((a, b) => a - b).map((index) => `replacement_lines line ${index + 1}: ${clipLine(edit.content_lines[index] ?? "")}`);
+  throw new Error(`[E_BOUNDARY_STRICT] Strict boundary dedup rejects this edit: ${seen.size} replacement line(s) re-include edge lines (${range}). ${removed.join("; ")}. Resend without those lines.`);
+}
+export function planEdit(
+  content: string,
+  edit: HEdit,
+  precomputedHashes: string[],
+  options?: {
+    filePath?: string;
+    servedHashes?: ReadonlyMap<string, string>;
+    skipBoundaryDedup?: boolean;
+    strictBoundaryDedup?: boolean;
+    signal?: AbortSignal;
+  },
+): PlannedEdit {
+  const signal = options?.signal;
+  abortIf(signal);
+  const lineIndex = buildIdx(content);
+  const fileHashes = precomputedHashes;
+  const warnings: string[] = [];
+
+  const rangeFixed = swapReversedRanges(edit, fileHashes, warnings);
+  const prefixFixed = stripDiffPrefixes(
+    stripBarePrefixes(rangeFixed, fileHashes, warnings),
+    warnings,
+  );
+
+  const { resolved: initialResolved, mismatches, boundaryDups } = valEdit(
+    prefixFixed,
+    lineIndex.fileLines,
+    fileHashes,
+    warnings,
+    signal,
+  );
+  if (mismatches.length || !initialResolved) {
+    const feedback = fmtMismatchWithHashes(
+      mismatches,
+      lineIndex.fileLines,
+      fileHashes,
+      options?.filePath,
+    );
+    throw new AnchorMismatchError(feedback.text, feedback.hashes, feedback.servedMap);
+  }
+
+  warnUnicodeEsc(prefixFixed, warnings);
+
+  if (options?.strictBoundaryDedup === true && boundaryDups.length > 0) {
+    throwStrictBoundaryDedup(prefixFixed, boundaryDups, initialResolved);
+  }
+  let resolved = initialResolved;
+  let autoFixes: AutoFix[] | undefined;
+  if (boundaryDups.length > 0 && !(options?.skipBoundaryDedup === true)) {
+    autoFixes = [];
+    const correctedEdit: HEdit = {
+      ...prefixFixed,
+      content_lines: [...prefixFixed.content_lines],
+    };
+    const seen = new Set<number>();
+    const uniqueDups: BDup[] = [];
+    for (const dup of boundaryDups) {
+      if (seen.has(dup.replacementLineIndex)) continue;
+      seen.add(dup.replacementLineIndex);
+      uniqueDups.push(dup);
+    }
+    const dupsByIndex = uniqueDups.sort(
+      (a, b) => b.replacementLineIndex - a.replacementLineIndex,
+    );
+    for (const dup of dupsByIndex) {
+      const idx = dup.replacementLineIndex;
+      if (idx < 0 || idx >= correctedEdit.content_lines.length) continue;
+      const removed = correctedEdit.content_lines.splice(idx, 1)[0];
+      autoFixes.push({ kind: dup.kind, removedLine: removed, removedLineIndex: idx });
+    }
+    const correctedResult = valEdit(
+      correctedEdit,
+      lineIndex.fileLines,
+      fileHashes,
+      warnings,
+      signal,
+    );
+    if (correctedResult.mismatches.length || !correctedResult.resolved) {
+      const feedback = fmtMismatchWithHashes(
+        correctedResult.mismatches,
+        lineIndex.fileLines,
+        fileHashes,
+        options?.filePath,
+      );
+      throw new AnchorMismatchError(feedback.text, feedback.hashes, feedback.servedMap);
+    }
+    resolved = correctedResult.resolved;
+  }
+
+  if (options?.servedHashes) {
+    abortIf(signal);
+    assertRangeServed(resolved, lineIndex.fileLines, fileHashes, options.servedHashes, options?.filePath);
+  }
+
+  return {
+    resolved,
+    warnings,
+    ...(autoFixes ? { autoFixes } : {}),
+  };
+}
 export function applyEdit(
 	content: string,
 	edit: HEdit,
@@ -156,6 +272,7 @@ export function applyEdit(
 	filePath?: string,
 	servedHashes?: ReadonlyMap<string, string>,
 	skipBoundaryDedup?: boolean,
+	strictBoundaryDedup?: boolean,
 	): {
 	content: string;
 	firstChangedLine: number | undefined;
@@ -164,88 +281,15 @@ export function applyEdit(
 	noopEdit?: NEdit;
 	autoFixes?: AutoFix[];
 } {
-	abortIf(signal);
-
-	const lineIndex = buildIdx(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);
-	const prefixFixed = stripDiffPrefixes(
-		stripBarePrefixes(rangeFixed, fileHashes, warnings),
-		warnings,
-	);
-
-	const { resolved: initialResolved, mismatches, boundaryDups } = valEdit(
-		prefixFixed,
-		lineIndex.fileLines,
-		fileHashes,
-		warnings,
-		signal,
-	);
-	if (mismatches.length || !initialResolved) {
-		const feedback = fmtMismatchWithHashes(
-			mismatches,
-			lineIndex.fileLines,
-			fileHashes,
-			filePath,
-		);
-		throw new AnchorMismatchError(feedback.text, feedback.hashes, feedback.servedMap);
-	}
-
-	warnUnicodeEsc(prefixFixed, warnings);
-
-	let resolved = initialResolved;
-	let autoFixes: AutoFix[] | undefined;
-	if (boundaryDups.length > 0 && !skipBoundaryDedup) {
-		autoFixes = [];
-		const correctedEdit: HEdit = {
-			...prefixFixed,
-			content_lines: [...prefixFixed.content_lines],
-		};
-		const seen = new Set<number>();
-		const uniqueDups: BDup[] = [];
-		for (const dup of boundaryDups) {
-			if (seen.has(dup.replacementLineIndex)) continue;
-			seen.add(dup.replacementLineIndex);
-			uniqueDups.push(dup);
-		}
-		const dupsByIndex = uniqueDups.sort(
-			(a, b) => b.replacementLineIndex - a.replacementLineIndex,
-		);
-		for (const dup of dupsByIndex) {
-			const idx = dup.replacementLineIndex;
-			if (idx < 0 || idx >= correctedEdit.content_lines.length) continue;
-			const removed = correctedEdit.content_lines.splice(idx, 1)[0];
-			autoFixes.push({ kind: dup.kind, removedLine: removed, removedLineIndex: idx });
-		}
-		const correctedResult = valEdit(
-			correctedEdit,
-			lineIndex.fileLines,
-			fileHashes,
-			warnings,
-			signal,
-		);
-		if (correctedResult.mismatches.length || !correctedResult.resolved) {
-			const feedback = fmtMismatchWithHashes(
-				correctedResult.mismatches,
-				lineIndex.fileLines,
-				fileHashes,
-				filePath,
-			);
-			throw new AnchorMismatchError(feedback.text, feedback.hashes, feedback.servedMap);
-		}
-		resolved = correctedResult.resolved;
-	}
-
-	if (servedHashes) {
-		abortIf(signal);
-		assertRangeServed(resolved, lineIndex.fileLines, fileHashes, servedHashes, filePath);
-	}
-
+  abortIf(signal);
+  if (precomputedHashes === undefined) {
+    throw new Error("[E_BAD_SHAPE] applyEdit requires the file's allocated anchors; derive them via lineHashes(content, path) first.");
+  }
+  const planned = planEdit(content, edit, precomputedHashes, { filePath, servedHashes, skipBoundaryDedup, strictBoundaryDedup, signal });
+  const lineIndex = buildIdx(content);
+  const warnings = planned.warnings;
+  const resolved = planned.resolved;
+  const autoFixes = planned.autoFixes;
 	const spanResult = resToSpan(resolved, content, lineIndex);
 	if (spanResult.kind === "noop") {
 		return {

package/src/hashline/index.ts

@@ -43,7 +43,10 @@ export {
 export {
 	buildIdx,
 	applyEdit,
+	planEdit,
+	type PlannedEdit,
 	fmtRegion,
 	fmtRow,
 	changedRange,
+	assertNotEmpty,
 } from "./apply";

package/src/insert.ts

@@ -3,43 +3,17 @@ import { Type } from "typebox";
 import { constants } from "fs";
 import { execPipeline, type ReqParams, type ReplaceDetails, previewFromPipe, previewError } from "./replace";
 import { commitEdit } from "./commit";
+import { batchMemberFor, executeBatchMember, noteBatchFailure } from "./batch";
 import { readNormFile, type NormFile } from "./file-reader";
-import { MAX_HASH_LINES, parseHashRef, resolveAnchorLine, type Anchor } from "./hashline";
+import { MAX_HASH_LINES, parseHashRef, resEdit, resolveAnchorLine, type Anchor, type HEdit } from "./hashline";
 import { stripAnchorRow } from "./hashline/resolve";
 import { loadP, loadGuide } from "./prompts";
-import { normReq } from "./payload-contract";
-import { decodeStringArray, isRec, rejectUnknownFields, splitLines } from "./utils";
+import { assertInsertReq, normReq, type InsertReq } from "./payload-contract";
+import { decodeStringArray, isRec, splitLines } from "./utils";
 import { clearBoundaryBypass } from "./boundary-bypass";
 import { queuedEdit, editToolBase, editRenderCallWrapper, editRenderResultWrapper, resolveEditTargetWithRequirement, throwIfStrictInput, withInsertPrompts, DEFAULT_EDIT_FLAGS, type EditToolFlags } from "./edit-common";
 import type { RPreview, RRState } from "./replace-render";
-
-const INSERT_KS = new Set(["path", "anchor", "direction", "lines"]);
-
-export interface InsertReq {
-  path?: string;
-  anchor: string;
-  direction: "before" | "after";
-  lines: string[];
-}
-
-export function assertInsertReq(request: unknown): asserts request is InsertReq {
-  if (!isRec(request)) {
-    throw new Error("[E_BAD_SHAPE] Insert request must be an object.");
-  }
-  rejectUnknownFields(request, INSERT_KS, "Insert request");
-  if (request.path !== undefined && typeof request.path !== "string") {
-    throw new Error('[E_BAD_SHAPE] Insert request field "path" must be a string when provided.');
-  }
-  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).');
-  }
-  if (request.direction !== "before" && request.direction !== "after") {
-    throw new Error('[E_BAD_SHAPE] Insert request "direction" must be "before" or "after".');
-  }
-  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.');
-  }
-}
+export { assertInsertReq, type InsertReq };
 
 const insertAnchorSchema = Type.String({
   description:
@@ -87,14 +61,14 @@ export function buildInsertToolSchema(requirePath: boolean): typeof insertToolSc
   ) as typeof insertToolSchema;
 }
 
-function parseInsertAnchor(raw: string): { ref: Anchor; warnings: string[] } {
+export function parseInsertAnchor(raw: string): { ref: Anchor; warnings: string[] } {
   const trimmedAnchor = raw.trim();
   const warnings: string[] = [];
   const anchorText = stripAnchorRow(trimmedAnchor, "anchor entry", warnings);
   return { ref: parseHashRef(anchorText), warnings };
 }
 
-function buildInsertEdit(
+export function buildInsertEdit(
   req: InsertReq,
   preload: NormFile,
   ref: Anchor,
@@ -216,32 +190,68 @@ export function buildInsertToolDef(flags: EditToolFlags = DEFAULT_EDIT_FLAGS): I
         anchor: req.anchor,
         providedPath: req.path,
         cwd: ctx.cwd,
+      }).catch((error: unknown) => {
+        const member = batchMemberFor(_toolCallId);
+        if (member) noteBatchFailure(member, error);
+        throw error;
       });
-      const { ref, warnings: anchorWarnings } = parseInsertAnchor(req.anchor);
-      await throwIfStrictInput([...anchorWarnings, ...insertWarnings]);
+      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);
         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,
+        if (!member) {
+          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),
+          });
+        }
+        let hedit: HEdit;
+        const resWarnings: string[] = [];
+        try {
+          hedit = resEdit(editParams, resWarnings);
+        } catch (error) {
+          noteBatchFailure(member, error);
+          throw error;
+        }
+        return executeBatchMember({
+          kind: "insert",
+          member,
+          targetPath,
           mutationTargetPath,
+          cwd: ctx.cwd,
           signal,
-          verb: "inserted",
-          noopNoun: "Insertion",
-          foldedAnchorLines: anchorLine === undefined ? 0 : 1,
-          prefixWarnings: [...anchorWarnings, ...insertWarnings],
-          onApplied: () => clearBoundaryBypass(mutationTargetPath),
+          hedit,
+          extraWarnings: [...anchorWarnings, ...insertWarnings, ...resWarnings],
+          skipBoundaryDedup: true,
+          strictBoundaryDedup: false,
+          foldedLines: anchorLine === undefined ? 0 : 1,
         });
       });
     },

package/src/payload-contract.ts

@@ -109,3 +109,31 @@ export function getPreviewInput(args: unknown): { path?: string; remove_from: st
     replacement_lines: normalized.replacement_lines as string[],
   };
 }
+
+const INSERT_KS = new Set(["path", "anchor", "direction", "lines"]);
+
+export interface InsertReq {
+  path?: string;
+  anchor: string;
+  direction: "before" | "after";
+  lines: string[];
+}
+
+export function assertInsertReq(request: unknown): asserts request is InsertReq {
+  if (!isRec(request)) {
+    throw new Error("[E_BAD_SHAPE] Insert request must be an object.");
+  }
+  rejectUnknownFields(request, INSERT_KS, "Insert request");
+  if (request.path !== undefined && typeof request.path !== "string") {
+    throw new Error('[E_BAD_SHAPE] Insert request field "path" must be a string when provided.');
+  }
+  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).');
+  }
+  if (request.direction !== "before" && request.direction !== "after") {
+    throw new Error('[E_BAD_SHAPE] Insert request "direction" must be "before" or "after".');
+  }
+  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.');
+  }
+}