@oh-my-pi/hashline 15.13.0 → 15.13.2

package/src/apply.ts

@@ -443,6 +443,50 @@ function describeBoundaryRepair(group: ReplacementGroup, action: string): string
 	);
 }
 
+/**
+ * A single-sided boundary echo in an otherwise delimiter-balanced *multi-line*
+ * replacement: the payload's leading XOR trailing edge exactly restates the
+ * surviving line(s) just outside the range — the off-by-one "range one line
+ * short of the keeper I retyped" mistake (e.g. att: payload ends with
+ * `const x = [];` and line B+1 is the same `const x = [];`). Two-sided echoes
+ * are handled by {@link findBoundaryEcho}; delimiter-imbalanced one-sided echoes
+ * by {@link findDuplicateSuffix}/{@link findDuplicatePrefix}.
+ *
+ * Scoped to multi-line ranges (a construct rewrite) on purpose: a single-line
+ * `replace N..N` expanding into several lines is an *expansion* where every
+ * payload line is intentional new content, so a payload line that happens to
+ * equal a neighbor stays — only a genuine block rewrite retypes a boundary
+ * keeper by mistake. The dropped lines must be delimiter-neutral so removing the
+ * duplicate keeps the already-balanced result balanced, and must not consume the
+ * whole payload.
+ */
+function findOneSidedBoundaryEcho(
+	group: ReplacementGroup,
+	fileLines: readonly string[],
+): { side: "leading" | "trailing"; count: number } | undefined {
+	if (group.deleteIndices.length <= 1) return undefined;
+	const leading = countDuplicateLeadingBoundaryLines(group, fileLines);
+	const trailing = countDuplicateTrailingBoundaryLines(group, fileLines);
+	if (leading > 0 === trailing > 0) return undefined;
+	const side = leading > 0 ? "leading" : "trailing";
+	const count = leading > 0 ? leading : trailing;
+	if (count >= group.payload.length) return undefined;
+	const echoLines =
+		side === "leading" ? group.payload.slice(0, count) : group.payload.slice(group.payload.length - count);
+	if (!balanceIsZero(computeDelimiterBalance(echoLines))) return undefined;
+	return { side, count };
+}
+
+function describeOneSidedEchoRepair(group: ReplacementGroup, side: "leading" | "trailing", count: number): string {
+	const where = side === "leading" ? "above" : "below";
+	return (
+		`Auto-repaired a replacement boundary echo at line ${group.startLine}: ` +
+		`dropped ${count} ${side} payload line(s) identical to the surviving line(s) just ${where} the range. ` +
+		`The range was one line short of the content you retyped — issue the payload as the final content for the ` +
+		`selected range only, and widen the range to consume any keeper you restate.`
+	);
+}
+
 /**
  * Normalize replacement groups so common off-by-one boundaries do not duplicate
  * unchanged surrounding lines or structural closers. Returns the repaired edit
@@ -481,6 +525,16 @@ function repairReplacementBoundaries(
 			computeDelimiterBalance(fileLines.slice(group.startLine - 1, group.endLine)),
 		);
 		if (balanceIsZero(delta)) {
+			const oneSided = findOneSidedBoundaryEcho(group, fileLines);
+			if (oneSided) {
+				warnings.push(describeOneSidedEchoRepair(group, oneSided.side, oneSided.count));
+				const trimmed =
+					oneSided.side === "leading"
+						? inserts.slice(oneSided.count)
+						: inserts.slice(0, inserts.length - oneSided.count);
+				out.push(...trimmed, ...deletes);
+				continue;
+			}
 			out.push(...inserts, ...deletes);
 			continue;
 		}
@@ -538,7 +592,7 @@ function repairReplacementBoundaries(
 // content lines are never crossed) places the body at the depth its
 // indentation names.
 //
-// Inward (block-lowered inserts only): `insert after block N:` anchors on the
+// Inward (block-lowered inserts only): `insert_after_block N:` anchors on the
 // resolved block's closing line, but a body indented deeper than that closer
 // claims a depth inside the block — the common misreading of the op as
 // "append at the end of block N's body". Sliding the landing point backward
@@ -576,7 +630,7 @@ interface AfterInsertGroup {
 	anchor: number;
 	/** Indices into the edit list, in patch order. */
 	members: number[];
-	/** First line of the resolved block when lowered from `insert after block N:`. */
+	/** First line of the resolved block when lowered from `insert_after_block N:`. */
 	blockStart?: number;
 }
 
