@oh-my-pi/hashline 15.10.10 → 15.10.12

package/README.md

@@ -51,6 +51,7 @@ Inside a section:
 - `replace block A:` — replace the syntactic block beginning on line A.
 - `delete A..B` / `delete block A` — delete concrete lines or a resolved block.
 - `insert before A:` / `insert after A:` / `insert head:` / `insert tail:` — insert following body rows.
+- `insert after block A:` — insert following body rows after the resolved block's last line.
 - `+TEXT` — literal body row (use `+` alone for a blank line).
 
 ## Abstractions

package/dist/types/block.d.ts

@@ -16,11 +16,11 @@ export interface ResolveBlockEditsOptions {
      */
     onResolved?: (resolution: BlockResolution) => void;
 }
-/** True when at least one edit is an unresolved `replace block N:` edit. */
+/** True when at least one edit is an unresolved deferred block edit. */
 export declare function hasBlockEdit(edits: readonly Edit[]): boolean;
 /**
- * Resolve every `replace block N:` edit in `edits` against `text` (parsed as
- * the language inferred from `path`). Non-block edits pass through untouched.
+ * Resolve every deferred block edit in `edits` against `text` (parsed as the
+ * language inferred from `path`). Non-block edits pass through untouched.
  * Returns a fresh edit list with no `block` variants. The fast path returns the
  * input unchanged when there is nothing to resolve.
  *

package/dist/types/messages.d.ts

@@ -29,19 +29,19 @@ export declare const EMPTY_REPLACE = "`replace N..M:` needs at least one `+TEXT`
 /** Error text emitted when a `replace block N:` hunk has no body. */
 export declare const EMPTY_BLOCK = "`replace block N:` needs at least one `+TEXT` body row. To delete a block, use `delete N..M` with the block's line range.";
 /**
- * Error text emitted when a `replace block N:` anchor cannot be resolved to a
+ * Error text emitted when a block-anchored op cannot be resolved to a
  * syntactic block (unrecognized language, blank/out-of-range line, no node
  * begins on line N such as a lone closing delimiter, or the resolved block has
  * a syntax error). Names the offending line and steers back to an explicit
- * `replace N..M:` range.
+ * concrete-line form.
  */
-export declare function blockUnresolvedMessage(line: number): string;
+export declare function blockUnresolvedMessage(line: number, op?: "replace" | "delete" | "insert_after"): string;
 /**
- * Error text emitted when a `replace block N:` edit reaches a code path that
+ * Error text emitted when a block-anchored edit reaches a code path that
  * has no {@link BlockResolver} wired in. Indicates a host-configuration bug
  * rather than authored-input error.
  */
-export declare const BLOCK_RESOLVER_UNAVAILABLE = "`replace block N:` is not available here (no tree-sitter block resolver is configured). Use `replace N..M:` with an explicit range.";
+export declare const BLOCK_RESOLVER_UNAVAILABLE = "Block-anchored ops (`replace block N:`, `delete block N`, `insert after block N:`) are not available here (no tree-sitter block resolver is configured). Use a concrete line range instead.";
 /**
  * Internal invariant error: `applyEdits` received an unresolved `replace block
  * N:` edit. Block edits must be expanded by `resolveBlockEdits` before reaching
@@ -54,6 +54,15 @@ export declare const DELETE_TAKES_NO_BODY = "`delete N..M` does not take body ro
 export declare const DELETE_BLOCK_TAKES_NO_BODY = "`delete block N` does not take body rows. Remove the body, or use `replace block N:` to replace the block.";
 /** Error text emitted when an insert hunk has no body. */
 export declare const EMPTY_INSERT = "`insert` needs at least one `+TEXT` body row.";
+/**
+ * Warning emitted when an `insert after` edit's body rows are indented
+ * shallower than the anchor line and the landing point was slid forward past
+ * the structural closer lines that follow. The body's indentation names the
+ * depth the author wants the new lines to sit at; anchoring inside a deeper
+ * construct is the common "insert after the block, anchored on the last line
+ * I read" mistake.
+ */
+export declare function afterInsertLandingShiftWarning(anchorLine: number, landingLine: number, crossed: number): string;
 /** Warning text emitted by `Recovery` when an external write fits a cached snapshot. */
 export declare const RECOVERY_EXTERNAL_WARNING = "Recovered from a stale file hash using a previous read snapshot (file changed externally between read and edit).";
 /** Warning text emitted by `Recovery` when a prior in-session edit advanced the hash. */

package/dist/types/snapshots.d.ts

@@ -34,6 +34,12 @@ export interface InMemorySnapshotStoreOptions {
     maxPaths?: number;
     /** Maximum full-file versions retained per path (default 4). Oldest dropped first. */
     maxVersionsPerPath?: number;
+    /**
+     * Global ceiling on retained snapshot text summed across every path's
+     * version history, measured in UTF-16 code units (default 64 MiB).
+     * Least-recently-used path histories are evicted to stay under it.
+     */
+    maxTotalBytes?: number;
 }
 /**
  * In-memory {@link SnapshotStore} backed by `lru-cache`. Per-path history is a

package/dist/types/tokenizer.d.ts

@@ -21,6 +21,9 @@ export type BlockTarget = {
 } | {
     kind: "insert_after";
     anchor: Anchor;
+} | {
+    kind: "insert_after_block";
+    anchor: Anchor;
 } | {
     kind: "bof";
 } | {

package/dist/types/types.d.ts

@@ -41,18 +41,21 @@ export type Edit = {
     oldAssertion?: string;
 } | {
     /**
-     * Deferred block edit (`replace block N:` / `delete block N`). The exact
-     * line span is unknown at parse time — it is computed by
-     * {@link resolveBlockEdits} once file text + path (→ language) are
-     * available, then expanded into concrete edits: a non-empty `payloads`
-     * (from `replace block`) becomes the same `replacement` inserts + deletes
-     * that `replace start..end:` produces; an empty `payloads` (from `delete
-     * block`) becomes a pure range deletion. `applyEdits` never sees this
+     * Deferred block edit (`replace block N:` / `delete block N` /
+     * `insert after block N:`). The exact line span is unknown at parse
+     * time — it is computed by {@link resolveBlockEdits} once file text +
+     * path (→ language) are available, then expanded into concrete edits:
+     * a non-empty `payloads` without `mode` (from `replace block`) becomes
+     * the same `replacement` inserts + deletes that `replace start..end:`
+     * produces; an empty `payloads` (from `delete block`) becomes a pure
+     * range deletion; `mode: "insert_after"` becomes plain `after_anchor`
+     * inserts at the block's last line. `applyEdits` never sees this
      * variant.
      */
     kind: "block";
     anchor: Anchor;
     payloads: string[];
