@oh-my-pi/pi-coding-agent 15.3.2 → 15.4.1

package/src/hashline/anchors.ts

@@ -1,113 +1,104 @@
-import { formatCodeFrameLine } from "../tools/render-utils";
 import { MISMATCH_CONTEXT } from "./constants";
-import { computeLineHash, describeAnchorExamples, HL_ANCHOR_RE_RAW, HL_BODY_SEP } from "./hash";
-import type { HashMismatch } from "./types";
+import { formatNumberedLine, HL_FILE_HASH_SEP, HL_FILE_PREFIX } from "./hash";
 
-const HL_HASH_HINT_RE = /^[a-z]{2}$/i;
-const HL_ANCHOR_EXAMPLES = describeAnchorExamples("160");
-const PARSE_TAG_RE = new RegExp(`^${HL_ANCHOR_RE_RAW}`);
+const LINE_REF_RE = /^\s*[>+\-*]*\s*(\d+)(?::.*)?\s*$/;
 
 export function formatFullAnchorRequirement(raw?: string): string {
-	const suffix = typeof raw === "string" ? raw.trim() : "";
-	const hashOnlyHint = HL_HASH_HINT_RE.test(suffix)
-		? ` It looks like you supplied only the hash suffix (${JSON.stringify(suffix)}). ` +
-			`Copy the full anchor exactly as shown (for example, "160${suffix}").`
-		: "";
 	const received = raw === undefined ? "" : ` Received ${JSON.stringify(raw)}.`;
 	return (
-		`the full anchor exactly as shown by read/search output ` +
-		`(line number + hash, for example ${HL_ANCHOR_EXAMPLES})${received}${hashOnlyHint}`
+		`a bare line number from read/search output plus the section header file hash ` +
+		`(for example ${HL_FILE_PREFIX}src/foo.ts${HL_FILE_HASH_SEP}1a2b and line "160")${received}`
 	);
 }
 