@@ -676,7 +730,7 @@ function resolveInwardLanding(
 /**
  * Slide mis-anchored after-insert hunks to the depth their body indentation
  * claims: outward past the structural closer lines that follow the anchor
- * when the body is shallower, or — for `insert after block N:` lowerings —
+ * when the body is shallower, or — for `insert_after_block N:` lowerings —
  * inward across the block's trailing closers when the body is deeper than
  * the block's closing line. Returns the corrected edit list plus one warning
  * per shifted hunk.

package/src/block.ts

@@ -1,6 +1,6 @@
 /**
- * Expand deferred block edits (`replace block N:` / `delete block N` /
- * `insert after block N:`) into concrete inserts + deletes.
+ * Expand deferred block edits (`replace_block N:` / `delete_block N` /
+ * `insert_after_block N:`) into concrete inserts + deletes.
  *
  * The hashline parser cannot expand a block edit on its own — the line span is
  * unknown until file text + path (→ language) are available. This transform
@@ -15,6 +15,7 @@
 import { STRUCTURAL_CLOSER_RE } from "./apply";
 import {
 	BLOCK_RESOLVER_UNAVAILABLE,
+	blockSingleLineMessage,
 	blockUnresolvedMessage,
 	insertAfterBlockCloserLoweredWarning,
 	insertAfterBlockUnresolvedLoweredWarning,
@@ -28,7 +29,7 @@ export interface ResolveBlockEditsOptions {
 	 * `blockUnresolvedMessage` error — used by the authoritative apply + final
 	 * preview paths. `"drop"` silently skips the edit — used by the streaming
 	 * preview, where a half-written file or transient parse error must not
-	 * throw. Unresolvable `insert after block N:` edits never reach this: they
+	 * throw. Unresolvable `insert_after_block N:` edits never reach this: they
 	 * are lowered to plain `insert after N:` with a warning.
 	 */
 	onUnresolved?: "throw" | "drop";
@@ -41,7 +42,7 @@ export interface ResolveBlockEditsOptions {
 	onResolved?: (resolution: BlockResolution) => void;
 	/**
 	 * Invoked once per diagnostic produced while resolving — currently the
-	 * `insert after block N:` lowerings (closer anchor or unresolvable block).
+	 * `insert_after_block N:` lowerings (closer anchor or unresolvable block).
 	 * Hosts should surface these on the apply result's `warnings`.
 	 */
 	onWarning?: (message: string) => void;
@@ -81,7 +82,7 @@ export function resolveBlockEdits(
 		const op = edit.mode === "insert_after" ? "insert_after" : edit.payloads.length === 0 ? "delete" : "replace";
 		const span = resolver ? resolver({ path, text, line: edit.anchor.line }) : null;
 		if (span === null) {
-			// `insert after block N:` never fails the patch — lower it to plain
+			// `insert_after_block N:` never fails the patch — lower it to plain
 			// `insert after N:` with a warning instead. Two flavors:
 			// - anchored on a pure closing-delimiter line: no block begins
 			//   there, but line N IS the end of one, and "after the end of the
@@ -110,6 +111,15 @@ export function resolveBlockEdits(
 				}`,
 			);
 		}
+		if (span.start === span.end) {
+			// A single-line block resolution means line N is a bare statement, not
+			// the opening line of a multi-line construct — the common mis-anchor
+			// that lands a body in the wrong scope (e.g. between a `case` body line
+			// and its `break;`). The plain op is exact for one line, so reject and
+			// point at it; drop instead on the lenient preview path.
+			if (onUnresolved === "drop") continue;
+			throw new Error(`line ${edit.lineNum}: ${blockSingleLineMessage(edit.anchor.line, op)}`);
+		}
 		options.onResolved?.({
 			anchorLine: edit.anchor.line,
 			start: span.start,
@@ -138,7 +148,7 @@ export function resolveBlockEdits(
 		// Mirror the parser's `replace start..end:` expansion exactly: one
 		// `before_anchor` replacement insert per payload row at `span.start`,
 		// then one delete per line across `[span.start, span.end]`. An empty
-		// `payloads` (from `delete block N`) emits no inserts — a pure deletion.
+		// `payloads` (from `delete_block N`) emits no inserts — a pure deletion.
 		for (const payload of edit.payloads) {
 			const cursor: Cursor = { kind: "before_anchor", anchor: { line: span.start } };
 			resolved.push({

package/src/format.ts

@@ -14,22 +14,25 @@ export const HL_FILE_SUFFIX = "]";
 export const HL_PAYLOAD_REPLACE = "+";
 
 /** Hunk-header keyword for concrete line replacement. */
-export const HL_REPLACE_KEYWORD = "replace";
-/** Hunk-header sub-keyword: `replace block N:` resolves N to a tree-sitter block range. */
-export const HL_BLOCK_KEYWORD = "block";
+export const HL_REPLACE_KEYWORD = "SWAP";
 /** Hunk-header keyword for concrete line deletion. */
-export const HL_DELETE_KEYWORD = "delete";
+export const HL_DELETE_KEYWORD = "DEL";
 /** Hunk-header keyword for insertion operations. */
-export const HL_INSERT_KEYWORD = "insert";
+export const HL_INSERT_KEYWORD = "INS";
 /** Insert position keyword for inserting before a concrete line. */
-export const HL_INSERT_BEFORE = "before";
+export const HL_INSERT_BEFORE = "PRE";
 /** Insert position keyword for inserting after a concrete line. */
-export const HL_INSERT_AFTER = "after";
+export const HL_INSERT_AFTER = "POST";
 /** Insert position keyword for inserting at the start of the file. */
-export const HL_INSERT_HEAD = "head";
+export const HL_INSERT_HEAD = "HEAD";
 /** Insert position keyword for inserting at the end of the file. */
-export const HL_INSERT_TAIL = "tail";
-/** Hunk-header terminator for body-bearing operations. */
+export const HL_INSERT_TAIL = "TAIL";
+/** Hunk-header keyword: `SWAP.BLK N:` resolves N to a tree-sitter block range and replaces its span. */
+export const HL_REPLACE_BLOCK_KEYWORD = "SWAP.BLK";
+/** Hunk-header keyword: `DEL.BLK N` resolves N to a tree-sitter block range and deletes its span. */
+export const HL_DELETE_BLOCK_KEYWORD = "DEL.BLK";
+/** Hunk-header keyword: `INS.BLK.POST N:` inserts after the last line of the tree-sitter block at N. */
+export const HL_INSERT_AFTER_BLOCK_KEYWORD = "INS.BLK.POST";
 export const HL_HEADER_COLON = ":";
 
 /** Separator between a hashline file path and its opaque snapshot tag. */
@@ -65,13 +68,13 @@ export function formatDeleteHeader(start: number, end = start): string {
 export function formatInsertHeader(cursor: Cursor): string {
 	switch (cursor.kind) {
 		case "before_anchor":
-			return `${HL_INSERT_KEYWORD} ${HL_INSERT_BEFORE} ${cursor.anchor.line}${HL_HEADER_COLON}`;
+			return `${HL_INSERT_KEYWORD}.${HL_INSERT_BEFORE} ${cursor.anchor.line}${HL_HEADER_COLON}`;
 		case "after_anchor":
-			return `${HL_INSERT_KEYWORD} ${HL_INSERT_AFTER} ${cursor.anchor.line}${HL_HEADER_COLON}`;
+			return `${HL_INSERT_KEYWORD}.${HL_INSERT_AFTER} ${cursor.anchor.line}${HL_HEADER_COLON}`;
 		case "bof":
-			return `${HL_INSERT_KEYWORD} ${HL_INSERT_HEAD}${HL_HEADER_COLON}`;
+			return `${HL_INSERT_KEYWORD}.${HL_INSERT_HEAD}${HL_HEADER_COLON}`;
 		case "eof":
-			return `${HL_INSERT_KEYWORD} ${HL_INSERT_TAIL}${HL_HEADER_COLON}`;
+			return `${HL_INSERT_KEYWORD}.${HL_INSERT_TAIL}${HL_HEADER_COLON}`;
 	}
 }
 

package/src/grammar.lark

@@ -12,13 +12,13 @@ replace_hunk: replace_anchor LF emit_op*
 replace_block_hunk: replace_block_anchor LF emit_op+
 insert_hunk: insert_anchor LF emit_op+
 insert_block_hunk: insert_block_anchor LF emit_op+
-delete_hunk: "delete " header_range LF
-delete_block_hunk: "delete block " LID LF
-replace_anchor: "replace " header_range ":"
-replace_block_anchor: "replace block " LID ":"
-insert_anchor:  "insert " insert_pos ":"
-insert_block_anchor: "insert after block " LID ":"
-insert_pos: "before " LID | "after " LID | "head" | "tail"
+delete_hunk: "DEL " header_range LF
+delete_block_hunk: "DEL.BLK " LID LF
+replace_anchor: "SWAP " header_range ":"
+replace_block_anchor: "SWAP.BLK " LID ":"
+insert_anchor:  "INS." insert_pos ":"
+insert_block_anchor: "INS.BLK.POST " LID ":"
+insert_pos: "PRE " LID | "POST " LID | "HEAD" | "TAIL"
 emit_op: "+" /(.*)/ LF
 
 header_range: LID ".." LID

package/src/input.ts

@@ -273,7 +273,7 @@ export class PatchSection {
 	get hasAnchorScopedEdit(): boolean {
 		return this.edits.some(edit => {
 			if (edit.kind === "delete") return true;
-			// A `replace block N:` edit is anchored to concrete content on line N.
+			// A `replace_block N:` edit is anchored to concrete content on line N.
 			if (edit.kind === "block") return true;
 			return edit.cursor.kind === "before_anchor" || edit.cursor.kind === "after_anchor";
 		});
@@ -305,7 +305,7 @@ export class PatchSection {
 	 * method directly when you've already validated the file content and
 	 * just want the result.
 	 *
-	 * `blockResolver` resolves any `replace block N:` edits against `text`; an
+	 * `blockResolver` resolves any `replace_block N:` edits against `text`; an
 	 * unresolvable block throws (this is the final, authoritative preview path).
 	 */
 	applyTo(text: string, blockResolver?: BlockResolver): ApplyResult {
@@ -331,7 +331,7 @@ export class PatchSection {
 	 * empty-payload edit. Intended for incremental diff previews; the writer
 	 * path should always use {@link applyTo}.
 	 *
-	 * `blockResolver` resolves any `replace block N:` edits against `text`; an
+	 * `blockResolver` resolves any `replace_block N:` edits against `text`; an
 	 * unresolvable block is silently dropped so a half-written file does not
 	 * throw mid-stream.
 	 */

package/src/messages.ts

@@ -44,11 +44,10 @@ export const ABORT_MARKER = "*** Abort";
 
 /** Two consecutive hunks targeted the exact same concrete range. */
 export const REPLACE_PAIR_COALESCED_WARNING =
-	"Two hunks targeted the same range; kept only the second. One `replace N..M:` hunk per range — the body is the final content, never old+new.";
+	"Two hunks targeted the same range; kept only the second. One `SWAP N..M:` hunk per range — the body is the final content, never old+new.";
 
 /** Bare bodyless hunk followed by an overlapping concrete hunk. */
-export const REPLACE_PAIR_COALESCED_OVERLAP_WARNING =
-	"Dropped a bare hunk overlapped by the concrete hunk after it. One `replace N..M:` hunk per range — the body is the final content, never old+new.";
+("Dropped a bare hunk overlapped by the concrete hunk after it. One `SWAP N..M:` hunk per range — the body is the final content, never old+new.");
 
 /** Bare body rows auto-converted to literal `+` rows. */
 export const BARE_BODY_AUTO_PIPED_WARNING =
@@ -59,17 +58,16 @@ export const MINUS_ROW_REJECTED =
 	"`-` rows are not valid; the range already names the lines being changed. For a literal `-` line, write `+-…`.";
 
 /** Replace hunk with no body. */
-export const EMPTY_REPLACE = "`replace N..M:` needs at least one `+TEXT` body row. To delete lines, use `delete N..M`.";
+export const EMPTY_REPLACE = "`SWAP N..M:` needs at least one `+TEXT` body row. To delete lines, use `DEL N..M`.";
 
-/** `replace block N:` hunk with no body. */
-export const EMPTY_BLOCK =
-	"`replace block N:` needs at least one `+TEXT` body row. To delete a block, use `delete block N`.";
+/** `replace_block N:` hunk with no body. */
+export const EMPTY_BLOCK = "`SWAP.BLK N:` needs at least one `+TEXT` body row. To delete a block, use `DEL.BLK N`.";
 
 /**
  * Block-anchored replace/delete could not resolve to a syntactic block
  * (unsupported language, blank/out-of-range line, no node beginning on N, or
  * parse error). Appends a {@link formatAnchoredContext} preview when
- * `fileLines` is given. `insert after block N:` never reaches this — it is
+ * `fileLines` is given. `insert_after_block N:` never reaches this — it is
  * lowered to plain `insert after N:` instead (see
  * {@link insertAfterBlockUnresolvedLoweredWarning}).
  */
@@ -78,8 +76,8 @@ export function blockUnresolvedMessage(
 	op: "replace" | "delete" = "replace",
 	fileLines?: readonly string[],
 ): string {
-	const phrase = op === "delete" ? `delete block ${line}` : `replace block ${line}:`;
-	const fallback = op === "delete" ? `delete ${line}..M` : `replace ${line}..M:`;
+	const phrase = op === "delete" ? `DEL.BLK ${line}` : `SWAP.BLK ${line}:`;
+	const fallback = op === "delete" ? `DEL ${line}..M` : `SWAP ${line}..M:`;
 	let message =
 		`\`${phrase}\` could not resolve a syntactic block beginning on line ${line} ` +
 		`(unsupported language, blank/closer line, or parse error). Use \`${fallback}\` with explicit lines.`;
@@ -92,42 +90,41 @@ export function blockUnresolvedMessage(
 
 /** Block-anchored edit reached a path with no {@link BlockResolver} wired in — a host-configuration bug. */
 export const BLOCK_RESOLVER_UNAVAILABLE =
-	"`replace block`/`delete block`/`insert after block` are not available here (no block resolver configured). Use a concrete line range.";
+	"`SWAP.BLK`/`DEL.BLK`/`INS.BLK.POST` are not available here (no block resolver configured). Use a concrete line range.";
 
 /**
- * `insert after block N:` anchored on a closing-delimiter line, lowered to
+ * `insert_after_block N:` anchored on a closing-delimiter line, lowered to
  * plain `insert after N:` — the closer ends a block, and inserting after it
  * is exactly what the plain form does.
  */
 export function insertAfterBlockCloserLoweredWarning(line: number): string {
-	return `\`insert after block ${line}:\` anchors on a closing delimiter, so it was applied as plain \`insert after ${line}:\`. Anchor on the line that OPENS the construct.`;
+	return `\`INS.BLK.POST ${line}:\` anchors on a closing delimiter, so it was applied as plain \`INS.POST ${line}:\`. Anchor on the line that OPENS the construct.`;
 }
 
 /**
- * `insert after block N:` anchor unresolvable (unsupported language, blank
+ * `insert_after_block N:` anchor unresolvable (unsupported language, blank
  * line, parse error, or no resolver), lowered to plain `insert after N:` —
  * applying with a warning beats failing the patch.
  */
 export function insertAfterBlockUnresolvedLoweredWarning(line: number): string {
-	return `\`insert after block ${line}:\` could not resolve a syntactic block on line ${line}, so it was applied as plain \`insert after ${line}:\`. Verify the landing line; anchor on a line that OPENS a construct.`;
+	return `\`INS.BLK.POST ${line}:\` could not resolve a syntactic block on line ${line}, so it was applied as plain \`INS.POST ${line}:\`. Verify the landing line; anchor on a line that OPENS a construct.`;
 }
 
 /**
- * Internal invariant: `applyEdits` received an unresolved `replace block N:`
+ * Internal invariant: `applyEdits` received an unresolved `replace_block N:`
  * edit; `resolveBlockEdits` must run first. Wiring bug, not authored input.
  */
 export const UNRESOLVED_BLOCK_INTERNAL =
-	"internal error: unresolved `replace block` edit reached the applier (resolveBlockEdits was not run).";
+	"internal error: unresolved `SWAP.BLK` edit reached the applier (resolveBlockEdits was not run).";
 
 /** Delete hunk received a body row. */
-export const DELETE_TAKES_NO_BODY = "`delete N..M` does not take body rows. Remove the body, or use `replace N..M:`.";
+export const DELETE_TAKES_NO_BODY = "`DEL N..M` does not take body rows. Remove the body, or use `SWAP N..M:`.";
 
-/** `delete block N` hunk received a body row. */
-export const DELETE_BLOCK_TAKES_NO_BODY =
-	"`delete block N` does not take body rows. Remove the body, or use `replace block N:`.";
+/** `delete_block N` hunk received a body row. */
+export const DELETE_BLOCK_TAKES_NO_BODY = "`DEL.BLK N` does not take body rows. Remove the body, or use `SWAP.BLK N:`.";
 
 /** Insert hunk with no body. */
-export const EMPTY_INSERT = "`insert` needs at least one `+TEXT` body row.";
+export const EMPTY_INSERT = "`INS` needs at least one `+TEXT` body row.";
 
 /**
  * `insert after` body indented shallower than the anchor: the landing slid
@@ -135,16 +132,16 @@ export const EMPTY_INSERT = "`insert` needs at least one `+TEXT` body row.";
  * I read instead of after the block" mistake.
  */
 export function afterInsertLandingShiftWarning(anchorLine: number, landingLine: number, crossed: number): string {
-	return `insert after ${anchorLine}: body indented shallower than the anchor, so the landing moved past ${crossed} closing line${crossed === 1 ? "" : "s"} to after line ${landingLine}. For the deeper position inside the block, re-issue with the body indented to match.`;
+	return `INS.POST ${anchorLine}: body indented shallower than the anchor, so the landing moved past ${crossed} closing line${crossed === 1 ? "" : "s"} to after line ${landingLine}. For the deeper position inside the block, re-issue with the body indented to match.`;
 }
 
 /**
- * `insert after block N:` body indented deeper than the block's closer: the
+ * `insert_after_block N:` body indented deeper than the block's closer: the
  * landing was pulled inside the block — a deeper body almost always means
  * "append inside the block's body".
  */
 export function blockInsertLandingShiftWarning(blockStart: number, closerLine: number, landingLine: number): string {
-	return `insert after block ${blockStart}: body indented deeper than closing line ${closerLine}, so it was placed inside the block, after line ${landingLine}. \`insert after block\` lands AFTER the block at sibling depth — if inside was intended, use plain \`insert after ${closerLine}:\`.`;
+	return `INS.BLK.POST ${blockStart}: body indented deeper than closing line ${closerLine}, so it was placed inside the block, after line ${landingLine}. \`INS.BLK.POST\` lands AFTER the block at sibling depth — if inside was intended, use plain \`INS.POST ${closerLine}:\`.`;
 }
 
 /** `Recovery`: an external write matched a cached snapshot. */
@@ -170,7 +167,7 @@ export const RECOVERY_SESSION_REPLAY_WARNING =
  * onto live content and warn instead of hard-failing.
  */
 export const HEADTAIL_DRIFT_WARNING =
-	"Applied the `insert head:`/`insert tail:` edit despite a stale snapshot tag (file changed since your read) — head/tail position is content-independent. Re-read if the drift was unexpected.";
+	"Applied the `INS.HEAD:`/`INS.TAIL:` edit despite a stale snapshot tag (file changed since your read) — head/tail position is content-independent. Re-read if the drift was unexpected.";
 
 /**
  * Section omitted the mandatory snapshot tag. Shared by the apply
@@ -179,3 +176,60 @@ export const HEADTAIL_DRIFT_WARNING =
 export function missingSnapshotTagMessage(sectionPath: string): string {
 	return `Missing hashline snapshot tag for ${sectionPath}; use \`${HL_FILE_PREFIX}${sectionPath}${HL_FILE_HASH_SEP}tag${HL_FILE_SUFFIX}\` from your latest read/search output. To create a new file, use the write tool.`;
 }
+
+/** Compress a line list into a sorted `1-4, 7, 10-12` range string. */
+function formatLineRanges(lines: readonly number[]): string {
+	const sorted = [...new Set(lines)].sort((a, b) => a - b);
+	if (sorted.length === 0) return "";
+	const parts: string[] = [];
+	let start = sorted[0];
+	let prev = sorted[0];
+	for (let i = 1; i <= sorted.length; i++) {
+		const current = sorted[i];
+		if (current === prev + 1) {
+			prev = current;
+			continue;
+		}
+		parts.push(start === prev ? `${start}` : `${start}-${prev}`);
+		start = current;
+		prev = current;
+	}
+	return parts.join(", ");
+}
+
+/**
+ * An anchored edit referenced lines the read that minted the cited tag never
+ * displayed (a partial range, or a structural summary that collapsed bodies).
+ * Editing lines you have not read is the off-by-memory failure that mangles
+ * files; reject and make the model re-read those exact lines first.
+ */
+export function unseenLinesMessage(sectionPath: string, unseenLines: readonly number[], tag: string): string {
+	return (
+		`This edit targets line(s) ${formatLineRanges(unseenLines)} of ${sectionPath} that were not shown in the ` +
+		`read/search output for ${HL_FILE_PREFIX}${sectionPath}${HL_FILE_HASH_SEP}${tag}${HL_FILE_SUFFIX} — a partial ` +
+		`range, a search hit, or a structural summary that collapsed bodies was displayed, not those exact lines. ` +
+		`Re-read those lines, then re-issue the edit against the fresh tag. NEVER author hunks against line numbers ` +
+		`you have not seen in the current snapshot.`
+	);
+}
+
+/** Op kind of a deferred block edit, for {@link blockSingleLineMessage}. */
+export type BlockOp = "replace" | "delete" | "insert_after";
+
+/**
+ * A `replace_block`/`delete_block`/`insert_after_block` anchor resolved to a
+ * single line — almost always a bare statement the model mis-anchored, not a
+ * multi-line construct. The plain op is unambiguous for one line; the block
+ * form only earns its keep when it spares counting a closing line you cannot
+ * see. Reject and point at both fixes.
+ */
+export function blockSingleLineMessage(line: number, op: BlockOp): string {
+	const blockForm = op === "insert_after" ? "INS.BLK.POST" : op === "delete" ? "DEL.BLK" : "SWAP.BLK";
+	const plainForm =
+		op === "insert_after" ? `INS.POST ${line}:` : op === "delete" ? `DEL ${line}` : `SWAP ${line}..${line}:`;
+	return (
+		`\`${blockForm} ${line}\` resolved a single-line block — line ${line} is a bare statement, not the opening line ` +
+		`of a multi-line construct. For that one line use \`${plainForm}\`; to act on an enclosing construct, anchor ${blockForm} ` +
+		`on the line that OPENS it (e.g. its \`function\`/\`if\`/\`case\` header), never a statement inside it.`
+	);
+}

package/src/parser.ts

@@ -52,33 +52,33 @@ function detectApplyPatchContamination(text: string, _hasPending: boolean): stri
 		return (
 			`apply_patch sentinel ${JSON.stringify(preview)} is not valid in hashline. ` +
 			"File sections start with `[path#HASH]` (no `Update File:` / `Add File:` keyword). " +
-			"Use `replace N..M:`, `delete N..M`, or `insert before|after|head|tail:` ops."
+			"Use `SWAP N..M:`, `DEL N..M`, or `INS.PRE|POST|HEAD|TAIL:` ops."
 		);
 	}
 	if (/^@@\s+[-+]?\d+,\d+\s+[-+]?\d+,\d+\s+@@/.test(trimmed)) {
 		return (
 			"unified-diff hunk header (`@@ -N,M +N,M @@`) is not valid in hashline. " +
-			"Use `replace N..M:`, `delete N..M`, or `insert before|after|head|tail:` ops."
+			"Use `SWAP N..M:`, `DEL N..M`, or `INS.PRE|POST|HEAD|TAIL:` ops."
 		);
 	}
 	if (trimmed.startsWith("@@")) {
 		const preview = trimmed.length > 48 ? `${trimmed.slice(0, 48)}…` : trimmed;
 		return (
 			`\`@@\`-bracketed hunk header ${JSON.stringify(preview)} is not valid in hashline. ` +
-			"Drop the `@@ ... @@` brackets and write a verb header such as `replace N..M:`."
+			"Drop the `@@ ... @@` brackets and write a verb header such as `SWAP N..M:`."
 		);
 	}
-	if (/^delete\s+[1-9]\d*(?:\s*(?:\.\.|-|…|\s)\s*[1-9]\d*)?\s*:/.test(trimmed)) {
-		return "`delete N..M` has no colon and no body. Remove the colon and body rows.";
+	if (/^DEL\s+[1-9]\d*(?:\s*(?:\.\.|-|…|\s)\s*[1-9]\d*)?\s*:/.test(trimmed)) {
+		return "`DEL N..M` has no colon and no body. Remove the colon and body rows.";
 	}
 	if (/^[1-9]\d*\s*$/.test(trimmed)) {
-		return `hunk headers need a verb. Use \`replace ${trimmed}..${trimmed}:\` to replace, or \`delete ${trimmed}\` to delete.`;
+		return `hunk headers need a verb. Use \`SWAP ${trimmed}..${trimmed}:\` to replace, or \`DEL ${trimmed}\` to delete.`;
 	}
 	const bareRange = /^([1-9]\d*)\s*[-. …]+\s*([1-9]\d*)\s*:?$/.exec(trimmed);
 	if (bareRange !== null) {
 		return (
 			`bare range hunk header ${JSON.stringify(trimmed)} is not valid. ` +
-			`Hunk headers need a verb: write \`replace ${bareRange[1]}..${bareRange[2]}:\` or \`delete ${bareRange[1]}..${bareRange[2]}\`.`
+			`Hunk headers need a verb: write \`SWAP ${bareRange[1]}..${bareRange[2]}:\` or \`DEL ${bareRange[1]}..${bareRange[2]}\`.`
 		);
 	}
 	return null;
@@ -253,7 +253,7 @@ export class Executor {
 		if (text.trim().length === 0) return;
 		throw new Error(
 			`line ${lineNum}: payload line has no preceding hunk header. ` +
-				`Use \`replace N..M:\`, \`delete N..M\`, or \`insert before|after|head|tail:\` above the body. Got ${JSON.stringify(text)}.`,
+				`Use \`SWAP N..M:\`, \`DEL N..M\`, or \`INS.PRE|POST|HEAD|TAIL:\` above the body. Got ${JSON.stringify(text)}.`,
 		);
 	}
 

package/src/patcher.ts

@@ -28,7 +28,7 @@ import { computeFileHash, formatHashlineHeader } from "./format";
 import type { Filesystem, WriteResult } from "./fs";
 import { isNotFound } from "./fs";
 import type { Patch, PatchSection } from "./input";
-import { HEADTAIL_DRIFT_WARNING, missingSnapshotTagMessage } from "./messages";
+import { HEADTAIL_DRIFT_WARNING, missingSnapshotTagMessage, unseenLinesMessage } from "./messages";
 import { MismatchError } from "./mismatch";
 import { detectLineEnding, type LineEnding, normalizeToLF, restoreLineEndings, stripBom } from "./normalize";
 import { Recovery, type RecoveryResult } from "./recovery";
@@ -41,8 +41,8 @@ export interface PatcherOptions {
 	/** Snapshot store that minted and resolves hashline section tags. Required. */
 	snapshots: SnapshotStore;
 	/**
-	 * Resolves `replace block N:` anchors to concrete line spans via tree-sitter.
-	 * Optional: when omitted, any `replace block N:` edit throws on apply (the
+	 * Resolves `replace_block N:` anchors to concrete line spans via tree-sitter.
+	 * Optional: when omitted, any `replace_block N:` edit throws on apply (the
 	 * host did not wire a resolver). Plain line-range ops never need it.
 	 */
 	blockResolver?: BlockResolver;
@@ -73,7 +73,7 @@ export interface PatchSectionResult {
 	/** Warnings collected by the parser, applier, and (optionally) recovery. */
 	warnings: string[];
 	/**
-	 * Resolved spans for any `replace block`/`delete block` ops, present when the
+	 * Resolved spans for any `replace_block`/`delete_block` ops, present when the
 	 * apply matched the tagged content. Undefined for patches with no block ops
 	 * (and for resolutions routed through drift recovery, where numbers shift).
 	 */
@@ -112,7 +112,7 @@ export class PreparedSection {
 function hasAnchorScopedEdit(edits: readonly Edit[]): boolean {
 	return edits.some(edit => {
 		if (edit.kind === "delete") return true;
-		// A `replace block N:` edit anchors to concrete content on line N.
+		// A `replace_block N:` edit anchors to concrete content on line N.
 		if (edit.kind === "block") return true;
 		return edit.cursor.kind === "before_anchor" || edit.cursor.kind === "after_anchor";
 	});
@@ -341,6 +341,22 @@ export class Patcher {
 	#recordFullSnapshot(canonicalPath: string, normalized: string): string {
 		return this.snapshots.record(canonicalPath, normalized);
 	}
+
+	/**
+	 * Reject an anchored edit that references a line the read which minted
+	 * `expected` never displayed. The snapshot's `seenLines` is the set of
+	 * 1-indexed lines a producer (read/search) actually showed under that tag;
+	 * absent or empty means no provenance was recorded, so the edit applies as
+	 * before. Only runs on the no-drift path, where anchor line numbers index
+	 * the tagged content 1:1.
+	 */
+	#assertSeenLines(section: PatchSection, canonicalPath: string, expected: string): void {
+		const seen = this.snapshots.byHash(canonicalPath, expected)?.seenLines;
+		if (!seen || seen.size === 0) return;
+		const unseen = section.collectAnchorLines().filter(line => !seen.has(line));
+		if (unseen.length === 0) return;
+		throw new Error(unseenLinesMessage(section.path, unseen, expected));
+	}
 	#mismatchError(
 		section: PatchSection,
 		canonicalPath: string,
@@ -370,7 +386,7 @@ export class Patcher {
 		const expected = exists ? section.fileHash : undefined;
 		const liveMatches = expected !== undefined && computeFileHash(normalized) === expected;
 
-		// Resolve `replace block N:` edits to concrete ranges before recovery
+		// Resolve `replace_block N:` edits to concrete ranges before recovery
 		// runs. Block anchors are expressed against the snapshot the section tag
 		// names, so resolve against that exact text:
 		//   - live content matches the tag (or there is no tag) → resolve against
@@ -404,6 +420,10 @@ export class Patcher {
 		// the caller read, so echo them back. (A drifted file falls through to
 		// recovery below, where line numbers shift, so resolutions are dropped.)
 		if (expected === undefined || liveMatches) {
+			// The line numbers in `edits` index the exact content the tag names.
+			// Reject any anchor the read never displayed: editing lines the model
+			// has not seen is the off-by-memory mistake that mangles files.
+			if (expected !== undefined) this.#assertSeenLines(section, canonicalPath, expected);
 			const result = applyEdits(normalized, resolved);
 			return withResolveWarnings(blockResolutions.length > 0 ? { ...result, blockResolutions } : result);
 		}