plugsuits 1.0.0

package/src/tools/modify/delete-file.test.ts

@@ -0,0 +1,200 @@
+import { afterAll, beforeAll, describe, expect, it } from "bun:test";
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  symlinkSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { executeDeleteFile } from "./delete-file";
+
+describe("executeDeleteFile", () => {
+  let tempDir: string;
+
+  beforeAll(() => {
+    tempDir = mkdtempSync(join(tmpdir(), "delete-file-test-"));
+  });
+
+  afterAll(() => {
+    if (existsSync(tempDir)) {
+      rmSync(tempDir, { recursive: true });
+    }
+  });
+
+  describe("file deletion", () => {
+    it("deletes file and returns metadata", async () => {
+      const testFile = join(tempDir, "to-delete.txt");
+      writeFileSync(testFile, "content to delete");
+
+      const result = await executeDeleteFile({ path: testFile }, { rootDir: tempDir });
+
+      expect(result).toContain("OK - deleted file: to-delete.txt");
+      expect(result).toContain(`path: ${testFile}`);
+      expect(result).toContain("bytes:");
+      expect(result).toContain("last_modified:");
+      expect(existsSync(testFile)).toBe(false);
+    });
+
+    it("includes correct byte size in response", async () => {
+      const testFile = join(tempDir, "sized.txt");
+      const content = "12345";
+      writeFileSync(testFile, content);
+
+      const result = await executeDeleteFile({ path: testFile }, { rootDir: tempDir });
+
+      expect(result).toContain("bytes: 5");
+    });
+  });
+
+  describe("directory deletion", () => {
+    it("throws error for directory without recursive flag", async () => {
+      const testDir = join(tempDir, "dir-no-recursive");
+      mkdirSync(testDir);
+
+      await expect(
+        executeDeleteFile({ path: testDir }, { rootDir: tempDir })
+      ).rejects.toThrow("recursive: true");
+
+      expect(existsSync(testDir)).toBe(true);
+    });
+
+    it("deletes empty directory with recursive flag", async () => {
+      const testDir = join(tempDir, "empty-dir");
+      mkdirSync(testDir);
+
+      const result = await executeDeleteFile(
+        { path: testDir, recursive: true },
+        { rootDir: tempDir }
+      );
+
+      expect(result).toContain("OK - deleted directory: empty-dir");
+      expect(result).toContain(`path: ${testDir}`);
+      expect(result).toContain("last_modified:");
+      expect(existsSync(testDir)).toBe(false);
+    });
+
+    it("deletes non-empty directory with recursive flag", async () => {
+      const testDir = join(tempDir, "non-empty-dir");
+      mkdirSync(testDir);
+      writeFileSync(join(testDir, "file1.txt"), "content1");
+      writeFileSync(join(testDir, "file2.txt"), "content2");
+      mkdirSync(join(testDir, "subdir"));
+      writeFileSync(join(testDir, "subdir", "nested.txt"), "nested");
+
+      const result = await executeDeleteFile(
+        { path: testDir, recursive: true },
+        { rootDir: tempDir }
+      );
+
+      expect(result).toContain("OK - deleted directory: non-empty-dir");
+      expect(existsSync(testDir)).toBe(false);
+    });
+  });
+
+  describe("ignore_missing option", () => {
+    it("throws error for non-existent file by default", async () => {
+      const nonExistent = join(tempDir, "does-not-exist.txt");
+
+      await expect(executeDeleteFile({ path: nonExistent }, { rootDir: tempDir })).rejects.toThrow();
+    });
+
+    it("returns skip message when ignore_missing is true", async () => {
+      const nonExistent = join(tempDir, "also-does-not-exist.txt");
+
+      const result = await executeDeleteFile(
+        { path: nonExistent, ignore_missing: true },
+        { rootDir: tempDir }
+      );
+
+      expect(result).toContain("SKIPPED");
+      expect(result).toContain("file does not exist");
+      expect(result).toContain(nonExistent);
+    });
+  });
+
+  describe("edge cases", () => {
+    it("handles file with special characters in name", async () => {
+      const testFile = join(tempDir, "file with spaces.txt");
+      writeFileSync(testFile, "content");
+
+      const result = await executeDeleteFile({ path: testFile }, { rootDir: tempDir });
+
+      expect(result).toContain("OK - deleted file: file with spaces.txt");
+      expect(existsSync(testFile)).toBe(false);
+    });
+
+    it("handles empty file", async () => {
+      const testFile = join(tempDir, "empty-file.txt");
+      writeFileSync(testFile, "");
+
+      const result = await executeDeleteFile({ path: testFile }, { rootDir: tempDir });
+
+      expect(result).toContain("OK - deleted file: empty-file.txt");
+      expect(result).toContain("bytes: 0");
+      expect(existsSync(testFile)).toBe(false);
+    });
+  });
+
+  describe("file safety (C-1, C-2)", () => {
+    it("C-1: blocks path traversal via .. segments", async () => {
+      const traversalPath = join(tempDir, "..", "..", "etc", "passwd");
+      await expect(
+        executeDeleteFile({ path: traversalPath }, { rootDir: tempDir })
+      ).rejects.toThrow(/[Pp]ath traversal blocked/);
+    });
+
+    it("C-1: blocks absolute paths outside project root", async () => {
+      await expect(
+        executeDeleteFile({ path: "/tmp/outside-project.txt" }, { rootDir: tempDir })
+      ).rejects.toThrow(/[Pp]ath traversal blocked|outside/);
+    });
+
+    it("C-2: blocks deletion of symlinks", async () => {
+      const realFile = join(tempDir, "real-delete-target.txt");
+      writeFileSync(realFile, "real content");
+      const symlinkPath = join(tempDir, "symlink-to-delete.txt");
+      symlinkSync(realFile, symlinkPath);
+
+      await expect(
+        executeDeleteFile({ path: symlinkPath }, { rootDir: tempDir })
+      ).rejects.toThrow(/symlink/i);
+
+      // Both the symlink and the real file should still exist
+      expect(existsSync(symlinkPath)).toBe(true);
+      expect(existsSync(realFile)).toBe(true);
+      expect(readFileSync(realFile, "utf-8")).toBe("real content");
+    });
+
+    it("C-2: blocks deletion of symlinks pointing outside root", async () => {
+      const outsideDir = mkdtempSync(join(tmpdir(), "outside-delete-"));
+      const outsideFile = join(outsideDir, "secret.txt");
+      writeFileSync(outsideFile, "secret data");
+      const symlinkPath = join(tempDir, "escape-delete-link.txt");
+      symlinkSync(outsideFile, symlinkPath);
+
+      try {
+        await expect(
+          executeDeleteFile({ path: symlinkPath }, { rootDir: tempDir })
+        ).rejects.toThrow(/symlink/i);
+        expect(existsSync(outsideFile)).toBe(true);
+        expect(readFileSync(outsideFile, "utf-8")).toBe("secret data");
+      } finally {
+        rmSync(outsideDir, { recursive: true });
+      }
+    });
+
+    it("allows deletion within project root (normal operation)", async () => {
+      const safeFile = join(tempDir, "safe-to-delete.txt");
+      writeFileSync(safeFile, "deletable content");
+
+      const result = await executeDeleteFile({ path: safeFile }, { rootDir: tempDir });
+
+      expect(result).toContain("OK - deleted file: safe-to-delete.txt");
+      expect(existsSync(safeFile)).toBe(false);
+    });
+  });
+});

