@oh-my-pi/pi-coding-agent 15.5.0 → 15.5.2

package/src/hashline/constants.ts

@@ -20,3 +20,32 @@ 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 a multi-line `A-B:` block, payload lines after the first should be prefixed with `+` — never reuse the read-output gutter format.";

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,

package/src/hashline/executor.ts

@@ -1,5 +1,17 @@
-import { ABORT_WARNING } from "./constants";
-import { HL_OP_CHARS, HL_OP_DELETE, HL_OP_INSERT_AFTER, HL_OP_INSERT_BEFORE, HL_OP_REPLACE } from "./hash";
+import {
+	ABORT_WARNING,
+	IMPLICIT_CONTINUATION_WARNING,
+	PAYLOAD_LINE_PREFIX_DEMOTED_WARNING,
+	REPLACE_PAIR_COALESCED_WARNING,
+} from "./constants";
+import {
+	HL_OP_CHARS,
+	HL_OP_DELETE,
+	HL_OP_INSERT_AFTER,
+	HL_OP_INSERT_BEFORE,
+	HL_OP_REPLACE,
+	HL_PAYLOAD_PREFIX,
+} from "./hash";
 import {
 	cloneCursor,
 	type HashlineToken,
@@ -15,6 +27,14 @@ function validateRangeOrder(range: ParsedRange, lineNum: number): void {
 	}
 }
 
