@oh-my-pi/pi-coding-agent 14.5.2 → 14.5.5

package/src/edit/modes/atom.ts

@@ -1,506 +1,552 @@
 /**
+ * Atom edit mode.
  *
- * Flat locator + verb edit mode backed by hashline anchors. Each entry carries
- * one shared `loc` selector plus one or more verbs (`pre`, `splice`, `post`).
- * The runtime resolves those verbs into internal anchor-scoped edits and still
- * reuses hashline's staleness scheme (`computeLineHash`) verbatim.
+ * Single-string compact wire format. Each file section starts with `---path`;
+ * each following line is one statement:
  *
- * External shapes (one entry):
- *   { path, loc: "5th",      splice:  ["..."] }
- *   { path, loc: "5th",      pre:  ["..."] }
- *   { path, loc: "5th",      post: ["..."] }
- *   { path, loc: "5th",      pre: [...], splice: [...], post: [...] }
- *   { path, loc: "$",        pre:  [...] }                            // prepend to file
- *   { path, loc: "$",        post: [...] }                            // append to file
- *   { path, loc: "$",        sed:  { pat, rep, g?, F? } }                 // sed on every line
- *
- * `splice: []` on a single-anchor locator deletes that line. `splice:[""]` preserves
- * a blank line. Line ranges are not supported.
- * in the same entry.
- *
- * For deleting or moving files, the agent should use bash.
+ *   @Lid                    move cursor to just after the anchored line
+ *   Lid=TEXT                set the anchored line to TEXT and move cursor after it
+ *   -Lid                    delete the anchored line and move cursor to its slot
+ *   +TEXT                   insert TEXT at the cursor
+ *   $                       move cursor to beginning of file
+ *   ^                       move cursor to end of file
  */
 
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
 import type { AgentToolResult } from "@oh-my-pi/pi-agent-core";
+import { isEnoent } from "@oh-my-pi/pi-utils";
 import { type Static, Type } from "@sinclair/typebox";
 import type { WritethroughCallback, WritethroughDeferredHandle } from "../../lsp";
 import type { ToolSession } from "../../tools";
-import { assertEditableFileContent } from "../../tools/auto-generated-guard";
-import { invalidateFsScanAfterWrite } from "../../tools/fs-cache-invalidation";
+import { assertEditableFile, assertEditableFileContent } from "../../tools/auto-generated-guard";
+import {
+	invalidateFsScanAfterDelete,
+	invalidateFsScanAfterRename,
+	invalidateFsScanAfterWrite,
+} from "../../tools/fs-cache-invalidation";
 import { outputMeta } from "../../tools/output-meta";
 import { enforcePlanModeWrite, resolvePlanPath } from "../../tools/plan-mode-guard";
 import { generateDiffString } from "../diff";
-import { computeLineHash, HASHLINE_BIGRAM_RE_SRC, HASHLINE_CONTENT_SEPARATOR } from "../line-hash";
+import { computeLineHash } from "../line-hash";
 import { detectLineEnding, normalizeToLF, restoreLineEndings, stripBom } from "../normalize";
 import type { EditToolDetails, LspBatchRequest } from "../renderer";
 import {
 	ANCHOR_REBASE_WINDOW,
 	type Anchor,
 	buildCompactHashlineDiffPreview,
-	formatFullAnchorRequirement,
 	HashlineMismatchError,
 	type HashMismatch,
-	hashlineParseText,
-	parseTag,
 	tryRebaseAnchor,
 } from "./hashline";
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Schema
 // ═══════════════════════════════════════════════════════════════════════════
-const textSchema = Type.Array(Type.String());
 
-/**
- * Flat entry shape with shared locator fields and verb-specific payloads.
- * The runtime validator (`resolveAtomToolEdit`) enforces legal locator/verb
- * combinations. Keeping the schema flat reduces tool-definition size and gives
- * weaker models fewer branching shapes to sample from.
- */
-export const atomEditSchema = Type.Object(
-	{
-		loc: Type.String({
-			description: 'edit location: "1ab", "$", or path override like "a.ts:1ab"',
-			examples: ["1ab", "$", "src/foo.ts:1ab"],
-		}),
-		splice: Type.Optional(textSchema),
-		pre: Type.Optional(textSchema),
-		post: Type.Optional(textSchema),
-		sed: Type.Optional(
-			Type.Object(
-				{
-					pat: Type.String({ description: "pattern to find" }),
-					rep: Type.String({ description: "replacement text" }),
-					g: Type.Optional(Type.Boolean({ description: "global replace", default: false })),
-					F: Type.Optional(Type.Boolean({ description: "literal replace", default: false })),
-				},
-				{
-					additionalProperties: false,
-				},
-			),
-		),
-	},
-	{ additionalProperties: false },
-);
-
-export const atomEditParamsSchema = Type.Object(
-	{
-		path: Type.Optional(Type.String({ description: "default file path for edits" })),
-		edits: Type.Array(atomEditSchema, { description: "edit ops" }),
-	},
-	{ additionalProperties: false },
-);
-
-export type AtomToolEdit = Static<typeof atomEditSchema>;
+export const atomEditParamsSchema = Type.Object({ input: Type.String() });
+
 export type AtomParams = Static<typeof atomEditParamsSchema>;
 
 // ═══════════════════════════════════════════════════════════════════════════
-// Internal resolved op shapes
+// Parser
 // ═══════════════════════════════════════════════════════════════════════════
 