+    mode?: "insert_after";
     lineNum: number;
     index: number;
 };
@@ -120,11 +123,11 @@ export interface BlockSpan {
     end: number;
 }
 /**
- * One `replace block N:` / `delete block N` anchor resolved to its concrete
- * line span. Surfaced on {@link ApplyResult} so the host can echo
- * "block N → lines start..end" and let the model catch a wrong opener — e.g. a
- * decorator or doc-comment that sits in a separate node outside the resolved
- * block.
+ * One `replace block N:` / `delete block N` / `insert after block N:` anchor
+ * resolved to its concrete line span. Surfaced on {@link ApplyResult} so the
+ * host can echo "block N → lines start..end" and let the model catch a wrong
+ * opener — e.g. a decorator or doc-comment that sits in a separate node
+ * outside the resolved block.
  */
 export interface BlockResolution {
     /** The 1-indexed line the block op was anchored on (the `N`). */
@@ -133,8 +136,8 @@ export interface BlockResolution {
     start: number;
     /** Last line of the resolved span (1-indexed, inclusive). */
     end: number;
-    /** True for `delete block N`; false for `replace block N:`. */
-    isDelete: boolean;
+    /** Which block op produced this resolution. */
+    op: "replace" | "delete" | "insert_after";
 }
 /** Request handed to a {@link BlockResolver} to resolve one `replace block N:` anchor. */
 export interface BlockResolverRequest {

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/hashline",
-	"version": "15.10.10",
+	"version": "15.10.12",
 	"description": "Hashline: a compact, line-anchored patch language and applier. Pluggable FS/IO so it works over disk, in-memory, or any custom backend.",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",

package/src/apply.ts

@@ -7,7 +7,7 @@
  * which absorbs common model mistakes where a payload restates unchanged range
  * boundaries or duplicates/drops structural closers.
  */
-import { UNRESOLVED_BLOCK_INTERNAL } from "./messages";
+import { afterInsertLandingShiftWarning, UNRESOLVED_BLOCK_INTERNAL } from "./messages";
 import { cloneCursor } from "./tokenizer";
 import type { Anchor, ApplyResult, Cursor, Edit } from "./types";
 
@@ -40,11 +40,21 @@ function getEditAnchors(edit: AppliedEdit): Anchor[] {
  * checked once per section via the header hash before this function runs.
  */
 function validateLineBounds(edits: AppliedEdit[], fileLines: string[]): void {
+	// `split("\n")` on a newline-terminated file yields a trailing "" sentinel.
+	// It is addressable for inserts (append-past-end), but deleting it would
+	// silently strip the file's final newline — an off-by-one that must error.
+	const phantomLine = fileLines.length > 1 && fileLines[fileLines.length - 1] === "" ? fileLines.length : 0;
 	for (const edit of edits) {
 		for (const anchor of getEditAnchors(edit)) {
 			if (anchor.line < 1 || anchor.line > fileLines.length) {
 				throw new Error(`Line ${anchor.line} does not exist (file has ${fileLines.length} lines)`);
 			}
+			if (edit.kind === "delete" && anchor.line === phantomLine) {
+				throw new Error(
+					`Line ${anchor.line} is the trailing blank sentinel of a newline-terminated file and has no content to delete. ` +
+						`End the range at line ${anchor.line - 1}, or use \`insert tail:\` to append.`,
+				);
+			}
 		}
 	}
 }
@@ -383,6 +393,21 @@ function findBoundaryEcho(group: ReplacementGroup, fileLines: readonly string[])
 	// repair would strip explicit replacement content with no signal that the
 	// payload was a mistake rather than an intentional duplication.
 	if (leadingMax + trailingMax >= group.payload.length) return undefined;
+	// Balance-neutrality guard (see header comment): the dropped echo lines must
+	// either be delimiter-neutral on their own or exactly cancel the payload/range
+	// balance delta. In brace-heavy code where bare closer lines repeat, an
+	// "echo" that shifts delimiter balance is structural content the payload
+	// placed intentionally — stripping it would corrupt the result.
+	const leadingBalance = computeDelimiterBalance(group.payload.slice(0, leadingMax));
+	const trailingBalance = computeDelimiterBalance(group.payload.slice(group.payload.length - trailingMax));
+	const droppedBalance = balanceDelta(leadingBalance, balanceNegate(trailingBalance));
+	if (!balanceIsZero(droppedBalance)) {
+		const delta = balanceDelta(
+			computeDelimiterBalance(group.payload),
+			computeDelimiterBalance(fileLines.slice(group.startLine - 1, group.endLine)),
+		);
+		if (!balanceEqual(droppedBalance, delta)) return undefined;
+	}
 	return { leading: leadingMax, trailing: trailingMax };
 }
 
@@ -481,6 +506,150 @@ function repairReplacementBoundaries(
 	return { edits: out, warnings };
 }
 
+// ═══════════════════════════════════════════════════════════════════════════
+// After-insert landing correction
+//
+// The body rows of an `insert after N:` hunk carry an implicit depth claim:
+// their leading indentation says how deep the author expects the new lines
+// to sit. When that depth is shallower than line N itself, the hunk is
+// inserting a sibling of some enclosing construct while anchored inside it —
+// the common shape is anchoring on the last statement of a block and writing
+// the body at the parent's depth. Sliding the landing point forward across
+// the structural closer lines that follow (and nothing else — content lines
+// are never crossed) places the body at the depth its indentation names.
+//
+// The shift is deliberately conservative: it fires only when the body and
+// anchor indentation are comparable (one is a prefix of the other), crosses
+// only pure closing-delimiter lines indented at or deeper than the body,
+// stops as soon as depth returns to the body's level, and is abandoned when
+// any other edit in the patch targets a crossed line. Every shift is
+// reported as a warning so the author can re-issue with deeper indentation
+// when the original landing was intended.
+
+/** Leading run of tabs and spaces. */
+function leadingIndent(line: string): string {
+	let end = 0;
+	while (end < line.length) {
+		const code = line.charCodeAt(end);
+		if (code !== 9 && code !== 32) break;
+		end++;
+	}
+	return line.slice(0, end);
+}
+
+/** `deeper` strictly extends `shallower` (same indent style, more depth). */
+function isIndentDeeper(deeper: string, shallower: string): boolean {
+	return deeper.length > shallower.length && deeper.startsWith(shallower);
+}
+
+interface AfterInsertGroup {
+	/** Anchor line shared by every insert row of the hunk. */
+	anchor: number;
+	/** Indices into the edit list, in patch order. */
+	members: number[];
+}
+
+/**
+ * Depth of an after-insert hunk's body: the shallowest indentation across its
+ * non-blank rows. Returns `undefined` when no depth claim can be made — an
+ * all-blank or all-closer body, or rows whose indentation styles are not
+ * mutually comparable (tabs vs spaces).
+ */
+function bodyTargetIndent(rows: readonly string[]): string | undefined {
+	const nonBlank = rows.filter(hasNonWhitespace);
+	if (nonBlank.length === 0) return undefined;
+	// A body of pure closers re-balances delimiters; it claims no depth.
+	if (nonBlank.every(row => STRUCTURAL_CLOSER_RE.test(row))) return undefined;
+	let target = leadingIndent(nonBlank[0] ?? "");
+	for (const row of nonBlank) {
+		const indent = leadingIndent(row);
+		if (indent.startsWith(target)) continue;
+		if (target.startsWith(indent)) target = indent;
+		else return undefined;
+	}
+	return target;
+}
+
+/**
+ * Resolve where an after-insert hunk anchored on `group.anchor` should land
+ * given its body depth `target`: the last structural closer line in the run
+ * directly below the anchor whose indentation still covers `target`. Returns
+ * `undefined` when the landing stays put.
+ */
+function resolveShiftedLanding(
+	group: AfterInsertGroup,
+	target: string,
+	fileLines: readonly string[],
+	targetedLines: ReadonlySet<number>,
+): { line: number; crossed: number } | undefined {
+	const anchorText = fileLines[group.anchor - 1];
+	if (anchorText === undefined || !hasNonWhitespace(anchorText)) return undefined;
+	if (!isIndentDeeper(leadingIndent(anchorText), target)) return undefined;
+
+	let landing = group.anchor;
+	let crossed = 0;
+	for (let line = group.anchor + 1; line <= fileLines.length; line++) {
+		const text = fileLines[line - 1] ?? "";
+		if (!hasNonWhitespace(text)) continue; // look past blanks, never land on them
+		if (!STRUCTURAL_CLOSER_RE.test(text)) break; // content is never crossed
+		const indent = leadingIndent(text);
+		if (!indent.startsWith(target)) break; // shallower than the body — crossing would over-escape
+		if (targetedLines.has(line)) return undefined; // another hunk owns this closer
+		landing = line;
+		crossed++;
+		if (indent.length === target.length) break; // depth returned to the body's level
+	}
+	return landing === group.anchor ? undefined : { line: landing, crossed };
+}
+
+/**
+ * Slide mis-anchored `insert after N:` hunks past the structural closer lines
+ * that directly follow their anchor when the body's indentation says the new
+ * lines belong at a shallower depth. Returns the corrected edit list plus one
+ * warning per shifted hunk.
+ */
+function repairAfterInsertLandings(
+	edits: readonly AppliedEdit[],
+	fileLines: readonly string[],
+): { edits: readonly AppliedEdit[]; warnings: string[] } {
+	// Group plain (non-replacement) after-anchor inserts per authored hunk:
+	// rows of one hunk share the anchor line and the patch header line.
+	const groups = new Map<string, AfterInsertGroup>();
+	edits.forEach((edit, idx) => {
+		if (edit.kind !== "insert" || edit.mode === "replacement") return;
+		if (edit.cursor.kind !== "after_anchor") return;
+		const key = `${edit.cursor.anchor.line}:${edit.lineNum}`;
+		const group = groups.get(key);
+		if (group === undefined) groups.set(key, { anchor: edit.cursor.anchor.line, members: [idx] });
+		else group.members.push(idx);
+	});
+	if (groups.size === 0) return { edits, warnings: [] };
+
+	// Lines explicitly targeted by any edit; a shift never crosses them.
+	const targetedLines = new Set<number>();
+	for (const edit of edits) {
+		if (edit.kind === "delete") targetedLines.add(edit.anchor.line);
+		else if (edit.cursor.kind === "before_anchor" || edit.cursor.kind === "after_anchor")
+			targetedLines.add(edit.cursor.anchor.line);
+	}
+
+	let out: AppliedEdit[] | undefined;
+	const warnings: string[] = [];
+	for (const group of groups.values()) {
+		const target = bodyTargetIndent(group.members.map(idx => (edits[idx] as InsertEdit).text));
+		if (target === undefined) continue;
+		const landing = resolveShiftedLanding(group, target, fileLines, targetedLines);
+		if (landing === undefined) continue;
+		out ??= [...edits];
+		for (const idx of group.members) {
+			const edit = out[idx] as InsertEdit;
+			out[idx] = { ...edit, cursor: { kind: "after_anchor", anchor: { line: landing.line } } };
+		}
+		warnings.push(afterInsertLandingShiftWarning(group.anchor, landing.line, landing.crossed));
+	}
+	return { edits: out ?? edits, warnings };
+}
+
 /**
  * Apply a parsed list of edits to a text body. Pure function — no I/O.
  *
@@ -508,13 +677,15 @@ export function applyEdits(text: string, edits: readonly Edit[]): ApplyResult {
 
 	const targetEdits = appliedEdits.map((edit, index) => cloneAppliedEdit(edit, index));
 	validateLineBounds(targetEdits, fileLines);
-	const { edits: repaired, warnings } = repairReplacementBoundaries(targetEdits, fileLines);
+	const { edits: repaired, warnings: boundaryWarnings } = repairReplacementBoundaries(targetEdits, fileLines);
+	const { edits: landed, warnings: landingWarnings } = repairAfterInsertLandings(repaired, fileLines);
+	const warnings = [...boundaryWarnings, ...landingWarnings];
 
 	// Partition edits into bof, eof, and anchor-targeted buckets.
 	const bofLines: string[] = [];
 	const eofLines: string[] = [];
 	const anchorEdits: IndexedEdit[] = [];
-	repaired.forEach((edit, idx) => {
+	landed.forEach((edit, idx) => {
 		if (edit.kind === "insert" && edit.cursor.kind === "bof") {
 			bofLines.push(edit.text);
 		} else if (edit.kind === "insert" && edit.cursor.kind === "eof") {

package/src/block.ts

@@ -1,13 +1,16 @@
 /**
- * Expand deferred `replace block N:` edits 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
  * runs at every apply/preview boundary that has text: it calls the injected
  * {@link BlockResolver} to resolve each block's `[start, end]` span, then emits
- * the exact same `before_anchor` replacement inserts + range deletes that
- * `replace start..end:` produces in the parser. After it runs, no `block` edits
- * remain, so {@link applyEdits} (and recovery) only ever see resolved edits.
+ * the exact same edits the concrete form produces in the parser: `replace
+ * start..end:` inserts + deletes for a replace, a pure range delete for a
+ * delete, and plain `after_anchor` inserts at `end` for an insert-after. After
+ * it runs, no `block` edits remain, so {@link applyEdits} (and recovery) only
+ * ever see resolved edits.
  */
 import { BLOCK_RESOLVER_UNAVAILABLE, blockUnresolvedMessage } from "./messages";
 import type { BlockResolution, BlockResolver, Cursor, Edit } from "./types";
@@ -30,14 +33,14 @@ export interface ResolveBlockEditsOptions {
 	onResolved?: (resolution: BlockResolution) => void;
 }
 
-/** True when at least one edit is an unresolved `replace block N:` edit. */
+/** True when at least one edit is an unresolved deferred block edit. */
 export function hasBlockEdit(edits: readonly Edit[]): boolean {
 	return edits.some(edit => edit.kind === "block");
 }
 
 /**
- * Resolve every `replace block N:` edit in `edits` against `text` (parsed as
- * the language inferred from `path`). Non-block edits pass through untouched.
+ * Resolve every deferred block edit in `edits` against `text` (parsed as the
+ * language inferred from `path`). Non-block edits pass through untouched.
  * Returns a fresh edit list with no `block` variants. The fast path returns the
  * input unchanged when there is nothing to resolve.
  *
@@ -61,19 +64,29 @@ export function resolveBlockEdits(
 			resolved.push(edit);
 			continue;
 		}
+		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) {
 			if (onUnresolved === "drop") continue;
 			throw new Error(
-				`line ${edit.lineNum}: ${resolver ? blockUnresolvedMessage(edit.anchor.line) : BLOCK_RESOLVER_UNAVAILABLE}`,
+				`line ${edit.lineNum}: ${resolver ? blockUnresolvedMessage(edit.anchor.line, op) : BLOCK_RESOLVER_UNAVAILABLE}`,
 			);
 		}
 		options.onResolved?.({
 			anchorLine: edit.anchor.line,
 			start: span.start,
 			end: span.end,
-			isDelete: edit.payloads.length === 0,
+			op,
 		});
+		if (op === "insert_after") {
+			// Mirror the parser's `insert after N:` lowering: one `after_anchor`
+			// insert per payload row, anchored on the block's last line.
+			for (const payload of edit.payloads) {
+				const cursor: Cursor = { kind: "after_anchor", anchor: { line: span.end } };
+				resolved.push({ kind: "insert", cursor, text: payload, lineNum: edit.lineNum, index: synthIndex++ });
+			}
+			continue;
+		}
 		// 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

package/src/diff-preview.ts

@@ -15,11 +15,22 @@ import type { CompactDiffOptions, CompactDiffPreview } from "./types";
 const DEFAULT_ADDED_RUN_CONTEXT_LINES = 2;
 
 const PREVIEW_ELISION_MARKER = "…";
+/** Blank row separating non-contiguous regions of a numbered diff. */
+const PREVIEW_GAP_ROW = "";
 const RAW_ELISION_MARKERS = new Set(["...", PREVIEW_ELISION_MARKER, `+${PREVIEW_ELISION_MARKER}`]);
 
+function isPreviewSeparator(line: string | undefined): boolean {
+	return line === PREVIEW_ELISION_MARKER || line === PREVIEW_GAP_ROW;
+}
+
 function appendPreviewLine(output: string[], line: string): void {
 	const normalized = RAW_ELISION_MARKERS.has(line) ? PREVIEW_ELISION_MARKER : line;
-	if (normalized === PREVIEW_ELISION_MARKER && output[output.length - 1] === PREVIEW_ELISION_MARKER) return;
+	// Separators (elision markers, blank gap rows) never stack: omitted
+	// removed lines between two separators would otherwise leave them
+	// adjacent. A leading separator is dropped outright.
+	if (isPreviewSeparator(normalized) && (output.length === 0 || isPreviewSeparator(output[output.length - 1]))) {
+		return;
+	}
 	output.push(normalized);
 }
 
@@ -107,6 +118,7 @@ export function buildCompactDiffPreview(diff: string, options: CompactDiffOption
 		}
 	}
 	flushAddedRun();
+	while (formatted.length > 0 && isPreviewSeparator(formatted[formatted.length - 1])) formatted.pop();
 
 	return { preview: formatted.join("\n"), addedLines, removedLines };
 }