package/src/tools/modify/delete-file.ts

@@ -0,0 +1,95 @@
+import { lstat, rm } from "node:fs/promises";
+import { basename } from "node:path";
+import { tool } from "ai";
+import { z } from "zod";
+import { assertWriteSafety } from "../utils/safety-utils";
+import DELETE_FILE_DESCRIPTION from "./delete-file.txt";
+
+const inputSchema = z.object({
+  path: z.string().describe("Path to delete"),
+  recursive: z
+    .boolean()
+    .optional()
+    .default(false)
+    .describe("Delete directories recursively (default: false)"),
+  ignore_missing: z
+    .boolean()
+    .optional()
+    .default(false)
+    .describe("Don't error if file doesn't exist (default: false)"),
+});
+
+export type DeleteFileInput = z.input<typeof inputSchema>;
+
+export interface DeleteFileOptions {
+  /** Override project root for safety checks (defaults to process.cwd()). */
+  rootDir?: string;
+}
+
+export async function executeDeleteFile(
+  { path, recursive = false, ignore_missing = false }: DeleteFileInput,
+  options?: DeleteFileOptions
+): Promise<string> {
+  // C-1 + C-2: Path traversal and symlink safety checks
+  const safePath = await assertWriteSafety(path, options?.rootDir);
+
+  // C-2: Use lstat (not stat) — lstat does NOT follow symlinks,
+  // so we see the symlink entry itself rather than its target.
+  let stats: Awaited<ReturnType<typeof lstat>>;
+  try {
+    stats = await lstat(safePath);
+  } catch (error) {
+    if (
+      ignore_missing &&
+      error instanceof Error &&
+      "code" in error &&
+      (error as NodeJS.ErrnoException).code === "ENOENT"
+    ) {
+      return `SKIPPED - file does not exist: ${path}`;
+    }
+    throw error;
+  }
+
+  // Reject symlink deletion — force explicit resolution
+  if (stats.isSymbolicLink()) {
+    throw new Error(
+      `Refusing to delete symlink: '${path}'. ` +
+        "Resolve the symlink first or operate on the real file directly."
+    );
+  }
+
+  const isDirectory = stats.isDirectory();
+  const fileName = basename(path);
+  const byteSize = isDirectory ? null : stats.size;
+  const mtime = stats.mtime.toISOString();
+
+  if (isDirectory && !recursive) {
+    throw new Error(
+      `Cannot delete directory '${path}' without recursive: true. ` +
+        "Set recursive: true to delete directories."
+    );
+  }
+
+  await rm(safePath, { recursive, force: false });
+
+  const output: string[] = [];
+
+  if (isDirectory) {
+    output.push(`OK - deleted directory: ${fileName}`);
+    output.push(`path: ${path}`);
+    output.push(`last_modified: ${mtime}`);
+  } else {
+    output.push(`OK - deleted file: ${fileName}`);
+    output.push(`path: ${path}`);
+    output.push(`bytes: ${byteSize}`);
+    output.push(`last_modified: ${mtime}`);
+  }
+
+  return output.join("\n");
+}
+
+export const deleteFileTool = tool({
+  description: DELETE_FILE_DESCRIPTION,
+  inputSchema,
+  execute: (input) => executeDeleteFile(input),
+});

