@prometheus-ai/hashline 0.5.4 → 0.5.8

package/src/input.ts

@@ -88,8 +88,9 @@ function normalizeHashlinePath(rawPath: string, cwd?: string): string {
 	const unquoted = stripApplyPatchPathNoise(unquoteHashlinePath(rawPath.trim()));
 	if (!cwd || !path.isAbsolute(unquoted)) return unquoted;
 	const relative = path.relative(path.resolve(cwd), path.resolve(unquoted));
+	const normalizedRelative = relative.split(path.sep).join("/");
 	const isWithinCwd = relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
-	return isWithinCwd ? relative || "." : unquoted;
+	return isWithinCwd ? normalizedRelative || "." : unquoted;
 }
 
 interface RawSection {
@@ -309,12 +310,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 +337,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

@@ -1,128 +1,181 @@
-/**
- * Centralized error and warning text emitted by the hashline parser, applier,
- * and patcher. Consolidating these as named constants makes them easy to
- * audit and keeps wording stable across the rendering paths that surface
- * them.
- */
+/** Centralized error/warning text for the hashline parser, applier, and patcher. */
 
-import { HL_FILE_HASH_SEP, HL_FILE_PREFIX, HL_FILE_SUFFIX } from "./format";
+import { formatNumberedLine, HL_FILE_HASH_SEP, HL_FILE_PREFIX, HL_FILE_SUFFIX } from "./format";
 
 /** Lines of context shown either side of a hash mismatch. */
 export const MISMATCH_CONTEXT = 2;
 
-/** Optional patch envelope start marker; silently consumed when present. */
+/**
+ * Numbered `LINE:TEXT` rows around `anchorLines` (±{@link MISMATCH_CONTEXT}),
+ * `*`-marking anchors, `...` between non-adjacent runs. Out-of-range anchors
+ * contribute no rows.
+ */
+export function formatAnchoredContext(anchorLines: readonly number[], fileLines: readonly string[]): string[] {
+	const displayLines = new Set<number>();
+	for (const line of anchorLines) {
+		if (line < 1 || line > fileLines.length) continue;
+		const lo = Math.max(1, line - MISMATCH_CONTEXT);
+		const hi = Math.min(fileLines.length, line + MISMATCH_CONTEXT);
+		for (let lineNum = lo; lineNum <= hi; lineNum++) displayLines.add(lineNum);
+	}
+	const anchorSet = new Set(anchorLines);
+	const rows: string[] = [];
+	let previous = -1;
+	for (const lineNum of [...displayLines].sort((a, b) => a - b)) {
+		if (previous !== -1 && lineNum > previous + 1) rows.push("...");
+		previous = lineNum;
+		const marker = anchorSet.has(lineNum) ? "*" : " ";
+		rows.push(`${marker}${formatNumberedLine(lineNum, fileLines[lineNum - 1] ?? "")}`);
+	}
+	return rows;
+}
+
+/** Optional patch envelope start marker; silently consumed. */
 export const BEGIN_PATCH_MARKER = "*** Begin Patch";
 
-/** Optional patch envelope end marker; terminates parsing when encountered. */
+/** Optional patch envelope end marker; terminates parsing. */
 export const END_PATCH_MARKER = "*** End Patch";
 
 /**
- * Recovery sentinel emitted by an agent loop when a contaminated tool-call
- * stream is truncated mid-call. Behaves like {@link END_PATCH_MARKER} for
- * parsing — terminates the line loop — and does not surface a warning.
+ * Truncation sentinel emitted by an agent loop mid-call. Ends parsing like
+ * {@link END_PATCH_MARKER}, without a warning.
  */
 export const ABORT_MARKER = "*** Abort";
 
-/** Warning text appended when two consecutive hunks target the exact same concrete range. */
+/** Two consecutive hunks targeted the exact same concrete range. */
 export const REPLACE_PAIR_COALESCED_WARNING =
-	"Detected two identical-range hashline hunks; kept only the second hunk. Issue ONE `replace N..M:` hunk per range — payload is the final desired content, never both old and new.";
+	"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.";
 
-/** Warning text appended when an empty bodyless hunk is followed by an overlapping concrete hunk. */
+/** Bare bodyless hunk followed by an overlapping concrete hunk. */
 export const REPLACE_PAIR_COALESCED_OVERLAP_WARNING =
-	"Detected an overlapping bare hashline hunk immediately followed by a concrete hunk; dropped the earlier bare hunk. Issue ONE `replace N..M:` hunk per range — payload is the final desired content, never both old and new.";
+	"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.";
 
-/** Warning text appended when bare body rows are auto-converted to literal rows. */
+/** Bare body rows auto-converted to literal `+` rows. */
 export const BARE_BODY_AUTO_PIPED_WARNING =
-	"Auto-prefixed bare body row(s) with `+`. Body rows must be `+TEXT` literal lines; pasting raw code as payload is not a portable shape.";
+	"Auto-prefixed bare body row(s) with `+`. Body rows must be `+TEXT` literal lines.";
 
-/** Error text emitted when a hunk body contains a unified-diff-style `-` row. */
+/** Unified-diff-style `-` row in a hunk body. */
 export const MINUS_ROW_REJECTED =
-	"`-` rows are not valid; hashline ranges already name the lines being changed. To insert a literal line starting with `-`, write `+-…`.";
+	"`-` rows are not valid; the range already names the lines being changed. For a literal `-` line, write `+-…`.";
 
-/** Error text emitted when a replace hunk has no body. */
+/** 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`.";
 
-/** Error text emitted when a `replace block N:` hunk has no body. */
+/** `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 N..M` with the block's line range.";
+	"`replace block N:` needs at least one `+TEXT` body row. To delete a block, use `delete block N`.";
 
 /**
- * Error text emitted when a `replace block N:` anchor 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.
+ * 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
+ * lowered to plain `insert after N:` instead (see
+ * {@link insertAfterBlockUnresolvedLoweredWarning}).
  */
-export function blockUnresolvedMessage(line: number): string {
-	return (
-		`\`replace block ${line}:\` 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.`
-	);
+export function blockUnresolvedMessage(
+	line: number,
+	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:`;
+	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.`;
+	if (fileLines) {
+		const context = formatAnchoredContext([line], fileLines);
+		if (context.length > 0) message += `\n\n${context.join("\n")}`;
+	}
+	return message;
 }
 
+/** 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.";
+
 /**
- * Error text emitted when a `replace block N:` edit reaches a code path that
- * has no {@link BlockResolver} wired in. Indicates a host-configuration bug
- * rather than authored-input error.
+ * `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 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 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.`;
+}
+
+/**
+ * `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.`;
+}
 
 /**
- * Internal invariant error: `applyEdits` received an unresolved `replace block
- * N:` edit. Block edits must be expanded by `resolveBlockEdits` before reaching
- * the applier; hitting this is a wiring bug, not authored-input error.
+ * 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).";
 
-/** Error text emitted when a delete hunk receives a body row. */
+/** 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:`.";
 
-/** Error text emitted when a `delete block N` hunk receives a body row. */
+/** `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:` to replace the block.";
+	"`delete block N` does not take body rows. Remove the body, or use `replace block N:`.";
 
-/** Error text emitted when an insert hunk has no body. */
+/** Insert hunk with no body. */
 export const EMPTY_INSERT = "`insert` needs at least one `+TEXT` body row.";
 
-/** Warning text emitted by `Recovery` when an external write fits a cached snapshot. */
+/**
+ * `insert after` body indented shallower than the anchor: the landing slid
+ * forward past trailing closer lines — the common "anchored on the last line
+ * 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.`;
+}
+
+/**
+ * `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}:\`.`;
+}
+
+/** `Recovery`: an external write matched 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).";
 
-/** Warning text emitted by `Recovery` when a prior in-session edit advanced the hash. */
+/** `Recovery`: a prior in-session edit advanced the hash. */
 export const RECOVERY_SESSION_CHAIN_WARNING =
-	"Recovered from a stale file hash using an earlier in-session snapshot (the file hash advanced after a prior edit in this session).";
+	"Recovered from a stale file hash using an earlier in-session snapshot (a prior edit in this session advanced the hash).";
 
 /**
- * Warning text emitted by `Recovery` when the session-chain replay
- * fast-path was taken. Distinct from {@link RECOVERY_SESSION_CHAIN_WARNING}
- * because replay is the less-certain mode: the structured-patch 3-way
- * merge refused, the anchor-content gate passed, but a coincidental
- * insert+delete pair earlier in the chain could still leave an anchor's
- * line number pointing at a duplicated row. Surface the hedge so the
- * model verifies before continuing.
+ * `Recovery`: session-chain replay fast-path. Less certain than
+ * {@link RECOVERY_SESSION_CHAIN_WARNING} — the 3-way merge refused, the
+ * anchor-content gate passed, but a coincidental insert+delete earlier in
+ * the chain could still misplace an anchor — hence the verify hedge.
  */
 export const RECOVERY_SESSION_REPLAY_WARNING =
-	"Recovered by replaying your edits onto the current file content — your previous edit in this session changed line(s) you re-targeted with a stale hash. Verify the diff matches your intent before continuing.";
+	"Recovered by replaying your edits onto the current file content (a prior in-session edit changed the lines you re-targeted with a stale hash). Verify the diff matches your intent.";
 
 /**
- * Warning emitted when an `insert head:` / `insert tail:` edit is applied to an
- * existing file whose snapshot tag is stale (the file drifted since the read).
- * Head/tail insert position is content-independent — "start"/"end" cannot move
- * with drift — so this is non-fatal: the edit applies onto the live content and
- * we surface the drift instead of hard-failing (unlike an anchored mismatch).
+ * `insert head:`/`insert tail:` applied despite a stale snapshot tag.
+ * Head/tail position is content-independent, so drift is non-fatal: apply
+ * onto live content and warn instead of hard-failing.
  */
 export const HEADTAIL_DRIFT_WARNING =
-	"Applied an `insert head:`/`insert tail:` edit onto the current file content even though the snapshot tag was stale (the file changed since your read). Head/tail position is content-independent, so the insert was not rejected — but re-read if the drift was unexpected.";
+	"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.";
 
 /**
- * Error text emitted when a hashline section omits the mandatory snapshot tag.
- * The tag is REQUIRED on every section, enforced identically by the apply path
- * ({@link Patcher.prepare}) and the preview/diff path, so both surfaces reuse
- * this single builder to stay in lockstep.
+ * Section omitted the mandatory snapshot tag. Shared by the apply
+ * ({@link Patcher.prepare}) and preview/diff paths so both stay in lockstep.
  */
 export function missingSnapshotTagMessage(sectionPath: string): string {
-	return `Missing hashline snapshot tag for edit to ${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.`;
+	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.`;
 }

package/src/mismatch.ts

@@ -6,8 +6,8 @@
  * plus a couple of lines of surrounding context. The {@link MismatchError}
  * formats this into a message at construction time.
  */
-import { formatNumberedLine, HL_FILE_HASH_EXAMPLES, HL_FILE_HASH_SEP, HL_FILE_PREFIX, HL_FILE_SUFFIX } from "./format";
-import { MISMATCH_CONTEXT } from "./messages";
+import { HL_FILE_HASH_EXAMPLES, HL_FILE_HASH_SEP, HL_FILE_PREFIX, HL_FILE_SUFFIX } from "./format";
+import { formatAnchoredContext } from "./messages";
 
 const LINE_REF_RE = /^\s*[>+\-*]*\s*(\d+)(?::.*)?\s*$/;
 /** Format the required-shape diagnostic shown when a line reference is malformed. */
@@ -46,17 +46,6 @@ export interface MismatchDetails {
 	hashRecognized?: boolean;
 }
 
-function getMismatchDisplayLines(anchorLines: readonly number[], fileLines: string[]): number[] {
-	const displayLines = new Set<number>();
-	for (const line of anchorLines) {
-		if (line < 1 || line > fileLines.length) continue;
-		const lo = Math.max(1, line - MISMATCH_CONTEXT);
-		const hi = Math.min(fileLines.length, line + MISMATCH_CONTEXT);
-		for (let lineNum = lo; lineNum <= hi; lineNum++) displayLines.add(lineNum);
-	}
-	return [...displayLines].sort((a, b) => a - b);
-}
-
 /**
  * Raised when a hashline section's snapshot tag doesn't match the live file's
  * content (and recovery, if configured, declined the merge). Carries the
@@ -113,19 +102,10 @@ export class MismatchError extends Error {
 	}
 
 	static formatMessage(details: MismatchDetails): string {
-		const anchorSet = new Set(details.anchorLines ?? []);
 		const lines = MismatchError.rejectionHeader(details);
-		const displayLines = getMismatchDisplayLines(details.anchorLines ?? [], details.fileLines);
-		if (displayLines.length === 0) return lines.join("\n");
-		lines.push("");
-		let previous = -1;
-		for (const lineNum of displayLines) {
-			if (previous !== -1 && lineNum > previous + 1) lines.push("...");
-			previous = lineNum;
-			const text = details.fileLines[lineNum - 1] ?? "";
-			const marker = anchorSet.has(lineNum) ? "*" : " ";
-			lines.push(`${marker}${formatNumberedLine(lineNum, text)}`);
-		}
+		const context = formatAnchoredContext(details.anchorLines ?? [], details.fileLines);
+		if (context.length === 0) return lines.join("\n");
+		lines.push("", ...context);
 		return lines.join("\n");
 	}
 }

package/src/parser.ts

@@ -12,6 +12,7 @@ import {
 	EMPTY_INSERT,
 	MINUS_ROW_REJECTED,
 } from "./messages";
+import { stripOneLeadingHashlinePrefix } from "./prefixes";
 import { type BlockTarget, cloneCursor, type ParsedRange, type Token, Tokenizer } from "./tokenizer";
 import type { Anchor, Cursor, Edit } from "./types";
 
@@ -31,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;
@@ -81,12 +89,18 @@ interface PendingComment {
 	text: string;
 }
 
-type PayloadRow = { kind: "literal"; text: string; lineNum: number };
+type PayloadRow = { kind: "literal"; text: string; lineNum: number; bare?: boolean };
 
 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 {
@@ -126,6 +140,7 @@ export class Executor {
 				return;
 			case "blank":
 				this.#consumePendingSkippableComments();
+				this.#handleBlank("", token.lineNum);
 				return;
 			case "payload-literal":
 				this.#consumePendingSkippableComments();
@@ -145,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;
 		}
 	}
@@ -207,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 });
 	}
 
@@ -214,13 +230,24 @@ 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.#pending.payloads.push({ kind: "literal", text, lineNum });
+			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
+			// row in isolation would corrupt a genuine body that merely starts
+			// with "digits:" (YAML ports "42:hello", timestamps "12:30") when it
+			// sits next to an unprefixed sibling. Rows with an explicit "+" go
+			// through #handleLiteralPayload and are never bare, never stripped.
+			this.#pending.payloads.push({ kind: "literal", text, lineNum, bare: true });
 			return;
 		}
 		if (text.trim().length === 0) return;
@@ -230,6 +257,56 @@ 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
+	 * the signature of content pasted straight from `read`/`search` output; a
+	 * mixed set means the `N:` is genuine payload content and must stay. Rows
+	 * authored with an explicit `+` are not bare and are never touched.
+	 */
+	#stripBarePrefixesIfUniform(payloads: PayloadRow[]): void {
+		let sawBare = false;
+		let allLiteralValues = true;
+		for (const row of payloads) {
+			if (!row.bare || row.text.trim().length === 0) continue;
+			sawBare = true;
+			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.trim().length > 0) row.text = stripOneLeadingHashlinePrefix(row.text);
+		}
+	}
+
 	#pushInsert(cursor: Cursor, text: string, lineNum: number, mode?: "replacement"): void {
 		this.#edits.push({
 			kind: "insert",
@@ -245,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++,
 		});
@@ -263,6 +341,7 @@ export class Executor {
 		const pending = this.#pending;
 		if (!pending) return;
 		const { target, lineNum, payloads } = pending;
+		this.#stripBarePrefixesIfUniform(payloads);
 		this.#pending = undefined;
 		if (target.kind === "delete") {
 			for (const anchor of expandRange(target.range)) this.#pushDelete(anchor, lineNum);
@@ -278,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

@@ -33,7 +33,7 @@ import { MismatchError } from "./mismatch";
 import { detectLineEnding, type LineEnding, normalizeToLF, restoreLineEndings, stripBom } from "./normalize";
 import { Recovery, type RecoveryResult } from "./recovery";
 import type { SnapshotStore } from "./snapshots";
-import type { ApplyResult, BlockResolver, Edit } from "./types";
+import type { ApplyResult, BlockResolution, BlockResolver, Edit } from "./types";
 
 export interface PatcherOptions {
 	/** Storage backend used for all reads and writes. */
@@ -72,6 +72,12 @@ export interface PatchSectionResult {
 	firstChangedLine?: number;
 	/** Warnings collected by the parser, applier, and (optionally) recovery. */
 	warnings: string[];
+	/**
+	 * 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).
+	 */
+	blockResolutions?: BlockResolution[];
 }
 
 export interface PatcherApplyResult {
@@ -193,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 };
 	}
 
@@ -300,6 +323,7 @@ export class Patcher {
 			fileHash,
 			header: formatHashlineHeader(section.path, fileHash),
 			firstChangedLine: applyResult.firstChangedLine,
+			blockResolutions: applyResult.blockResolutions,
 			warnings,
 		};
 	}
@@ -355,6 +379,8 @@ export class Patcher {
 		//     resulting ranges flow through the 3-way-merge recovery below.
 		// 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 =
@@ -362,20 +388,32 @@ export class Patcher {
 			if (baseText === undefined) {
 				throw this.#mismatchError(section, canonicalPath, normalized, expected ?? "", false);
 			}
-			resolved = resolveBlockEdits(edits, baseText, section.path, this.blockResolver, { onUnresolved: "throw" });
+			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 ?? [])] };
 
-		if (expected === undefined) return applyEdits(normalized, resolved);
-		// Whole-file unchanged → the tag still names the live content, so an
-		// edit anchored at ANY line (displayed or not) is safe to apply.
-		if (liveMatches) return applyEdits(normalized, resolved);
+		// 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
+		// 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) {
+			const result = applyEdits(normalized, resolved);
+			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
 		// content and warn instead of hard-failing — unlike an anchored
 		// 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.
@@ -385,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);
 	}