package/src/grammar.lark

@@ -7,15 +7,17 @@ file_header: "[" filename "#" file_hash "]" LF
 file_hash: /[0-9A-F]{4}/
 filename: /[^#\r\n]+/
 
-hunk: replace_hunk | replace_block_hunk | insert_hunk | delete_hunk | delete_block_hunk
+hunk: replace_hunk | replace_block_hunk | insert_hunk | insert_block_hunk | delete_hunk | delete_block_hunk
 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"
 emit_op: "+" /(.*)/ LF
 

package/src/messages.ts

@@ -47,27 +47,39 @@ export const EMPTY_BLOCK =
 	"`replace block N:` needs at least one `+TEXT` body row. To delete a block, use `delete N..M` with the block's line range.";
 
 /**
- * Error text emitted when a `replace block N:` anchor cannot be resolved to a
+ * Error text emitted when a block-anchored op cannot be resolved to a
  * syntactic block (unrecognized language, blank/out-of-range line, no node
  * begins on line N such as a lone closing delimiter, or the resolved block has
  * a syntax error). Names the offending line and steers back to an explicit
- * `replace N..M:` range.
+ * concrete-line form.
  */
-export function blockUnresolvedMessage(line: number): string {
+export function blockUnresolvedMessage(line: number, op: "replace" | "delete" | "insert_after" = "replace"): string {
+	const phrase =
+		op === "delete"
+			? `delete block ${line}`
+			: op === "insert_after"
+				? `insert after block ${line}:`
+				: `replace block ${line}:`;
+	const fallback =
+		op === "delete"
+			? `\`delete ${line}..M\``
+			: op === "insert_after"
+				? `\`insert after M:\` with the block's explicit last line`
+				: `\`replace ${line}..M:\` with the block's explicit end line`;
 	return (
-		`\`replace block ${line}:\` could not resolve a syntactic block beginning on line ${line}. ` +
+		`\`${phrase}\` could not resolve a syntactic block beginning on line ${line}. ` +
 		`The language may be unsupported, the line may be blank or a closing delimiter, or the block may not parse. ` +
-		`Use \`replace ${line}..M:\` with the block's explicit end line instead.`
+		`Use ${fallback} instead.`
 	);
 }
 
 /**
- * Error text emitted when a `replace block N:` edit reaches a code path that
+ * Error text emitted when a block-anchored edit reaches a code path that
  * has no {@link BlockResolver} wired in. Indicates a host-configuration bug
  * rather than authored-input error.
  */
 export const BLOCK_RESOLVER_UNAVAILABLE =
-	"`replace block N:` is not available here (no tree-sitter block resolver is configured). Use `replace N..M:` with an explicit range.";
+	"Block-anchored ops (`replace block N:`, `delete block N`, `insert after block N:`) are not available here (no tree-sitter block resolver is configured). Use a concrete line range instead.";
 
 /**
  * Internal invariant error: `applyEdits` received an unresolved `replace block
@@ -87,6 +99,22 @@ export const DELETE_BLOCK_TAKES_NO_BODY =
 /** Error text emitted when an insert hunk has no body. */
 export const EMPTY_INSERT = "`insert` needs at least one `+TEXT` body row.";
 
+/**
+ * Warning emitted when an `insert after` edit's body rows are indented
+ * shallower than the anchor line and the landing point was slid forward past
+ * the structural closer lines that follow. The body's indentation names the
+ * depth the author wants the new lines to sit at; anchoring inside a deeper
+ * construct is the common "insert after the block, anchored on the last line
+ * I read" mistake.
+ */
+export function afterInsertLandingShiftWarning(anchorLine: number, landingLine: number, crossed: number): string {
+	return (
+		`insert after ${anchorLine}: the body is indented shallower than line ${anchorLine}, so the landing was moved past ` +
+		`${crossed} closing line${crossed === 1 ? "" : "s"} to after line ${landingLine}. ` +
+		`If you meant the deeper position inside the block, re-issue with the body indented to match.`
+	);
+}
+
 /** Warning text emitted by `Recovery` when an external write fits a cached snapshot. */
 export const RECOVERY_EXTERNAL_WARNING =
 	"Recovered from a stale file hash using a previous read snapshot (file changed externally between read and edit).";

package/src/parser.ts

@@ -32,6 +32,13 @@ function isSkippableCommentLine(line: string): boolean {
 	return line.trimStart().startsWith("#");
 }
 
+/**
+ * Stripped remainder of a bare `N: <value>` row that is a lone quoted or
+ * numeric literal (optionally comma-terminated) — the shape of a numeric-keyed
+ * dict/YAML body rather than read-output paste.
+ */
+const BARE_LITERAL_VALUE_RE = /^\s*(?:"[^"]*"|'[^']*'|[-+]?\d+(?:\.\d+)?)\s*,?\s*$/;
+
 function detectApplyPatchContamination(text: string, _hasPending: boolean): string | null {
 	const trimmed = text.trimStart();
 	if (trimmed.length === 0) return null;
@@ -88,6 +95,12 @@ interface Pending {
 	target: BlockTarget;
 	lineNum: number;
 	payloads: PayloadRow[];
+	/**
+	 * Blank rows seen after the body started. Interior blanks are committed to
+	 * the payload when the next non-blank row arrives; trailing blanks before
+	 * the next header/op are layout separators and are discarded on flush.
+	 */
+	deferredBlanks: PayloadRow[];
 }
 
 export class Executor {
@@ -127,6 +140,7 @@ export class Executor {
 				return;
 			case "blank":
 				this.#consumePendingSkippableComments();
+				this.#handleBlank("", token.lineNum);
 				return;
 			case "payload-literal":
 				this.#consumePendingSkippableComments();
@@ -146,7 +160,7 @@ export class Executor {
 					validateRangeOrder(token.target.range, token.lineNum);
 				}
 				this.#flushPending();
-				this.#pending = { target: token.target, lineNum: token.lineNum, payloads: [] };
+				this.#pending = { target: token.target, lineNum: token.lineNum, payloads: [], deferredBlanks: [] };
 				return;
 		}
 	}
@@ -208,6 +222,7 @@ export class Executor {
 		}
 		if (pending.target.kind === "delete") throw new Error(`line ${lineNum}: ${DELETE_TAKES_NO_BODY}`);
 		if (pending.target.kind === "delete_block") throw new Error(`line ${lineNum}: ${DELETE_BLOCK_TAKES_NO_BODY}`);
+		this.#commitDeferredBlanks(pending);
 		pending.payloads.push({ kind: "literal", text, lineNum });
 	}
 
@@ -215,12 +230,16 @@ export class Executor {
 		const contamination = detectApplyPatchContamination(text, this.#pending !== undefined);
 		if (contamination !== null) throw new Error(`line ${lineNum}: ${contamination}`);
 		if (this.#pending) {
-			if (text.trim().length === 0) return;
+			if (text.trim().length === 0) {
+				this.#handleBlank(text, lineNum);
+				return;
+			}
 			if (this.#pending.target.kind === "delete") throw new Error(`line ${lineNum}: ${DELETE_TAKES_NO_BODY}`);
 			if (this.#pending.target.kind === "delete_block")
 				throw new Error(`line ${lineNum}: ${DELETE_BLOCK_TAKES_NO_BODY}`);
 			if (text.trimStart().charCodeAt(0) === 45 /* - */) throw new Error(`line ${lineNum}: ${MINUS_ROW_REJECTED}`);
 			if (!this.#warnings.includes(BARE_BODY_AUTO_PIPED_WARNING)) this.#warnings.push(BARE_BODY_AUTO_PIPED_WARNING);
+			this.#commitDeferredBlanks(this.#pending);
 			// Defer read-output line-number stripping to #flushPending: a bare
 			// "N:text" row is only a copy-paste artifact from snapshot output
 			// when *every* bare row in the hunk carries that prefix. Stripping a
@@ -238,6 +257,28 @@ export class Executor {
 		);
 	}
 
+	/**
+	 * A blank row inside a hunk body is ambiguous: interior blanks are body
+	 * content (a bare-pasted body legitimately contains empty lines), while
+	 * blanks before the body starts or trailing into the next op are layout.
+	 * Defer them; {@link #commitDeferredBlanks} folds them in only when a later
+	 * non-blank row proves they were interior.
+	 */
+	#handleBlank(text: string, lineNum: number): void {
+		const pending = this.#pending;
+		if (!pending) return;
+		if (pending.target.kind === "delete" || pending.target.kind === "delete_block") return;
+		if (pending.payloads.length === 0) return;
+		pending.deferredBlanks.push({ kind: "literal", text, lineNum, bare: true });
+	}
+
+	#commitDeferredBlanks(pending: Pending): void {
+		if (pending.deferredBlanks.length === 0) return;
+		if (!this.#warnings.includes(BARE_BODY_AUTO_PIPED_WARNING)) this.#warnings.push(BARE_BODY_AUTO_PIPED_WARNING);
+		pending.payloads.push(...pending.deferredBlanks);
+		pending.deferredBlanks = [];
+	}
+
 	/**
 	 * Strip a single read-output line-number prefix (`N:`) from every bare body
 	 * row, but only when *all* bare rows carry one. A uniform set of prefixes is
@@ -247,14 +288,22 @@ export class Executor {
 	 */
 	#stripBarePrefixesIfUniform(payloads: PayloadRow[]): void {
 		let sawBare = false;
+		let allLiteralValues = true;
 		for (const row of payloads) {
-			if (!row.bare) continue;
+			if (!row.bare || row.text.trim().length === 0) continue;
 			sawBare = true;
-			if (stripOneLeadingHashlinePrefix(row.text) === row.text) return;
+			const stripped = stripOneLeadingHashlinePrefix(row.text);
+			if (stripped === row.text) return;
+			allLiteralValues &&= BARE_LITERAL_VALUE_RE.test(stripped);
 		}
 		if (!sawBare) return;
+		// A body where every stripped remainder is a lone quoted/numeric literal
+		// (optionally comma-terminated) is the shape of a numeric-keyed dict or
+		// YAML mapping (`1: "one",`), not read-output paste; stripping the "N:"
+		// keys would mangle every line. Leave such bodies untouched.
+		if (allLiteralValues) return;
 		for (const row of payloads) {
-			if (row.bare) row.text = stripOneLeadingHashlinePrefix(row.text);
+			if (row.bare && row.text.trim().length > 0) row.text = stripOneLeadingHashlinePrefix(row.text);
 		}
 	}
 
@@ -273,11 +322,12 @@ export class Executor {
 		this.#edits.push({ kind: "delete", anchor: { ...anchor }, lineNum, index: this.#editIndex++ });
 	}
 
-	#pushBlock(anchor: Anchor, payloads: readonly PayloadRow[], lineNum: number): void {
+	#pushBlock(anchor: Anchor, payloads: readonly PayloadRow[], lineNum: number, mode?: "insert_after"): void {
 		this.#edits.push({
 			kind: "block",
 			anchor: { ...anchor },
 			payloads: payloads.map(payload => payload.text),
+			...(mode === undefined ? {} : { mode }),
 			lineNum,
 			index: this.#editIndex++,
 		});
@@ -307,6 +357,11 @@ export class Executor {
 			this.#pushBlock(target.anchor, payloads, lineNum);
 			return;
 		}
+		if (target.kind === "insert_after_block") {
+			if (payloads.length === 0) throw new Error(`line ${lineNum}: ${EMPTY_INSERT}`);
+			this.#pushBlock(target.anchor, payloads, lineNum, "insert_after");
+			return;
+		}
 		if (payloads.length === 0) {
 			if (target.kind === "replace") {
 				for (const anchor of expandRange(target.range)) this.#pushDelete(anchor, lineNum);

package/src/patcher.ts

@@ -199,7 +199,24 @@ export class Patcher {
 		}
 
 		const results: PatchSectionResult[] = [];
-		for (const entry of prepared) results.push(await this.commit(entry));
+		for (let index = 0; index < prepared.length; index++) {
+			try {
+				results.push(await this.commit(prepared[index]));
+			} catch (error) {
+				// A mid-batch write failure leaves earlier sections on disk with no
+				// rollback; report exactly which sections landed so the caller can
+				// re-issue only the missing ones instead of double-applying.
+				const written = prepared.slice(0, index).map(entry => entry.section.path);
+				const notWritten = prepared.slice(index + 1).map(entry => entry.section.path);
+				const message = error instanceof Error ? error.message : String(error);
+				throw new Error(
+					`Failed to write ${prepared[index].section.path}: ${message}` +
+						(written.length > 0 ? ` Sections already written: ${written.join(", ")}.` : "") +
+						(notWritten.length > 0 ? ` Sections not written: ${notWritten.join(", ")}.` : ""),
+					{ cause: error },
+				);
+			}
+		}
 		return { sections: results };
 	}
 

package/src/prompt.md

@@ -5,14 +5,15 @@ Every file section starts with `[PATH#TAG]`. `TAG` is the 4-hex snapshot tag fro
 </headers>
 
 <ops>
-replace N..M:      replace original lines N..M with the body rows below. CAUTION, IT IS INCLUSIVE! MAKE SURE YOU INTEND TO DELETE BOTH ENDS!
-replace block N:   replace the whole syntactic block that BEGINS on line N — header line through closing line — resolved with tree-sitter, so you never count the end. Body rows below. Reach for this to rewrite a whole construct (function/`if`/loop/class body): the end can't be mis-counted or clipped mid-block. Point N at the line that OPENS the construct (the `if`/`function`/`def`/`{`-bearing line), not a closing `}` or a blank line. The span is EXACTLY that node — a leading decorator/attribute/doc-comment is a separate node and is NOT swept in (see rules).
-delete N..M        delete original lines N..M. No body.
-delete block N     delete the whole syntactic block that BEGINS on line N.
-insert before N:   insert the body rows immediately before line N.
-insert after N:    insert the body rows immediately after line N.
-insert head:       insert the body rows at the very start of the file.
-insert tail:       insert the body rows at the very end of the file.
+`replace N..M:` — replace original lines N..M with the body rows below. CAUTION, IT IS INCLUSIVE! MAKE SURE YOU INTEND TO DELETE BOTH ENDS!
+`replace block N:` — replace the whole syntactic block that BEGINS on line N — header line through closing line — resolved with tree-sitter, so you never count the end. Body rows below. Point N at the line that OPENS the construct (the `if`/`function`/`def`/`{`-bearing line), not a closing `}` or a blank line; a leading decorator/attribute/doc-comment is a separate node and is NOT swept in (see rules).
+`delete N..M` — delete original lines N..M. No body.
+`delete block N` — delete the whole syntactic block that BEGINS on line N.
+`insert before N:` — insert the body rows immediately before line N.
+`insert after N:` — insert the body rows immediately after line N.
+`insert after block N:` — insert the body rows after the END of the syntactic block that BEGINS on line N (resolved like `replace block`).
+`insert head:` — insert the body rows at the very start of the file.
+`insert tail:` — insert the body rows at the very end of the file.
 Single line: `replace N..N:` / `delete N`. The range is the ORIGINAL lines you touch; body length is irrelevant (replacing 1 line with 10 is still `replace N..N:`).
 </ops>
 
@@ -27,12 +28,14 @@ There is NO other body row kind. NEVER write `-old` or a bare/context line. To k
 - Numbers refer to the ORIGINAL file and stay valid for the whole patch — they do not shift as hunks apply.
 - Across calls they do NOT survive: each applied edit mints a fresh `#TAG` and renumbers the file, so the tag and line numbers you just used are dead. Anchor the next edit on the `[PATH#TAG]` and lines from the edit response (or re-`read`), never on pre-edit numbers.
 - A line number is an offset, not a structural boundary: never `insert after N` into a construct you have not read, and never start or end a `replace`/`delete` range mid-expression or mid-block. If unsure what is on those lines, `read` them first.
+- Body indentation is a depth claim: indent body rows for the depth they should live at — an `insert after` body indented shallower than its anchor lands past the closing lines below it (the result warns and names the landing line).
 - A valid `#TAG` is NOT permission to patch the whole file — it certifies the snapshot, not your knowledge of it. Authority to touch a line comes from having literally seen that line as a `LINE:TEXT` row in a `read`/`search`, not from holding the tag. Every line in a hunk's range, and the lines bounding it, must be lines you actually saw.
 - An elided or partial read is NOT a read of the gap. A `…` (or any collapsed/truncated region) between two excerpts means those lines are UNSEEN — treat them exactly like lines you never opened. Never place a hunk on, or span a range across, an elided region; `read` that range explicitly first. Reconstructing it from memory of "what the code probably looks like" is how ranges drift off-by-N and shred neighboring blocks.
 - On a stale-tag rejection — or any result you cannot fully account for — STOP and re-`read`. Never stack more line-numbered edits onto output you have not re-grounded; that compounds corruption.
 - One hunk per range; the body is the final content, never an old/new pair.
-- Keep every range as tight as the change: a range must cover ONLY lines whose content actually changes. Never widen it to swallow an unchanged signature, brace, or neighboring statement just to rewrite a few lines inside — change one line with `replace N..N`, not the whole block around it. (A range where every line genuinely changes is correctly long; tightness is about excluding unchanged lines, not about being short.) This bounds the blast radius if a number is off: a stale one-line range corrupts one line, while a stale wide range shreds every line it spans. (This is about hand-counted `replace N..M` ranges; the `replace block N` operator is the opposite — tree-sitter fixes the end, so it can't be mis-counted or clipped.)
-- `replace block N` vs `replace N..M`: use `replace block N` to rewrite a WHOLE construct (function / `if` / loop / class body) — tree-sitter resolves its closing line, so a long body can't be mis-counted and a stale end can't clip it mid-block; the edit result echoes the span it matched (`replace block N → resolved lines A-B`), so glance at it to confirm you got what you meant. Use `replace N..M` to change specific lines inside a construct. The resolved span is EXACTLY the node beginning on line N: a leading decorator, attribute, or doc-comment is a separate node and is NOT included. To replace a decorated/annotated definition together with its decorator, point N at the FIRST decorator line (Python parses `@dec` + `def` as one block). A leading line-comment that parses as its own node (e.g. Rust `///`) is not captured by any single opener — use `replace N..M` spanning the comment and the construct.
+- Keep every range as tight as the change: a range covers ONLY lines whose content actually changes. Never widen it to swallow an unchanged signature, brace, or neighboring statement just to rewrite a few lines inside — change one line with `replace N..N`, not the whole block around it. Tightness means excluding unchanged lines, not being short: a range where every line genuinely changes is correctly long. Tight ranges bound the blast radius of a stale number: a stale one-line range corrupts one line; a stale wide range shreds every line it spans. This applies to hand-counted `replace N..M` ranges; `replace block N` is exempt — tree-sitter fixes the end.
+- `replace block N` vs `replace N..M`: use `replace block N` to rewrite a WHOLE construct (function / `if` / loop / class body) — tree-sitter resolves its closing line, so a long body can't be mis-counted and a stale end can't clip it mid-block. The edit result echoes the span it matched (`replace block N → resolved lines A-B`); glance at it to confirm you got what you meant. Use `replace N..M` to change specific lines inside a construct.
+- The resolved span of `replace block N` is EXACTLY the node beginning on line N. A leading decorator, attribute, or doc-comment is a separate node and is NOT included; to take a decorated definition together with its decorator, point N at the FIRST decorator line (Python parses `@dec` + `def` as one block). A leading line-comment that parses as its own node (e.g. Rust `///`) is not captured by any single opener — use `replace N..M` spanning the comment and the construct.
 - To change lines 2 and 5 while keeping 3–4, issue two hunks (`replace 2..2:` and `replace 5..5:`). Untouched lines are simply absent from every range.
 - Pure additions use `insert`, never a widened `replace`. If the change only adds lines, `insert before/after` the spot and keep every existing line out of all ranges. Do NOT `replace` a span of keepers and retype them around the new line "to preserve" them — those retyped keepers are exactly what gets silently dropped when one is forgotten. A keeper that never enters your body cannot be lost. `replace` is only for lines whose own text changes.
 - NEVER use this tool to format code — reordering imports, re-indenting, aligning columns, or any mechanical restyling. That is the project formatter's job; run it instead of hand-editing layout here.

package/src/snapshots.ts

@@ -62,12 +62,20 @@ export abstract class SnapshotStore {
 
 const DEFAULT_MAX_PATHS = 30;
 const DEFAULT_MAX_VERSIONS_PER_PATH = 4;
+/** Global ceiling on retained snapshot text across all paths (UTF-16 code units). */
+const DEFAULT_MAX_TOTAL_BYTES = 64 * 1024 * 1024;
 
 export interface InMemorySnapshotStoreOptions {
 	/** Maximum number of distinct paths tracked at once (default 30). LRU eviction. */
 	maxPaths?: number;
 	/** Maximum full-file versions retained per path (default 4). Oldest dropped first. */
 	maxVersionsPerPath?: number;
+	/**
+	 * Global ceiling on retained snapshot text summed across every path's
+	 * version history, measured in UTF-16 code units (default 64 MiB).
+	 * Least-recently-used path histories are evicted to stay under it.
+	 */
+	maxTotalBytes?: number;
 }
 
 /**
@@ -85,7 +93,15 @@ export class InMemorySnapshotStore extends SnapshotStore {
 
 	constructor(options: InMemorySnapshotStoreOptions = {}) {
 		super();
-		this.#versions = new LRUCache<string, Snapshot[]>({ max: options.maxPaths ?? DEFAULT_MAX_PATHS });
+		this.#versions = new LRUCache<string, Snapshot[]>({
+			max: options.maxPaths ?? DEFAULT_MAX_PATHS,
+			maxSize: options.maxTotalBytes ?? DEFAULT_MAX_TOTAL_BYTES,
+			sizeCalculation: history => {
+				let total = 1;
+				for (const version of history) total += version.text.length;
+				return total;
+			},
+		});
 		this.#maxVersionsPerPath = options.maxVersionsPerPath ?? DEFAULT_MAX_VERSIONS_PER_PATH;
 	}
 

package/src/tokenizer.ts

@@ -204,6 +204,7 @@ export type BlockTarget =
 	| { kind: "delete_block"; anchor: Anchor }
 	| { kind: "insert_before"; anchor: Anchor }
 	| { kind: "insert_after"; anchor: Anchor }
+	| { kind: "insert_after_block"; anchor: Anchor }
 	| { kind: "bof" }
 	| { kind: "eof" };
 
@@ -238,6 +239,16 @@ function scanInsertTarget(line: string, index: number, end: number): TargetScan
 	}
 	const afterEnd = scanKeyword(line, cursor, end, HL_INSERT_AFTER);
 	if (afterEnd !== null) {
+		// `insert after block N:` — resolve N to a tree-sitter block range at
+		// apply time and insert after its last line. Try the `block` sub-keyword
+		// before falling back to a literal `insert after N:` anchor.
+		const blockEnd = scanKeyword(line, skipWhitespace(line, afterEnd, end), end, HL_BLOCK_KEYWORD);
+		if (blockEnd !== null) {
+			const anchor = scanLineNumber(line, skipWhitespace(line, blockEnd, end), end);
+			if (anchor === null) return null;
+			const nextIndex = consumeOptionalColon(line, anchor.nextIndex, end);
+			return { target: { kind: "insert_after_block", anchor: { line: anchor.line } }, nextIndex };
+		}
 		const anchor = scanLineNumber(line, skipWhitespace(line, afterEnd, end), end);
 		if (anchor === null) return null;
 		const nextIndex = consumeOptionalColon(line, anchor.nextIndex, end);

package/src/types.ts

@@ -35,18 +35,21 @@ export type Edit =
 	| { kind: "delete"; anchor: Anchor; lineNum: number; index: number; oldAssertion?: string }
 	| {
 			/**
-			 * Deferred block edit (`replace block N:` / `delete block N`). The exact
-			 * line span is unknown at parse time — it is computed by
-			 * {@link resolveBlockEdits} once file text + path (→ language) are
-			 * available, then expanded into concrete edits: a non-empty `payloads`
-			 * (from `replace block`) becomes the same `replacement` inserts + deletes
-			 * that `replace start..end:` produces; an empty `payloads` (from `delete
-			 * block`) becomes a pure range deletion. `applyEdits` never sees this
+			 * Deferred block edit (`replace block N:` / `delete block N` /
+			 * `insert after block N:`). The exact line span is unknown at parse
+			 * time — it is computed by {@link resolveBlockEdits} once file text +
+			 * path (→ language) are available, then expanded into concrete edits:
+			 * a non-empty `payloads` without `mode` (from `replace block`) becomes
+			 * the same `replacement` inserts + deletes that `replace start..end:`
+			 * produces; an empty `payloads` (from `delete block`) becomes a pure
+			 * range deletion; `mode: "insert_after"` becomes plain `after_anchor`
+			 * inserts at the block's last line. `applyEdits` never sees this
 			 * variant.
 			 */
 			kind: "block";
 			anchor: Anchor;
 			payloads: string[];
+			mode?: "insert_after";
 			lineNum: number;
 			index: number;
 	  };
@@ -122,11 +125,11 @@ export interface BlockSpan {
 }
 
 /**
- * One `replace block N:` / `delete block N` anchor resolved to its concrete
- * line span. Surfaced on {@link ApplyResult} so the host can echo
- * "block N → lines start..end" and let the model catch a wrong opener — e.g. a
- * decorator or doc-comment that sits in a separate node outside the resolved
- * block.
+ * One `replace block N:` / `delete block N` / `insert after block N:` anchor
+ * resolved to its concrete line span. Surfaced on {@link ApplyResult} so the
+ * host can echo "block N → lines start..end" and let the model catch a wrong
+ * opener — e.g. a decorator or doc-comment that sits in a separate node
+ * outside the resolved block.
  */
 export interface BlockResolution {
 	/** The 1-indexed line the block op was anchored on (the `N`). */
@@ -135,8 +138,8 @@ export interface BlockResolution {
 	start: number;
 	/** Last line of the resolved span (1-indexed, inclusive). */
 	end: number;
-	/** True for `delete block N`; false for `replace block N:`. */
-	isDelete: boolean;
+	/** Which block op produced this resolution. */
+	op: "replace" | "delete" | "insert_after";
 }
 
 /** Request handed to a {@link BlockResolver} to resolve one `replace block N:` anchor. */