-export function parseTag(ref: string): { line: number; hash: string } {
-	const match = ref.match(PARSE_TAG_RE);
+export function parseTag(ref: string): { line: number } {
+	const match = ref.match(LINE_REF_RE);
 	if (!match) {
 		throw new Error(`Invalid line reference. Expected ${formatFullAnchorRequirement(ref)}.`);
 	}
 	const line = Number.parseInt(match[1], 10);
 	if (line < 1) throw new Error(`Line number must be >= 1, got ${line} in "${ref}".`);
-	return { line, hash: match[2] };
+	return { line };
 }
 
-function getMismatchDisplayLines(mismatches: HashMismatch[], fileLines: string[]): number[] {
+export interface HashlineMismatchDetails {
+	path?: string;
+	expectedFileHash: string;
+	actualFileHash: string;
+	fileLines: string[];
+	anchorLines?: readonly number[];
+}
+
+function getMismatchDisplayLines(anchorLines: readonly number[], fileLines: string[]): number[] {
 	const displayLines = new Set<number>();
-	for (const mismatch of mismatches) {
-		const lo = Math.max(1, mismatch.line - MISMATCH_CONTEXT);
-		const hi = Math.min(fileLines.length, mismatch.line + MISMATCH_CONTEXT);
+	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);
 }
 
 export class HashlineMismatchError extends Error {
-	readonly remaps: ReadonlyMap<string, string>;
+	readonly path: string | undefined;
+	readonly expectedFileHash: string;
+	readonly actualFileHash: string;
+	readonly fileLines: string[];
+	readonly anchorLines: readonly number[];
 
-	constructor(
-		public readonly mismatches: HashMismatch[],
-		public readonly fileLines: string[],
-	) {
-		super(HashlineMismatchError.formatMessage(mismatches, fileLines));
+	constructor(details: HashlineMismatchDetails) {
+		super(HashlineMismatchError.formatMessage(details));
 		this.name = "HashlineMismatchError";
-
-		const remaps = new Map<string, string>();
-		for (const mismatch of mismatches) {
-			const actual = computeLineHash(mismatch.line, fileLines[mismatch.line - 1] ?? "");
-			remaps.set(`${mismatch.line}${mismatch.expected}`, `${mismatch.line}${actual}`);
-		}
-		this.remaps = remaps;
+		this.path = details.path;
+		this.expectedFileHash = details.expectedFileHash;
+		this.actualFileHash = details.actualFileHash;
+		this.fileLines = details.fileLines;
+		this.anchorLines = details.anchorLines ?? [];
 	}
 
 	get displayMessage(): string {
-		return HashlineMismatchError.formatDisplayMessage(this.mismatches, this.fileLines);
+		return HashlineMismatchError.formatDisplayMessage({
+			path: this.path,
+			expectedFileHash: this.expectedFileHash,
+			actualFileHash: this.actualFileHash,
+			fileLines: this.fileLines,
+			anchorLines: this.anchorLines,
+		});
 	}
 
-	private static rejectionHeader(mismatches: HashMismatch[]): string[] {
-		const noun = mismatches.length > 1 ? "anchors do" : "anchor does";
+	static rejectionHeader(details: HashlineMismatchDetails): string[] {
+		const pathText = details.path ? ` for ${details.path}` : "";
 		return [
-			`Edit rejected: ${mismatches.length} ${noun} not match the current file (marked *).`,
-			"The edit was NOT applied, please use the updated file content shown below, and issue another edit tool-call.",
+			`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.`,
 		];
 	}
 
-	static formatDisplayMessage(mismatches: HashMismatch[], fileLines: string[]): string {
-		const mismatchSet = new Set<number>(mismatches.map(m => m.line));
-		const displayLines = getMismatchDisplayLines(mismatches, fileLines);
-		const width = displayLines.reduce((cur, n) => Math.max(cur, String(n).length), 0);
-
-		const out = [...HashlineMismatchError.rejectionHeader(mismatches), ""];
-		let previous = -1;
-		for (const lineNum of displayLines) {
-			if (previous !== -1 && lineNum > previous + 1) out.push("...");
-			previous = lineNum;
-			const marker = mismatchSet.has(lineNum) ? "*" : " ";
-			out.push(formatCodeFrameLine(marker, lineNum, fileLines[lineNum - 1] ?? "", width));
-		}
-		return out.join("\n");
+	static formatDisplayMessage(details: HashlineMismatchDetails): string {
+		return HashlineMismatchError.formatMessage(details);
 	}
 
-	static formatMessage(mismatches: HashMismatch[], fileLines: string[]): string {
-		const mismatchSet = new Set<number>(mismatches.map(m => m.line));
-		const lines = HashlineMismatchError.rejectionHeader(mismatches);
+	static formatMessage(details: HashlineMismatchDetails): string {
+		const anchorSet = new Set(details.anchorLines ?? []);
+		const lines = HashlineMismatchError.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 getMismatchDisplayLines(mismatches, fileLines)) {
+		for (const lineNum of displayLines) {
 			if (previous !== -1 && lineNum > previous + 1) lines.push("...");
 			previous = lineNum;
-			const text = fileLines[lineNum - 1] ?? "";
-			const hash = computeLineHash(lineNum, text);
-			const marker = mismatchSet.has(lineNum) ? "*" : " ";
-			lines.push(`${marker}${lineNum}${hash}${HL_BODY_SEP}${text}`);
+			const text = details.fileLines[lineNum - 1] ?? "";
+			const marker = anchorSet.has(lineNum) ? "*" : " ";
+			lines.push(`${marker}${formatNumberedLine(lineNum, text)}`);
 		}
 		return lines.join("\n");
 	}
 }
 
-export function validateLineRef(ref: { line: number; hash: string }, fileLines: string[]): void {
+export function validateLineRef(ref: { line: number }, fileLines: string[]): void {
 	if (ref.line < 1 || ref.line > fileLines.length) {
 		throw new Error(`Line ${ref.line} does not exist (file has ${fileLines.length} lines)`);
 	}
-	const actualHash = computeLineHash(ref.line, fileLines[ref.line - 1] ?? "");
-	if (actualHash !== ref.hash) {
-		throw new HashlineMismatchError([{ line: ref.line, expected: ref.hash, actual: actualHash }], fileLines);
-	}
 }

package/src/hashline/apply.ts

@@ -1,8 +1,5 @@
-import { HashlineMismatchError } from "./anchors";
-import { RANGE_INTERIOR_HASH } from "./constants";
-import { computeLineHash } from "./hash";
-import { cloneCursor } from "./parser";
-import type { Anchor, HashlineApplyOptions, HashlineCursor, HashlineEdit, HashMismatch } from "./types";
+import { cloneCursor } from "./tokenizer";
+import type { Anchor, HashlineApplyOptions, HashlineCursor, HashlineEdit } from "./types";
 
 export interface HashlineApplyResult {
 	lines: string;
@@ -43,26 +40,17 @@ function getHashlineEditAnchors(edit: HashlineEdit): Anchor[] {
 }
 
 /**
- * Verify every anchor's hash. Any mismatch is reported as a `HashMismatch`;
- * there is no auto-rebase. Callers are expected to surface mismatches as
- * `HashlineMismatchError` so the model re-reads and re-anchors.
+ * Verify every anchored edit points at an existing line. File-version binding is
+ * checked once per section via the header hash before this function runs.
  */
-function validateHashlineAnchors(edits: HashlineEdit[], fileLines: string[]): HashMismatch[] {
-	const mismatches: HashMismatch[] = [];
+function validateHashlineLineBounds(edits: HashlineEdit[], fileLines: string[]): void {
 	for (const edit of edits) {
 		for (const anchor of getHashlineEditAnchors(edit)) {
 			if (anchor.line < 1 || anchor.line > fileLines.length) {
 				throw new Error(`Line ${anchor.line} does not exist (file has ${fileLines.length} lines)`);
 			}
-			if (anchor.hash === RANGE_INTERIOR_HASH) continue;
-
-			const actualHash = computeLineHash(anchor.line, fileLines[anchor.line - 1] ?? "");
-			if (actualHash === anchor.hash) continue;
-
-			mismatches.push({ line: anchor.line, expected: anchor.hash, actual: actualHash });
 		}
 	}
-	return mismatches;
 }
 
 function insertAtStart(fileLines: string[], lineOrigins: HashlineLineOrigin[], lines: string[]): void {
@@ -287,15 +275,10 @@ function contiguousRange(start: number, count: number): number[] {
 	return Array.from({ length: count }, (_, offset) => start + offset);
 }
 
-function deleteEditForAutoAbsorbedLine(
-	line: number,
-	sourceLineNum: number,
-	index: number,
-	fileLines: string[],
-): HashlineEdit {
+function deleteEditForAutoAbsorbedLine(line: number, sourceLineNum: number, index: number): HashlineEdit {
 	return {
 		kind: "delete",
-		anchor: { line, hash: computeLineHash(line, fileLines[line - 1] ?? "") },
+		anchor: { line },
 		lineNum: sourceLineNum,
 		index,
 	};
@@ -314,7 +297,7 @@ function cursorMatches(a: HashlineCursor, b: HashlineCursor): boolean {
 	if (a.kind === "bof" || a.kind === "eof") return true;
 	const aAnchor = (a as { anchor: Anchor }).anchor;
 	const bAnchor = (b as { anchor: Anchor }).anchor;
-	return aAnchor.line === bAnchor.line && aAnchor.hash === bAnchor.hash;
+	return aAnchor.line === bAnchor.line;
 }
 
 /**
@@ -606,13 +589,13 @@ function absorbReplacementBoundaryDuplicates(
 		}
 
 		for (const line of contiguousRange(startLine - safePrefixCount, safePrefixCount)) {
-			absorbed.push(deleteEditForAutoAbsorbedLine(line, group.sourceLineNum, nextSyntheticIndex++, fileLines));
+			absorbed.push(deleteEditForAutoAbsorbedLine(line, group.sourceLineNum, nextSyntheticIndex++));
 		}
 		for (let groupIndex = group.startIndex; groupIndex <= group.endIndex; groupIndex++) {
 			absorbed.push(edits[groupIndex]);
 		}
 		for (const line of contiguousRange(endLine + 1, safeSuffixCount)) {
-			absorbed.push(deleteEditForAutoAbsorbedLine(line, group.sourceLineNum, nextSyntheticIndex++, fileLines));
+			absorbed.push(deleteEditForAutoAbsorbedLine(line, group.sourceLineNum, nextSyntheticIndex++));
 		}
 
 		index = group.endIndex;
@@ -653,8 +636,7 @@ export function applyHashlineEdits(
 		if (firstChangedLine === undefined || line < firstChangedLine) firstChangedLine = line;
 	};
 
-	const mismatches = validateHashlineAnchors(edits, fileLines);
-	if (mismatches.length > 0) throw new HashlineMismatchError(mismatches, fileLines);
+	validateHashlineLineBounds(edits, fileLines);
 
 	const normalizedEdits = absorbReplacementBoundaryDuplicates(edits, fileLines, warnings, options);
 
@@ -669,10 +651,9 @@ export function applyHashlineEdits(
 			continue;
 		}
 		const nextLineNum = anchorLine + 1;
-		const nextContent = fileLines[nextLineNum - 1] ?? "";
 		edit.cursor = {
 			kind: "before_anchor",
-			anchor: { line: nextLineNum, hash: computeLineHash(nextLineNum, nextContent) },
+			anchor: { line: nextLineNum },
 		};
 	}
 
@@ -711,6 +692,23 @@ export function applyHashlineEdits(
 		}
 		if (beforeLines.length === 0 && !deleteLine) continue;
 
+		const replaceMode = beforeLines.length > 0;
+		if (deleteLine && !replaceMode) {
+			const balance = computeDelimiterBalance([currentLine]);
+			const trimmedCurrentLine = currentLine.trim();
+			const touchesStructuralBoundary =
+				trimmedCurrentLine.startsWith(")") ||
+				trimmedCurrentLine.startsWith("]") ||
+				trimmedCurrentLine.startsWith("}") ||
+				trimmedCurrentLine.endsWith("(") ||
+				trimmedCurrentLine.endsWith("[") ||
+				trimmedCurrentLine.endsWith("{");
+			if (balance.paren !== 0 || balance.bracket !== 0 || balance.brace !== 0 || touchesStructuralBoundary) {
+				warnings.push(
+					`Deleted line ${line} contains a structural bracket/brace boundary (${JSON.stringify(trimmedCurrentLine)}); verify the file is still balanced or use 'A:<replacement>' to keep the boundary intact.`,
+				);
+			}
+		}
 		const replacement = deleteLine ? beforeLines : [...beforeLines, currentLine];
 		const origins = replacement.map((): HashlineLineOrigin => (deleteLine ? "replacement" : "insert"));
 		if (!deleteLine) {

package/src/hashline/constants.ts

@@ -1,9 +1,6 @@
 /** Lines of context shown either side of a hash mismatch. */
 export const MISMATCH_CONTEXT = 2;
 
-/** Filler hash used for the interior of a multi-line range; not validated. */
-export const RANGE_INTERIOR_HASH = "**";
-
 /** Optional patch envelope start marker; silently consumed when present. */
 export const BEGIN_PATCH_MARKER = "*** Begin Patch";
 

package/src/hashline/diff-preview.ts

@@ -1,4 +1,3 @@
-import { computeLineHash, HL_BODY_SEP } from "./hash";
 import type { CompactHashlineDiffOptions, CompactHashlineDiffPreview } from "./types";
 
 export function buildCompactHashlineDiffPreview(
@@ -11,7 +10,7 @@ export function buildCompactHashlineDiffPreview(
 
 	// `generateDiffString` numbers `+` lines with the post-edit line number,
 	// `-` lines with the pre-edit line number, and context lines with the
-	// pre-edit line number. To emit fresh anchors usable for follow-up edits,
+	// pre-edit line number. To emit fresh line numbers usable for follow-up edits,
 	// we convert context-line numbers to post-edit positions by tracking the
 	// running offset (added so far - removed so far) as we walk the diff.
 	const formatted = lines.map(line => {
@@ -28,13 +27,13 @@ export function buildCompactHashlineDiffPreview(
 		switch (kind) {
 			case "+":
 				addedLines++;
-				return `+${lineNumber}${computeLineHash(lineNumber, content)}${HL_BODY_SEP}${content}`;
+				return `+${lineNumber}:${content}`;
 			case "-":
 				removedLines++;
-				return `-${lineNumber}--${HL_BODY_SEP}${content}`;
+				return `-${lineNumber}:${content}`;
 			default: {
 				const newLineNumber = lineNumber + addedLines - removedLines;
-				return ` ${newLineNumber}${computeLineHash(newLineNumber, content)}${HL_BODY_SEP}${content}`;
+				return ` ${newLineNumber}:${content}`;
 			}
 		}
 	});

package/src/hashline/diff.ts

@@ -3,9 +3,10 @@ import { normalizeToLF, stripBom } from "../edit/normalize";
 import { readEditFileText } from "../edit/read-file";
 import { resolveToCwd } from "../tools/path-utils";
 import { applyHashlineEdits } from "./apply";
-import { type HashlineInputSection, splitHashlineInputs } from "./input";
-import { parseHashline } from "./parser";
-import type { HashlineApplyOptions } from "./types";
+import { parseHashline } from "./executor";
+import { computeFileHash } from "./hash";
+import { splitHashlineInputs } from "./input";
+import type { HashlineApplyOptions, HashlineEdit, HashlineInputSection } from "./types";
 
 async function readHashlineFileText(
 	_file: { text(): Promise<string> },
@@ -20,6 +21,28 @@ async function readHashlineFileText(
 	}
 }
 
+function hasAnchorScopedEdit(edits: readonly HashlineEdit[]): boolean {
+	return edits.some(edit => {
+		if (edit.kind === "delete") return true;
+		return edit.cursor.kind === "before_anchor" || edit.cursor.kind === "after_anchor";
+	});
+}
+
+function validateSectionHash(
+	section: HashlineInputSection,
+	text: string,
+	edits: readonly HashlineEdit[],
+): string | null {
+	if (section.fileHash === undefined) {
+		return hasAnchorScopedEdit(edits)
+			? `Missing hashline file hash for anchored edit to ${section.path}; use \`¶${section.path}#hash\` from your latest read.`
+			: null;
+	}
+	const currentHash = computeFileHash(text);
+	if (currentHash === section.fileHash) return null;
+	return `Hashline file hash mismatch for ${section.path}: section is bound to #${section.fileHash}, but current file hashes to #${currentHash}; re-read and try again.`;
+}
+
 export async function computeHashlineSectionDiff(
 	section: HashlineInputSection,
 	cwd: string,
@@ -30,7 +53,10 @@ export async function computeHashlineSectionDiff(
 		const rawContent = await readHashlineFileText(Bun.file(absolutePath), absolutePath, section.path);
 		const { text: content } = stripBom(rawContent);
 		const normalized = normalizeToLF(content);
-		const result = applyHashlineEdits(normalized, parseHashline(section.diff), options);
+		const { edits } = parseHashline(section.diff);
+		const hashError = validateSectionHash(section, normalized, edits);
+		if (hashError) return { error: hashError };
+		const result = applyHashlineEdits(normalized, edits, options);
 		if (normalized === result.lines) return { error: `No changes would be made to ${section.path}.` };
 		return generateDiffString(normalized, result.lines);
 	} catch (err) {

package/src/hashline/execute.ts

@@ -13,13 +13,15 @@ import { enforcePlanModeWrite, resolvePlanPath } from "../tools/plan-mode-guard"
 import { HashlineMismatchError } from "./anchors";
 import { applyHashlineEdits, type HashlineApplyResult } from "./apply";
 import { buildCompactHashlineDiffPreview } from "./diff-preview";
-import { type HashlineInputSection, splitHashlineInputs } from "./input";
-import { parseHashlineWithWarnings } from "./parser";
+import { parseHashline } from "./executor";
+import { computeFileHash } from "./hash";
+import { splitHashlineInputs } from "./input";
 import { tryRecoverHashlineWithCache } from "./recovery";
 import type {
 	ExecuteHashlineSingleOptions,
 	HashlineApplyOptions,
 	HashlineEdit,
+	HashlineInputSection,
 	hashlineEditParamsSchema,
 } from "./types";
 
@@ -46,6 +48,27 @@ function hasAnchorScopedEdit(edits: HashlineEdit[]): boolean {
 	});
 }
 
+function collectAnchorLines(edits: HashlineEdit[]): number[] {
+	const lines = new Set<number>();
+	for (const edit of edits) {
+		if (edit.kind === "delete") {
+			lines.add(edit.anchor.line);
+			continue;
+		}
+		if (edit.cursor.kind === "before_anchor" || edit.cursor.kind === "after_anchor") {
+			lines.add(edit.cursor.anchor.line);
+		}
+	}
+	return [...lines].sort((a, b) => a - b);
+}
+
+function assertSectionHashAllowed(sectionPath: string, fileHash: string | undefined, edits: HashlineEdit[]): void {
+	if (fileHash !== undefined || !hasAnchorScopedEdit(edits)) return;
+	throw new Error(
+		`Missing hashline file hash for anchored edit to ${sectionPath}; use \`¶${sectionPath}#hash\` from your latest read.`,
+	);
+}
+
 function formatNoChangeDiagnostic(pathText: string): string {
 	return `Edits to ${pathText} resulted in no changes being made.`;
 }
@@ -65,36 +88,48 @@ function getEditDetails(result: AgentToolResult<EditToolDetails>): EditToolDetai
 }
 
 /**
- * Apply hashline edits with anchor-stale recovery: on `HashlineMismatchError`,
- * consult the read-snapshot cache for the file and 3-way-merge the edits onto
- * the current text. If recovery succeeds, return the merged result with a
- * synthetic warning. Otherwise re-throw the original mismatch error.
+ * Apply hashline edits with file-hash stale recovery. The section hash gates
+ * line-number edits against the version shown to the model; if the live file
+ * drifted, snapshot recovery attempts a strict 3-way merge.
  */
 function applyHashlineEditsWithRecovery(
 	session: ToolSession,
 	absolutePath: string,
+	pathText: string,
 	text: string,
+	fileHash: string | undefined,
 	edits: HashlineEdit[],
 	options: HashlineApplyOptions,
 ): HashlineApplyResult {
-	try {
-		return applyHashlineEdits(text, edits, options);
-	} catch (err) {
-		if (!(err instanceof HashlineMismatchError)) throw err;
-		const recovered = tryRecoverHashlineWithCache({
-			cache: getFileReadCache(session),
-			absolutePath,
-			currentText: text,
-			edits,
-			options,
-		});
-		if (!recovered) throw err;
+	if (fileHash === undefined) return applyHashlineEdits(text, edits, options);
+
+	const currentHash = computeFileHash(text);
+	if (currentHash === fileHash) return applyHashlineEdits(text, edits, options);
+
+	const cache = getFileReadCache(session);
+	const recovered = tryRecoverHashlineWithCache({
+		cache,
+		absolutePath,
+		currentText: text,
+		fileHash,
+		edits,
+		options,
+	});
+	if (recovered) {
 		return {
 			lines: recovered.lines,
 			firstChangedLine: recovered.firstChangedLine,
 			warnings: recovered.warnings,
 		};
 	}
+
+	throw new HashlineMismatchError({
+		path: pathText,
+		expectedFileHash: fileHash,
+		actualFileHash: currentHash,
+		fileLines: text.split("\n"),
+		anchorLines: collectAnchorLines(edits),
+	});
 }
 
 /**
@@ -103,10 +138,11 @@ function applyHashlineEditsWithRecovery(
  * any changes in a multi-section batch.
  */
 async function preflightHashlineSection(options: ExecuteHashlineSingleOptions & HashlineInputSection): Promise<void> {
-	const { session, path: sectionPath, diff } = options;
+	const { session, path: sectionPath, fileHash, diff } = options;
 
 	const absolutePath = resolvePlanPath(session, sectionPath);
-	const { edits } = parseHashlineWithWarnings(diff);
+	const { edits } = parseHashline(diff);
+	assertSectionHashAllowed(sectionPath, fileHash, edits);
 	enforcePlanModeWrite(session, sectionPath, { op: "update" });
 
 	const source = await readHashlineFile(absolutePath, sectionPath);
@@ -118,7 +154,9 @@ async function preflightHashlineSection(options: ExecuteHashlineSingleOptions &
 	const result = applyHashlineEditsWithRecovery(
 		session,
 		absolutePath,
+		sectionPath,
 		normalized,
+		source.exists ? fileHash : undefined,
 		edits,
 		getHashlineApplyOptions(session),
 	);
@@ -131,6 +169,7 @@ async function executeHashlineSection(
 	const {
 		session,
 		path: sourcePath,
+		fileHash,
 		diff,
 		signal,
 		batchRequest,
@@ -139,7 +178,8 @@ async function executeHashlineSection(
 	} = options;
 
 	const absolutePath = resolvePlanPath(session, sourcePath);
-	const { edits, warnings: parseWarnings } = parseHashlineWithWarnings(diff);
+	const { edits, warnings: parseWarnings } = parseHashline(diff);
+	assertSectionHashAllowed(sourcePath, fileHash, edits);
 	enforcePlanModeWrite(session, sourcePath, { op: "update" });
 
 	const source = await readHashlineFile(absolutePath, sourcePath);
@@ -152,7 +192,9 @@ async function executeHashlineSection(
 	const result = applyHashlineEditsWithRecovery(
 		session,
 		absolutePath,
+		sourcePath,
 		originalNormalized,
+		source.exists ? fileHash : undefined,
 		edits,
 		getHashlineApplyOptions(session),
 	);
@@ -182,7 +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.
-	getFileReadCache(session).recordContiguous(absolutePath, 1, result.lines.split("\n"));
+	getFileReadCache(session).recordContiguous(absolutePath, 1, result.lines.split("\n"), {
+		fullText: result.lines,
+		fileHash: computeFileHash(result.lines),
+	});
 
 	const diffResult = generateDiffString(originalNormalized, result.lines);
 	const meta = outputMeta()
@@ -257,11 +302,31 @@ export async function executeHashlineSingle(
  * Path order is preserved by first occurrence.
  */
 function mergeSamePathSections(sections: HashlineInputSection[]): HashlineInputSection[] {
-	const byPath = new Map<string, string[]>();
+	const byPath = new Map<string, { fileHash?: string; diffs: string[] }>();
 	for (const section of sections) {
 		const existing = byPath.get(section.path);
-		if (existing) existing.push(section.diff);
-		else byPath.set(section.path, [section.diff]);
+		if (existing) {
+			if (
+				existing.fileHash !== undefined &&
+				section.fileHash !== undefined &&
+				existing.fileHash !== section.fileHash
+			) {
+				throw new Error(
+					`Conflicting hashline file hashes for ${section.path}: #${existing.fileHash} and #${section.fileHash}. Re-read the file and retry with one current header.`,
+				);
+			}
+			if (existing.fileHash === undefined && section.fileHash !== undefined) existing.fileHash = section.fileHash;
+			existing.diffs.push(section.diff);
+			continue;
+		}
+		byPath.set(section.path, {
+			...(section.fileHash !== undefined ? { fileHash: section.fileHash } : {}),
+			diffs: [section.diff],
+		});
 	}
-	return Array.from(byPath, ([path, diffs]) => ({ path, diff: diffs.join("\n") }));
+	return Array.from(byPath, ([path, entry]) => ({
+		path,
+		...(entry.fileHash !== undefined ? { fileHash: entry.fileHash } : {}),
+		diff: entry.diffs.join("\n"),
+	}));
 }