package/src/tools/modify/delete-file.txt

@@ -0,0 +1,9 @@
+### delete_file
+**Purpose**: Permanently delete a file or directory
+
+**When to use**:
+- Removing obsolete files
+- Cleaning temporary artifacts
+- Deleting directories with explicit recursive intent
+
+**DO NOT use shell**: Prefer this over `rm` / `rm -rf`

package/src/tools/modify/edit-file-diagnostics.ts

@@ -0,0 +1,210 @@
+import { computeLineHash, tryParseLineTag } from "../utils/hashline";
+
+const ANCHOR_HASH_EXTRACT_REGEX = /#([ZPMQVRWSNKTXJBYH]{2})/i;
+const NUMERIC_LINE_PREFIX_REGEX = /^\d+$/;
+const HASHLINE_ALPHABET_PREFIX_REGEX = /^[ZPMQVRWSNKTXJBYH]{2}$/i;
+const ANCHOR_PREFIX_REGEX = /^\s*(\d+\s*#\s*[ZPMQVRWSNKTXJBYH]{2})/i;
+const HASH_SPACE_REGEX = /\s*#\s*/;
+const KEY_VALUE_IN_POS_REGEX = /['"]lines['"\s]*:/;
+const XML_MARKUP_IN_POS_REGEX = /<\/?parameter/;
+const POS_DISPLAY_MAX_LENGTH = 80;
+
+const missingLinesFailures = new Map<string, number>();
+const missingLinesFileFailures = new Map<string, number>();
+export const ESCALATION_THRESHOLD = 2;
+export const ESCALATION_EXAMPLE_THRESHOLD = 4;
+export const ESCALATION_BAIL_THRESHOLD = 6;
+export const FILE_BAIL_THRESHOLD = 10;
+
+export function trackMissingLinesFailure(
+  pos: string | undefined,
+  filePath?: string
+): number {
+  if (filePath) {
+    const fileCount = (missingLinesFileFailures.get(filePath) ?? 0) + 1;
+    missingLinesFileFailures.set(filePath, fileCount);
+  }
+  if (!pos) {
+    return 1;
+  }
+  const key = pos.trim();
+  const count = (missingLinesFailures.get(key) ?? 0) + 1;
+  missingLinesFailures.set(key, count);
+  return count;
+}
+
+export function resetMissingLinesFailures(): void {
+  missingLinesFailures.clear();
+  missingLinesFileFailures.clear();
+}
+
+export function getMissingLinesFailureCount(pos: string): number {
+  return missingLinesFailures.get(pos) ?? 0;
+}
+
+export function getFileFailureCount(filePath: string): number {
+  return missingLinesFileFailures.get(filePath) ?? 0;
+}
+
+export function suggestLineForHash(
+  raw: string,
+  fileLines: string[]
+): string | null {
+  const hashMatch = raw.match(ANCHOR_HASH_EXTRACT_REGEX);
+  if (!hashMatch) {
+    return null;
+  }
+  const hash = hashMatch[1].toUpperCase();
+  for (let i = 0; i < fileLines.length; i += 1) {
+    if (computeLineHash(i + 1, fileLines[i] ?? "") === hash) {
+      return `Did you mean "${i + 1}#${hash}"?`;
+    }
+  }
+  return null;
+}
+
+export function diagnoseAnchorFailure(
+  raw: string,
+  fieldName: string,
+  fileLines?: string[]
+): string {
+  const hashIdx = raw.indexOf("#");
+  let message: string;
+
+  if (hashIdx > 0) {
+    const prefix = raw.slice(0, hashIdx).trim();
+    const suffix = raw.slice(hashIdx + 1).trim();
+
+    if (!NUMERIC_LINE_PREFIX_REGEX.test(prefix)) {
+      message = `${fieldName} "${raw}": "${prefix}" is not a line number. Use the actual line number from read_file output.`;
+    } else if (HASHLINE_ALPHABET_PREFIX_REGEX.test(suffix)) {
+      message = `${fieldName} "${raw}" is not a valid {line_number}#{hash_id} anchor.`;
+    } else {
+      message = `${fieldName} "${raw}": hash portion "${suffix}" is not valid. Hash must be 2 characters from the hashline alphabet.`;
+    }
+  } else {
+    message = `${fieldName} "${raw}" is not a valid {line_number}#{hash_id} anchor — missing # separator.`;
+  }
+
+  if (fileLines && fileLines.length > 0) {
+    const hint = suggestLineForHash(raw, fileLines);
+    if (hint) {
+      message += ` ${hint}`;
+    }
+  }
+
+  return message;
+}
+
+export function diagnoseMissingLines(pos: string | undefined): string {
+  const base = "replace requires explicit 'lines' field.";
+
+  if (!pos || pos.trim().length === 0) {
+    return base;
+  }
+
+  const truncated =
+    pos.length > POS_DISPLAY_MAX_LENGTH
+      ? `${pos.slice(0, POS_DISPLAY_MAX_LENGTH - 3)}...`
+      : pos;
+
+  if (KEY_VALUE_IN_POS_REGEX.test(pos)) {
+    return `${base} Detected key-value syntax in pos — 'pos' and 'lines' must be separate JSON fields.`;
+  }
+
+  if (XML_MARKUP_IN_POS_REGEX.test(pos)) {
+    return `${base} Detected XML markup in pos — use JSON fields: pos for anchor, lines for content.`;
+  }
+
+  const anchorMatch = pos.match(ANCHOR_PREFIX_REGEX);
+  if (anchorMatch) {
+    const anchorText = anchorMatch[1].replace(HASH_SPACE_REGEX, "#");
+    const rest = pos.slice(anchorMatch[0].length);
+    if (rest.trim().length > 0) {
+      return `${base} pos contains content after anchor '${anchorText}' — move replacement text to 'lines'.`;
+    }
+    return `${base} Add 'lines' with the replacement content for anchor '${anchorText}'.`;
+  }
+
+  return `${base} pos should contain only a {line_number}#{hash_id} anchor, not content. Got: "${truncated}".`;
+}
+
+export function getEscalatedHint(
+  pos: string | undefined,
+  fileLines: string[],
+  failureCount: number
+): string | null {
+  if (!pos || fileLines.length === 0) {
+    return null;
+  }
+  const parsed = tryParseLineTag(pos);
+  if (!parsed) {
+    return null;
+  }
+  const lineIndex = parsed.line - 1;
+  if (lineIndex < 0 || lineIndex >= fileLines.length) {
+    return null;
+  }
+  const content = fileLines[lineIndex];
+  const anchor = `${parsed.line}#${parsed.hash}`;
+
+  if (failureCount >= ESCALATION_EXAMPLE_THRESHOLD) {
+    return `STOP REPEATING (attempt ${failureCount}). You MUST include 'lines' as a separate JSON field. Correct format: {"op":"replace","pos":"${anchor}","lines":["your replacement text"]}. Current line ${parsed.line} contains: '${content}'.`;
+  }
+
+  return `Line ${parsed.line} currently contains '${content}'. Set lines to the replacement content.`;
+}
+
+export function buildEscalationBailMessage(
+  edits: Array<{ pos?: string; end?: string }>,
+  filePath: string,
+  fileLines: string[]
+): string | null {
+  const anchorBail = edits.some((e) => {
+    const pos = e.pos?.trim();
+    return pos && getMissingLinesFailureCount(pos) >= ESCALATION_BAIL_THRESHOLD;
+  });
+  const fileBail = getFileFailureCount(filePath) >= FILE_BAIL_THRESHOLD;
+  if (!(anchorBail || fileBail)) {
+    return null;
+  }
+
+  const failingEdit =
+    edits.find((e) => {
+      const pos = e.pos?.trim();
+      return (
+        pos && getMissingLinesFailureCount(pos) >= ESCALATION_BAIL_THRESHOLD
+      );
+    }) ?? edits.find((e) => e.pos?.trim());
+  const anchor = failingEdit?.pos?.trim() ?? "";
+  const parsedTag = tryParseLineTag(anchor);
+  const lineContent = parsedTag && fileLines[parsedTag.line - 1];
+  const anchorFailCount = getMissingLinesFailureCount(anchor);
+  const fileFailCount = getFileFailureCount(filePath);
+  const failCount = Math.max(anchorFailCount, fileFailCount);
+
+  const parts: string[] = [
+    `⚠️ edit_file: NOT APPLIED (attempt ${failCount}) — 'lines' field is missing.`,
+    "",
+    `Your input: {"op": "replace", "pos": "${anchor}"}`,
+    `The file ${filePath} was NOT changed.`,
+    "",
+    `To replace this line, you MUST include 'lines' as a separate JSON field:`,
+    `  {"op": "replace", "pos": "${anchor}", "lines": ["your new content here"]}`,
+  ];
+
+  if (lineContent !== undefined && lineContent !== null) {
+    parts.push(
+      "",
+      `Line ${parsedTag?.line} currently contains: "${lineContent}"`
+    );
+  }
+
+  parts.push(
+    "",
+    `To delete this line: {"op": "replace", "pos": "${anchor}", "lines": []}`,
+    "Alternatively, use write_file to replace the entire file content."
+  );
+
+  return parts.join("\n");
+}

package/src/tools/modify/edit-file-repair.ts

@@ -0,0 +1,183 @@
+const SINGLE_LINE_SPLIT_REGEX = /\r?\n/;
+const ANCHOR_PREFIX_REGEX = /^\s*(\d+\s*#\s*[ZPMQVRWSNKTXJBYH]{2})/i;
+const EMBEDDED_END_REGEX =
+  /['"']?end['"']?\s*[:=]\s*['"']?(\d+\s*#\s*[ZPMQVRWSNKTXJBYH]{2})['"']?/i;
+const NULL_VALUE_REGEX = /^null\s*[})]?\s*$/;
+const ARRAY_VALUE_REGEX = /^\[([^\]]*)\]/;
+const COMMA_SPLIT_REGEX = /,\s*/;
+const QUOTE_STRIP_REGEX = /^['"]|['"]$/g;
+const STRING_VALUE_REGEX = /^['"](.*)['"]/;
+const KV_LINES_REGEX = /['"]?lines['"]?\s*[:=]\s*(.+?)\s*[})]?\s*$/;
+const QS_LINES_REGEX = /[&?]\s*lines\s*[:=]\s*(.+?)\s*$/;
+const HASH_NORMALIZE_REGEX = /\s*#\s*/;
+const LEADING_SEPARATOR_REGEX = /^[|=%:,;]\s*/;
+const GARBAGE_CONTENT_REGEX = /^['"]?[\]})>]|<\/|<\w+>|^\s*}/;
+
+export interface HashlineToolEdit {
+  end?: string;
+  lines?: string[] | string | null;
+  op: "append" | "prepend" | "replace";
+  pos?: string;
+}
+
+export interface RepairResult {
+  edit: HashlineToolEdit;
+  warnings: string[];
+}
+
+export function assertSingleLineAnchor(
+  anchor: string | undefined,
+  fieldName: "pos" | "end"
+): void {
+  if (!anchor) {
+    return;
+  }
+  if (anchor.includes("\n") || anchor.includes("\r")) {
+    const lineCount = anchor.split(SINGLE_LINE_SPLIT_REGEX).length;
+    throw new Error(
+      `${fieldName} contains ${lineCount} lines — must be a single-line {line_number}#{hash_id} anchor.`
+    );
+  }
+}
+
+function tryParseEmbeddedValue(raw: string): string[] | null | undefined {
+  const trimmed = raw.trim();
+
+  if (NULL_VALUE_REGEX.test(trimmed)) {
+    return null;
+  }
+
+  const arrayMatch = trimmed.match(ARRAY_VALUE_REGEX);
+  if (arrayMatch) {
+    const inner = arrayMatch[1].trim();
+    if (inner.length === 0) {
+      return [];
+    }
+    const elements = inner.split(COMMA_SPLIT_REGEX).map((el) => {
+      const s = el.trim();
+      const unquoted = s.replace(QUOTE_STRIP_REGEX, "");
+      return unquoted;
+    });
+    return elements;
+  }
+
+  const stringMatch = trimmed.match(STRING_VALUE_REGEX);
+  if (stringMatch) {
+    return [stringMatch[1]];
+  }
+
+  return undefined;
+}
+
+function tryExtractEmbeddedLines(
+  posAfterAnchor: string
+): string[] | null | undefined {
+  const kvMatch = posAfterAnchor.match(KV_LINES_REGEX);
+  if (kvMatch) {
+    return tryParseEmbeddedValue(kvMatch[1]);
+  }
+
+  const qsMatch = posAfterAnchor.match(QS_LINES_REGEX);
+  if (qsMatch) {
+    return tryParseEmbeddedValue(qsMatch[1]);
+  }
+
+  return undefined;
+}
+
+function tryExtractEmbeddedEnd(rest: string): string | undefined {
+  const endMatch = rest.match(EMBEDDED_END_REGEX);
+  if (!endMatch) {
+    return undefined;
+  }
+  return endMatch[1].replace(HASH_NORMALIZE_REGEX, "#");
+}
+
+function repairAnchorField(
+  raw: string | undefined
+): { cleanAnchor: string; rest: string } | null {
+  if (!raw) {
+    return null;
+  }
+  if (raw.includes("\n") || raw.includes("\r")) {
+    return null;
+  }
+  const anchorMatch = raw.match(ANCHOR_PREFIX_REGEX);
+  if (!anchorMatch) {
+    return null;
+  }
+  const cleanAnchor = anchorMatch[1].replace(HASH_NORMALIZE_REGEX, "#");
+  const rest = raw.slice(anchorMatch[0].length);
+  if (rest.trim().length === 0) {
+    return null;
+  }
+  return { cleanAnchor, rest };
+}
+
+export function repairMalformedEdit(edit: HashlineToolEdit): RepairResult {
+  const warnings: string[] = [];
+  let repairedPos = edit.pos;
+  let repairedEnd = edit.end;
+  let repairedLines = edit.lines;
+
+  const posRepair = repairAnchorField(edit.pos);
+  if (posRepair) {
+    repairedPos = posRepair.cleanAnchor;
+    warnings.push(
+      `Auto-repaired pos: extracted anchor '${posRepair.cleanAnchor}' from malformed value.`
+    );
+
+    if (edit.lines === undefined) {
+      const extractedLines = tryExtractEmbeddedLines(posRepair.rest);
+      if (extractedLines !== undefined) {
+        repairedLines = extractedLines;
+        warnings.push(
+          "Auto-repaired lines: extracted embedded content from pos field."
+        );
+      } else {
+        const plainContent = posRepair.rest
+          .replace(LEADING_SEPARATOR_REGEX, "")
+          .trim();
+        const looksLikeGarbage = GARBAGE_CONTENT_REGEX.test(plainContent);
+        if (plainContent.length > 0 && !looksLikeGarbage) {
+          repairedLines = plainContent.split("\n");
+          warnings.push(
+            `Auto-repaired lines: extracted trailing content '${plainContent.slice(0, 60)}' from pos as replacement text.`
+          );
+        }
+      }
+    }
+  }
+
+  const endRepair = repairAnchorField(edit.end);
+  if (endRepair) {
+    repairedEnd = endRepair.cleanAnchor;
+    warnings.push(
+      `Auto-repaired end: extracted anchor '${endRepair.cleanAnchor}' from malformed value.`
+    );
+  }
+
+  if (repairedEnd === undefined && posRepair) {
+    const extractedEnd = tryExtractEmbeddedEnd(posRepair.rest);
+    if (extractedEnd) {
+      repairedEnd = extractedEnd;
+      warnings.push(
+        `Auto-repaired end: extracted anchor '${extractedEnd}' from embedded content in pos.`
+      );
+    }
+  }
+
+  if (warnings.length === 0) {
+    return { edit, warnings };
+  }
+
+  return {
+    edit: {
+      ...edit,
+      pos: repairedPos,
+      end: repairedEnd,
+      lines: repairedLines,
+    },
+    warnings,
+  };
+}