@oh-my-pi/hashline 15.11.3 → 15.11.4

package/dist/types/apply.d.ts

@@ -1,4 +1,6 @@
 import type { ApplyResult, Edit } from "./types";
+/** A line that is nothing but closing delimiters: `}`, `)`, `];`, `})`, `},`. */
+export declare const STRUCTURAL_CLOSER_RE: RegExp;
 /**
  * Apply a parsed list of edits to a text body. Pure function — no I/O.
  *

package/dist/types/block.d.ts

@@ -15,6 +15,12 @@ export interface ResolveBlockEditsOptions {
      * edits.
      */
     onResolved?: (resolution: BlockResolution) => void;
+    /**
+     * Invoked once per diagnostic produced while resolving — currently only the
+     * closer-anchor lowering of `insert after block N:`. Hosts should surface
+     * these on the apply result's `warnings`.
+     */
+    onWarning?: (message: string) => void;
 }
 /** True when at least one edit is an unresolved deferred block edit. */
 export declare function hasBlockEdit(edits: readonly Edit[]): boolean;

package/dist/types/messages.d.ts

@@ -50,6 +50,13 @@ export declare function blockUnresolvedMessage(line: number, op?: "replace" | "d
  * rather than authored-input error.
  */
 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.";
+/**
+ * Warning emitted when an `insert after block N:` anchored on a pure
+ * closing-delimiter line is lowered to plain `insert after N:`. No block
+ * begins on a closer, but the closer IS the end of one — and inserting after
+ * the end of that block is exactly what the plain form does.
+ */
+export declare function insertAfterBlockCloserLoweredWarning(line: number): string;
 /**
  * Internal invariant error: `applyEdits` received an unresolved `replace block
  * N:` edit. Block edits must be expanded by `resolveBlockEdits` before reaching
@@ -71,6 +78,14 @@ export declare const EMPTY_INSERT = "`insert` needs at least one `+TEXT` body ro
  * I read" mistake.
  */
 export declare function afterInsertLandingShiftWarning(anchorLine: number, landingLine: number, crossed: number): string;
+/**
+ * Warning emitted when an `insert after block N:` body is indented deeper
+ * than the block's closing line and the landing was pulled back inside the
+ * block. `insert after block` places content AFTER the block at sibling
+ * depth; a deeper body almost always means "append inside the block's body"
+ * — the misuse this corrects.
+ */
+export declare function blockInsertLandingShiftWarning(blockStart: number, closerLine: number, landingLine: 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/types.d.ts

@@ -33,6 +33,13 @@ export type Edit = {
     lineNum: number;
     index: number;
     mode?: "replacement";
+    /**
+     * Present on inserts lowered from `insert after block N:`: the
+     * resolved block's first line. Lets the applier slide a body that
+     * claims a depth inside the block back across the block's trailing
+     * closer lines (never above this line).
+     */
+    blockStart?: number;
 } | {
     kind: "delete";
     anchor: Anchor;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/hashline",
-	"version": "15.11.3",
+	"version": "15.11.4",
 	"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 { afterInsertLandingShiftWarning, UNRESOLVED_BLOCK_INTERNAL } from "./messages";
+import { afterInsertLandingShiftWarning, blockInsertLandingShiftWarning, UNRESOLVED_BLOCK_INTERNAL } from "./messages";
 import { cloneCursor } from "./tokenizer";
 import type { Anchor, ApplyResult, Cursor, Edit } from "./types";
 
@@ -123,7 +123,7 @@ function bucketAnchorEditsByLine(edits: IndexedEdit[]): Map<number, IndexedEdit[
 // wrapper" mistake.
 
 /** A line that is nothing but closing delimiters: `}`, `)`, `];`, `})`, `},`. */
-const STRUCTURAL_CLOSER_RE = /^\s*[)\]}]+[;,]?\s*$/;
+export const STRUCTURAL_CLOSER_RE = /^\s*[)\]}]+[;,]?\s*$/;
 
 interface DelimiterBalance {
 	paren: number;
@@ -511,20 +511,32 @@ function repairReplacementBoundaries(
 //
 // 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.
+// to sit. Two corrections share that claim, in opposite directions:
 //
-// 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.
+// Outward (any after-insert): when the 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.
+//
+// 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
+// across the block's trailing closer lines places the body inside, at its
+// claimed depth. Scoped to block-lowered inserts because there the author
+// named the opener and never saw the closer; a plain `insert after M:` on a
+// closer line stays literal (the escape hatch for genuinely-after content
+// such as method-chain continuations).
+//
+// Both shifts are deliberately conservative: they fire only when the body
+// and anchor indentation are comparable (one is a prefix of the other),
+// cross only pure closing-delimiter lines, stop as soon as depth matches the
+// body's claim, and are 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 when the original landing was intended.
 
 /** Leading run of tabs and spaces. */
 function leadingIndent(line: string): string {
@@ -547,6 +559,8 @@ 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:`. */
+	blockStart?: number;
 }
 
 /**
@@ -603,10 +617,52 @@ function resolveShiftedLanding(
 }
 
 /**
- * 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.
+ * Resolve where a block-lowered after-insert anchored on the block's closing
+ * line should land given a body depth `target` deeper than that closer: just
+ * above the block's trailing run of closer lines, bounded below by
+ * `blockStart` (an empty block lands the body right after its opener).
+ * Returns `undefined` when the landing stays put.
+ */
+function resolveInwardLanding(
+	group: AfterInsertGroup,
+	target: string,
+	blockStart: number,
+	fileLines: readonly string[],
+	targetedLines: ReadonlySet<number>,
+): number | undefined {
+	const anchorText = fileLines[group.anchor - 1];
+	if (anchorText === undefined || !hasNonWhitespace(anchorText)) return undefined;
+	// Fires only when the block ends in a pure closer the body out-indents.
+	// Blocks ending in content (indentation-only languages) already land the
+	// body inside the block — nothing to correct.
+	if (!STRUCTURAL_CLOSER_RE.test(anchorText)) return undefined;
+	if (!isIndentDeeper(target, leadingIndent(anchorText))) return undefined;
+
+	let landing = group.anchor;
+	for (let line = group.anchor; line > blockStart; line--) {
+		const text = fileLines[line - 1] ?? "";
+		if (!hasNonWhitespace(text)) {
+			landing = line - 1; // look past trailing blanks, never land after one
+			continue;
+		}
+		if (!STRUCTURAL_CLOSER_RE.test(text)) break; // content reached — land right after it
+		const indent = leadingIndent(text);
+		if (!isIndentDeeper(target, indent)) break; // closer at the body's depth — land after it
+		// Another hunk owns this closer (the group's own rows put the anchor
+		// itself in `targetedLines`; that one is ours to cross).
+		if (line !== group.anchor && targetedLines.has(line)) return undefined;
+		landing = line - 1;
+	}
+	return landing === group.anchor ? undefined : landing;
+}
+
+/**
+ * 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 —
+ * 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.
  */
 function repairAfterInsertLandings(
 	edits: readonly AppliedEdit[],
@@ -620,7 +676,8 @@ function repairAfterInsertLandings(
 		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] });
+		if (group === undefined)
+			groups.set(key, { anchor: edit.cursor.anchor.line, members: [idx], blockStart: edit.blockStart });
 		else group.members.push(idx);
 	});
 	if (groups.size === 0) return { edits, warnings: [] };
@@ -635,17 +692,27 @@ function repairAfterInsertLandings(
 
 	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;
+	const retarget = (group: AfterInsertGroup, line: number): void => {
 		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 } } };
+			out[idx] = { ...edit, cursor: { kind: "after_anchor", anchor: { line } } };
+		}
+	};
+	for (const group of groups.values()) {
+		const target = bodyTargetIndent(group.members.map(idx => (edits[idx] as InsertEdit).text));
+		if (target === undefined) continue;
+		const outward = resolveShiftedLanding(group, target, fileLines, targetedLines);
+		if (outward !== undefined) {
+			retarget(group, outward.line);
+			warnings.push(afterInsertLandingShiftWarning(group.anchor, outward.line, outward.crossed));
+			continue;
 		}
-		warnings.push(afterInsertLandingShiftWarning(group.anchor, landing.line, landing.crossed));
+		if (group.blockStart === undefined) continue;
+		const inward = resolveInwardLanding(group, target, group.blockStart, fileLines, targetedLines);
+		if (inward === undefined) continue;
+		retarget(group, inward);
+		warnings.push(blockInsertLandingShiftWarning(group.blockStart, group.anchor, inward));
 	}
 	return { edits: out ?? edits, warnings };
 }

package/src/block.ts

@@ -12,7 +12,8 @@
  * it runs, no `block` edits remain, so {@link applyEdits} (and recovery) only
  * ever see resolved edits.
  */
-import { BLOCK_RESOLVER_UNAVAILABLE, blockUnresolvedMessage } from "./messages";
+import { STRUCTURAL_CLOSER_RE } from "./apply";
+import { BLOCK_RESOLVER_UNAVAILABLE, blockUnresolvedMessage, insertAfterBlockCloserLoweredWarning } from "./messages";
 import type { BlockResolution, BlockResolver, Cursor, Edit } from "./types";
 
 export interface ResolveBlockEditsOptions {
@@ -31,6 +32,12 @@ export interface ResolveBlockEditsOptions {
 	 * edits.
 	 */
 	onResolved?: (resolution: BlockResolution) => void;
+	/**
+	 * Invoked once per diagnostic produced while resolving — currently only the
+	 * closer-anchor lowering of `insert after block N:`. Hosts should surface
+	 * these on the apply result's `warnings`.
+	 */
+	onWarning?: (message: string) => void;
 }
 
 /** True when at least one edit is an unresolved deferred block edit. */
@@ -67,6 +74,22 @@ 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` 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 block" is exactly plain `insert after N:`. Lower it
+			// instead of failing the patch; warn so the author learns the
+			// opener-only rule.
+			if (op === "insert_after" && resolver) {
+				const anchorText = text.split("\n")[edit.anchor.line - 1];
+				if (anchorText !== undefined && STRUCTURAL_CLOSER_RE.test(anchorText)) {
+					options.onWarning?.(insertAfterBlockCloserLoweredWarning(edit.anchor.line));
+					for (const payload of edit.payloads) {
+						const cursor: Cursor = { kind: "after_anchor", anchor: { line: edit.anchor.line } };
+						resolved.push({ kind: "insert", cursor, text: payload, lineNum: edit.lineNum, index: synthIndex++ });
+					}
+					continue;
+				}
+			}
 			if (onUnresolved === "drop") continue;
 			throw new Error(
 				`line ${edit.lineNum}: ${
@@ -82,10 +105,20 @@ export function resolveBlockEdits(
 		});
 		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.
+			// insert per payload row, anchored on the block's last line. The
+			// `blockStart` tag lets the applier's landing correction slide a
+			// body that claims a depth inside the block back across the block's
+			// trailing closer lines.
 			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++ });
+				resolved.push({
+					kind: "insert",
+					cursor,
+					text: payload,
+					lineNum: edit.lineNum,
+					index: synthIndex++,
+					blockStart: span.start,
+				});
 			}
 			continue;
 		}

package/src/input.ts

@@ -309,12 +309,16 @@ export class PatchSection {
 	 */
 	applyTo(text: string, blockResolver?: BlockResolver): ApplyResult {
 		const { edits, warnings } = this.parse();
-		const resolved = resolveBlockEdits(edits, text, this.path, blockResolver, { onUnresolved: "throw" });
+		const resolveWarnings: string[] = [];
+		const resolved = resolveBlockEdits(edits, text, this.path, blockResolver, {
+			onUnresolved: "throw",
+			onWarning: warning => resolveWarnings.push(warning),
+		});
 		const result = applyEdits(text, resolved);
 		// Preserve parse warnings so consumers don't need to call `parse()`
 		// separately.
-		const merged = warnings.length === 0 ? result.warnings : [...warnings, ...(result.warnings ?? [])];
-		return merged && merged.length > 0
+		const merged = [...warnings, ...resolveWarnings, ...(result.warnings ?? [])];
+		return merged.length > 0
 			? { ...result, warnings: merged }
 			: { text: result.text, firstChangedLine: result.firstChangedLine };
 	}
@@ -332,10 +336,14 @@ export class PatchSection {
 	 */
 	applyPartialTo(text: string, blockResolver?: BlockResolver): ApplyResult {
 		const { edits, warnings } = parsePatchStreaming(this.diff);
-		const resolved = resolveBlockEdits(edits, text, this.path, blockResolver, { onUnresolved: "drop" });
+		const resolveWarnings: string[] = [];
+		const resolved = resolveBlockEdits(edits, text, this.path, blockResolver, {
+			onUnresolved: "drop",
+			onWarning: warning => resolveWarnings.push(warning),
+		});
 		const result = applyEdits(text, resolved);
-		const merged = warnings.length === 0 ? result.warnings : [...warnings, ...(result.warnings ?? [])];
-		return merged && merged.length > 0
+		const merged = [...warnings, ...resolveWarnings, ...(result.warnings ?? [])];
+		return merged.length > 0
 			? { ...result, warnings: merged }
 			: { text: result.text, firstChangedLine: result.firstChangedLine };
 	}

package/src/messages.ts

@@ -116,6 +116,19 @@ export function blockUnresolvedMessage(
 export 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.";
 
+/**
+ * Warning emitted when an `insert after block N:` anchored on a pure
+ * closing-delimiter line is lowered to plain `insert after N:`. No block
+ * begins on a closer, but the closer IS the end of one — and inserting after
+ * the end of that block is exactly what the plain form does.
+ */
+export function insertAfterBlockCloserLoweredWarning(line: number): string {
+	return (
+		`\`insert after block ${line}:\` anchors on a closing-delimiter line; no block begins there, so it was applied as plain \`insert after ${line}:\`. ` +
+		"Anchor `insert after block` on the line that OPENS the construct."
+	);
+}
+
 /**
  * Internal invariant error: `applyEdits` received an unresolved `replace block
  * N:` edit. Block edits must be expanded by `resolveBlockEdits` before reaching
@@ -150,6 +163,22 @@ export function afterInsertLandingShiftWarning(anchorLine: number, landingLine:
 	);
 }
 
+/**
+ * Warning emitted when an `insert after block N:` body is indented deeper
+ * than the block's closing line and the landing was pulled back inside the
+ * block. `insert after block` places content AFTER the block at sibling
+ * depth; a deeper body almost always means "append inside the block's body"
+ * — the misuse this corrects.
+ */
+export function blockInsertLandingShiftWarning(blockStart: number, closerLine: number, landingLine: number): string {
+	return (
+		`insert after block ${blockStart}: the body is indented deeper than the block's closing line ${closerLine}, ` +
+		`so it was placed inside the block, after line ${landingLine}. ` +
+		"`insert after block` always lands AFTER the block at sibling depth — if you meant that, " +
+		`re-issue as plain \`insert after ${closerLine}:\` with the body indented to match line ${closerLine}.`
+	);
+}
+
 /** 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/patcher.ts

@@ -380,6 +380,7 @@ export class Patcher {
 		// When a block edit needs the tagged snapshot but it is unavailable, the
 		// range cannot be placed safely — reject with a MismatchError (re-read).
 		const blockResolutions: BlockResolution[] = [];
+		const resolveWarnings: string[] = [];
 		let resolved: readonly Edit[] = edits;
 		if (hasBlockEdit(edits)) {
 			const baseText =
@@ -390,8 +391,13 @@ export class Patcher {
 			resolved = resolveBlockEdits(edits, baseText, section.path, this.blockResolver, {
 				onUnresolved: "throw",
 				onResolved: resolution => blockResolutions.push(resolution),
+				onWarning: warning => resolveWarnings.push(warning),
 			});
 		}
+		const withResolveWarnings = (result: ApplyResult): ApplyResult =>
+			resolveWarnings.length === 0
+				? result
+				: { ...result, warnings: [...resolveWarnings, ...(result.warnings ?? [])] };
 
 		// No tag, or the tag still names the live content: an edit anchored at any
 		// line is safe to apply, and the resolved block spans line up with what
@@ -399,7 +405,7 @@ export class Patcher {
 		// recovery below, where line numbers shift, so resolutions are dropped.)
 		if (expected === undefined || liveMatches) {
 			const result = applyEdits(normalized, resolved);
-			return blockResolutions.length > 0 ? { ...result, blockResolutions } : result;
+			return withResolveWarnings(blockResolutions.length > 0 ? { ...result, blockResolutions } : result);
 		}
 		// Head/tail-only inserts are position-stable: "start"/"end" cannot move
 		// with content drift, so a stale tag is non-fatal. Apply onto the live
@@ -407,7 +413,7 @@ export class Patcher {
 		// mismatch, which cannot be safely relocated and must reject.
 		if (!hasAnchorScopedEdit(resolved)) {
 			const result = applyEdits(normalized, resolved);
-			return { ...result, warnings: [HEADTAIL_DRIFT_WARNING, ...(result.warnings ?? [])] };
+			return withResolveWarnings({ ...result, warnings: [HEADTAIL_DRIFT_WARNING, ...(result.warnings ?? [])] });
 		}
 		// File drifted: try to replay the edit against the version the tag
 		// names and 3-way-merge it onto the live content.
@@ -417,7 +423,7 @@ export class Patcher {
 			fileHash: expected,
 			edits: resolved,
 		});
-		if (recovered) return recoveryToApplyResult(recovered);
+		if (recovered) return withResolveWarnings(recoveryToApplyResult(recovered));
 		const hashRecognized = this.snapshots.byHash(canonicalPath, expected) !== null;
 		throw this.#mismatchError(section, canonicalPath, normalized, expected, hashRecognized);
 	}

package/src/prompt.md

@@ -5,13 +5,13 @@ 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. 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).
+`replace N..M:` — replace original lines N..M with the body rows below. INCLUSIVE — line M is consumed too.
+`replace block N:` — replace the whole syntactic block that BEGINS on line N; tree-sitter resolves the closing line. Body rows below.
 `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. Point N at the line that OPENS the construct (the `if`/`function`/`def`/`{`-bearing line), not the closing delimiter / last visible line; if you have the last line, use plain `insert after M:` instead.
+`insert after block N:` — insert the body rows after the END of the block that BEGINS on line N — outside it, at sibling depth. To append inside a block, use `insert after`.
 `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:`).
@@ -24,22 +24,22 @@ There is NO other body row kind. NEVER write `-old` or a bare/context line. To k
 </body-rows>
 
 <rules>
-- Line numbers come from `read`/`search` (`LINE:TEXT`). Copy the `[PATH#TAG]` header; use the bare LINE numbers.
-- 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.
+- Line numbers and the `[PATH#TAG]` header come from your latest `read`/`search` (`LINE:TEXT` rows).
+- Numbers refer to the ORIGINAL file; they do not shift as hunks apply.
+- They die with the call: every applied edit mints a fresh `#TAG` and renumbers — anchor the next edit on the edit response or a fresh `read`.
+- Touch only lines you literally saw as `LINE:TEXT`; the tag certifies the snapshot, not your knowledge of it.
+- Elided regions (`…`) are UNSEEN — never place or span a hunk across one; `read` it first.
+- Never start or end a range mid-expression or mid-block.
+- Indent body rows exactly for the depth they should live at.
+- On a stale-tag rejection or any surprising result: STOP and re-`read` before further edits.
 - 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 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.
-- `insert after block N` follows the same opener-only anchor rule as `replace block N`: N is the first line of the syntactic block, never a line inside it, its closing delimiter, or its last visible line. To append after a closing delimiter you can see, use plain `insert after M:`.
-- 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.
+- Ranges cover ONLY lines whose content changes. Never widen over unchanged lines — a stale wide range shreds everything it spans.
+- Whole construct → `replace block N` (tree-sitter resolves the end); lines inside it → `replace N..M`.
+- `replace block N` resolves EXACTLY the node at N. Leading decorators/attributes/doc-comments are separate nodes: point N at the FIRST decorator to sweep both; standalone line-comments are never swept — use `replace N..M`.
+- `insert after block N`: N is the opener, never the closer or last visible line; saw the closer? Use plain `insert after M:`.
+- Non-adjacent changes = separate hunks; untouched lines stay out of every range.
+- Pure additions use `insert`, never a widened `replace` — retyped keepers are exactly what gets dropped.
+- NEVER format/restyle code with this tool; run the project formatter instead.
 </rules>
 
 <example>
@@ -137,7 +137,7 @@ insert after 3:
 
 <critical>
 If you remember nothing else:
-1. RE-GROUND AFTER EVERY EDIT. Each applied edit mints a fresh `#TAG` and renumbers the file — the tag and line numbers you just used are now dead. Take the next edit's numbers from the edit response or a fresh `read`, never from pre-edit memory. On a stale-tag rejection or any unexpected result, STOP and re-`read`.
-2. RANGES ARE TIGHT AND IN-BOUNDS. Cover only lines whose content actually changes; never widen a range to swallow an unchanged signature, brace, or statement, and never start or end a range mid-expression or mid-block. A stale one-line range corrupts one line; a stale wide range shreds everything it spans — to rewrite a whole construct, prefer `replace block N` so tree-sitter fixes the end.
-3. THE BODY IS THE FINAL CONTENT. Only `+TEXT` rows under a `:` header — never `-old`/bare context lines, never an old/new pair. The range does the deleting.
+1. RE-GROUND AFTER EVERY EDIT. Every apply mints a fresh `#TAG` and renumbers — take the next edit's numbers from the edit response or a fresh `read`. Stale tag or surprise? STOP, re-`read`.
+2. RANGES ARE TIGHT. Cover only lines that change; a stale wide range shreds everything it spans. Whole construct → `replace block N`.
+3. THE BODY IS THE FINAL CONTENT. Only `+TEXT` rows; never `-old`/context lines. The range does the deleting.
 </critical>

package/src/types.ts

@@ -31,6 +31,13 @@ export type Edit =
 			lineNum: number;
 			index: number;
 			mode?: "replacement";
+			/**
+			 * Present on inserts lowered from `insert after block N:`: the
+			 * resolved block's first line. Lets the applier slide a body that
+			 * claims a depth inside the block back across the block's trailing
+			 * closer lines (never above this line).
+			 */
+			blockStart?: number;
 	  }
 	| { kind: "delete"; anchor: Anchor; lineNum: number; index: number; oldAssertion?: string }
 	| {