@oh-my-pi/pi-coding-agent 15.5.1 → 15.5.3

package/CHANGELOG.md

@@ -2,6 +2,32 @@
 
 ## [Unreleased]
 
+## [15.5.3] - 2026-05-27
+### Breaking Changes
+
+- Disallowed inline payload on hashline `↑`, `↓`, and `:` operations (including BOF/EOF inserts), requiring payload text to be supplied on standalone `+` continuation rows
+
+### Changed
+
+- Warned when legacy inline `LINE:TEXT` lines are accepted as payload continuations only when inside a pending multi-line `A-B:` replacement
+
+## [15.5.2] - 2026-05-26
+### Breaking Changes
+
+- Changed the hashline patch format so payload continuation lines now require a leading `+`, rejecting unprefixed multiline payload rows that were previously accepted as fallback payload text
+
+### Changed
+
+- Changed hashline payload parsing so blank lines are only preserved when prefixed with `+`, so blank separator lines between operations are ignored unless explicitly marked
+- Changed payload escaping so a line beginning with `+` is now represented as `++...` while the leading marker is stripped before writing
+- Changed the default `task.simple` mode from `default` to `schema-free`, so task-call `schema` inputs are disabled by default while shared `context` and user prompt/session-defined output schemas remain available
+- Changed `tools.approvalMode: yolo` to auto-approve tool calls even when a tool marks `override: true`; user `tools.approval.<tool>` policies (`allow`/`prompt`/`deny`) now remain the only controls for yolo mode.
+- Changed the hashline edit executor to coalesce two consecutive `A-B:` ops on the identical range last-wins (the model painted a before/after pair) and append a warning, instead of throwing `anchor line X is already targeted by the :/! op on line Y`. Other overlap shapes (different ranges, `A-B:`+`!`, `!`+`!`) still throw.
+
+### Fixed
+
+- Fixed nested replace parsing so line-anchored `N:` rows inside a pending `A-B:` replacement now trigger overlap errors instead of being silently folded into the replacement payload
+
 ## [15.5.1] - 2026-05-26
 
 ### Breaking Changes

package/dist/types/config/settings-schema.d.ts