+function rangesEqual(a: ParsedRange, b: ParsedRange): boolean {
+	return a.start.line === b.start.line && a.end.line === b.end.line;
+}
+
+function rangeContains(outer: ParsedRange, inner: ParsedRange): boolean {
+	return outer.start.line <= inner.start.line && inner.end.line <= outer.end.line;
+}
+
 function expandRange(range: ParsedRange): Anchor[] {
 	const anchors: Anchor[] = [];
 	for (let line = range.start.line; line <= range.end.line; line++) {
@@ -30,7 +50,6 @@ type PendingOp =
 interface Pending {
 	op: PendingOp;
 	payload: string[];
-	pendingBlanks: number;
 }
 
 /**
@@ -81,16 +100,18 @@ export class HashlineExecutor {
 				this.#terminated = true;
 				return;
 			case "header":
-				this.#flushPending(false);
+				this.#flushPending();
 				return;
 			case "blank":
-				if (this.#pending) this.#pending.pendingBlanks++;
 				return;
 			case "payload":
 				this.#handlePayload(token.text, token.lineNum);
 				return;
+			case "raw":
+				this.#handleRaw(token.text, token.lineNum);
+				return;
 			case "op-delete":
-				this.#flushPending(false);
+				this.#flushPending();
 				if (token.trailingPayload) {
 					throw new Error(
 						`line ${token.lineNum}: ${HL_OP_DELETE} deletes only. Payload is forbidden after ${HL_OP_DELETE}; use ${HL_OP_REPLACE} to replace.`,
@@ -102,32 +123,62 @@ export class HashlineExecutor {
 				}
 				return;
 			case "op-insert":
-				this.#flushPending(false);
+				this.#flushPending();
 				this.#pending = {
 					op: { kind: "insert", cursor: token.cursor, lineNum: token.lineNum },
-					payload: [token.inlineBody ?? ""],
-					pendingBlanks: 0,
+					payload: token.inlineBody === undefined ? [] : [token.inlineBody],
 				};
 				return;
 			case "op-replace":
-				this.#flushPending(false);
 				validateRangeOrder(token.range, token.lineNum);
+				if (this.#pending !== undefined && this.#pending.op.kind === "replace") {
+					const outer = this.#pending.op.range;
+					const inner = token.range;
+					if (rangesEqual(outer, inner)) {
+						// Identical-range before/after pair. Drop the "before" payload
+						// silently; the second op proceeds as the lone winner. Other
+						// overlap shapes (different ranges, replace+delete, delete+delete)
+						// still hit the post-hoc validator.
+						this.#pending = undefined;
+						if (!this.#warnings.includes(REPLACE_PAIR_COALESCED_WARNING)) {
+							this.#warnings.push(REPLACE_PAIR_COALESCED_WARNING);
+						}
+					} else if (rangeContains(outer, inner)) {
+						// Model wrote a payload line in read-output `LINE:TEXT` format
+						// (or `A-B:TEXT` for a sub-range) inside an outer `A-B:` block.
+						// The tokenizer can't tell payload from op when the anchor and
+						// sigil shape are identical, so demote: append the op's inline
+						// body to the pending payload, strip the `LINE:` prefix, and
+						// keep accumulating. Without this the inner anchors would each
+						// register as their own delete and clash with the outer range.
+						this.#pending.payload.push(token.inlineBody ?? "");
+						if (!this.#warnings.includes(PAYLOAD_LINE_PREFIX_DEMOTED_WARNING)) {
+							this.#warnings.push(PAYLOAD_LINE_PREFIX_DEMOTED_WARNING);
+						}
+						return;
+					}
+				}
+				this.#flushPending();
 				this.#pending = {
 					op: { kind: "replace", range: token.range, lineNum: token.lineNum },
-					payload: [token.inlineBody ?? ""],
-					pendingBlanks: 0,
+					payload: token.inlineBody === undefined ? [] : [token.inlineBody],
 				};
 				return;
 		}
 	}
 
 	/**
-	 * Flush any open pending op (including its trailing blank lines, which
-	 * are payload-significant) and return the accumulated edits and
-	 * warnings. The executor is single-use; reset() is required for reuse.
+	 * 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[]; warnings: string[] } {
-		this.#flushPending(true);
+		this.#flushPending();
+		this.#validateNoOverlappingDeletes();
 		return { edits: this.#edits, warnings: this.#warnings };
 	}
 
@@ -140,18 +191,69 @@ export class HashlineExecutor {
 		this.#terminated = false;
 	}
 
+	/**
+	 * Each `:` / `!` op contributes a delete edit per line in its range; if
+	 * any line ends up targeted by deletes originating from two different
+	 * source ops (distinguished by their `lineNum`), the patch is internally
+	 * inconsistent. Identical-range `A-B:` pairs are already collapsed by
+	 * `feed()`; remaining shapes here are an `A-B:` that overlaps a later
+	 * `N!`/`N:` with a different range, or two `!` deletes on the same line.
+	 * The applier would run both literally and the file would end up with two
+	 * copies of the line, not a chosen winner.
+	 */
+	#validateNoOverlappingDeletes(): void {
+		const sourceLinesByAnchor = new Map<number, number[]>();
+		for (const edit of this.#edits) {
+			if (edit.kind !== "delete") continue;
+			let sourceLines = sourceLinesByAnchor.get(edit.anchor.line);
+			if (sourceLines === undefined) {
+				sourceLines = [];
+				sourceLinesByAnchor.set(edit.anchor.line, sourceLines);
+			}
+			if (!sourceLines.includes(edit.lineNum)) sourceLines.push(edit.lineNum);
+		}
+		for (const [anchorLine, sourceLines] of sourceLinesByAnchor) {
+			if (sourceLines.length < 2) continue;
+			const [firstOp, secondOp] = [...sourceLines].sort((a, b) => a - b);
+			throw new Error(
+				`line ${secondOp}: anchor line ${anchorLine} is already targeted by the ${HL_OP_REPLACE}/${HL_OP_DELETE} op on line ${firstOp}. ` +
+					`Issue ONE op per range; payload is only the final desired content, never a before/after pair.`,
+			);
+		}
+	}
+
 	#handlePayload(text: string, lineNum: number): void {
 		if (this.#pending) {
-			this.#flushPendingBlanks();
 			this.#pending.payload.push(text);
 			return;
 		}
 
-		// Whitespace-only payload outside any pending op is a visual
-		// separator (matches the legacy outer-loop isBlankLine skip);
-		// only fully-empty lines arrive as `blank` tokens.
+		throw new Error(
+			`line ${lineNum}: payload line has no preceding ${HL_OP_INSERT_BEFORE}, ${HL_OP_INSERT_AFTER}, ${HL_OP_REPLACE}, or ${HL_OP_DELETE} operation. ` +
+				`Got ${JSON.stringify(`${HL_PAYLOAD_PREFIX}${text}`)}.`,
+		);
+	}
+
+	#handleRaw(text: string, lineNum: number): void {
+		if (this.#pending) {
+			if (text.trim().length === 0) return;
+			// Lenient legacy fallback: the tokenizer routes a line to `raw` only
+			// when it does not parse as an op, header, payload, or envelope
+			// marker. A `raw` token while a pending op exists is therefore an
+			// unambiguous continuation row that the model authored without the
+			// `+` prefix. Accept it as payload and warn so the canonical
+			// `+`-prefixed form remains preferred.
+			this.#pending.payload.push(text);
+			if (!this.#warnings.includes(IMPLICIT_CONTINUATION_WARNING)) {
+				this.#warnings.push(IMPLICIT_CONTINUATION_WARNING);
+			}
+			return;
+		}
+
+		// Whitespace-only raw lines outside any pending op are silently dropped;
+		// fully empty lines arrive as `blank` tokens.
 		if (text.trim().length === 0) return;
