pi-hashline-edit-pro 4.5.3 → 5.0.0

package/src/edit-common.ts

@@ -13,13 +13,17 @@ export interface EditToolFlags {
   strictInput: boolean;
   autoRead: boolean;
   autoReadAllActive: boolean;
+  replaceWithinEnabled: boolean;
+  copyMoveEnabled: boolean;
 }
 
 export const DEFAULT_EDIT_FLAGS: EditToolFlags = {
   requirePath: false,
   strictInput: false,
   autoRead: true,
-  autoReadAllActive: false
+  autoReadAllActive: false,
+  replaceWithinEnabled: true,
+  copyMoveEnabled: true
 };
 
 export async function currentEditFlags(): Promise<EditToolFlags> {
@@ -28,7 +32,9 @@ export async function currentEditFlags(): Promise<EditToolFlags> {
     requirePath: config.requirePath === true,
     strictInput: config.strictInput === true,
     autoRead: config.autoRead !== false,
-    autoReadAllActive: (config.autoReadAll ?? "off") !== "off"
+    autoReadAllActive: (config.autoReadAll ?? "off") !== "off",
+    replaceWithinEnabled: config.replaceWithinEnabled !== false,
+    copyMoveEnabled: config.copyMoveEnabled !== false
   };
 }
 
@@ -41,18 +47,18 @@ export function withReplacePrompts(base: { description: string; snippet: string;
     guidelines = guidelines.filter((guideline) => !guideline.includes("post-edit diff"));
     description = description.replace("and the last call shows the combined diff,", "and the last call shows the combined result,");
   }
+  if (!flags.replaceWithinEnabled) {
+    description = description.replace(/\n?To change only part of a line without retyping the rest, use `replace_within` instead; it preserves every character the request does not name\./, "");
+  }
   const descriptionParts = [description];
   if (flags.requirePath) {
     descriptionParts.push("Also give `path` matching the file the anchors were served for; it is required and must match anchor ownership.");
     snippetParts.push("; include `path` (required)");
-    guidelines.push("`replace`: include `path` matching the file the anchors were served for; it is required.");
   } else {
     descriptionParts.push("Path resolution is anchor-only; do not pass `path`.");
-    guidelines.push("`replace`: path resolution is anchor-only; don't pass `path`.");
   }
   if (flags.strictInput) {
     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.");
   }
   return { description: descriptionParts.join(" "), snippet: snippetParts.join(""), guidelines };
 }
