@oh-my-pi/hashline 15.5.6 → 15.5.7

package/dist/types/messages.d.ts

@@ -32,5 +32,13 @@ export declare const VIRTUAL_REPLACE_REJECTED_MESSAGE = "BOF:/EOF: anchors are v
 export declare const RECOVERY_EXTERNAL_WARNING = "Recovered from a stale file hash using a previous read snapshot (file changed externally between read and edit).";
 /** Warning text emitted by `Recovery` when a prior in-session edit advanced the hash. */
 export declare 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).";
-/** Warning text emitted by `Recovery` when the session-chain fast-path was taken. */
+/**
+ * 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.
+ */
 export declare const RECOVERY_SESSION_REPLAY_WARNING = "Recovered by replaying your edits onto the current file content \u2014 your previous edit in this session changed line(s) you re-targeted with a stale hash. Verify the diff matches your intent before continuing.";

package/dist/types/recovery.d.ts

@@ -22,8 +22,12 @@ export interface RecoveryResult {
  *
  * 1. Apply on the cached `fullText` snapshot, then 3-way-merge onto current.
  * 2. (Session chain) If the snapshot wasn't the head, retry on current text
- *    when line counts match — the user's previous edit advanced the hash but
- *    didn't shift line numbers.
+ *    when line counts match AND every edit's anchor line content is unchanged
+ *    between snapshot and current — the previous in-session edit advanced
+ *    the hash and the model's anchors still name the same logical rows. Emits
+ *    a dedicated {@link RECOVERY_SESSION_REPLAY_WARNING} because even with
+ *    both guards a coincidental insert+delete pair on duplicate rows can
+ *    still land the edit on the wrong row; see {@link replaySessionChainOnCurrent}.
  * 3. Reconstruct from a sparse snapshot (lines map only), verify the rebuilt
  *    text hashes to the expected value, then 3-way-merge.
  */

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/hashline",
-	"version": "15.5.6",
+	"version": "15.5.7",
 	"description": "Hashline: a compact, line-anchored patch language and applier. Pluggable FS/IO so it works over disk, in-memory, or any custom backend.",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",

package/src/apply.ts

@@ -39,9 +39,18 @@ function isReplacementInsert(edit: Edit): edit is Extract<Edit, { kind: "insert"
 
 function getEditAnchors(edit: Edit): Anchor[] {
 	if (edit.kind === "delete") return [edit.anchor];
-	if (edit.cursor.kind === "before_anchor") return [edit.cursor.anchor];
-	if (edit.cursor.kind === "after_anchor") return [edit.cursor.anchor];
-	return [];
+	switch (edit.cursor.kind) {
+		case "before_anchor":
+		case "after_anchor":
+			return [edit.cursor.anchor];
+		case "bof":
+		case "eof":
+			return [];
+		default: {
+			const _exhaustive: never = edit.cursor;
+			return _exhaustive;
+		}
+	}
 }
 
 /**

package/src/messages.ts

@@ -48,6 +48,14 @@ export const RECOVERY_EXTERNAL_WARNING =
 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).";
 
-/** Warning text emitted by `Recovery` when the session-chain fast-path was taken. */
+/**
+ * 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.
+ */
 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.";

package/src/prompt.md

@@ -25,22 +25,18 @@ A-B:
 `EOF:` — virtual position after the last line.
 </anchors>
 
-<payload-sigils>
+<sigils>
 `|content` — replace A..B with `content`.
 `↑content` — insert `content` before A.
 `↓content` — insert `content` after B.
-</payload-sigils>
+</sigils>
 
 <semantics>
-- **No payload rows → delete.** `5:` deletes line 5.
-- **Any `|` row → replace.** Delete A..B; insert all `|` rows there.
-- **Only `↑`/`↓` rows → preserve.** Anchor lines stay unchanged.
+- **No payload → delete.** `5:` deletes line 5.
 - **Buckets combine.** `↑` before A, `|` in place, `↓` after B.
 - **Bucket order ignores interleaving.** Output order = all `↑`, then `|`/original, then all `↓`.
 - **Order within a bucket is preserved.** Two `↑` rows stack top-down.
-- **Blank payload rows are explicit.** Bare `|`, `↑`, or `↓` writes one blank line.
-- **BOF/EOF only insert.** `↑` and `↓` are equivalent there; `|` is invalid.
-- **Escape leading payload sigils by doubling.** `||x` writes `|x`; `↑↑x` writes `↑x`; `↓↓x` writes `↓x`.
+- **Blank payload = explicit.** Bare `|`, `↑`, or `↓` writes one blank line.
 - **Line numbers are frozen.** Later anchors still reference pre-edit lines.
 </semantics>
 
@@ -78,6 +74,7 @@ A-B:
 <common-failures>
 - **NEVER use inline payload.** `5:content` is invalid; write `5:` then `|content`.
 - **Do not repeat preserved lines.** If line 5 should survive, omit `|`.
+- **`↑`/`↓` payloads are new bytes only.** Never echo the anchor or a neighbor line — that line already exists; copying it into a `↓` row appends a duplicate.
 - **Do not echo read gutters.** `84:content` is not payload.
 - **Do not replay past B.** Stop before B+1; widen the anchor if B+1 changes.
 - **NEVER fabricate file hashes.** Missing? Re-`read`.
@@ -98,6 +95,15 @@ A-B:
 5:
 ↑const Y = X;
 
+# WRONG — echoing the anchor into a ↓ payload duplicates it.
+# Line 5 already contains `const X = 1;`.
+5:
+↓const X = 1;
+↓const Y = 2;
+# RIGHT — payload is only the new line; the anchor survives automatically.
+5:
+↓const Y = 2;
+
 # WRONG — read-output gutters inside payload.
 5-6:
 5:const X = "b";

package/src/recovery.ts

@@ -13,7 +13,7 @@ import { applyEdits } from "./apply";
 import { computeFileHash } from "./format";
 import { RECOVERY_EXTERNAL_WARNING, RECOVERY_SESSION_CHAIN_WARNING, RECOVERY_SESSION_REPLAY_WARNING } from "./messages";
 import type { Snapshot, SnapshotStore } from "./snapshots";
-import type { ApplyOptions, ApplyResult, Edit } from "./types";
+import type { Anchor, ApplyOptions, ApplyResult, Edit } from "./types";
 
 // Section hashes are line-precise; never let Diff.applyPatch slide a hunk
 // onto a duplicate closer 100+ lines away. If snapshot replay does not
@@ -63,16 +63,72 @@ function applyEditsToSnapshot(
 	return { text: merged, firstChangedLine, warnings };
 }
 
+function collectAnchorLines(edits: readonly Edit[]): number[] {
+	const lines: number[] = [];
+	for (const edit of edits) {
+		for (const anchor of getEditAnchors(edit)) lines.push(anchor.line);
+	}
+	return lines;
+}
+
+function getEditAnchors(edit: Edit): Anchor[] {
+	if (edit.kind === "delete") return [edit.anchor];
+	switch (edit.cursor.kind) {
+		case "before_anchor":
+		case "after_anchor":
+			return [edit.cursor.anchor];
+		case "bof":
+		case "eof":
+			return [];
+		default: {
+			const _exhaustive: never = edit.cursor;
+			return _exhaustive;
+		}
+	}
+}
+
+/**
+ * Returns true when every anchor line in `edits` has identical content in
+ * `previousText` and `currentText`. The session-chain replay fast-path
+ * requires this: if the prior in-session edit rewrote the line the model is
+ * now re-targeting with a stale hash, replaying onto current would silently
+ * overwrite the new content with whatever the model authored against the
+ * old content — a corruption window, not a recovery.
+ */
+function verifyAnchorContent(previousText: string, currentText: string, edits: readonly Edit[]): boolean {
+	const lines = collectAnchorLines(edits);
+	if (lines.length === 0) return true;
+	const prev = previousText.split("\n");
+	const curr = currentText.split("\n");
+	for (const line of lines) {
+		const idx = line - 1;
+		if (idx < 0 || idx >= prev.length || idx >= curr.length) return false;
+		if (prev[idx] !== curr[idx]) return false;
+	}
+	return true;
+}
+
 function replaySessionChainOnCurrent(
 	previousText: string,
 	currentText: string,
 	edits: readonly Edit[],
 	options: ApplyOptions,
 ): RecoveryResult | 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.
+	// Two guards narrow the corruption window. Neither alone is sufficient,
+	// and even together they don't fully prove correctness — replay is the
+	// less-certain recovery mode and emits RECOVERY_SESSION_REPLAY_WARNING
+	// so the caller can verify the diff.
+	//   - Equal line counts: every line number in `edits` still resolves to
+	//     SOME logical row (no net shift across the prior chain). A
+	//     coincidental insert+delete pair can still leave indices pointing
+	//     at different logical rows than the model anchored against.
+	//   - Anchor-content alignment: the row at each anchor's line index has
+	//     identical content in previous and current. Catches the common
+	//     case of a prior edit rewriting the targeted line; can still be
+	//     coincidentally satisfied by a duplicated row at the shifted
+	//     index.
 	if (previousText.split("\n").length !== currentText.split("\n").length) return null;
+	if (!verifyAnchorContent(previousText, currentText, edits)) return null;
 	let applied: ApplyResult;
 	try {
 		applied = applyEdits(currentText, [...edits], options);
@@ -123,8 +179,12 @@ function isHeadSnapshot(head: Snapshot | null, snapshot: Snapshot): boolean {
  *
  * 1. Apply on the cached `fullText` snapshot, then 3-way-merge onto current.
  * 2. (Session chain) If the snapshot wasn't the head, retry on current text
- *    when line counts match — the user's previous edit advanced the hash but
- *    didn't shift line numbers.
+ *    when line counts match AND every edit's anchor line content is unchanged
+ *    between snapshot and current — the previous in-session edit advanced
+ *    the hash and the model's anchors still name the same logical rows. Emits
+ *    a dedicated {@link RECOVERY_SESSION_REPLAY_WARNING} because even with
+ *    both guards a coincidental insert+delete pair on duplicate rows can
+ *    still land the edit on the wrong row; see {@link replaySessionChainOnCurrent}.
  * 3. Reconstruct from a sparse snapshot (lines map only), verify the rebuilt
  *    text hashes to the expected value, then 3-way-merge.
  */
@@ -148,10 +208,10 @@ export class Recovery {
 		if (snapshot.fullText !== undefined) {
 			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 user 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.
+			// Session-chain fallback: the 3-way merge on the snapshot refused.
+			// Replay onto current is gated by line-count equality AND
+			// anchor-content alignment — see `replaySessionChainOnCurrent`
+			// for why both guards together still don't fully prove correctness.
 			if (isSessionChain) return replaySessionChainOnCurrent(snapshot.fullText, currentText, edits, options);
 			return null;
 		}