-export type AtomEdit =
-	| { op: "splice"; pos: Anchor; lines: string[] }
-	| { op: "pre"; pos: Anchor; lines: string[] }
-	| { op: "post"; pos: Anchor; lines: string[] }
-	| { op: "del"; pos: Anchor }
-	| { op: "append_file"; lines: string[] }
-	| { op: "prepend_file"; lines: string[] }
-	| { op: "sed"; pos: Anchor; spec: SedSpec; expression: string }
-	| { op: "sed_file"; spec: SedSpec; expression: string };
-
-export interface SedSpec {
-	pattern: string;
-	replacement: string;
-	global: boolean;
-	literal: boolean;
+// Permissive: any 2 lowercase letters. Invalid hashes flow through to a
+// HashlineMismatchError downstream, matching the other hashline-backed modes.
+const LID_RE = /^([1-9]\d*)([a-z]{2})/;
+const LID_EXACT_RE = /^([1-9]\d*)([a-z]{2})$/;
+
+interface ParsedAnchor {
+	line: number;
+	hash: string;
 }
 
-// ═══════════════════════════════════════════════════════════════════════════
-// Param guards
-// ═══════════════════════════════════════════════════════════════════════════
+type ParsedOp = { op: "set"; text: string; allowOldNewRepair: boolean } | { op: "delete" };
 
-const ATOM_VERB_KEYS = ["splice", "pre", "post", "sed"] as const;
-type AtomOptionalKey = "loc" | (typeof ATOM_VERB_KEYS)[number];
-const ATOM_OPTIONAL_KEYS = ["loc", ...ATOM_VERB_KEYS] as const satisfies readonly AtomOptionalKey[];
+type AnchorStmt =
+	| { kind: "bare_anchor"; anchor: ParsedAnchor; lineNum: number }
+	| { kind: "anchor_op"; anchor: ParsedAnchor; op: ParsedOp; lineNum: number }
+	| { kind: "bof"; lineNum: number }
+	| { kind: "eof"; lineNum: number };
 
-// Matches just the LINE+BIGRAM prefix of an anchor reference. Used to detect
-// optional `|content` suffixes (e.g. `82zu|  for (...)`) so the suffix can be
-// captured as a content hint for anchor disambiguation.
-const ANCHOR_PREFIX_RE = new RegExp(`^\\s*[>+-]*\\s*\\d+${HASHLINE_BIGRAM_RE_SRC}`);
+type InsertStmt = {
+	kind: "insert";
+	text: string;
+	lineNum: number;
+};
 
-// Splits `path:loc` references where the right side starts with a valid anchor
-// (single `\d+<bigram>` or `<anchor>-<anchor>` range, optionally followed by a
-// content suffix using `|` or `:`). The non-greedy `(.+?)` picks the leftmost
-// colon whose RHS is a real anchor, so colons inside the loc's content suffix
-// (TS type annotations, etc.) don't break the split. Drive-letter prefixes like
-// `C:\path\a.ts:160sr` still resolve correctly because the first colon's RHS
-// fails the anchor pattern.
-const ANCHOR_TAG_RE_SRC = `\\s*[>+-]*\\s*\\d+${HASHLINE_BIGRAM_RE_SRC}`;
-const PATH_LOC_SPLIT_RE = new RegExp(`^(.+?):(${ANCHOR_TAG_RE_SRC}(?:-${ANCHOR_TAG_RE_SRC})?(?:[|:].*)?)$`);
+type DiffishAddStmt = {
+	kind: "diffish_add";
+	anchor: ParsedAnchor;
+	text: string;
+	lineNum: number;
+};
 
-function stripNullAtomFields(edit: AtomToolEdit): AtomToolEdit {
-	let next: Record<string, unknown> | undefined;
-	const fields = edit as Record<string, unknown>;
-	for (const key of ATOM_OPTIONAL_KEYS) {
-		if (fields[key] !== null) continue;
-		next ??= { ...fields };
-		delete next[key];
-	}
-	return (next ?? fields) as AtomToolEdit;
+type DeleteWithOldStmt = {
+	kind: "delete_with_old";
+	anchor: ParsedAnchor;
+	old: string;
+	lineNum: number;
+};
+
+type ParsedStmt = AnchorStmt | InsertStmt | DiffishAddStmt | DeleteWithOldStmt;
+
+type AtomCursor = { kind: "bof" } | { kind: "eof" } | { kind: "anchor"; anchor: Anchor };
+
+export type AtomEdit =
+	| { kind: "insert"; cursor: AtomCursor; text: string; lineNum: number; index: number }
+	| { kind: "set"; anchor: Anchor; text: string; lineNum: number; index: number; allowOldNewRepair: boolean }
+	| { kind: "delete"; anchor: Anchor; lineNum: number; index: number; oldAssertion?: string };
+
+interface AtomApplyResult {
+	lines: string;
+	firstChangedLine?: number;
+	warnings?: string[];
+	noopEdits?: AtomNoopEdit[];
 }
 
-type ParsedAtomLoc = { kind: "anchor"; pos: Anchor } | { kind: "file" };
+interface AtomNoopEdit {
+	editIndex: number;
+	loc: string;
+	reason: string;
+	current: string;
+}
 
-// ═══════════════════════════════════════════════════════════════════════════
-// Resolution
-// ═══════════════════════════════════════════════════════════════════════════
+interface IndexedAnchorEdit {
+	edit: Extract<AtomEdit, { kind: "insert" | "set" | "delete" }>;
+	idx: number;
+}
 
-/**
- * Parse an anchor reference like `"5th"`.
- *
- * Tolerant: on a malformed reference we still try to extract a 1-indexed line
- * number from the leading digits so the validator can surface the *correct*
- * `LINEHASH|content` for the user. The bogus hash is preserved in the returned
- * anchor so the validator emits a content-rich mismatch error.
- *
- * If we cannot recover even a line number, throw a usage-style error with the
- * raw reference quoted.
- */
-function parseAnchor(raw: string, opName: string): Anchor {
-	if (typeof raw !== "string" || raw.length === 0) {
-		throw new Error(`${opName} requires ${formatFullAnchorRequirement()}.`);
-	}
-	try {
-		return parseTag(raw);
-	} catch {
-		const lineMatch = /^\s*[>+-]*\s*(\d+)/.exec(raw);
-		if (lineMatch) {
-			const line = Number.parseInt(lineMatch[1], 10);
-			if (line >= 1) {
-				// Sentinel hash that will never match a real line, forcing the validator
-				// to report a mismatch with the actual hash + line content.
-				return { line, hash: "??" };
-			}
-		}
-		throw new Error(
-			`${opName} requires ${formatFullAnchorRequirement(raw)} Could not find a line number in the anchor.`,
-		);
+function cloneCursor(cursor: AtomCursor): AtomCursor {
+	if (cursor.kind !== "anchor") return cursor;
+	return { kind: "anchor", anchor: { ...cursor.anchor } };
+}
+
+function parseLidStmt(body: string, lineNum: number): AnchorStmt | null {
+	const m = LID_RE.exec(body);
+	if (!m) return null;
+
+	const ln = Number.parseInt(m[1], 10);
+	const hash = m[2];
+	const rest = body.slice(m[0].length);
+	const anchor = { line: ln, hash };
+	if (rest.length === 0) {
+		return { kind: "bare_anchor", anchor, lineNum };
 	}
+
+	const replacement = /^[ \t]*([=|])(.*)$/.exec(rest);
+	if (!replacement) return null;
+	return {
+		kind: "anchor_op",
+		anchor,
+		op: { op: "set", text: replacement[2], allowOldNewRepair: replacement[1] === "|" },
+		lineNum,
+	};
 }
 
-function tryParseAtomTag(raw: string): Anchor | undefined {
-	try {
-		return parseTag(raw);
-	} catch {
-		return undefined;
+function parseDeleteStmt(body: string, lineNum: number): ParsedStmt[] | null {
+	const trimmedBody = body.trimStart();
+	const exact = LID_EXACT_RE.exec(trimmedBody);
+	if (exact) {
+		const ln = Number.parseInt(exact[1], 10);
+		return [{ kind: "anchor_op", anchor: { line: ln, hash: exact[2] }, op: { op: "delete" }, lineNum }];
+	}
+
+	const m = LID_RE.exec(trimmedBody);
+	if (m && (trimmedBody[m[0].length] === "|" || trimmedBody[m[0].length] === "=")) {
+		const ln = Number.parseInt(m[1], 10);
+		const old = trimmedBody.slice(m[0].length + 1);
+		return [{ kind: "delete_with_old", anchor: { line: ln, hash: m[2] }, old, lineNum }];
 	}
+	if (m && trimmedBody[m[0].length] === " ") {
+		const ln = Number.parseInt(m[1], 10);
+		const text = trimmedBody.slice(m[0].length + 1);
+		return [
+			{ kind: "anchor_op", anchor: { line: ln, hash: m[2] }, op: { op: "delete" }, lineNum },
+			{ kind: "insert", text, lineNum },
+		];
+	}
+
+	return null;
 }
 
-function resolveAtomEntryPath(
-	edit: AtomToolEdit,
-	topLevelPath: string | undefined,
-	editIndex: number,
-): AtomToolEdit & { path: string } {
-	const entry = stripNullAtomFields(edit);
-	let loc = entry.loc;
-	let pathOverride: string | undefined;
-	if (typeof loc === "string") {
-		const split = loc.match(PATH_LOC_SPLIT_RE);
-		if (split) {
-			pathOverride = split[1];
-			loc = split[2]!;
-		}
+function throwMalformedLidDiagnostic(line: string, lineNum: number, raw: string): never {
+	const text = line.trimStart();
+	const withoutLegacyMove = text.startsWith("@@ ") ? text.slice(3).trimStart() : text;
+	const withoutMove = withoutLegacyMove.startsWith("@") ? withoutLegacyMove.slice(1) : withoutLegacyMove;
+	const withoutDelete = withoutMove.startsWith("-") ? withoutMove.slice(1).trimStart() : withoutMove;
+
+	const partial = /^([a-z]{2})(?=[ \t]*[=|])/.exec(withoutDelete);
+	if (partial) {
+		throw new Error(
+			`Diff line ${lineNum}: \`${partial[1]}\` is not a full Lid. Use the full Lid from read output, e.g. \`119${partial[1]}\`.`,
+		);
 	}
-	const path = pathOverride || topLevelPath;
-	if (!path) {
+
+	const missing = /^([1-9]\d*)(?=[ \t]*[=|]|$)/.exec(withoutDelete);
+	if (missing) {
+		const prefix = text.startsWith("@@ ") ? `@@ ${missing[1]}` : missing[1];
 		throw new Error(
-			`Edit ${editIndex}: missing path. Provide a top-level path or prefix loc with a file path (for example "a.ts:160sr").`,
+			`Diff line ${lineNum}: \`${prefix}\` is missing the two-letter Lid suffix. Use the full Lid from read output, e.g. \`${prefix.startsWith("@@ ") ? "@@ " : ""}${missing[1]}ab\`.`,
 		);
 	}
-	return { ...entry, path, ...(loc !== entry.loc ? { loc } : {}) };
-}
 
-export function resolveAtomEntryPaths(
-	edits: readonly AtomToolEdit[],
-	topLevelPath: string | undefined,
-): (AtomToolEdit & { path: string })[] {
-	return edits.map((edit, i) => resolveAtomEntryPath(edit, topLevelPath, i));
+	throw new Error(`Diff line ${lineNum}: cannot parse "${raw}".`);
 }
 
-function parseLoc(raw: string, editIndex: number): ParsedAtomLoc {
-	if (raw === "$") return { kind: "file" };
-	// Detect range syntax explicitly: "<anchor>-<anchor>". A bare `-` inside the
-	// loc (e.g. line content like `i--`) should not trigger the range error.
-	const dash = raw.indexOf("-");
-	if (dash > 0) {
-		const left = raw.slice(0, dash);
-		const right = raw.slice(dash + 1);
-		if (tryParseAtomTag(left) !== undefined && tryParseAtomTag(right) !== undefined) {
-			throw new Error(
-				`Edit ${editIndex}: atom loc does not support line ranges. Use a single anchor like "160sr" or "$".`,
-			);
+function parseDiffLine(raw: string, lineNum: number): ParsedStmt[] {
+	// Strip trailing CR (CRLF tolerance).
+	const line = raw.endsWith("\r") ? raw.slice(0, -1) : raw;
+	if (line.length === 0) return [];
+
+	// `+TEXT` inserts at the cursor. Everything after `+` is content. A
+	// `+Lid|TEXT` or `+Lid=TEXT` line is a diff-ish add (unified-diff trap):
+	// emit a tagged stmt so the normalizer can fuse it with a preceding `-Lid`.
+	if (line[0] === "+") {
+		const body = line.slice(1);
+		const m = LID_RE.exec(body);
+		if (m) {
+			const sep = body[m[0].length];
+			if (sep === "=" || sep === "|") {
+				const ln = Number.parseInt(m[1], 10);
+				const text = body.slice(m[0].length + 1);
+				return [{ kind: "diffish_add", anchor: { line: ln, hash: m[2] }, text, lineNum }];
+			}
 		}
+
+		// Auto-fix: `+@Lid` and `+-Lid` are almost always typos where the agent
+		// prefixed a cursor-move or delete op with `+`. Insert content matching
+		// these op shapes is essentially never legitimate in source code, and
+		// silently emitting them as literal text corrupts the file (e.g. a stray
+		// `@12ly` line in a C++ source). Split into the op + a blank `+` insert
+		// so the line count of the edit script is preserved for any downstream
+		// offset-sensitive logic.
+		if (body.length > 1 && (body[0] === "@" || body[0] === "-")) {
+			try {
+				const opStmts = parseDiffLine(body, lineNum);
+				const allOps = opStmts.length > 0 && opStmts.every(s => s.kind !== "insert" && s.kind !== "diffish_add");
+				if (allOps) {
+					return [...opStmts, { kind: "insert", text: "", lineNum }];
+				}
+			} catch {
+				// Body looked op-shaped but failed to parse; fall through to literal insert.
+			}
+		}
+		return [{ kind: "insert", text: body, lineNum }];
 	}
-	const pos = parseAnchor(raw, "loc");
-	// Capture an optional content suffix after the anchor: `82zu|  for (...)`.
-	// The suffix acts as a hint for anchor disambiguation when the model's hash
-	// is wrong but the content reveals the intended line.
-	const hint = extractAnchorContentHint(raw);
-	if (hint !== undefined) {
-		pos.contentHint = hint;
-	}
-	return { kind: "anchor", pos };
-}
 
-function extractAnchorContentHint(raw: string): string | undefined {
-	const match = raw.match(ANCHOR_PREFIX_RE);
-	if (!match) return undefined;
-	const rest = raw.slice(match[0].length);
-	// Accept either the canonical `|` (HASHLINE_CONTENT_SEPARATOR) or the legacy
-	// `:` separator. Models trained on older docs still emit `82zu:  for (...)`.
-	const sep = rest[0];
-	if (sep !== HASHLINE_CONTENT_SEPARATOR && sep !== ":") return undefined;
-	const hint = rest.slice(1);
-	if (hint.trim().length === 0) return undefined;
-	return hint;
-}
+	// Canonical file-scope locators.
+	if (line === "$") return [{ kind: "bof", lineNum }];
+	if (line === "^") return [{ kind: "eof", lineNum }];
 
-function parseSedSpec(input: unknown, editIndex: number): SedSpec {
-	if (input === null || typeof input !== "object" || Array.isArray(input)) {
-		throw new Error(`Edit ${editIndex}: sed must be an object with shape {pat, rep, g?, F?}.`);
+	// `-Lid` deletes the anchored line. Leniently accept `- Lid` and the
+	// historical `-Lid TEXT` delete-then-insert recovery.
+	if (line[0] === "-") {
+		const parsed = parseDeleteStmt(line.slice(1), lineNum);
+		if (parsed) return parsed;
+		throw new Error(`Diff line ${lineNum}: \`-\` must be followed by a Lid (e.g. \`-5xx\`). Got "${raw}".`);
 	}
-	const obj = input as Record<string, unknown>;
-	const pat = obj.pat;
-	const rep = obj.rep;
-	if (typeof pat !== "string" || pat.length === 0) {
-		throw new Error(`Edit ${editIndex}: sed.pat must be a non-empty string.`);
+
+	// Legacy move prefix. Runtime accepts old locators and common slipped edit
+	// operations, while the grammar/prompt bias models to canonical syntax.
+	if (line.startsWith("@@ ")) {
+		const body = line.slice(3);
+		if (body === "BOF") return [{ kind: "bof", lineNum }];
+		if (body === "EOF") return [{ kind: "eof", lineNum }];
+
+		const deleteStmt = body.startsWith("-") ? parseDeleteStmt(body.slice(1), lineNum) : null;
+		if (deleteStmt) return deleteStmt;
+
+		const lidStmt = parseLidStmt(body, lineNum);
+		if (lidStmt) return [lidStmt];
+
+		throwMalformedLidDiagnostic(line, lineNum, raw);
 	}
-	if (pat.includes("\n")) {
-		throw new Error(
-			`Edit ${editIndex}: sed.pat must be a single line; contains a newline. Use \`splice\` to replace multiple lines, anchoring the first changed line and listing replacement lines in the array.`,
-		);
+
+	// Canonical `@Lid` cursor moves. Leniently recover `@Lid=TEXT`,
+	// `@Lid|TEXT`, `@$`, and `@^`.
+	if (line[0] === "@") {
+		const body = line.slice(1);
+		if (body === "$") return [{ kind: "bof", lineNum }];
+		if (body === "^") return [{ kind: "eof", lineNum }];
+		const lidStmt = parseLidStmt(body, lineNum);
+		if (lidStmt) return [lidStmt];
+		throwMalformedLidDiagnostic(line, lineNum, raw);
 	}
-	if (typeof rep !== "string") {
-		throw new Error(`Edit ${editIndex}: sed.rep must be a string.`);
+
+	// `Lid=TEXT` sets the anchored line. Legacy `Lid|TEXT` remains accepted.
+	// A bare `Lid` is a cursor move.
+	const lidStmt = parseLidStmt(line, lineNum);
+	if (lidStmt) return [lidStmt];
+
+	if (/^[a-z]{2}(?=[ \t]*[=|])/.test(line) || /^[1-9]\d*(?=[ \t]*[=|]|$)/.test(line)) {
+		throwMalformedLidDiagnostic(line, lineNum, raw);
 	}
-	const readBool = (key: "g" | "F", defaultValue: boolean): boolean => {
-		const v = obj[key];
-		if (v === undefined) return defaultValue;
-		if (typeof v !== "boolean") {
-			throw new Error(`Edit ${editIndex}: sed.${key} must be a boolean when provided.`);
-		}
-		return v;
-	};
-	const global = readBool("g", false);
-	const literal = readBool("F", false);
-	return { pattern: pat, replacement: rep, global, literal };
-}
 
-function formatSedExpression(spec: SedSpec): string {
-	const obj: { pat: string; rep: string; g?: boolean; F?: boolean } = {
-		pat: spec.pattern,
-		rep: spec.replacement,
-	};
-	// Only emit non-default flags so error messages stay compact (g defaults false).
-	if (spec.global) obj.g = true;
-	if (spec.literal) obj.F = true;
-	return JSON.stringify(obj);
+	// Reject any line that doesn't match a recognized op. Common case: a model
+	// emitted multi-line content after a `Lid=` or similar without `+` prefixes,
+	// or pasted raw context. Silently treating these as inserts corrupts files.
+	const preview = line.length > 80 ? `${line.slice(0, 80)}…` : line;
+	throw new Error(
+		`Diff line ${lineNum}: unrecognized op. Lines must start with \`+\`, \`-\`, \`@\`, \`$\`, \`^\`, or a Lid (\`Lid=TEXT\`). To insert literal text use \`+TEXT\`. Got "${preview}".`,
+	);
 }
 
-function applyLiteralSed(currentLine: string, spec: SedSpec): { result: string; matched: boolean } {
-	const idx = currentLine.indexOf(spec.pattern);
-	if (idx === -1) return { result: currentLine, matched: false };
-	if (spec.global) {
-		return { result: currentLine.split(spec.pattern).join(spec.replacement), matched: true };
+function tokenizeDiff(diff: string): ParsedStmt[] {
+	const out: ParsedStmt[] = [];
+	const lines = diff.split("\n");
+	for (let i = 0; i < lines.length; i++) {
+		const lineNum = i + 1;
+		const stmts = parseDiffLine(lines[i], lineNum);
+		for (const stmt of stmts) {
+			// Last-set-wins: when the same anchor (line+hash) gets a second `set`,
+			// drop the earlier one. Models sometimes echo the OLD line and then the
+			// NEW line as replacements (e.g. `119yh|OLD` / `119yh|NEW`); the last is
+			// the intended value.
+			if (stmt.kind === "anchor_op" && stmt.op.op === "set") {
+				const key = `${stmt.anchor.line}:${stmt.anchor.hash}`;
+				for (let j = out.length - 1; j >= 0; j--) {
+					const prior = out[j];
+					if (
+						prior.kind === "anchor_op" &&
+						prior.op.op === "set" &&
+						`${prior.anchor.line}:${prior.anchor.hash}` === key
+					) {
+						out.splice(j, 1);
+						break;
+					}
+				}
+			}
+			out.push(stmt);
+		}
 	}
-	return {
-		result: currentLine.slice(0, idx) + spec.replacement + currentLine.slice(idx + spec.pattern.length),
-		matched: true,
-	};
+	return normalizeHunks(out);
 }
 
-function applySedToLine(
-	currentLine: string,
-	spec: SedSpec,
-): { result: string; matched: boolean; error?: string; literalFallback?: boolean } {
-	if (spec.literal) {
-		return applyLiteralSed(currentLine, spec);
-	}
-	let flags = "";
-	if (spec.global) flags += "g";
-	let re: RegExp | undefined;
-	let compileError: string | undefined;
-	try {
-		re = new RegExp(spec.pattern, flags);
-	} catch (e) {
-		compileError = (e as Error).message;
-	}
-	if (re?.test(currentLine)) {
-		re.lastIndex = 0;
-		const probe = re.exec(currentLine);
-		re.lastIndex = 0;
-		// Zero-length matches (e.g. `()`, `(?=…)`, `^`, `$`) cause `String.replace` to
-		// insert the replacement at the match position rather than substitute. When that
-		// happens, fall through to the literal-substring fallback below — the model almost
-		// always meant the pattern literally (`()` is the parens, `^` is a caret, etc.).
-		if (!probe || probe[0].length > 0) {
-			return { result: currentLine.replace(re, spec.replacement), matched: true };
-		}
-	}
-	// Fall back to literal substring match. Models frequently send sed patterns
-	// containing unescaped regex metacharacters (parentheses, `?`, `.`) that they
-	// intend as literal code. Trying a literal match before reporting failure
-	// recovers the obvious intent without changing semantics for patterns that
-	// already match as regex.
-	const literal = applyLiteralSed(currentLine, spec);
-	if (literal.matched) {
-		return { ...literal, literalFallback: true };
-	}
-	if (compileError !== undefined) {
-		return { result: currentLine, matched: false, error: compileError };
-	}
-	return { result: currentLine, matched: false };
-}
-
-function classifyAtomEdit(edit: AtomToolEdit): string {
-	const entry = stripNullAtomFields(edit);
-	const verbs = ATOM_VERB_KEYS.filter(k => entry[k] !== undefined);
-	return verbs.length > 0 ? verbs.join("+") : "unknown";
-}
-
-function resolveAtomToolEdit(edit: AtomToolEdit, editIndex = 0): AtomEdit[] {
-	const entry = stripNullAtomFields(edit);
-	const verbKeysPresent = ATOM_VERB_KEYS.filter(k => entry[k] !== undefined);
-	if (verbKeysPresent.length === 0) {
-		throw new Error(
-			`Edit ${editIndex}: missing verb. Each entry must include at least one of: ${ATOM_VERB_KEYS.join(", ")}.`,
+// Detect contiguous `[delete | delete_with_old]+ [insert | diffish_add]+`
+// hunks and reorder so adds land at the FIRST delete's slot (block
+// replacement). Single-line `-Lid` + `+Lid|TEXT` (same Lid) fuses to a
+// `set`. Standalone `+Lid|TEXT` and `+Lid|TEXT` referencing a Lid not in
+function normalizeHunks(stmts: ParsedStmt[]): ParsedStmt[] {
+	const isDelete = (s: ParsedStmt): boolean =>
+		(s.kind === "anchor_op" && s.op.op === "delete") || s.kind === "delete_with_old";
+	const isAdd = (s: ParsedStmt): boolean => s.kind === "insert" || s.kind === "diffish_add";
+	const out: ParsedStmt[] = [];
+	let i = 0;
+	while (i < stmts.length) {
+		const stmt = stmts[i];
+		if (!isDelete(stmt)) {
+			if (stmt.kind === "diffish_add") {
+				const lid = `${stmt.anchor.line}${stmt.anchor.hash}`;
+				throw new Error(
+					`Diff line ${stmt.lineNum}: \`+${lid}|...\` looks like a unified-diff replacement marker. Use \`${lid}=TEXT\` to replace, or precede with \`-${lid}\` to delete-then-replace.`,
+				);
+			}
+			out.push(stmt);
+			i++;
+			continue;
+		}
+		const deletes: ParsedStmt[] = [];
+		while (i < stmts.length && isDelete(stmts[i])) {
+			deletes.push(stmts[i]);
+			i++;
+		}
+		const adds: ParsedStmt[] = [];
+		while (i < stmts.length && isAdd(stmts[i])) {
+			adds.push(stmts[i]);
+			i++;
+		}
+		const deletedLids = new Set(
+			deletes.map(d => {
+				const a = (d as { anchor: ParsedAnchor }).anchor;
+				return `${a.line}${a.hash}`;
+			}),
 		);
-	}
-	if (typeof entry.loc !== "string") {
-		throw new Error(`Edit ${editIndex}: missing loc. Use a selector like "160sr" or "$".`);
-	}
-
-	const loc = parseLoc(entry.loc, editIndex);
-	const resolved: AtomEdit[] = [];
-
-	if (loc.kind === "file") {
-		if (entry.splice !== undefined) {
-			throw new Error(`Edit ${editIndex}: loc "$" supports pre, post, and sed (not splice).`);
+		for (const add of adds) {
+			if (add.kind !== "diffish_add") continue;
+			const lid = `${add.anchor.line}${add.anchor.hash}`;
+			if (!deletedLids.has(lid)) {
+				throw new Error(
+					`Diff line ${add.lineNum}: \`+${lid}|...\` references a Lid that was not deleted in the preceding run. Use \`${lid}=TEXT\` to replace, or precede with \`-${lid}\`.`,
+				);
+			}
+		}
+		// Split the delete run into file-contiguous sub-runs. The block
+		// reorder (inserts land at the FIRST delete's slot) is meaningful only
+		// when the deletes describe a single contiguous file range. When the
+		// agent stacks deletes that target far-apart lines (e.g. `-186 -197
+		// -198 -199` to remove a debug line at 186 AND replace 197-199), each
+		// far-apart delete moves the cursor on its own; only the LAST
+		// contiguous group should attract the inserts.
+		const subruns = splitContiguousDeletes(deletes);
+		for (let r = 0; r < subruns.length - 1; r++) {
+			for (const d of subruns[r]) out.push(d);
 		}
-		if (entry.pre !== undefined) {
-			resolved.push({ op: "prepend_file", lines: hashlineParseText(entry.pre) });
+		const lastDeletes = subruns[subruns.length - 1];
+
+		// Single-line case: 1 delete in the last sub-run + 1 diffish_add same Lid → fuse to set.
+		if (lastDeletes.length === 1 && adds.length === 1 && adds[0].kind === "diffish_add") {
+			const dAnchor = (lastDeletes[0] as { anchor: ParsedAnchor }).anchor;
+			const a = adds[0];
+			if (a.anchor.line === dAnchor.line && a.anchor.hash === dAnchor.hash) {
+				out.push({
+					kind: "anchor_op",
+					anchor: a.anchor,
+					op: { op: "set", text: a.text, allowOldNewRepair: false },
+					lineNum: a.lineNum,
+				});
+				continue;
+			}
 		}
-		if (entry.post !== undefined) {
-			resolved.push({ op: "append_file", lines: hashlineParseText(entry.post) });
+		// Block: emit lastDeletes[0], then all inserts (which land at lastDeletes[0]'s slot
+		// because the cursor binds to lastDeletes[0] before the inserts), then the
+		// remaining lastDeletes.
+		out.push(lastDeletes[0]);
+		for (const add of adds) {
+			const text = add.kind === "insert" ? add.text : (add as DiffishAddStmt).text;
+			out.push({ kind: "insert", text, lineNum: add.lineNum });
 		}
-		if (entry.sed !== undefined) {
-			const spec = parseSedSpec(entry.sed, editIndex);
-			resolved.push({ op: "sed_file", spec, expression: formatSedExpression(spec) });
+		for (let j = 1; j < lastDeletes.length; j++) {
+			out.push(lastDeletes[j]);
 		}
-		return resolved;
 	}
+	return out;
+}
 
-	if (entry.pre !== undefined) {
-		resolved.push({ op: "pre", pos: loc.pos, lines: hashlineParseText(entry.pre) });
-	}
-	if (entry.splice !== undefined) {
-		if (Array.isArray(entry.splice) && entry.splice.length === 0) {
-			// Models often default `splice: []` alongside other verbs (notably `sed`).
-			// Treating that combination as an explicit `del` produces a confusing
-			// `Conflicting ops` error. When another mutating verb is present, drop
-			// the empty `splice` instead of treating it as a deletion.
-			if (entry.sed === undefined) {
-				resolved.push({ op: "del", pos: loc.pos });
-			}
+function makeAnchor(anchor: ParsedAnchor): Anchor {
+	return { line: anchor.line, hash: anchor.hash };
+}
+
+function splitContiguousDeletes(deletes: ParsedStmt[]): ParsedStmt[][] {
+	if (deletes.length === 0) return [];
+	const getLine = (s: ParsedStmt): number => {
+		if (s.kind === "anchor_op") return s.anchor.line;
+		if (s.kind === "delete_with_old") return s.anchor.line;
+		throw new Error("internal: splitContiguousDeletes received non-delete stmt");
+	};
+	const subruns: ParsedStmt[][] = [];
+	let current: ParsedStmt[] = [deletes[0]];
+	for (let i = 1; i < deletes.length; i++) {
+		if (getLine(deletes[i]) === getLine(deletes[i - 1]) + 1) {
+			current.push(deletes[i]);
 		} else {
-			resolved.push({ op: "splice", pos: loc.pos, lines: hashlineParseText(entry.splice) });
-		}
-	}
-	if (entry.post !== undefined) {
-		resolved.push({ op: "post", pos: loc.pos, lines: hashlineParseText(entry.post) });
-	}
-	if (entry.sed !== undefined) {
-		const spliceIsExplicitReplacement = Array.isArray(entry.splice) && entry.splice.length > 0;
-		// Models often duplicate intent by sending both an explicit `splice` and a
-		// matching `sed`. The explicit replacement wins; the redundant `sed` would
-		// otherwise trigger a confusing `Conflicting ops` rejection.
-		if (!spliceIsExplicitReplacement) {
-			const spec = parseSedSpec(entry.sed, editIndex);
-			resolved.push({ op: "sed", pos: loc.pos, spec, expression: formatSedExpression(spec) });
+			subruns.push(current);
+			current = [deletes[i]];
 		}
 	}
-	return resolved;
+	subruns.push(current);
+	return subruns;
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
-// Validation
+// Build cursor-program from ParsedStmt[]
 // ═══════════════════════════════════════════════════════════════════════════
 
-function* getAtomAnchors(edit: AtomEdit): Iterable<Anchor> {
-	switch (edit.op) {
-		case "splice":
-		case "pre":
-		case "post":
-		case "del":
-		case "sed":
-			yield edit.pos;
-			return;
-		default:
-			return;
-	}
-}
+export function parseAtom(diff: string): AtomEdit[] {
+	const edits: AtomEdit[] = [];
+	let cursor: AtomCursor = { kind: "eof" };
+	let index = 0;
 
-/**
- * Search for a line near `anchor.line` whose trimmed content equals the
- * anchor's content hint. Returns the closest match (preferring lines below the
- * requested anchor on ties) or `null` when no line matches. Strict equality on
- * trimmed content keeps this conservative \u2014 we only retarget when there is no
- * ambiguity about the model's intent.
- */
-function findLineByContentHint(anchor: Anchor, fileLines: string[]): number | null {
-	const hint = anchor.contentHint?.trim();
-	if (!hint) return null;
-	const lo = Math.max(1, anchor.line - ANCHOR_REBASE_WINDOW);
-	const hi = Math.min(fileLines.length, anchor.line + ANCHOR_REBASE_WINDOW);
-	let best: { line: number; distance: number } | null = null;
-	for (let line = lo; line <= hi; line++) {
-		if (fileLines[line - 1].trim() !== hint) continue;
-		const distance = Math.abs(line - anchor.line);
-		if (best === null || distance < best.distance) {
-			best = { line, distance };
+	for (const stmt of tokenizeDiff(diff)) {
+		if (stmt.kind === "insert") {
+			edits.push({ kind: "insert", cursor: cloneCursor(cursor), text: stmt.text, lineNum: stmt.lineNum, index });
+			index++;
+			continue;
+		}
+
+		if (stmt.kind === "bof") {
+			cursor = { kind: "bof" };
+			continue;
+		}
+		if (stmt.kind === "eof") {
+			cursor = { kind: "eof" };
+			continue;
 		}
+
+		if (stmt.kind === "delete_with_old") {
+			const anchor = makeAnchor(stmt.anchor);
+			cursor = { kind: "anchor", anchor: { ...anchor } };
+			edits.push({ kind: "delete", anchor, lineNum: stmt.lineNum, index, oldAssertion: stmt.old });
+			index++;
+			continue;
+		}
+
+		if (stmt.kind === "diffish_add") {
+			throw new Error("Internal atom error: unresolved diff-ish add reached parseAtom.");
+		}
+
+		const anchor = makeAnchor(stmt.anchor);
+		cursor = { kind: "anchor", anchor: { ...anchor } };
+		if (stmt.kind === "bare_anchor") continue;
+
+		if (stmt.op.op === "set") {
+			if (stmt.op.text.includes("\r")) {
+				throw new Error(
+					`Diff line ${stmt.lineNum}: set value contains a carriage return; use a single-line value.`,
+				);
+			}
+			edits.push({
+				kind: "set",
+				anchor,
+				text: stmt.op.text,
+				lineNum: stmt.lineNum,
+				index,
+				allowOldNewRepair: stmt.op.allowOldNewRepair,
+			});
+			index++;
+			continue;
+		}
+
+		edits.push({ kind: "delete", anchor, lineNum: stmt.lineNum, index });
+		index++;
 	}
-	return best?.line ?? null;
+
+	return edits;
+}
+
+function formatNoAtomEditDiagnostic(_path: string, diff: string): string {
+	const body = diff
+		.split("\n")
+		.map(line => (line.endsWith("\r") ? line.slice(0, -1) : line))
+		.filter(line => line.trim().length > 0)
+		.slice(0, 3)
+		.map(line => `  ${line}`)
+		.join("\n");
+	const preview = body.length > 0 ? `\nReceived only locator/context lines:\n${body}` : "";
+	return `Cursor moved but no mutation found. Add +TEXT to insert, -Lid to delete, or Lid=TEXT to replace.${preview}`;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Apply cursor-program
+// ═══════════════════════════════════════════════════════════════════════════
+
+function getAtomEditAnchors(edit: AtomEdit): Anchor[] {
+	if (edit.kind === "set" || edit.kind === "delete") return [edit.anchor];
+	if (edit.cursor.kind === "anchor") return [edit.cursor.anchor];
+	return [];
 }
 
 function validateAtomAnchors(edits: AtomEdit[], fileLines: string[], warnings: string[]): HashMismatch[] {
 	const mismatches: HashMismatch[] = [];
+	const rebasedAnchors = new Map<Anchor, HashMismatch>();
+	const rebasedMutatingAnchors: { original: string; rebased: number; hash: string }[] = [];
 	for (const edit of edits) {
-		for (const anchor of getAtomAnchors(edit)) {
+		for (const anchor of getAtomEditAnchors(edit)) {
 			if (anchor.line < 1 || anchor.line > fileLines.length) {
 				throw new Error(`Line ${anchor.line} does not exist (file has ${fileLines.length} lines)`);
 			}
 			const actualHash = computeLineHash(anchor.line, fileLines[anchor.line - 1]);
 			if (actualHash === anchor.hash) continue;
-			// When the model supplied a content hint after the anchor (e.g.
-			// `82zu|  for (...)`), prefer rebasing to the line that actually matches
-			// that content. This avoids false positives from hash-only rebasing where
-			// a coincidentally matching hash on a nearby line silently retargets the
-			// edit to the wrong line.
-			const hinted = findLineByContentHint(anchor, fileLines);
-			if (hinted !== null) {
-				const original = `${anchor.line}${anchor.hash}`;
-				const hintedHash = computeLineHash(hinted, fileLines[hinted - 1]);
-				anchor.line = hinted;
-				anchor.hash = hintedHash;
-				warnings.push(
-					`Auto-rebased anchor ${original} → ${hinted}${hintedHash} (matched the content hint provided after the anchor).`,
-				);
-				continue;
-			}
+
 			const rebased = tryRebaseAnchor(anchor, fileLines);
 			if (rebased !== null) {
 				const original = `${anchor.line}${anchor.hash}`;
+				rebasedAnchors.set(anchor, { line: anchor.line, expected: anchor.hash, actual: actualHash });
 				anchor.line = rebased;
+				if (edit.kind === "set" || edit.kind === "delete") {
+					rebasedMutatingAnchors.push({ original, rebased, hash: anchor.hash });
+				}
 				warnings.push(
 					`Auto-rebased anchor ${original} → ${rebased}${anchor.hash} (line shifted within ±${ANCHOR_REBASE_WINDOW}; hash matched).`,
 				);
@@ -509,53 +555,231 @@ function validateAtomAnchors(edits: AtomEdit[], fileLines: string[], warnings: s
 			mismatches.push({ line: anchor.line, expected: anchor.hash, actual: actualHash });
 		}
 	}
+
+	// Rebase cap: a single stale anchor (e.g. unrelated upstream edit) is fine,
+	// but multiple mutating anchors all rebasing is the signature of a miscounted
+	// block edit (agent stacked `Lid=X` ops over a contiguous range whose new
+	// length differs from the old). Refuse so the agent retries with the
+	// `-Lid`+`+TEXT` block-rewrite recipe instead of silently corrupting the file.
+	if (rebasedMutatingAnchors.length > 1) {
+		const detail = rebasedMutatingAnchors.map(r => `${r.original} → ${r.rebased}${r.hash}`).join(", ");
+		throw new Error(
+			`Refusing edit: ${rebasedMutatingAnchors.length} mutating anchors needed auto-rebase (${detail}). ` +
+				"This usually means a `Lid=X` chain was used to rewrite a contiguous block whose new length differs from the old. " +
+				"Rewrite the block by deleting each original line with `-Lid` (one per line) and emitting the new content as `+TEXT` lines.",
+		);
+	}
+
+	// Detect post-rebase conflicts. If any conflicting anchor was rebased, surface
+	// the original hash mismatch instead — the rebase itself is what created the
+	// conflict, and the model needs to fix the stale anchor, not deduplicate.
+	const seenLines = new Map<number, Anchor>();
+	for (const edit of edits) {
+		if (edit.kind !== "set" && edit.kind !== "delete") continue;
+		const existing = seenLines.get(edit.anchor.line);
+		if (existing) {
+			const rebasedA = rebasedAnchors.get(edit.anchor);
+			const rebasedB = rebasedAnchors.get(existing);
+			if (rebasedA) mismatches.push(rebasedA);
+			else if (rebasedB) mismatches.push(rebasedB);
+			continue;
+		}
+		seenLines.set(edit.anchor.line, edit.anchor);
+	}
 	return mismatches;
 }
 
-function validateNoConflictingAnchorOps(edits: AtomEdit[]): void {
-	// For each anchor line, at most one mutating op (splice/del). Multiple `sed`
-	// ops on the same line are allowed and applied sequentially. `pre`/`post`
-	// (insert ops) may coexist with them — they don't mutate the anchor line.
+function validateNoConflictingAtomMutations(edits: AtomEdit[]): void {
 	const mutatingPerLine = new Map<number, string>();
 	for (const edit of edits) {
-		if (edit.op !== "splice" && edit.op !== "del" && edit.op !== "sed") continue;
-		const existing = mutatingPerLine.get(edit.pos.line);
+		if (edit.kind !== "set" && edit.kind !== "delete") continue;
+		const existing = mutatingPerLine.get(edit.anchor.line);
 		if (existing) {
-			if (existing === "sed" && edit.op === "sed") continue;
 			throw new Error(
-				`Conflicting ops on anchor line ${edit.pos.line}: \`${existing}\` and \`${edit.op}\`. ` +
-					`At most one of splice/del is allowed per anchor.`,
+				`Conflicting ops on anchor line ${edit.anchor.line}: \`${existing}\` and \`${edit.kind}\`. ` +
+					"At most one mutating op (set/delete) is allowed per anchor.",
 			);
 		}
-		mutatingPerLine.set(edit.pos.line, edit.op);
+		mutatingPerLine.set(edit.anchor.line, edit.kind);
 	}
 }
 
-// ═══════════════════════════════════════════════════════════════════════════
-// Apply
-// ═══════════════════════════════════════════════════════════════════════════
+function repairAtomOldNewSetLine(currentLine: string, nextLine: string): string {
+	const marker = `${currentLine}|`;
+	if (!nextLine.startsWith(marker)) return nextLine;
+	const repaired = nextLine.slice(marker.length);
+	return repaired.length > 0 ? repaired : nextLine;
+}
 
-export interface AtomNoopEdit {
-	editIndex: number;
-	loc: string;
-	reason: string;
-	current: string;
+function insertAtStart(fileLines: string[], lines: string[]): void {
+	if (lines.length === 0) return;
+	if (fileLines.length === 1 && fileLines[0] === "") {
+		fileLines.splice(0, 1, ...lines);
+		return;
+	}
+	fileLines.splice(0, 0, ...lines);
 }
 
-export function applyAtomEdits(
-	text: string,
-	edits: AtomEdit[],
-): {
-	lines: string;
-	firstChangedLine: number | undefined;
-	warnings?: string[];
-	noopEdits?: AtomNoopEdit[];
-} {
+function insertAtEnd(fileLines: string[], lines: string[]): number | undefined {
+	if (lines.length === 0) return undefined;
+	if (fileLines.length === 1 && fileLines[0] === "") {
+		fileLines.splice(0, 1, ...lines);
+		return 1;
+	}
+	const hasTrailingNewline = fileLines.length > 0 && fileLines[fileLines.length - 1] === "";
+	const insertIdx = hasTrailingNewline ? fileLines.length - 1 : fileLines.length;
+	fileLines.splice(insertIdx, 0, ...lines);
+	return insertIdx + 1;
+}
+
+function isSameFileCursor(a: AtomCursor, b: AtomCursor): boolean {
+	return a.kind === b.kind && a.kind !== "anchor";
+}
+
+function collectFileInsertRuns(
+	fileInserts: Extract<AtomEdit, { kind: "insert" }>[],
+): Array<{ cursor: AtomCursor; lines: string[] }> {
+	const runs: Array<{ cursor: AtomCursor; lines: string[] }> = [];
+	for (const edit of fileInserts.sort((a, b) => a.index - b.index)) {
+		const prev = runs[runs.length - 1];
+		if (prev && isSameFileCursor(prev.cursor, edit.cursor)) {
+			prev.lines.push(edit.text);
+			continue;
+		}
+		runs.push({ cursor: edit.cursor, lines: [edit.text] });
+	}
+	return runs;
+}
+function applyFileCursorInserts(
+	fileLines: string[],
+	fileInserts: Extract<AtomEdit, { kind: "insert" }>[],
+): number | undefined {
+	let firstChangedLine: number | undefined;
+	const trackFirstChanged = (line: number) => {
+		if (firstChangedLine === undefined || line < firstChangedLine) firstChangedLine = line;
+	};
+
+	for (const run of collectFileInsertRuns(fileInserts)) {
+		if (run.cursor.kind === "bof") {
+			insertAtStart(fileLines, run.lines);
+			trackFirstChanged(1);
+			continue;
+		}
+		if (run.cursor.kind === "eof") {
+			const changedLine = insertAtEnd(fileLines, run.lines);
+			if (changedLine !== undefined) trackFirstChanged(changedLine);
+		}
+	}
+
+	return firstChangedLine;
+}
+
+function getAnchorForAnchorEdit(edit: IndexedAnchorEdit["edit"]): Anchor {
+	if (edit.kind !== "insert") return edit.anchor;
+	if (edit.cursor.kind !== "anchor") {
+		throw new Error("Internal atom error: file-scoped insert reached anchor application.");
+	}
+	return edit.cursor.anchor;
+}
+
+// Heuristic: detect (and when safe, auto-fix) lines that became adjacent
+// duplicates of themselves after the edit, when they were not adjacent
+// duplicates before. This is the signature of a botched block rewrite that
+// missed one delete on the front or back of the deletion range, leaving a
+// stale copy of a line the agent already re-emitted (e.g. inserting a new
+// closing `}` while the original `}` was never deleted, producing `}\n}`).
+//
+// Auto-fix is gated on bracket balance: we only remove the duplicate line if
+// its removal restores the original file's `{}`/`()`/`[]` delta. That makes
+// the fix safe in the common case (a stray closing brace shifts balance by
+// one) and conservative when the duplicate is intentional (balance unchanged
+// → warning only). When two adjacent lines are textually identical, removing
+// either yields the same content, so we don't have to decide which is "the
+// stale copy" — we just remove one and verify balance restores.
+function detectAndAutoFixDuplicates(
+	originalLines: string[],
+	finalLines: string[],
+): { fixed: string[] | null; warnings: string[] } {
+	const countAdjacent = (lines: string[]): Map<string, number> => {
+		const counts = new Map<string, number>();
+		for (let i = 0; i + 1 < lines.length; i++) {
+			if (lines[i] !== lines[i + 1]) continue;
+			if (lines[i].trim().length === 0) continue;
+			counts.set(lines[i], (counts.get(lines[i]) ?? 0) + 1);
+		}
+		return counts;
+	};
+
+	const computeBalance = (lines: string[]): { brace: number; paren: number; bracket: number } => {
+		let brace = 0;
+		let paren = 0;
+		let bracket = 0;
+		for (const line of lines) {
+			for (const ch of line) {
+				if (ch === "{") brace++;
+				else if (ch === "}") brace--;
+				else if (ch === "(") paren++;
+				else if (ch === ")") paren--;
+				else if (ch === "[") bracket++;
+				else if (ch === "]") bracket--;
+			}
+		}
+		return { brace, paren, bracket };
+	};
+
+	const balancesEqual = (
+		a: { brace: number; paren: number; bracket: number },
+		b: { brace: number; paren: number; bracket: number },
+	): boolean => a.brace === b.brace && a.paren === b.paren && a.bracket === b.bracket;
+
+	const orig = countAdjacent(originalLines);
+	const fin = countAdjacent(finalLines);
+	const newDupPositions: number[] = [];
+	for (let i = 0; i + 1 < finalLines.length; i++) {
+		if (finalLines[i] !== finalLines[i + 1]) continue;
+		if (finalLines[i].trim().length === 0) continue;
+		const text = finalLines[i];
+		if ((fin.get(text) ?? 0) <= (orig.get(text) ?? 0)) continue;
+		newDupPositions.push(i);
+	}
+
+	if (newDupPositions.length === 0) return { fixed: null, warnings: [] };
+
+	const formatPreview = (text: string): string => JSON.stringify(text.length > 60 ? `${text.slice(0, 60)}…` : text);
+
+	// Auto-fix only when there is exactly one new adjacent duplicate AND the
+	// edit shifted bracket balance. Removing one of the two identical lines
+	// must restore the original delta exactly.
+	if (newDupPositions.length === 1) {
+		const pos = newDupPositions[0];
+		const origBalance = computeBalance(originalLines);
+		const finalBalance = computeBalance(finalLines);
+		if (!balancesEqual(origBalance, finalBalance)) {
+			const trial = finalLines.slice(0, pos).concat(finalLines.slice(pos + 1));
+			if (balancesEqual(computeBalance(trial), origBalance)) {
+				return {
+					fixed: trial,
+					warnings: [
+						`Auto-fixed: removed duplicate line ${pos + 1} (${formatPreview(finalLines[pos])}); the edit left two adjacent identical lines and bracket balance was off. Verify the result.`,
+					],
+				};
+			}
+		}
+	}
+
+	const warnings = newDupPositions.slice(0, 3).map(pos => {
+		return `Suspicious duplicate: lines ${pos + 1} and ${pos + 2} are both ${formatPreview(finalLines[pos])}. The edit may have left a stale copy of a line you meant to replace — verify the result.`;
+	});
+	return { fixed: null, warnings };
+}
+
+export function applyAtomEdits(text: string, edits: AtomEdit[]): AtomApplyResult {
 	if (edits.length === 0) {
 		return { lines: text, firstChangedLine: undefined };
 	}
 
 	const fileLines = text.split("\n");
+	const originalLines = fileLines.slice();
 	const warnings: string[] = [];
 	let firstChangedLine: number | undefined;
 	const noopEdits: AtomNoopEdit[] = [];
@@ -564,55 +788,31 @@ export function applyAtomEdits(
 	if (mismatches.length > 0) {
 		throw new HashlineMismatchError(mismatches, fileLines);
 	}
-	// When a `del` and a `sed`/`splice` target the same anchor (across separate edit
-	// entries), the `del` is almost always a hallucinated cleanup the model added on top
-	// of the real replacement. Drop the `del` silently so the replacement wins, matching
-	// the in-entry handling for `splice: []` paired with `sed`.
-	const replacedLines = new Set<number>();
-	for (const e of edits) {
-		if (e.op === "splice" || e.op === "sed") replacedLines.add(e.pos.line);
-	}
-	let effective = edits;
-	if (replacedLines.size > 0) {
-		effective = edits.filter(e => !(e.op === "del" && replacedLines.has(e.pos.line)));
-	}
-	validateNoConflictingAnchorOps(effective);
+	validateNoConflictingAtomMutations(edits);
 
 	const trackFirstChanged = (line: number) => {
-		if (firstChangedLine === undefined || line < firstChangedLine) {
-			firstChangedLine = line;
-		}
+		if (firstChangedLine === undefined || line < firstChangedLine) firstChangedLine = line;
 	};
 
-	// Partition: anchor-scoped vs file-scoped. Preserve original order via the
-	// captured idx so multiple pre/post on the same target are emitted in the order
-	// the model produced them.
-	type Indexed<T> = { edit: T; idx: number };
-	type AnchorEdit = Exclude<AtomEdit, { op: "append_file" } | { op: "prepend_file" } | { op: "sed_file" }>;
-	const anchorEdits: Indexed<AnchorEdit>[] = [];
-	const appendEdits: Indexed<Extract<AtomEdit, { op: "append_file" }>>[] = [];
-	const sedFileEdits: Indexed<Extract<AtomEdit, { op: "sed_file" }>>[] = [];
-	const prependEdits: Indexed<Extract<AtomEdit, { op: "prepend_file" }>>[] = [];
-	effective.forEach((edit, idx) => {
-		if (edit.op === "append_file") appendEdits.push({ edit, idx });
-		else if (edit.op === "prepend_file") prependEdits.push({ edit, idx });
-		else if (edit.op === "sed_file") sedFileEdits.push({ edit, idx });
-		else anchorEdits.push({ edit, idx });
+	const anchorEdits: IndexedAnchorEdit[] = [];
+	const fileInserts: Extract<AtomEdit, { kind: "insert" }>[] = [];
+	edits.forEach((edit, idx) => {
+		if (edit.kind === "insert" && edit.cursor.kind !== "anchor") {
+			fileInserts.push(edit);
+			return;
+		}
+		anchorEdits.push({ edit, idx });
 	});
 
-	// Group anchor edits by line so all ops on the same line are applied as a
-	// single splice. This makes the per-anchor outcome independent of index
-	// shifts caused by sibling ops (e.g. `post` paired with `del` on the same
-	// anchor, or repeated `pre`/`post` inserts that previously reversed).
-	const byLine = new Map<number, Indexed<AnchorEdit>[]>();
+	const byLine = new Map<number, IndexedAnchorEdit[]>();
 	for (const entry of anchorEdits) {
-		const line = entry.edit.pos.line;
-		let bucket = byLine.get(line);
-		if (!bucket) {
-			bucket = [];
-			byLine.set(line, bucket);
+		const line = getAnchorForAnchorEdit(entry.edit).line;
+		const bucket = byLine.get(line);
+		if (bucket) {
+			bucket.push(entry);
+		} else {
+			byLine.set(line, [entry]);
 		}
-		bucket.push(entry);
 	}
 
 	const anchorLines = [...byLine.keys()].sort((a, b) => b - a);
@@ -626,237 +826,454 @@ export function applyAtomEdits(
 		let replacement: string[] = [currentLine];
 		let replacementSet = false;
 		let anchorMutated = false;
-		let anchorDeleted = false;
-		const beforeLines: string[] = [];
 		const afterLines: string[] = [];
 
 		for (const { edit } of bucket) {
-			switch (edit.op) {
-				case "pre":
-					beforeLines.push(...edit.lines);
-					break;
-				case "post":
-					afterLines.push(...edit.lines);
+			switch (edit.kind) {
+				case "insert":
+					afterLines.push(edit.text);
 					break;
-				case "del":
-					replacement = [];
-					replacementSet = true;
-					anchorDeleted = true;
-					break;
-				case "splice":
-					replacement = edit.lines.length === 0 ? [""] : [...edit.lines];
+				case "set":
+					replacement = [edit.allowOldNewRepair ? repairAtomOldNewSetLine(currentLine, edit.text) : edit.text];
 					replacementSet = true;
 					anchorMutated = true;
 					break;
-				case "sed": {
-					const input = replacementSet ? (replacement[0] ?? "") : currentLine;
-					const { result, matched, error, literalFallback } = applySedToLine(input, edit.spec);
-					if (error) {
-						throw new Error(`Edit sed expression ${JSON.stringify(edit.expression)} rejected: ${error}`);
-					}
-					if (!matched) {
+				case "delete":
+					if (edit.oldAssertion !== undefined && edit.oldAssertion !== currentLine) {
 						throw new Error(
-							`Edit sed expression ${JSON.stringify(edit.expression)} did not match line ${edit.pos.line}: ${JSON.stringify(input)}`,
-						);
-					}
-					if (literalFallback) {
-						warnings.push(
-							`sed expression ${JSON.stringify(edit.expression)} did not match as a regex on line ${edit.pos.line}; applied literal substring substitution instead. Use the \`F\` flag (e.g. \`s/.../.../F\`) for literal patterns or escape regex metacharacters.`,
+							`Diff line ${edit.lineNum}: \`-${edit.anchor.line}${edit.anchor.hash}\` asserts the deleted line is ${JSON.stringify(edit.oldAssertion)}, but the file has ${JSON.stringify(currentLine)}. Re-anchor and retry.`,
 						);
 					}
-					replacement = [result];
+					replacement = [];
 					replacementSet = true;
 					anchorMutated = true;
 					break;
-				}
 			}
 		}
 
-		const noOp = !replacementSet && beforeLines.length === 0 && afterLines.length === 0;
-		if (noOp) continue;
-
-		const originalLine = fileLines[idx];
 		const replacementProducesNoChange =
-			beforeLines.length === 0 &&
-			afterLines.length === 0 &&
-			replacement.length === 1 &&
-			replacement[0] === originalLine;
+			afterLines.length === 0 && replacement.length === 1 && replacement[0] === currentLine;
 		if (replacementProducesNoChange) {
 			const firstEdit = bucket[0]?.edit;
-			const loc = firstEdit ? `${firstEdit.pos.line}${firstEdit.pos.hash}` : `${line}`;
-			const reason = "replacement is identical to the current line content";
+			const anchor = firstEdit ? getAnchorForAnchorEdit(firstEdit) : undefined;
 			noopEdits.push({
 				editIndex: bucket[0]?.idx ?? 0,
-				loc,
-				reason,
-				current: originalLine,
+				loc: anchor ? `${anchor.line}${anchor.hash}` : `${line}`,
+				reason:
+					firstEdit?.kind === "set"
+						? "replacement is identical to the current line content; use `Lid=NEW_TEXT` and do not copy an unchanged read line"
+						: "replacement is identical to the current line content",
+				current: currentLine,
 			});
 			continue;
 		}
 
-		const combined = [...beforeLines, ...replacement, ...afterLines];
+		const combined = [...replacement, ...afterLines];
 		fileLines.splice(idx, 1, ...combined);
-
-		if (beforeLines.length > 0 || anchorMutated || anchorDeleted) {
+		if (anchorMutated) {
 			trackFirstChanged(line);
 		} else if (afterLines.length > 0) {
 			trackFirstChanged(line + 1);
 		}
+		if (!replacementSet && afterLines.length === 0) continue;
 	}
 
-	// Apply prepend_file ops in original order so the first one ends up at the
-	// very top of the file.
-	prependEdits.sort((a, b) => a.idx - b.idx);
-	for (const { edit } of prependEdits) {
-		if (edit.lines.length === 0) continue;
-		if (fileLines.length === 1 && fileLines[0] === "") {
-			fileLines.splice(0, 1, ...edit.lines);
-		} else {
-			// Insert in reverse cumulative order so later splices push earlier
-			// content further down, preserving the original op order.
-			fileLines.splice(0, 0, ...edit.lines);
-		}
-		trackFirstChanged(1);
-	}
+	const fileFirstChangedLine = applyFileCursorInserts(fileLines, fileInserts);
+	if (fileFirstChangedLine !== undefined) trackFirstChanged(fileFirstChangedLine);
 
-	// Apply append_file ops in original order. When the file ends with a
-	// trailing newline (last split element is the empty sentinel), insert
-	// before that sentinel so the trailing newline is preserved.
-	appendEdits.sort((a, b) => a.idx - b.idx);
-	for (const { edit } of appendEdits) {
-		if (edit.lines.length === 0) continue;
-		if (fileLines.length === 1 && fileLines[0] === "") {
-			fileLines.splice(0, 1, ...edit.lines);
-			trackFirstChanged(1);
-			continue;
-		}
-		const hasTrailingNewline = fileLines.length > 0 && fileLines[fileLines.length - 1] === "";
-		const insertIdx = hasTrailingNewline ? fileLines.length - 1 : fileLines.length;
-		fileLines.splice(insertIdx, 0, ...edit.lines);
-		trackFirstChanged(insertIdx + 1);
-	}
-
-	// Apply sed_file ops last so they observe the post-anchor / post-prepend /
-	// post-append state of the file. Each op runs across every content line and
-	let warnedLiteralFallback = false;
-	sedFileEdits.sort((a, b) => a.idx - b.idx);
-	for (const { edit } of sedFileEdits) {
-		const hasTrailingNewline = fileLines.length > 1 && fileLines[fileLines.length - 1] === "";
-		const upper = hasTrailingNewline ? fileLines.length - 1 : fileLines.length;
-		let anyMatched = false;
-		let lastCompileError: string | undefined;
-		for (let i = 0; i < upper; i++) {
-			const line = fileLines[i] ?? "";
-			const r = applySedToLine(line, edit.spec);
-			if (r.error) lastCompileError = r.error;
-			if (!r.matched) continue;
-			anyMatched = true;
-			if (r.literalFallback && !warnedLiteralFallback) {
-				warnings.push(
-					`sed expression ${JSON.stringify(edit.expression)} did not match as a regex; applied literal substring substitution. Use the \`F\` flag (e.g. \`s/.../.../F\`) for literal patterns or escape regex metacharacters.`,
-				);
-				warnedLiteralFallback = true;
-			}
-			if (r.result !== line) {
-				fileLines[i] = r.result;
-				trackFirstChanged(i + 1);
-			}
-		}
-		if (!anyMatched) {
-			if (lastCompileError !== undefined) {
-				throw new Error(`Edit sed expression ${JSON.stringify(edit.expression)} rejected: ${lastCompileError}`);
-			}
-			throw new Error(`Edit sed expression ${JSON.stringify(edit.expression)} did not match any line in the file.`);
-		}
+	const dupCheck = detectAndAutoFixDuplicates(originalLines, fileLines);
+	if (dupCheck.fixed !== null) {
+		fileLines.length = 0;
+		fileLines.push(...dupCheck.fixed);
 	}
+	for (const w of dupCheck.warnings) warnings.push(w);
 
 	return {
 		lines: fileLines.join("\n"),
 		firstChangedLine,
 		...(warnings.length > 0 ? { warnings } : {}),
-		...(noopEdits.length > 0 ? { noopEdits } : {}),
+		...(noopEdits.length > 0 && firstChangedLine === undefined ? { noopEdits } : {}),
 	};
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
+// Wire-format split: extract `---` headers from the input string.
+// ═══════════════════════════════════════════════════════════════════════════
+
+const FILE_HEADER_PREFIX = "---";
+const REMOVE_FILE_OPERATION = "!rm";
+const MOVE_FILE_OPERATION = "!mv";
+
+type AtomWholeFileOperation =
+	| { kind: "delete"; lineNum: number }
+	| { kind: "move"; destination: string; lineNum: number };
+
+interface AtomInputSection {
+	path: string;
+	diff: string;
+	wholeFileOperation?: AtomWholeFileOperation;
+}
+
+export interface SplitAtomOptions {
+	cwd?: string;
+	path?: string;
+}
+
+function isBlankHeaderPreamble(line: string): boolean {
+	return line.replace(/\r$/, "").trim().length === 0;
+}
+
+function unquoteAtomPath(pathText: string): string {
+	if (pathText.length < 2) return pathText;
+	const first = pathText[0];
+	const last = pathText[pathText.length - 1];
+	if ((first === '"' || first === "'") && first === last) {
+		return pathText.slice(1, -1);
+	}
+	return pathText;
+}
+
+function normalizeAtomPath(rawPath: string, cwd?: string): string {
+	const unquoted = unquoteAtomPath(rawPath.trim());
+	if (!cwd || !path.isAbsolute(unquoted)) return unquoted;
+
+	const relative = path.relative(path.resolve(cwd), path.resolve(unquoted));
+	const isWithinCwd = relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+	return isWithinCwd ? relative || "." : unquoted;
+}
+
+function parseAtomHeaderLine(line: string, cwd?: string): string | null {
+	if (!line.startsWith(FILE_HEADER_PREFIX)) return null;
+	let body = line.slice(FILE_HEADER_PREFIX.length);
+	if (body.startsWith(" ")) body = body.slice(1);
+	const parsedPath = normalizeAtomPath(body, cwd);
+	if (parsedPath.length === 0) {
+		throw new Error(`atom input header "${FILE_HEADER_PREFIX}" is empty; provide a file path.`);
+	}
+	return parsedPath;
+}
+
+function parseSingleAtomPathArgument(rawPath: string, directive: string, lineNum: number, cwd?: string): string {
+	const trimmed = rawPath.trim();
+	if (trimmed.length === 0) {
+		throw new Error(`Atom line ${lineNum}: ${directive} requires exactly one non-empty destination path.`);
+	}
+
+	const quote = trimmed[0];
+	if (quote === '"' || quote === "'") {
+		if (trimmed.length < 2 || trimmed[trimmed.length - 1] !== quote) {
+			throw new Error(`Atom line ${lineNum}: ${directive} requires exactly one destination path.`);
+		}
+	} else if (/\s/.test(trimmed)) {
+		throw new Error(`Atom line ${lineNum}: ${directive} requires exactly one destination path.`);
+	}
+
+	const destination = normalizeAtomPath(trimmed, cwd);
+	if (destination.length === 0) {
+		throw new Error(`Atom line ${lineNum}: ${directive} requires exactly one non-empty destination path.`);
+	}
+	return destination;
+}
+
+function parseAtomWholeFileOperationLine(
+	rawLine: string,
+	lineNum: number,
+	cwd?: string,
+): AtomWholeFileOperation | null {
+	const line = rawLine.replace(/\r$/, "").trimEnd();
+	if (line === REMOVE_FILE_OPERATION) {
+		return { kind: "delete", lineNum };
+	}
+	if (line.startsWith(`${REMOVE_FILE_OPERATION} `) || line.startsWith(`${REMOVE_FILE_OPERATION}\t`)) {
+		throw new Error(`Atom line ${lineNum}: ${REMOVE_FILE_OPERATION} does not take a destination path.`);
+	}
+
+	if (line === MOVE_FILE_OPERATION) {
+		throw new Error(`Atom line ${lineNum}: ${MOVE_FILE_OPERATION} requires exactly one non-empty destination path.`);
+	}
+	if (line.startsWith(`${MOVE_FILE_OPERATION} `) || line.startsWith(`${MOVE_FILE_OPERATION}\t`)) {
+		const rawDestination = line.slice(MOVE_FILE_OPERATION.length);
+		return {
+			kind: "move",
+			destination: parseSingleAtomPathArgument(rawDestination, MOVE_FILE_OPERATION, lineNum, cwd),
+			lineNum,
+		};
+	}
+
+	return null;
+}
+
+function getAtomWholeFileOperation(
+	sectionPath: string,
+	lines: string[],
+	cwd?: string,
+): AtomWholeFileOperation | undefined {
+	let operation: AtomWholeFileOperation | undefined;
+	let operationToken = "";
+	let hasLineEdit = false;
+
+	for (let i = 0; i < lines.length; i++) {
+		const lineNum = i + 1;
+		const line = lines[i].replace(/\r$/, "");
+		if (line.trim().length === 0) continue;
+
+		const parsed = parseAtomWholeFileOperationLine(line, lineNum, cwd);
+		if (parsed) {
+			if (operation) {
+				throw new Error(
+					`Atom section ${sectionPath}: use only one ${REMOVE_FILE_OPERATION} or ${MOVE_FILE_OPERATION} operation.`,
+				);
+			}
+			operation = parsed;
+			operationToken = parsed.kind === "delete" ? REMOVE_FILE_OPERATION : MOVE_FILE_OPERATION;
+			continue;
+		}
+
+		hasLineEdit = true;
+	}
+
+	if (operation && hasLineEdit) {
+		throw new Error(
+			`Atom section ${sectionPath} mixes ${operationToken} with line edits; ${REMOVE_FILE_OPERATION} and ${MOVE_FILE_OPERATION} must be the only operation in their section.`,
+		);
+	}
+
+	return operation;
+}
+
+function hasAtomHeaderLine(input: string): boolean {
+	const stripped = input.startsWith("\uFEFF") ? input.slice(1) : input;
+	return stripped.split("\n").some(rawLine => rawLine.replace(/\r$/, "").startsWith(FILE_HEADER_PREFIX));
+}
+
+function containsRecognizableAtomOperations(input: string): boolean {
+	for (const rawLine of input.split("\n")) {
+		const line = rawLine.replace(/\r$/, "");
+		if (line.length === 0) continue;
+		if (line[0] === "+") return true;
+		if (line === "$" || line === "^") return true;
+		if (/^- ?[1-9]\d*[a-z]{2}(?: .*)?$/.test(line)) return true;
+		if (/^@?[1-9]\d*[a-z]{2}(?:[ \t]*[=|].*)?$/.test(line)) return true;
+		if (/^@@ (?:BOF|EOF|(?:- ?)?[1-9]\d*[a-z]{2}(?:[ \t]*[=|].*)?)$/.test(line)) return true;
+	}
+	return false;
+}
+
+function stripLeadingBlankLines(input: string): string {
+	const stripped = input.startsWith("\uFEFF") ? input.slice(1) : input;
+	const lines = stripped.split("\n");
+	while (lines.length > 0 && isBlankHeaderPreamble(lines[0] ?? "")) {
+		lines.shift();
+	}
+	return lines.join("\n");
+}
+
+function normalizeFallbackInput(input: string, options: SplitAtomOptions): string {
+	if (hasAtomHeaderLine(input) || !options.path || !containsRecognizableAtomOperations(input)) {
+		return input;
+	}
+	const fallbackPath = normalizeAtomPath(options.path, options.cwd);
+	if (fallbackPath.length === 0) return input;
+	return `${FILE_HEADER_PREFIX}${fallbackPath}\n${input}`;
+}
+
+function getTextContent(result: AgentToolResult<EditToolDetails>): string {
+	return result.content.map(part => (part.type === "text" ? part.text : "")).join("\n");
+}
+
+function getEditDetails(result: AgentToolResult<EditToolDetails>): EditToolDetails {
+	if (result.details === undefined) {
+		return { diff: "" };
+	}
+	return result.details;
+}
+
+/**
+ * Split the wire-format `input` string into `{ path, diff }`. The first
+ * non-empty line MUST be `---<path>` or `--- <path>`. Tolerates a leading BOM.
+ */
+export function splitAtomInput(input: string, options: SplitAtomOptions = {}): { path: string; diff: string } {
+	const [section] = splitAtomInputs(input, options);
+	return section;
+}
+
+export function splitAtomInputs(input: string, options: SplitAtomOptions = {}): AtomInputSection[] {
+	const stripped = stripLeadingBlankLines(normalizeFallbackInput(input, options));
+	const lines = stripped.split("\n");
+	const firstLine = (lines[0] ?? "").replace(/\r$/, "");
+	if (!firstLine.startsWith(FILE_HEADER_PREFIX)) {
+		throw new Error(
+			`atom input must begin with "${FILE_HEADER_PREFIX}<path>" on the first non-blank line; got: ${JSON.stringify(
+				firstLine.slice(0, 120),
+			)}`,
+		);
+	}
+
+	const sections: AtomInputSection[] = [];
+	let currentPath = "";
+	let currentLines: string[] = [];
+	const flush = () => {
+		if (currentPath.length === 0) return;
+		const wholeFileOperation = getAtomWholeFileOperation(currentPath, currentLines, options.cwd);
+		sections.push({
+			path: currentPath,
+			diff: currentLines.join("\n"),
+			...(wholeFileOperation ? { wholeFileOperation } : {}),
+		});
+		currentLines = [];
+	};
+
+	for (const rawLine of lines) {
+		const line = rawLine.replace(/\r$/, "");
+		const headerPath = parseAtomHeaderLine(line, options.cwd);
+		if (headerPath !== null) {
+			flush();
+			currentPath = headerPath;
+			continue;
+		}
+		currentLines.push(rawLine);
+	}
+	flush();
+	return sections;
+}
+
+// ═════════════════════════════════════════════════════════════════════════════
 // Executor
 // ═══════════════════════════════════════════════════════════════════════════
 
 export interface ExecuteAtomSingleOptions {
 	session: ToolSession;
-	path: string;
-	edits: AtomToolEdit[];
+	input: string;
+	path?: string;
 	signal?: AbortSignal;
 	batchRequest?: LspBatchRequest;
 	writethrough: WritethroughCallback;
 	beginDeferredDiagnosticsForPath: (path: string) => WritethroughDeferredHandle;
 }
 
-export async function executeAtomSingle(
-	options: ExecuteAtomSingleOptions,
-): Promise<AgentToolResult<EditToolDetails, typeof atomEditParamsSchema>> {
-	const { session, path, edits, signal, batchRequest, writethrough, beginDeferredDiagnosticsForPath } = options;
+interface ReadAtomFileResult {
+	exists: boolean;
+	rawContent: string;
+}
 
-	const contentEdits = edits.flatMap((edit, i) => resolveAtomToolEdit(edit, i));
+async function readAtomFile(absolutePath: string): Promise<ReadAtomFileResult> {
+	try {
+		return { exists: true, rawContent: await Bun.file(absolutePath).text() };
+	} catch (error) {
+		if (isEnoent(error)) return { exists: false, rawContent: "" };
+		throw error;
+	}
+}
 
-	enforcePlanModeWrite(session, path, { op: "update" });
+function hasAnchorScopedEdit(edits: AtomEdit[]): boolean {
+	return edits.some(edit => edit.kind === "set" || edit.kind === "delete" || edit.cursor.kind === "anchor");
+}
 
-	if (path.endsWith(".ipynb") && contentEdits.length > 0) {
-		throw new Error("Cannot edit Jupyter notebooks with the Edit tool. Use the NotebookEdit tool instead.");
+function formatNoChangeDiagnostic(path: string, result: AtomApplyResult): string {
+	let diagnostic = `Edits to ${path} resulted in no changes being made.`;
+	if (result.noopEdits && result.noopEdits.length > 0) {
+		const details = result.noopEdits
+			.map(e => {
+				const preview =
+					e.current.length > 0
+						? `\n  current: ${JSON.stringify(e.current.length > 200 ? `${e.current.slice(0, 200)}…` : e.current)}`
+						: "";
+				return `Edit ${e.editIndex} (${e.loc}): ${e.reason}.${preview}`;
+			})
+			.join("\n");
+		diagnostic += `\n${details}`;
 	}
+	return diagnostic;
+}
 
-	const absolutePath = resolvePlanPath(session, path);
+async function executeAtomWholeFileOperation(
+	options: ExecuteAtomSingleOptions & AtomInputSection & { wholeFileOperation: AtomWholeFileOperation },
+): Promise<AgentToolResult<EditToolDetails, typeof atomEditParamsSchema>> {
+	const { session, path: sectionPath, wholeFileOperation } = options;
+	const absolutePath = resolvePlanPath(session, sectionPath);
 
-	const sourceFile = Bun.file(absolutePath);
-	const sourceExists = await sourceFile.exists();
-
-	if (!sourceExists) {
-		const lines: string[] = [];
-		for (const edit of contentEdits) {
-			if (edit.op === "append_file") {
-				lines.push(...edit.lines);
-			} else if (edit.op === "prepend_file") {
-				lines.unshift(...edit.lines);
-			} else {
-				throw new Error(`File not found: ${path}`);
-			}
-		}
+	if (sectionPath.endsWith(".ipynb")) {
+		throw new Error("Cannot edit Jupyter notebooks with the Edit tool. Use the NotebookEdit tool instead.");
+	}
 
-		await Bun.write(absolutePath, lines.join("\n"));
-		invalidateFsScanAfterWrite(absolutePath);
+	if (wholeFileOperation.kind === "delete") {
+		enforcePlanModeWrite(session, sectionPath, { op: "delete" });
+		await assertEditableFile(absolutePath, sectionPath);
+		try {
+			await fs.unlink(absolutePath);
+		} catch (error) {
+			if (isEnoent(error)) throw new Error(`File not found: ${sectionPath}`);
+			throw error;
+		}
+		invalidateFsScanAfterDelete(absolutePath);
 		return {
-			content: [{ type: "text", text: `Created ${path}` }],
-			details: {
-				diff: "",
-				op: "create",
-				meta: outputMeta().get(),
-			},
+			content: [{ type: "text", text: `Deleted ${sectionPath}` }],
+			details: { diff: "", op: "delete", meta: outputMeta().get() },
 		};
 	}
 
-	const rawContent = await sourceFile.text();
-	assertEditableFileContent(rawContent, path);
+	const destinationPath = wholeFileOperation.destination;
+	if (destinationPath.endsWith(".ipynb")) {
+		throw new Error("Cannot edit Jupyter notebooks with the Edit tool. Use the NotebookEdit tool instead.");
+	}
+
+	enforcePlanModeWrite(session, sectionPath, { op: "update", move: destinationPath });
+	const absoluteDestinationPath = resolvePlanPath(session, destinationPath);
+	if (absoluteDestinationPath === absolutePath) {
+		throw new Error("rename path is the same as source path");
+	}
+
+	await assertEditableFile(absolutePath, sectionPath);
+	try {
+		await fs.mkdir(path.dirname(absoluteDestinationPath), { recursive: true });
+		await fs.rename(absolutePath, absoluteDestinationPath);
+	} catch (error) {
+		if (isEnoent(error)) throw new Error(`File not found: ${sectionPath}`);
+		throw error;
+	}
+	invalidateFsScanAfterRename(absolutePath, absoluteDestinationPath);
+
+	return {
+		content: [{ type: "text", text: `Moved ${sectionPath} to ${destinationPath}` }],
+		details: { diff: "", op: "update", move: destinationPath, meta: outputMeta().get() },
+	};
+}
+
+async function executeAtomSection(
+	options: ExecuteAtomSingleOptions & AtomInputSection,
+): Promise<AgentToolResult<EditToolDetails, typeof atomEditParamsSchema>> {
+	const { session, path, diff, signal, batchRequest, writethrough, beginDeferredDiagnosticsForPath } = options;
+	if (options.wholeFileOperation) {
+		return executeAtomWholeFileOperation({ ...options, wholeFileOperation: options.wholeFileOperation });
+	}
+
+	const edits = parseAtom(diff);
+	if (edits.length === 0 && diff.trim().length > 0) {
+		throw new Error(formatNoAtomEditDiagnostic(path, diff));
+	}
+
+	enforcePlanModeWrite(session, path, { op: "update" });
+
+	if (path.endsWith(".ipynb") && edits.length > 0) {
+		throw new Error("Cannot edit Jupyter notebooks with the Edit tool. Use the NotebookEdit tool instead.");
+	}
+
+	const absolutePath = resolvePlanPath(session, path);
+	const source = await readAtomFile(absolutePath);
+	if (!source.exists && hasAnchorScopedEdit(edits)) {
+		throw new Error(`File not found: ${path}`);
+	}
+
+	if (source.exists) {
+		assertEditableFileContent(source.rawContent, path);
+	}
 
-	const { bom, text } = stripBom(rawContent);
+	const { bom, text } = stripBom(source.rawContent);
 	const originalEnding = detectLineEnding(text);
 	const originalNormalized = normalizeToLF(text);
-
-	const result = applyAtomEdits(originalNormalized, contentEdits);
+	const result = applyAtomEdits(originalNormalized, edits);
 	if (originalNormalized === result.lines) {
-		let diagnostic = `Edits to ${path} resulted in no changes being made.`;
-		if (result.noopEdits && result.noopEdits.length > 0) {
-			const details = result.noopEdits
-				.map(e => {
-					const preview =
-						e.current.length > 0
-							? `\n  current: ${JSON.stringify(e.current.length > 200 ? `${e.current.slice(0, 200)}…` : e.current)}`
-							: "";
-					return `Edit ${e.editIndex} (${e.loc}): ${e.reason}.${preview}`;
-				})
-				.join("\n");
-			diagnostic += `\n${details}`;
-		}
-		throw new Error(diagnostic);
+		throw new Error(formatNoChangeDiagnostic(path, result));
 	}
 
 	const finalContent = bom + restoreLineEndings(result.lines, originalEnding);
@@ -874,31 +1291,66 @@ export async function executeAtomSingle(
 	const meta = outputMeta()
 		.diagnostics(diagnostics?.summary ?? "", diagnostics?.messages ?? [])
 		.get();
-
-	const resultText = `Updated ${path}`;
 	const preview = buildCompactHashlineDiffPreview(diffResult.diff);
-	const summaryLine = `Changes: +${preview.addedLines} -${preview.removedLines}${
-		preview.preview ? "" : " (no textual diff preview)"
-	}`;
 	const warningsBlock = result.warnings?.length ? `\n\nWarnings:\n${result.warnings.join("\n")}` : "";
-	const previewBlock = preview.preview ? `\n\nDiff preview:\n${preview.preview}` : "";
+	const previewBlock = preview.preview ? `\n${preview.preview}` : "";
+	const resultText = preview.preview ? `${path}:` : source.exists ? `Updated ${path}` : `Created ${path}`;
 
 	return {
 		content: [
 			{
 				type: "text",
-				text: `${resultText}\n${summaryLine}${previewBlock}${warningsBlock}`,
+				text: `${resultText}${previewBlock}${warningsBlock}`,
 			},
 		],
 		details: {
 			diff: diffResult.diff,
 			firstChangedLine: result.firstChangedLine ?? diffResult.firstChangedLine,
 			diagnostics,
-			op: "update",
+			op: source.exists ? "update" : "create",
 			meta,
 		},
 	};
 }
 
-// Helpers exposed for tests / external dispatch.
-export { classifyAtomEdit, parseAnchor, resolveAtomToolEdit };
+export async function executeAtomSingle(
+	options: ExecuteAtomSingleOptions,
+): Promise<AgentToolResult<EditToolDetails, typeof atomEditParamsSchema>> {
+	const sections = splitAtomInputs(options.input, { cwd: options.session.cwd, path: options.path });
+	if (sections.length === 1) {
+		const [section] = sections;
+		return executeAtomSection({ ...options, ...section });
+	}
+
+	const results = [];
+	for (const section of sections) {
+		results.push({
+			path: section.path,
+			result: await executeAtomSection({ ...options, ...section }),
+		});
+	}
+
+	return {
+		content: [
+			{
+				type: "text",
+				text: results.map(({ result }) => getTextContent(result)).join("\n\n"),
+			},
+		],
+		details: {
+			diff: results.map(({ result }) => getEditDetails(result).diff).join("\n"),
+			perFileResults: results.map(({ path, result }) => {
+				const details = getEditDetails(result);
+				return {
+					path,
+					diff: details.diff,
+					firstChangedLine: details.firstChangedLine,
+					diagnostics: details.diagnostics,
+					op: details.op,
+					move: details.move,
+					meta: details.meta,
+				};
+			}),
+		},
+	};
+}