-		// Orphan payload outside any pending op: pick the most specific
+		// Orphan raw text outside any pending op: pick the most specific
 		// diagnostic so the model sees the actionable hint.
 		if (isDeleteOpWithPayload(text)) {
 			throw new Error(
@@ -174,19 +276,12 @@ export class HashlineExecutor {
 		);
 	}
 
-	#flushPendingBlanks(): void {
-		if (!this.#pending) return;
-		for (let count = 0; count < this.#pending.pendingBlanks; count++) this.#pending.payload.push("");
-		this.#pending.pendingBlanks = 0;
-	}
-
-	#flushPending(includeTrailingBlanks: boolean): void {
+	#flushPending(): void {
 		const pending = this.#pending;
 		if (!pending) return;
-		if (includeTrailingBlanks) this.#flushPendingBlanks();
 
 		const { op, payload } = pending;
-		const linesToInsert = payload;
+		const linesToInsert = payload.length === 0 ? [""] : payload;
 
 		if (op.kind === "insert") {
 			for (const text of linesToInsert) {

package/src/hashline/grammar.lark

@@ -14,7 +14,7 @@ insert_after: anchor "$HOP_INSERT_AFTER$" inline_body? LF payload*
 replace: range "$HOP_REPLACE$" inline_body? LF payload*
 delete: range "$HOP_DELETE$" LF
 inline_body: /[^\n]+/
-payload: /(.*)/ LF
+payload: "+" /[^\n]*/ LF
 
 anchor: LID | "EOF" | "BOF"
 range: LID ("-" LID)?

package/src/hashline/hash.ts

@@ -7,12 +7,12 @@ const regexEscape = (str: string): string => str.replace(/[.*+?^${}()|[\]\\]/g,
 
 /**
  * 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 const HL_ANCHOR_DECORATION_RE_RAW = `\\s*[>+\\-*]*\\s*`;
+export const HL_ANCHOR_DECORATION_RE_RAW = `\\s*[>\\-*]*\\s*`;
 
 /** Capture-group regex source for a decorated bare line-number anchor. */
 export const HL_ANCHOR_RE_RAW = `${HL_ANCHOR_DECORATION_RE_RAW}(\\d+)`;
@@ -74,9 +74,9 @@ export function resolveHashlineGrammarPlaceholders(grammar: string): string {
 /**
  * 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.
@@ -86,6 +86,9 @@ export const HL_OP_INSERT_AFTER = "↓";
 export const HL_OP_REPLACE = ":";
 export const HL_OP_DELETE = "!";
 
+/** Prefix for payload continuation lines. The prefix itself is not written. */
+export const HL_PAYLOAD_PREFIX = "+";
+
 /** All hashline edit op sigils, concatenated for fast membership tests. */
 export const HL_OP_CHARS = `${HL_OP_INSERT_BEFORE}${HL_OP_INSERT_AFTER}${HL_OP_REPLACE}${HL_OP_DELETE}`;
 

package/src/hashline/recovery.ts

@@ -29,6 +29,8 @@ const HASHLINE_RECOVERY_EXTERNAL_WARNING =
 	"Recovered from a stale file hash using a previous read snapshot (file changed externally between read and edit).";
 const HASHLINE_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).";
+const HASHLINE_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.";
 
 function applyEditsToSnapshot(
 	previousText: string,
@@ -62,6 +64,30 @@ function applyEditsToSnapshot(
 	};
 }
 
+function replaySessionChainOnCurrent(
+	previousText: string,
+	currentText: string,
+	edits: HashlineEdit[],
+	options: HashlineApplyOptions,
+): HashlineRecoveryResult | null {
+	// Only safe when no insert/delete shifted line counts in the prior edit
+	// chain: if total line counts match, every line number in `edits` still
+	// resolves to the same logical row.
+	if (previousText.split("\n").length !== currentText.split("\n").length) return null;
+	let applied: HashlineApplyResult;
+	try {
+		applied = applyHashlineEdits(currentText, edits, options);
+	} catch {
+		return null;
+	}
+	if (applied.lines === currentText) return null;
+	return {
+		lines: applied.lines,
+		firstChangedLine: applied.firstChangedLine,
+		warnings: [HASHLINE_RECOVERY_SESSION_REPLAY_WARNING, ...(applied.warnings ?? [])],
+	};
+}
+
 function buildSparseOverlayText(currentText: string, snapshotLines: ReadonlyMap<number, string>): string {
 	const overlaid = currentText.split("\n");
 	let maxCachedLine = 0;
@@ -95,8 +121,16 @@ export function tryRecoverHashlineWithCache(args: HashlineRecoveryArgs): Hashlin
 	if (!snapshot || snapshot.lines.size === 0) return null;
 
 	const recoveryWarning = resolveRecoveryWarning(head, snapshot);
+	const isSessionChain = !isHeadSnapshot(head, snapshot);
 	if (snapshot.fullText !== undefined) {
-		return applyEditsToSnapshot(snapshot.fullText, currentText, edits, options, recoveryWarning);
+		const merged = applyEditsToSnapshot(snapshot.fullText, currentText, edits, options, recoveryWarning);
+		if (merged !== null) return merged;
+		// Session-chain fast-path: prior in-session edit changed the same line(s)
+		// the model is now re-targeting with the stale hash. When line counts
+		// match, the edits' line numbers still resolve to the right rows — replay
+		// onto the current text directly.
+		if (isSessionChain) return replaySessionChainOnCurrent(snapshot.fullText, currentText, edits, options);
+		return null;
 	}
 
 	const overlayText = buildSparseOverlayText(currentText, snapshot.lines);

package/src/hashline/tokenizer.ts

@@ -7,6 +7,7 @@ import {
 	HL_OP_INSERT_AFTER,
 	HL_OP_INSERT_BEFORE,
 	HL_OP_REPLACE,
+	HL_PAYLOAD_PREFIX,
 } from "./hash";
 import type { Anchor, HashlineCursor } from "./types";
 
@@ -20,6 +21,7 @@ const CHAR_SPACE = 32;
 const CHAR_LOWER_A = 97;
 const CHAR_LOWER_F = 102;
 const CHAR_PILCROW = HL_FILE_PREFIX.charCodeAt(0);
+const CHAR_PAYLOAD_PREFIX = HL_PAYLOAD_PREFIX.charCodeAt(0);
 const FILE_HASH_LENGTH = 4;
 
 function isDigitCode(code: number): boolean {
@@ -31,7 +33,7 @@ function isNonZeroDigitCode(code: number): boolean {
 }
 
 function isDecorationCode(code: number): boolean {
-	return code === 42 || code === 43 || code === 45 || code === 62;
+	return code === 42 || code === 45 || code === 62;
 }
 
 function isHexDigitCode(code: number): boolean {
@@ -91,7 +93,7 @@ export function cloneCursor(cursor: HashlineCursor): HashlineCursor {
 }
 
 // Leniently accept anchors copied from read/search output:
-//   - optional leading line-marker decoration (`*`, `>`, `+`, `-`)
+//   - optional leading line-marker decoration (`*`, `>`, `-`)
 //   - the required bare line number
 function skipDecoratedAnchorPrefix(line: string, end = trimEndIndex(line)): number {
 	let index = skipWhitespace(line, 0, end);
@@ -339,7 +341,8 @@ export type HashlineToken =
 	| (TokenBase & { kind: "op-insert"; cursor: HashlineCursor; inlineBody: string | undefined })
 	| (TokenBase & { kind: "op-replace"; range: ParsedRange; inlineBody: string | undefined })
 	| (TokenBase & { kind: "op-delete"; range: ParsedRange; trailingPayload: boolean })
-	| (TokenBase & { kind: "payload"; text: string });
+	| (TokenBase & { kind: "payload"; text: string })
+	| (TokenBase & { kind: "raw"; text: string });
 
 function classifyLine(line: string, lineNum: number): HashlineToken {
 	if (isEmptyLine(line)) return { kind: "blank", lineNum };
@@ -356,6 +359,9 @@ function classifyLine(line: string, lineNum: number): HashlineToken {
 		}
 	}
 
+	if (line.charCodeAt(0) === CHAR_PAYLOAD_PREFIX) {
+		return { kind: "payload", lineNum, text: line.slice(HL_PAYLOAD_PREFIX.length) };
+	}
 	const op = tryParseOp(line);
 	if (op !== null) {
 		if (op.kind === "insert") {
@@ -367,7 +373,7 @@ function classifyLine(line: string, lineNum: number): HashlineToken {
 		return { kind: "op-delete", lineNum, range: op.range, trailingPayload: op.trailingPayload };
 	}
 
-	return { kind: "payload", lineNum, text: line };
+	return { kind: "raw", lineNum, text: line };
 }
 
 /**