@@ -78,39 +84,84 @@ export function withInsertPrompts(base: { description: string; snippet: string;
   if (flags.requirePath) {
     descriptionParts.push("Also give `path` matching the file the anchor was served for; it is required and must match anchor ownership.");
     snippetParts.push("; include `path` (required)");
-    guidelines.push("`insert`: include `path` matching the file the anchor was served for; it is required.");
   } else {
     descriptionParts.push("Path resolution is anchor-only; do not pass `path`.");
-    guidelines.push("`insert`: path resolution is anchor-only; don't pass `path`.");
   }
   if (flags.strictInput) {
     descriptionParts.push("Strict-input mode is on: auto-fixable slips are rejected instead of fixed with warnings.");
-    guidelines.push("`insert`: strict-input is on: auto-fixable slips are rejected instead of fixed.");
   }
   return { description: descriptionParts.join(" "), snippet: snippetParts.join(""), guidelines };
 }
 
+export function withReplaceWithinPrompts(base: { description: string; snippet: string; guidelines: string[] }, flags: EditToolFlags): { description: string; snippet: string; guidelines: string[] } {
+  const descriptionParts = [base.description];
+  const snippetParts = [base.snippet];
+  const guidelines = base.guidelines.map((guideline) => flags.copyMoveEnabled ? guideline : guideline.replace(", like `copy` and `move`", ""));
+  if (flags.requirePath) {
+    descriptionParts.push("Also give `path` matching the file the anchors were served for; it is required and must match anchor ownership.");
+    snippetParts.push("; include `path` (required)");
+  } else {
+    descriptionParts.push("Path resolution is anchor-only; do not pass `path`.");
+  }
+  if (flags.strictInput) {
+    descriptionParts.push("Strict-input mode is on: auto-fixable slips are rejected instead of fixed with warnings.");
+  }
+  return { description: descriptionParts.join(" "), snippet: snippetParts.join(""), guidelines };
+}
+
+function gatedEditOps(ops: string[], flags: EditToolFlags): string[] {
+  return ops.filter((op) => {
+    if (op === "replace_within") return flags.replaceWithinEnabled;
+    if (op === "copy" || op === "move") return flags.copyMoveEnabled;
+    return true;
+  });
+}
+
+function joinOps(ops: string[], options?: { backtick?: boolean; separator?: "/" }): string {
+  const formatted = ops.map((op) => (options?.backtick ? `\`${op}\`` : op));
+  if (options?.separator === "/") return formatted.join("/");
+  if (formatted.length <= 1) return formatted[0] ?? "";
+  const last = formatted[formatted.length - 1]!;
+  const head = formatted.slice(0, -1).join(", ");
+  return formatted.length === 2 ? `${head} or ${last}` : `${head}, or ${last}`;
+}
+
+export function withGrepPrompts(base: { description: string; snippet: string }, flags: EditToolFlags): { description: string; snippet: string } {
+  if (flags.copyMoveEnabled) return base;
+  return { ...base, description: base.description.replaceAll("replace, insert, copy, or move", joinOps(gatedEditOps(["replace", "insert", "copy", "move"], flags))) };
+}
+
 export function withUndoPrompts(base: { description: string; snippet: string; guidelines: string[] }, flags: EditToolFlags): { description: string; snippet: string; guidelines: string[] } {
-  if (flags.autoRead) return { description: base.description, snippet: base.snippet, guidelines: [...base.guidelines] };
-  const guidelines = base.guidelines.map((guideline) => guideline.includes("bad diff") ? "`undo_last_change`: only the last `replace`/`insert` per file is undoable; a `write` clears it, so undo right after a bad edit — review what you're restoring." : guideline);
-  return { description: base.description, snippet: base.snippet, guidelines };
+  const ops = gatedEditOps(["replace", "replace_within", "insert", "copy", "move"], flags);
+  let description = base.description;
+  let snippet = base.snippet;
+  let guidelines = [...base.guidelines];
+  if (!flags.autoRead) {
+    guidelines = guidelines.map((guideline) => guideline.includes("bad diff") ? "`undo_last_change`: only the last `replace`/`replace_within`/`insert`/`copy`/`move` per file is undoable; a `write` clears it, so undo right after a bad edit — review what you're restoring." : guideline);
+  }
+  if (ops.length !== 5) {
+    description = description.replaceAll("replace, replace_within, insert, copy, or move", joinOps(ops));
+    snippet = snippet.replaceAll("`replace`, `replace_within`, `insert`, `copy`, or `move`", joinOps(ops, { backtick: true }));
+    guidelines = guidelines.map((guideline) => guideline.replaceAll("`replace`/`replace_within`/`insert`/`copy`/`move`", joinOps(ops, { backtick: true, separator: "/" })));
+  }
+  if (!flags.copyMoveEnabled) {
+    guidelines = guidelines.filter((guideline) => !guideline.includes("cross-file `move`"));
+  }
+  return { description, snippet, guidelines };
 }
 
-export function withTransferPrompts(base: { description: string; snippet: string; guidelines: string[] }, flags: EditToolFlags, toolName: "copy" | "move"): { description: string; snippet: string; guidelines: string[] } {
+export function withTransferPrompts(base: { description: string; snippet: string; guidelines: string[] }, flags: EditToolFlags): { description: string; snippet: string; guidelines: string[] } {
   const descriptionParts = [base.description];
   const snippetParts = [base.snippet];
   const guidelines = [...base.guidelines];
   if (flags.requirePath) {
     descriptionParts.push("Also give `path` matching the source or destination file the anchors were served for; it is required and must match anchor ownership.");
     snippetParts.push("; include `path` (required)");
-    guidelines.push(`\`${toolName}\`: include \`path\` matching the source or destination file the anchors were served for; it is required.`);
   } else {
     descriptionParts.push("Path resolution is anchor-only; do not pass `path`.");
-    guidelines.push(`\`${toolName}\`: path resolution is anchor-only; don't pass \`path\`.`);
   }
   if (flags.strictInput) {
     descriptionParts.push("Strict-input mode is on: auto-fixable slips are rejected instead of fixed with warnings.");
-    guidelines.push(`\`${toolName}\`: strict-input is on: auto-fixable slips are rejected instead of fixed.`);
   }
   return { description: descriptionParts.join(" "), snippet: snippetParts.join(""), guidelines };
 }

package/src/edit-fidelity.ts

@@ -0,0 +1,108 @@
+import { splitLines } from "./utils";
+import type { DiffSpan } from "./replace-diff";
+
+const INVISIBLE_RE = /\p{Default_Ignorable_Code_Point}/u;
+const LOOKALIKE_SPACE_RE = /[\u00a0\u1680\u2000-\u200a\u202f\u205f\u3000]/u;
+const LOOKALIKE_DASH_RE = /[\u2010-\u2015\u2212]/u;
+const LOOKALIKE_QUOTE_RE = /[\u2018\u2019\u201c\u201d]/u;
+const MAX_LISTED_CHARS = 3;
+
+const CHAR_NAMES: Readonly<Record<number, string>> = {
+  0x00a0: "no-break space",
+  0x200b: "zero-width space",
+  0x200c: "zero-width non-joiner",
+  0x200d: "zero-width joiner",
+  0x200e: "left-to-right mark",
+  0x200f: "right-to-left mark",
+  0x2011: "non-breaking hyphen",
+  0x202f: "narrow no-break space",
+  0x2060: "word joiner",
+  0xfeff: "zero-width no-break space",
+};
+
+const LOOKALIKE_SUBSTITUTES: Readonly<Record<string, string>> = {
+  "\u00a0": " ",
+  "\u1680": " ",
+  "\u2000": " ",
+  "\u2001": " ",
+  "\u2002": " ",
+  "\u2003": " ",
+  "\u2004": " ",
+  "\u2005": " ",
+  "\u2006": " ",
+  "\u2007": " ",
+  "\u2008": " ",
+  "\u2009": " ",
+  "\u200a": " ",
+  "\u202f": " ",
+  "\u205f": " ",
+  "\u3000": " ",
+  "\u2010": "-",
+  "\u2011": "-",
+  "\u2012": "-",
+  "\u2013": "-",
+  "\u2014": "-",
+  "\u2015": "-",
+  "\u2212": "-",
+  "\u2018": "'",
+  "\u2019": "'",
+  "\u201c": "\"",
+  "\u201d": "\"",
+};
+
+export function isFidelitySensitiveChar(char: string): boolean {
+  return INVISIBLE_RE.test(char) || LOOKALIKE_SPACE_RE.test(char) || LOOKALIKE_DASH_RE.test(char) || LOOKALIKE_QUOTE_RE.test(char);
+}
+
+function describeChar(char: string): string {
+  const codePoint = char.codePointAt(0)!;
+  const hex = `U+${codePoint.toString(16).toUpperCase().padStart(4, "0")}`;
+  const name = CHAR_NAMES[codePoint];
+  return name === undefined ? hex : `${hex} (${name})`;
+}
+
+function unicodeLostHint(chars: string[]): string {
+  const listed = chars.slice(0, MAX_LISTED_CHARS).map(describeChar).join(", ");
+  const more = chars.length > MAX_LISTED_CHARS ? ` (+${chars.length - MAX_LISTED_CHARS} more)` : "";
+  return `[H_UNICODE_LOST] The removed line contained ${listed}${more}, which the replacement does not. If the request did not ask to remove it, copy the character from the served row.`;
+}
+
+function withCharsRestored(line: string, chars: readonly string[], replacementFor: (char: string) => string): string {
+  let out = line;
+  for (const char of chars) out = out.split(char).join(replacementFor(char));
+  return out;
+}
+
+function isDeliberateCharFix(oldLine: string, newLine: string, lostChars: readonly string[]): boolean {
+  if (lostChars.length === 0) return false;
+  if (withCharsRestored(oldLine, lostChars, (char) => LOOKALIKE_SUBSTITUTES[char] ?? "") === newLine) return true;
+  return withCharsRestored(oldLine, lostChars, () => "") === newLine;
+}
+
+export function fidelityHints(originalContent: string, resultContent: string, spans: readonly DiffSpan[] | undefined): string[] {
+  if (spans === undefined || spans.length === 0) return [];
+  const oldLines = splitLines(originalContent);
+  const newLines = splitLines(resultContent);
+  const lost = new Set<string>();
+  let offset = 0;
+  for (const span of [...spans].sort((a, b) => a.start - b.start)) {
+    const removedCount = span.end >= span.start ? span.end - span.start + 1 : 0;
+    const removed = removedCount > 0 ? oldLines.slice(span.start, span.end + 1) : [];
+    const inserted = newLines.slice(span.start + offset, span.start + offset + span.replacementCount);
+    if (removed.length > 0 && inserted.length > 0) {
+      const insertedText = inserted.join("\n");
+      const dropped: string[] = [];
+      for (const line of removed) {
+        for (const char of line) {
+          if (!dropped.includes(char) && isFidelitySensitiveChar(char) && !insertedText.includes(char)) dropped.push(char);
+        }
+      }
+      const deliberateFix = removed.length === 1 && inserted.length === 1 && isDeliberateCharFix(removed[0]!, inserted[0]!, dropped);
+      if (!deliberateFix) {
+        for (const char of dropped) lost.add(char);
+      }
+    }
+    offset += span.replacementCount - removedCount;
+  }
+  return lost.size > 0 ? [unicodeLostHint([...lost].sort())] : [];
+}

package/src/grep.ts

@@ -11,8 +11,9 @@ import { globToRegex } from "./glob";
 import { MAX_HASH_LINES, fmtRow, HASH_LEN, HASH_SEP, HASH_CLASS } from "./hashline";
 import { ANCHOR_POOL_EXHAUSTED_PREFIX, MAX_GREP_LINE_BYTES } from "./constants";
 import { toCwd, toDisplayPath } from "./paths";
-import { loadP, loadGuide } from "./prompts";
+import { loadP } from "./prompts";
 import { normReq } from "./payload-contract";
+import { DEFAULT_EDIT_FLAGS, withGrepPrompts, type EditToolFlags } from "./edit-common";
 import { abortIf, clipLine, errCode, gutterWidth, isRec, makePrepareArguments, rejectUnknownFields, truncateToBytes, visLines } from "./utils";
 import { withAnchorSession, formatAnchorReclaimNotice, takeReclaimedPaths } from "./anchor-registry";
 import { serveRows } from "./served";
@@ -529,13 +530,13 @@ export function renderGrepResult(result: { content?: Array<{ type: string; text?
   if (lines.length > maxLines) shown.push(theme.fg("muted", `... ${lines.length - maxLines} more grep lines (${expandHint()})`));
   return reuseText(context, shown.join("\n"));
 }
-export function regGrep(pi: ExtensionAPI): void {
+export function regGrep(pi: ExtensionAPI, flags: EditToolFlags = DEFAULT_EDIT_FLAGS): void {
+  const prompted = withGrepPrompts({ description: loadP("../prompts/grep.md"), snippet: loadP("../prompts/grep-snippet.md") }, flags);
   pi.registerTool({
     name: "anchor_grep",
     label: "Anchor Grep",
-    description: loadP("../prompts/grep.md"),
-    promptSnippet: loadP("../prompts/grep-snippet.md"),
-    promptGuidelines: loadGuide("../prompts/grep-guidelines.md"),
+    description: prompted.description,
+    promptSnippet: prompted.snippet,
     prepareArguments: makePrepareArguments(),
     parameters: grepToolSchema,
     executionMode: "sequential",

package/src/hashline/index.ts

@@ -19,6 +19,7 @@ export {
 	parseHashRef,
 	parseText,
 	parseTextWithSeparators,
+	parsePayloadText,
 	type Anchor,
 	type ParsedText,
 } from "./parse";
@@ -27,6 +28,7 @@ export {
 	type HEdit,
 	type RHEdit,
 	type HTEdit,
+	type HTPayloadEdit,
 	type NEdit,
 	resEdit,
 	stripAnchorRow,

package/src/hashline/parse.ts

@@ -96,3 +96,10 @@ export function parseTextWithSeparators(edit: string[]): ParsedText {
 export function parseText(edit: string[]): string[] {
 	return parseTextWithSeparators(edit).lines;
 }
+
+export function parsePayloadText(text: string): ParsedText {
+	if (text.length === 0) return { lines: [], separators: [] };
+	const parsed = splitWithEndings(text);
+	const lineCount = text.endsWith("\n") || text.endsWith("\r") ? parsed.lines.length - 1 : parsed.lines.length;
+	return { lines: parsed.lines.slice(0, lineCount), separators: parsed.endings.slice(0, lineCount) };
+}

package/src/hashline/resolve.ts

@@ -1,8 +1,8 @@
 import { abortIf, rejectUnknownFields, clipLine, decodeStringArray, assertNoNul } from "../utils";
-import { parseHashRef, parseTextWithSeparators, type Anchor } from "./parse";
+import { parseHashRef, parsePayloadText, parseTextWithSeparators, type Anchor, type ParsedText } from "./parse";
 import { HASH_SEP, stripRowPrefix, lineChecksum, type RowPrefixKind } from "./hash";
 import { HASH_RUN } from "./alphabet";
-import { NEW_CONTENT_NOT_ARRAY_MSG, MAX_RANGE_STALE_LINES } from "../constants";
+import { NEW_CONTENT_NOT_ARRAY_MSG, NEW_CONTENT_NOT_STRING_MSG, MAX_RANGE_STALE_LINES } from "../constants";
 import type { LineEnding } from "../normalize";
 
 export type RAnchor = {
@@ -38,6 +38,12 @@ export type HTEdit = {
   remove_to: string;
 };
 
+export type HTPayloadEdit = {
+  replacement_lines: string;
+  remove_from: string;
+  remove_to: string;
+};
+
 function resAnchorFromMap(
 	ref: Anchor,
 	hashIndex: Map<string, number[]>,
@@ -116,30 +122,57 @@ export function fmtMismatchWithHashes(
 
 const ITEM_KS = new Set(["replacement_lines", "remove_from", "remove_to"]);
 
+function assertBounds(edit: Record<string, unknown>): void {
+	if ("remove_from" in edit && typeof edit.remove_from !== "string") {
+		throw new Error(
+			`[E_BAD_SHAPE] Field "remove_from" must be an anchor string (4-char anchor).`,
+		);
+	}
+	if ("remove_to" in edit && typeof edit.remove_to !== "string") {
+		throw new Error(
+			`[E_BAD_SHAPE] Field "remove_to" must be an anchor string (4-char anchor).`,
+		);
+	}
+	if (typeof edit.remove_from !== "string" || typeof edit.remove_to !== "string") {
+		throw new Error(
+			`[E_BAD_SHAPE] The edit requires "remove_from" and "remove_to" anchor strings (4-char anchors from read output).`,
+		);
+	}
+}
+
 function assertItem(edit: Record<string, unknown>): void {
-  rejectUnknownFields(edit, ITEM_KS, "Edit", "The edit takes only { replacement_lines, remove_from, remove_to }.");
+	rejectUnknownFields(edit, ITEM_KS, "Edit", "The edit takes only { replacement_lines, remove_from, remove_to }.");
+	assertBounds(edit);
+	if (!("replacement_lines" in edit)) {
+		throw new Error(`[E_BAD_SHAPE] The edit requires a "replacement_lines" array (use [] to delete).`);
+	}
+	if (!Array.isArray(edit.replacement_lines) || edit.replacement_lines.some((line) => typeof line !== "string")) {
+		throw new Error(NEW_CONTENT_NOT_ARRAY_MSG);
+	}
+}
 
-  if ("remove_from" in edit && typeof edit.remove_from !== "string") {
-    throw new Error(
-      `[E_BAD_SHAPE] Field "remove_from" must be an anchor string (4-char anchor).`,
-    );
-  }
-  if ("remove_to" in edit && typeof edit.remove_to !== "string") {
-    throw new Error(
-      `[E_BAD_SHAPE] Field "remove_to" must be an anchor string (4-char anchor).`,
-    );
-  }
-  if (!("replacement_lines" in edit)) {
-    throw new Error(`[E_BAD_SHAPE] The edit requires a "replacement_lines" array (use [] to delete).`);
-  }
-  if (!Array.isArray(edit.replacement_lines) || edit.replacement_lines.some((line) => typeof line !== "string")) {
-    throw new Error(NEW_CONTENT_NOT_ARRAY_MSG);
-  }
-  if (typeof edit.remove_from !== "string" || typeof edit.remove_to !== "string") {
-    throw new Error(
-      `[E_BAD_SHAPE] The edit requires "remove_from" and "remove_to" anchor strings (4-char anchors from read output).`,
-    );
-  }
+function assertPayloadItem(edit: Record<string, unknown>): void {
+	rejectUnknownFields(edit, ITEM_KS, "Edit", "The edit takes only { replacement_lines, remove_from, remove_to }.");
+	assertBounds(edit);
+	if (!("replacement_lines" in edit)) {
+		throw new Error(`[E_BAD_SHAPE] The edit requires a "replacement_lines" string (use "" to delete).`);
+	}
+	if (typeof edit.replacement_lines !== "string") {
+		throw new Error(NEW_CONTENT_NOT_STRING_MSG);
+	}
+}
+
+function resolveParsedEdit(removeFrom: string, removeTo: string, parsed: ParsedText, warnings?: string[]): HEdit {
+	const replaceLines = parsed.lines;
+	assertNoNul(replaceLines);
+	const bounds = [removeFrom, removeTo].map((ref) => {
+		return stripAnchorRow(ref.trim(), "remove_from/remove_to entry", warnings);
+	}) as [string, string];
+	return {
+		content_lines: replaceLines,
+		hash_bounds: [parseHashRef(bounds[0]), parseHashRef(bounds[1])],
+		...(parsed.separators.some((separator) => separator !== undefined) ? { content_separators: parsed.separators } : {}),
+	};
 }
 
 export const ANCHOR_ROW_RE = new RegExp(`^([+-]?)(${HASH_RUN})│`);
@@ -161,20 +194,14 @@ export function stripAnchorRow(
 	return match[2]!;
 }
 
-export function resEdit(edit: HTEdit, warnings?: string[]): HEdit {
-  assertItem(edit as Record<string, unknown>);
-
-  const parsed = parseTextWithSeparators(decodeStringArray(edit.replacement_lines, warnings) ?? edit.replacement_lines);
-  const replaceLines = parsed.lines;
-  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];
-  return {
-    content_lines: replaceLines,
-    hash_bounds: [parseHashRef(bounds[0]), parseHashRef(bounds[1])],
-    ...(parsed.separators.some((separator) => separator !== undefined) ? { content_separators: parsed.separators } : {}),
-  };
+export function resEdit(edit: HTEdit | HTPayloadEdit, warnings?: string[]): HEdit {
+	if (typeof edit.replacement_lines === "string") {
+		assertPayloadItem(edit as unknown as Record<string, unknown>);
+		return resolveParsedEdit(edit.remove_from, edit.remove_to, parsePayloadText(edit.replacement_lines), warnings);
+	}
+	assertItem(edit as Record<string, unknown>);
+	const parsed = parseTextWithSeparators(decodeStringArray(edit.replacement_lines, warnings) ?? edit.replacement_lines);
+	return resolveParsedEdit(edit.remove_from, edit.remove_to, parsed, warnings);
 }
 
 function warnUnicodeEsc(

package/src/insert.ts

@@ -1,43 +1,38 @@
 import type { ExtensionAPI, ToolDefinition } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 import { constants } from "node:fs";
-import { execPipeline, type ReqParams, type ReplaceDetails, previewFromPipe, previewError } from "./replace";
+import { execPipeline, type ReplaceDetails, previewFromPipe, previewError } from "./replace";
 import { commitEdit } from "./commit";
 import { batchMemberFor, ensureBatchBase, executeBatchMember, noteBatchFailure } from "./batch";
 import { readNormFile, type NormFile } from "./file-reader";
-import { MAX_HASH_LINES, parseHashRef, parseTextWithSeparators, resEdit, resolveAnchorLine, type Anchor, type HEdit, type StripWarningLocation } from "./hashline";
+import { MAX_HASH_LINES, parseHashRef, parsePayloadText, resEdit, resolveAnchorLine, type Anchor, type HEdit, type HTEdit, type StripWarningLocation } from "./hashline";
 import type { LineEnding } from "./normalize";
 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, literalEscapeHint, splitLines } from "./utils";
+import { isRec, literalEscapeHint, splitLines } from "./utils";
 import { queuedEdit, editToolBase, editRenderCallWrapper, editRenderResultWrapper, resolveEditTargetWithRequirement, throwIfStrictInput, withInsertPrompts, DEFAULT_EDIT_FLAGS, type EditToolFlags } from "./edit-common";
 import type { RPreview, RRState } from "./replace-render";
 export { assertInsertReq, type InsertReq };
 
 const insertAnchorSchema = Type.String({
   description:
-    'Bare 4-char anchor from a served anchor│content row (the text before the `│` separator), never the row content. A pasted diff row or `anchor│` prefix is stripped with a warning. The anchor line is preserved; lines go after or before it.',
+    "4-char anchor of the line to insert next to (never the row content). A pasted diff row is stripped with a warning; the anchor line is preserved.",
 });
 
 const insertDirectionSchema = Type.Union(
   [Type.Literal("after"), Type.Literal("before")],
   { description: '"after" or "before"' },
 );
-
-const insertLinesSchema = Type.Array(
-  Type.String({
-    description: "One line to insert. A real line break (\\n, \\r\\n, or \\r) splits it into lines and sets their endings.",
-  }),
-  {
-    description: 'One string per line; [""] is a blank line; never include the anchor line.',
-  }
-);
+const insertLinesSchema = Type.String({
+  description:
+    'The exact text to insert. "" inserts nothing, "\\n" is one blank line, and a trailing line break sets the last line\'s ending instead of adding a blank line. Never include the anchor line.',
+});
 
 const insertPathRequiredSchema = Type.String({
   description:
-    "Path to the file the anchor was served for; required and must match anchor ownership. The anchor still resolves the target.",
+    "Path to the file the anchor was served for; required and must match anchor ownership.",
 });
 
 const insertToolSchema = Type.Object(
@@ -74,12 +69,12 @@ export function buildInsertEdit(
   preload: NormFile,
   ref: Anchor,
   path: string,
-): { editParams: ReqParams; anchorLine: string | undefined; contentSeparators: (LineEnding | undefined)[] } {
-  const parsed = parseTextWithSeparators(req.lines);
+): { editParams: HTEdit; anchorLine: string | undefined; contentSeparators: (LineEnding | undefined)[] } {
+  const parsed = parsePayloadText(req.lines);
   const fileLines = splitLines(preload.normalized);
   const line = resolveAnchorLine(ref, fileLines, preload.fileHashes, path);
   const anchorLine = preload.normalized.length === 0 ? undefined : fileLines[line - 1];
-  const editParams: ReqParams = {
+  const editParams: HTEdit = {
     remove_from: ref.hash,
     remove_to: ref.hash,
     replacement_lines:
@@ -104,15 +99,10 @@ function insertStripWarning(anchorLine: string | undefined, direction: "before"
 export async function insertPreview(request: unknown, cwd: string, signal?: AbortSignal): Promise<RPreview> {
   try {
     const normalized = normReq(request);
-    const previewFixes: string[] = [];
-    if (isRec(normalized)) {
-      const expanded = decodeStringArray(normalized.lines, previewFixes, "lines");
-      if (expanded) normalized.lines = expanded;
-    }
     assertInsertReq(normalized);
     const previewReq = normalized as InsertReq;
     const { ref, warnings: previewAnchorWarnings } = parseInsertAnchor(previewReq.anchor);
-    await throwIfStrictInput([...previewFixes, ...previewAnchorWarnings]);
+    await throwIfStrictInput(previewAnchorWarnings);
     const targetPath = await resolveEditTargetWithRequirement({
       anchor: previewReq.anchor,
       providedPath: previewReq.path,
@@ -141,7 +131,7 @@ export async function insertPreview(request: unknown, cwd: string, signal?: Abor
   }
 }
 
-function getInsertInput(args: unknown): { path?: string; anchor?: string; direction?: "before" | "after"; lines?: string[] } | null {
+function getInsertInput(args: unknown): { path?: string; anchor?: string; direction?: "before" | "after"; lines?: string } | null {
   let normalized: unknown;
   try {
     normalized = normReq(args);
@@ -152,8 +142,7 @@ function getInsertInput(args: unknown): { path?: string; anchor?: string; direct
   if (
     typeof normalized.anchor !== "string" ||
     (normalized.direction !== "before" && normalized.direction !== "after") ||
-    !Array.isArray(normalized.lines) ||
-    normalized.lines.some((line) => typeof line !== "string")
+    typeof normalized.lines !== "string"
   ) {
     return null;
   }
@@ -161,7 +150,7 @@ function getInsertInput(args: unknown): { path?: string; anchor?: string; direct
     ...(typeof normalized.path === "string" ? { path: normalized.path } : {}),
     anchor: normalized.anchor as string,
     direction: normalized.direction as "before" | "after",
-    lines: normalized.lines as string[],
+    lines: normalized.lines,
   };
 }
 
@@ -186,14 +175,10 @@ export function buildInsertToolDef(flags: EditToolFlags = DEFAULT_EDIT_FLAGS): I
     async execute(_toolCallId, params, signal, _onUpdate, ctx) {
       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 literalEscape = literalEscapeHint(req.lines, "lines");
+        const insertWarnings: string[] = [];
+        const literalEscape = literalEscapeHint([req.lines], "lines");
         if (literalEscape !== undefined) insertWarnings.push(literalEscape);
         const targetPath = await resolveEditTargetWithRequirement({
           anchor: req.anchor,