@@ -2151,7 +2151,7 @@ export declare const SETTINGS_SCHEMA: {
         readonly ui: {
             readonly tab: "interaction";
             readonly label: "Tool Approval";
-            readonly description: "Default approval behaviour for tool calls. 'Always ask' auto-approves read-only tools only. 'Write' auto-approves read and workspace-write tools. 'Yolo' auto-approves every tier unless a tool declares a safety override. `tools.approval.<tool>` overrides are honored in every mode.";
+            readonly description: "Default approval behaviour for tool calls. 'Always ask' auto-approves read-only tools only. 'Write' auto-approves read and workspace-write tools. 'Yolo' auto-approves all tiers; user policy may still prompt or block.";
             readonly options: readonly [{
                 readonly value: "always-ask";
                 readonly label: "Always ask";
@@ -2163,7 +2163,7 @@ export declare const SETTINGS_SCHEMA: {
             }, {
                 readonly value: "yolo";
                 readonly label: "Yolo";
-                readonly description: "Auto-approve read, write, and exec tools. Safety overrides declared by tools (for example critical bash patterns) still require confirmation.";
+                readonly description: "Auto-approve read, write, and exec tools. User policy can still require confirmation or block calls.";
             }];
         };
     };
@@ -2765,7 +2765,7 @@ export declare const SETTINGS_SCHEMA: {
     readonly "task.simple": {
         readonly type: "enum";
         readonly values: readonly ["default", "schema-free", "independent"];
-        readonly default: "default";
+        readonly default: "schema-free";
         readonly ui: {
             readonly tab: "tasks";
             readonly label: "Task Input Mode";

package/dist/types/hashline/constants.d.ts

@@ -15,3 +15,34 @@ export declare const END_PATCH_MARKER = "*** End Patch";
 export declare const ABORT_MARKER = "*** Abort";
 /** Warning text appended to the tool result when ABORT_MARKER terminates parsing. */
 export declare const ABORT_WARNING = "Tool stream truncated mid-call due to detected output corruption. Applied ops above are valid. Re-issue any remaining edits.";
+/**
+ * Warning text appended when two consecutive `A-B:` ops on the exact same
+ * range get coalesced (model painted a before/after pair). The second op
+ * wins; the first op's payload is silently discarded.
+ */
+export declare const REPLACE_PAIR_COALESCED_WARNING = "Detected an identical-range before/after replace pair; kept only the second block's payload. Issue ONE op per range \u2014 the payload is the final desired content, never both old and new.";
+/**
+ * Warning text appended when un-prefixed continuation lines are accepted as
+ * implicit payload (lenient legacy behavior). The model authored a multi-line
+ * replace without `+` prefixes; the parser accepted it because the lines did
+ * not classify as ops/headers/payloads, but the canonical syntax requires `+`
+ * on every continuation line after the op.
+ */
+export declare const IMPLICIT_CONTINUATION_WARNING = "Accepted continuation line(s) without the `+` prefix as implicit payload. Canonical syntax is `A-B:` followed by `+` on every continuation row; without `+`, lines that look like ops will be parsed as new ops instead of payload. Prefer the explicit form.";
+/**
+ * Warning text appended when an inner `LINE:TEXT` (or sub-range `A-B:TEXT`)
+ * op arrives while an outer `A-B:` replace is still pending and the inner
+ * anchor falls inside the outer range. The model used the read-output
+ * `LINE:TEXT` format as if it were a payload-continuation line; we strip the
+ * `LINE:` prefix and append the body to the pending payload, but warn so the
+ * canonical `+`-continuation form remains preferred.
+ */
+export declare const PAYLOAD_LINE_PREFIX_DEMOTED_WARNING = "Detected one or more `LINE:TEXT` lines whose anchors fell inside a pending replace range; treated them as payload-continuation lines and stripped the `LINE:` prefix. Inside an `A-B:` block, every payload line must be on its own row prefixed with `+` \u2014 never reuse the read-output gutter format.";
+/**
+ * Warning text appended when an op carries an inline payload (`LINE:TEXT`,
+ * `A-B:TEXT`, `LINE↑TEXT`, `LINE↓TEXT`). Canonical syntax is bare op +
+ * `+`-prefixed continuation rows; we accept the inline form leniently so the
+ * model's first-attempt edit still lands, but warn so the canonical form
+ * remains preferred.
+ */
+export declare const INLINE_PAYLOAD_ACCEPTED_WARNING = "Accepted inline payload on the op line (e.g. `LINE:CONTENT`, `LINE\u2191CONTENT`). Canonical syntax is the bare op followed by `+`-prefixed payload rows on the next line(s). Prefer the explicit form.";

package/dist/types/hashline/executor.d.ts

@@ -28,12 +28,13 @@ export declare class HashlineExecutor {
      */
     feed(token: HashlineToken): void;
     /**
-     * Flush any open pending op (with its full accumulated payload, blanks
-     * included) and return the accumulated edits and warnings. The executor
-     * is single-use; reset() is required for reuse.
-     * Throws if two replace/delete ops target the same line — that pattern
-     * means the diff is painting a before/after picture instead of stating
-     * the final state, and applying both would silently duplicate content.
+     * Flush any open pending op (with its full accumulated payload, including
+     * explicit `+` blank lines) and return the accumulated edits and warnings.
+     * The executor is single-use; reset() is required for reuse.
+     * Throws if two replace/delete ops target the same line with non-identical
+     * shapes (different ranges, replace+delete, delete+delete). Identical-range
+     * `A-B:` pairs in the same hunk are coalesced last-wins by `feed()` with a
+     * warning, so they never reach the validator.
      */
     end(): {
         edits: HashlineEdit[];

package/dist/types/hashline/hash.d.ts

@@ -4,14 +4,14 @@
  */
 /**
  * Decoration prefix that may precede a line number in tool output:
- * `>` (context line in grep), `+` (added line in diff), `-` (removed line),
- * `*` (match line). Any combination, in any order, surrounded by optional
+ * `>` (context line in grep), `-` (removed line), `*` (match line).
+ * Any combination, in any order, surrounded by optional
  * whitespace. Output formatters emit at most one decoration per line; the
  * parser stays liberal because it accepts whatever the model echoes back.
  */
-export declare const HL_ANCHOR_DECORATION_RE_RAW = "\\s*[>+\\-*]*\\s*";
+export declare const HL_ANCHOR_DECORATION_RE_RAW = "\\s*[>\\-*]*\\s*";
 /** Capture-group regex source for a decorated bare line-number anchor. */
-export declare const HL_ANCHOR_RE_RAW = "\\s*[>+\\-*]*\\s*(\\d+)";
+export declare const HL_ANCHOR_RE_RAW = "\\s*[>\\-*]*\\s*(\\d+)";
 /** Bare positive line-number Lid (no decorations, no captures, no anchors). */
 export declare const HL_LINE_RE_RAW = "[1-9]\\d*";
 /** Capture-group form of {@link HL_LINE_RE_RAW}. */
@@ -45,9 +45,9 @@ export declare function resolveHashlineGrammarPlaceholders(grammar: string): str
 /**
  * op lines have an `ANCHOR<SIGIL>[INLINE_PAYLOAD]` shape, where SIGIL is one of
  * {@link HL_OP_INSERT_BEFORE}, {@link HL_OP_INSERT_AFTER}, {@link HL_OP_REPLACE},
- * or {@link HL_OP_DELETE}.
- * Multi-line payloads follow on subsequent lines as verbatim file content with no
- * per-line marker.
+ * or {@link HL_OP_DELETE}. Multi-line payloads follow on subsequent lines
+ * prefixed with {@link HL_PAYLOAD_PREFIX}; that prefix is stripped before the
+ * payload is written.
  *
  * These constants are the single source of truth for the edit parser, grammar,
  * renderer, and prompt.
@@ -56,6 +56,8 @@ export declare const HL_OP_INSERT_BEFORE = "\u2191";
 export declare const HL_OP_INSERT_AFTER = "\u2193";
 export declare const HL_OP_REPLACE = ":";
 export declare const HL_OP_DELETE = "!";
+/** Prefix for payload continuation lines. The prefix itself is not written. */
+export declare const HL_PAYLOAD_PREFIX = "+";
 /** All hashline edit op sigils, concatenated for fast membership tests. */
 export declare const HL_OP_CHARS = "\u2191\u2193:!";
 /** Hashline edit file section header marker. */

package/dist/types/hashline/tokenizer.d.ts

@@ -53,6 +53,9 @@ export type HashlineToken = (TokenBase & {
 }) | (TokenBase & {
     kind: "payload";
     text: string;
+}) | (TokenBase & {
+    kind: "raw";
+    text: string;
 });
 /**
  * Stateful, line-oriented classifier for hashline diff text. Use the streaming

package/dist/types/tools/approval.d.ts

@@ -25,8 +25,8 @@ export interface ResolvedApproval {
  *  2. User per-tool override, if set and valid.
  *  3. Active mode tier comparison.
  *
- * Tool decisions with `override: true` force a prompt in every mode unless the
- * user explicitly denies the tool; deny remains the strongest policy.
+ * In yolo mode, override-based tool prompts are ignored; user `tools.approval`
+ * settings remain authoritative.
  */
 export declare function resolveApproval(tool: ApprovalSubject, args: unknown, mode: ApprovalMode, userConfig?: Record<string, unknown>): ResolvedApproval;
 /**

package/dist/types/tools/bash.d.ts

@@ -7,11 +7,11 @@ import type { ToolSession } from ".";
 import { type OutputMeta } from "./output-meta";
 export declare const BASH_DEFAULT_PREVIEW_LINES = 10;
 /**
- * Bash patterns that force an approval prompt even in yolo mode.
+ * Bash patterns flagged as safety critical for approval policy.
  *
- * Kept intentionally tight — the cost of a false positive is one extra prompt;
- * the cost of a false negative is data loss or a compromised host. New patterns
- * should target shapes that are virtually never legitimate in automation.
+ * Kept intentionally tight — the cost of a false negative is data loss or a compromised host,
+ * while false positives remain actionable through user policy control.
+ * New patterns should target shapes that are virtually never legitimate in automation.
  */
 export declare const CRITICAL_BASH_PATTERNS: readonly [RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp];
 declare const bashSchemaBase: z.ZodObject<{
@@ -42,6 +42,7 @@ export interface BashToolDetails {
     meta?: OutputMeta;
     timeoutSeconds?: number;
     requestedTimeoutSeconds?: number;
+    wallTimeMs?: number;
     terminalId?: string;
     async?: {
         state: "running" | "completed" | "failed";

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "15.5.1",
+	"version": "15.5.3",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -47,12 +47,12 @@
 		"@agentclientprotocol/sdk": "0.21.0",
 		"@babel/parser": "^7.29.3",
 		"@mozilla/readability": "^0.6.0",
-		"@oh-my-pi/omp-stats": "15.5.1",
-		"@oh-my-pi/pi-agent-core": "15.5.1",
-		"@oh-my-pi/pi-ai": "15.5.1",
-		"@oh-my-pi/pi-natives": "15.5.1",
-		"@oh-my-pi/pi-tui": "15.5.1",
-		"@oh-my-pi/pi-utils": "15.5.1",
+		"@oh-my-pi/omp-stats": "15.5.3",
+		"@oh-my-pi/pi-agent-core": "15.5.3",
+		"@oh-my-pi/pi-ai": "15.5.3",
+		"@oh-my-pi/pi-natives": "15.5.3",
+		"@oh-my-pi/pi-tui": "15.5.3",
+		"@oh-my-pi/pi-utils": "15.5.3",
 		"@puppeteer/browsers": "^2.13.0",
 		"@types/turndown": "5.0.6",
 		"@xterm/headless": "^6.0.0",

package/src/config/settings-schema.ts

@@ -1805,7 +1805,7 @@ export const SETTINGS_SCHEMA = {
 	// Default tool approval mode (interaction tab, but governs the tool wrapper).
 	//   "always-ask" — auto-approves read-tier tools only; prompts for write/exec.
 	//   "write"      — auto-approves read and write-tier tools; prompts for exec.
-	//   "yolo"       — auto-approves every tier unless a tool declares `override: true`.
+	//   "yolo"       — auto-approves every tier.
 	"tools.approvalMode": {
 		type: "enum",
 		values: ["always-ask", "write", "yolo"] as const,
@@ -1814,7 +1814,7 @@ export const SETTINGS_SCHEMA = {
 			tab: "interaction",
 			label: "Tool Approval",
 			description:
-				"Default approval behaviour for tool calls. 'Always ask' auto-approves read-only tools only. 'Write' auto-approves read and workspace-write tools. 'Yolo' auto-approves every tier unless a tool declares a safety override. `tools.approval.<tool>` overrides are honored in every mode.",
+				"Default approval behaviour for tool calls. 'Always ask' auto-approves read-only tools only. 'Write' auto-approves read and workspace-write tools. 'Yolo' auto-approves all tiers; user policy may still prompt or block.",
 			options: [
 				{
 					value: "always-ask",
@@ -1831,7 +1831,7 @@ export const SETTINGS_SCHEMA = {
 					value: "yolo",
 					label: "Yolo",
 					description:
-						"Auto-approve read, write, and exec tools. Safety overrides declared by tools (for example critical bash patterns) still require confirmation.",
+						"Auto-approve read, write, and exec tools. User policy can still require confirmation or block calls.",
 				},
 			],
 		},
@@ -2405,7 +2405,7 @@ export const SETTINGS_SCHEMA = {
 	"task.simple": {
 		type: "enum",
 		values: TASK_SIMPLE_MODES,
-		default: "default",
+		default: "schema-free",
 		ui: {
 			tab: "tasks",
 			label: "Task Input Mode",

package/src/edit/streaming.ts

@@ -388,6 +388,9 @@ function buildHashlineNaturalOrderPreviews(
 			case "abort":
 			case "op-delete":
 				continue;
+			case "blank":
+			case "raw":
+				continue;
 			case "header":
 				currentPath = token.path;
 				if (currentPath) ensure(currentPath);
@@ -404,10 +407,6 @@ function buildHashlineNaturalOrderPreviews(
 				if (!currentPath || token.inlineBody === undefined) continue;
 				ensure(currentPath).push(`+${token.inlineBody}`);
 				continue;
-			case "blank":
-				if (!currentPath) continue;
-				ensure(currentPath).push("+");
-				continue;
 			case "payload":
 				if (!currentPath) continue;
 				ensure(currentPath).push(`+${token.text}`);

package/src/extensibility/extensions/wrapper.ts

@@ -111,9 +111,8 @@ export class ExtensionToolWrapper<TParameters extends TSchema = TSchema, TDetail
 		context?: AgentToolContext,
 	) {
 		// 1. Check approval policy (before extension handlers).
-		// CLI `--auto-approve` / `--yolo` forces yolo mode for the session, but
-		// tool-level safety overrides still prompt. User `tools.approval.<tool>`
-		// policies are honored in every mode.
+		// CLI `--auto-approve` / `--yolo` sets approval mode to yolo.
+		// User `tools.approval.<tool>` policies are still applied in all modes.
 		const cliAutoApprove = context?.autoApprove === true;
 		const settings: Settings | undefined = context?.settings;
 		const configuredMode = (settings?.get("tools.approvalMode") ?? "yolo") as ApprovalMode;

package/src/hashline/anchors.ts

@@ -71,7 +71,7 @@ export class HashlineMismatchError extends Error {
 		const pathText = details.path ? ` for ${details.path}` : "";
 		return [
 			`Edit rejected${pathText}: file changed between read and edit.`,
-			`Section is bound to ${HL_FILE_HASH_SEP}${details.expectedFileHash}, but the current file hashes to ${HL_FILE_HASH_SEP}${details.actualFileHash}; re-read and try again.`,
+			`Section is bound to ${HL_FILE_HASH_SEP}${details.expectedFileHash}, but the current file hashes to ${HL_FILE_HASH_SEP}${details.actualFileHash}. If your previous edit in this session modified this file, copy the ${HL_FILE_PREFIX}path${HL_FILE_HASH_SEP}newhash from that edit's response. Otherwise re-read the file before retrying.`,
 		];
 	}
 

package/src/hashline/apply.ts

@@ -53,6 +53,57 @@ function validateHashlineLineBounds(edits: HashlineEdit[], fileLines: string[]):
 	}
 }
 
+/**
+ * Refuse a single-line replace whose target line is blank and whose payload is
+ * non-empty. The model is almost certainly miscounting: `A:CONTENT` overwrites
+ * the existing line, so applying it to a blank target deletes the blank cadence
+ * and inserts content in its place. To insert content at a blank line, use
+ * `A↑` (insert before) or `A↓` (insert after) instead.
+ *
+ * Only fires for the simple shape: exactly one `insert(before_anchor A)` + one
+ * `delete(A)` sharing the same source op line, no other inserts/deletes from
+ * that op.
+ */
+function detectReplaceOnBlankTarget(edits: HashlineEdit[], fileLines: string[]): string | null {
+	type Pair = {
+		insert?: Extract<HashlineEdit, { kind: "insert" }>;
+		delete?: Extract<HashlineEdit, { kind: "delete" }>;
+		multi?: boolean;
+	};
+	const byOpLine = new Map<number, Pair>();
+	for (const edit of edits) {
+		const pair = byOpLine.get(edit.lineNum) ?? {};
+		if (pair.multi) continue;
+		if (edit.kind === "insert") {
+			if (pair.insert) pair.multi = true;
+			else pair.insert = edit;
+		} else {
+			if (pair.delete) pair.multi = true;
+			else pair.delete = edit;
+		}
+		byOpLine.set(edit.lineNum, pair);
+	}
+	for (const pair of byOpLine.values()) {
+		if (pair.multi || !pair.insert || !pair.delete) continue;
+		const insert = pair.insert;
+		const del = pair.delete;
+		if (insert.cursor.kind !== "before_anchor") continue;
+		if (insert.cursor.anchor.line !== del.anchor.line) continue;
+		if (insert.text.includes("\n")) continue;
+		if (insert.text.trim().length === 0) continue;
+		const targetLine = del.anchor.line;
+		const oldLine = fileLines[targetLine - 1];
+		if (oldLine === undefined || oldLine.trim().length !== 0) continue;
+		return (
+			`Edit rejected: replace at line ${targetLine} targets a blank line but the payload is non-empty. ` +
+			`'A:CONTENT' overwrites the line at A; to insert content next to a blank line, use 'A${"\u2191"}' (insert before) ` +
+			`or 'A${"\u2193"}' (insert after) instead. If you really meant to replace this blank with content, ` +
+			`widen the range to include surrounding non-blank lines so the intent is explicit.`
+		);
+	}
+	return null;
+}
+
 function insertAtStart(fileLines: string[], lineOrigins: HashlineLineOrigin[], lines: string[]): void {
 	if (lines.length === 0) return;
 	const origins = lines.map((): HashlineLineOrigin => "insert");
@@ -160,10 +211,10 @@ function countMatchingSuffixBlock(fileLines: string[], endLine: number, replacem
 	return 0;
 }
 
-// Single-line duplicate absorption is limited to structural closing delimiters.
-// General one-line context is too easy to delete incorrectly, but duplicated
-// `};` / `)` / `]` boundaries usually indicate a replacement range stopped one
-// line early and would otherwise produce a syntax error.
+// Single-line replacement-boundary absorption is limited to structural closing
+// delimiters. General one-line context is too easy to delete incorrectly, but
+// duplicated `};` / `)` / `]` boundaries often mean a replacement range stopped
+// one line early and would otherwise produce a syntax error.
 const STRUCTURAL_CLOSING_BOUNDARY_RE = /^\s*[\])}]+[;,]?\s*$/;
 
 function isStructuralClosingBoundaryLine(line: string): boolean {
@@ -176,8 +227,6 @@ interface DelimiterBalance {
 	brace: number;
 }
 
-const ZERO_DELIMITER_BALANCE: DelimiterBalance = { paren: 0, bracket: 0, brace: 0 };
-
 /**
  * Naive bracket counter — does NOT skip string/template/comment contents. The
  * single-line structural absorb relies on this being safe-by-asymmetry: the
@@ -285,6 +334,7 @@ function countMatchingSingleNonStructuralPrefixDuplicate(
 ): number {
 	if (replacement.length === 0 || startLine <= 1) return 0;
 	const line = replacement[0];
+	if (line.trim().length === 0) return 0;
 	if (isStructuralClosingBoundaryLine(line)) return 0;
 	if (fileLines[startLine - 2] !== line) return 0;
 	return 1;
@@ -297,6 +347,7 @@ function countMatchingSingleNonStructuralSuffixDuplicate(
 ): number {
 	if (replacement.length === 0 || endLine >= fileLines.length) return 0;
 	const line = replacement[replacement.length - 1];
+	if (line.trim().length === 0) return 0;
 	if (isStructuralClosingBoundaryLine(line)) return 0;
 	if (fileLines[endLine] !== line) return 0;
 	return 1;
@@ -400,12 +451,11 @@ interface PureInsertAbsorbResult {
 }
 
 /**
- * Mirror of replacement-absorb's prefix/suffix block check, but for pure
- * inserts: drop payload lines that exactly duplicate the file lines
- * immediately above (leading) or immediately below (trailing) the insertion
- * point. Generic context echo absorption requires the caller's opt-in setting;
- * without it, only single structural closing delimiters use the
- * balance-validated structural rule below.
+ * For a pure-insert group, drop only multi-line context echoes that exactly
+ * duplicate the file lines adjacent to the insertion point. Single-line pure
+ * insert duplicates are ambiguous (`N↓}` may be an accidental anchor echo or an
+ * intentional inserted delimiter), so they are left literal even when generic
+ * duplicate absorption is enabled.
  */
 function tryAbsorbPureInsertGroup(
 	group: HashlinePureInsertGroup,
@@ -435,33 +485,11 @@ function tryAbsorbPureInsertGroup(
 			}
 		}
 	}
-	if (
-		absorbedLeading === 0 &&
-		allowGenericBoundaryAbsorb &&
-		group.cursor.kind === "after_anchor" &&
-		group.payload.length > 0 &&
-		aboveEndIdx >= 0 &&
-		!isStructuralClosingBoundaryLine(group.payload[0]) &&
-		group.payload[0] === fileLines[aboveEndIdx]
-	) {
-		absorbedLeading = 1;
-	}
-	if (
-		absorbedLeading === 0 &&
-		group.payload.length > 0 &&
-		aboveEndIdx >= 0 &&
-		isStructuralClosingBoundaryLine(group.payload[0]) &&
-		group.payload[0] === fileLines[aboveEndIdx] &&
-		shouldDropSingleStructuralBoundary(group.payload, group.payload.slice(1), ZERO_DELIMITER_BALANCE)
-	) {
-		absorbedLeading = 1;
-	}
 
 	// Trailing: payload[len-k..len-1] vs fileLines[belowStartIdx..belowStartIdx+k-1].
 	// Don't double-count payload lines already absorbed as leading.
 	let absorbedTrailing = 0;
-	const remainingPayload = group.payload.slice(absorbedLeading);
-	const remaining = remainingPayload.length;
+	const remaining = group.payload.length - absorbedLeading;
 	if (allowGenericBoundaryAbsorb) {
 		const maxTrail = Math.min(remaining, fileLines.length - belowStartIdx);
 		for (let count = maxTrail; count >= 2; count--) {
@@ -478,27 +506,6 @@ function tryAbsorbPureInsertGroup(
 			}
 		}
 	}
-	if (
-		absorbedTrailing === 0 &&
-		group.cursor.kind === "before_anchor" &&
-		allowGenericBoundaryAbsorb &&
-		remaining > 0 &&
-		belowStartIdx < fileLines.length &&
-		!isStructuralClosingBoundaryLine(remainingPayload[remainingPayload.length - 1]) &&
-		remainingPayload[remainingPayload.length - 1] === fileLines[belowStartIdx]
-	) {
-		absorbedTrailing = 1;
-	}
-	if (
-		absorbedTrailing === 0 &&
-		remaining > 0 &&
-		belowStartIdx < fileLines.length &&
-		isStructuralClosingBoundaryLine(remainingPayload[remainingPayload.length - 1]) &&
-		remainingPayload[remainingPayload.length - 1] === fileLines[belowStartIdx] &&
-		shouldDropSingleStructuralBoundary(remainingPayload, remainingPayload.slice(0, -1), ZERO_DELIMITER_BALANCE)
-	) {
-		absorbedTrailing = 1;
-	}
 
 	if (absorbedLeading === 0 && absorbedTrailing === 0) return empty;
 
@@ -683,6 +690,9 @@ export function applyHashlineEdits(
 
 	validateHashlineLineBounds(edits, fileLines);
 
+	const blankTargetError = detectReplaceOnBlankTarget(edits, fileLines);
+	if (blankTargetError !== null) throw new Error(blankTargetError);
+
 	const normalizedEdits = absorbReplacementBoundaryDuplicates(edits, fileLines, warnings, options);
 
 	// Normalize after_anchor inserts to before_anchor of the next line, or EOF

package/src/hashline/constants.ts

@@ -20,3 +20,41 @@ export const ABORT_MARKER = "*** Abort";
 /** Warning text appended to the tool result when ABORT_MARKER terminates parsing. */
 export const ABORT_WARNING =
 	"Tool stream truncated mid-call due to detected output corruption. Applied ops above are valid. Re-issue any remaining edits.";
+
+/**
+ * Warning text appended when two consecutive `A-B:` ops on the exact same
+ * range get coalesced (model painted a before/after pair). The second op
+ * wins; the first op's payload is silently discarded.
+ */
+export const REPLACE_PAIR_COALESCED_WARNING =
+	"Detected an identical-range before/after replace pair; kept only the second block's payload. Issue ONE op per range — the payload is the final desired content, never both old and new.";
+
+/**
+ * Warning text appended when un-prefixed continuation lines are accepted as
+ * implicit payload (lenient legacy behavior). The model authored a multi-line
+ * replace without `+` prefixes; the parser accepted it because the lines did
+ * not classify as ops/headers/payloads, but the canonical syntax requires `+`
+ * on every continuation line after the op.
+ */
+export const IMPLICIT_CONTINUATION_WARNING =
+	"Accepted continuation line(s) without the `+` prefix as implicit payload. Canonical syntax is `A-B:` followed by `+` on every continuation row; without `+`, lines that look like ops will be parsed as new ops instead of payload. Prefer the explicit form.";
+
+/**
+ * Warning text appended when an inner `LINE:TEXT` (or sub-range `A-B:TEXT`)
+ * op arrives while an outer `A-B:` replace is still pending and the inner
+ * anchor falls inside the outer range. The model used the read-output
+ * `LINE:TEXT` format as if it were a payload-continuation line; we strip the
+ * `LINE:` prefix and append the body to the pending payload, but warn so the
+ * canonical `+`-continuation form remains preferred.
+ */
+export const PAYLOAD_LINE_PREFIX_DEMOTED_WARNING =
+	"Detected one or more `LINE:TEXT` lines whose anchors fell inside a pending replace range; treated them as payload-continuation lines and stripped the `LINE:` prefix. Inside an `A-B:` block, every payload line must be on its own row prefixed with `+` — never reuse the read-output gutter format.";
+/**
+ * Warning text appended when an op carries an inline payload (`LINE:TEXT`,
+ * `A-B:TEXT`, `LINE↑TEXT`, `LINE↓TEXT`). Canonical syntax is bare op +
+ * `+`-prefixed continuation rows; we accept the inline form leniently so the
+ * model's first-attempt edit still lands, but warn so the canonical form
+ * remains preferred.
+ */
+export const INLINE_PAYLOAD_ACCEPTED_WARNING =
+	"Accepted inline payload on the op line (e.g. `LINE:CONTENT`, `LINE↑CONTENT`). Canonical syntax is the bare op followed by `+`-prefixed payload rows on the next line(s). Prefer the explicit form.";

package/src/hashline/execute.ts

@@ -14,7 +14,7 @@ import { HashlineMismatchError } from "./anchors";
 import { applyHashlineEdits, type HashlineApplyResult } from "./apply";
 import { buildCompactHashlineDiffPreview } from "./diff-preview";
 import { parseHashline } from "./executor";
-import { computeFileHash } from "./hash";
+import { computeFileHash, formatHashlineHeader } from "./hash";
 import { splitHashlineInputs } from "./input";
 import { tryRecoverHashlineWithCache } from "./recovery";
 import type {
@@ -224,9 +224,10 @@ async function executeHashlineSection(
 	// of the file: the model just received it back as the diff/preview. Cache
 	// it so a follow-up edit anchored against this state can still recover
 	// if the file is touched out-of-band before the next edit lands.
+	const newFileHash = computeFileHash(result.lines);
 	getFileReadCache(session).recordContiguous(absolutePath, 1, result.lines.split("\n"), {
 		fullText: result.lines,
-		fileHash: computeFileHash(result.lines),
+		fileHash: newFileHash,
 	});
 
 	const diffResult = generateDiffString(originalNormalized, result.lines);
@@ -238,6 +239,7 @@ async function executeHashlineSection(
 	const warnings = [...parseWarnings, ...(result.warnings ?? [])];
 	const warningsBlock = warnings.length > 0 ? `\n\nWarnings:\n${warnings.join("\n")}` : "";
 	const previewBlock = preview.preview ? `\n${preview.preview}` : "";
+	const newHashLine = `\n${formatHashlineHeader(sourcePath, newFileHash)}`;
 	const headline = preview.preview
 		? `${sourcePath}:`
 		: source.exists
@@ -245,7 +247,7 @@ async function executeHashlineSection(
 			: `Created ${sourcePath}`;
 
 	return {
-		content: [{ type: "text", text: `${headline}${previewBlock}${warningsBlock}` }],
+		content: [{ type: "text", text: `${headline}${newHashLine}${previewBlock}${warningsBlock}` }],
 		details: {
 			diff: diffResult.diff,
 			firstChangedLine: result.firstChangedLine ?? diffResult.firstChangedLine,