pi-hashline-edit-pro 0.5.1 → 0.6.1

package/README.md

@@ -1,6 +1,6 @@
 # pi-hashline-edit-pro
 
-A [pi-coding-agent](https://github.com/badlogic/pi-mono/tree/main/packages/coding-agent) extension that replaces the built-in `read` and `edit` tools with a hash-anchored line-editing workflow. Strict semantics, no silent relocation, no autocorrection, no fuzzy fallback. 4-character content hashes over a 64-character URL-safe base64 alphabet give 24 bits of entropy per anchor, so collisions are effectively zero in any realistic file.
+A [pi-coding-agent](https://github.com/badlogic/pi-mono/tree/main/packages/coding-agent) extension that replaces the built-in `read` and `edit` tools with a hash-anchored line-replacing workflow. Strict semantics, no silent relocation, no autocorrection, no fuzzy fallback. 4-character content hashes over a 64-character URL-safe base64 alphabet give 24 bits of entropy per anchor, so collisions are effectively zero in any realistic file.
 
 Fork of [pi-hashline-edit](https://github.com/RimuruW/pi-hashline-edit) by RimuruW. The strict-semantics policy is unchanged. This fork extends the upstream design in two ways: a 4-character hash length and an occurrence-aware discriminator that makes identical content at different positions hash to different values.
 
@@ -55,42 +55,42 @@ Optional parameters:
 - `offset` -- start reading from this line number (1-indexed).
 - `limit` -- maximum number of lines to return.
 
-Images (JPEG, PNG, GIF, WebP) are passed through as attachments and do not participate in the hashline protocol. Binary and directory paths are rejected with a descriptive error. Empty files return an advisory suggesting `prepend`/`append` instead of a synthetic anchor.
+Images (JPEG, PNG, GIF, WebP) are passed through as attachments and do not participate in the hashline protocol. Binary and directory paths are rejected with a descriptive error. Empty files return an advisory suggesting using replace to insert content.
 
-### `edit` -- hash-anchored modifications
+### `replace` -- hash-anchored modifications
 
-Edits use the `HASH│content` anchors from `read` output to target lines precisely:
+Replaces using the `HASH│content` anchors from `read` output to target lines precisely:
 
 ```json
 {
   "path": "src/main.ts",
   "edits": [
-    { "op": "replace", "start": "ve7o", "end": "ve7o", "lines": ["  console.log('hashline');"] }
+    { "start": "ve7o", "end": "ve7o", "lines": ["  console.log('hashline');"] }
   ]
 }
 ```
 
-| Op | Purpose | Fields |
-|---|---|---|
-| `replace` | Replace the inclusive range `start`..`end`. To replace a single line, set `start` = `end`. | `start` required, `end` required, `lines` |
-| `append` | Insert lines after `pos`. Omit `pos` to append at EOF. | `pos` optional, `lines` |
-| `prepend` | Insert lines before `pos`. Omit `pos` to prepend at BOF. | `pos` optional, `lines` |
+| Field | Purpose |
+|---|---|
+| `start` | Range-start anchor (required). |
+| `end` | Range-end anchor (required). Single-line replace: set `start` = `end`. |
+| `lines` | Replacement content (one string per line). Use `[]` to delete. |
 
 - **Request structure validation.** The request envelope (path, edits, returnMode, returnRanges) and individual edit items are validated before any file I/O. Unknown fields, missing required fields, invalid types, and malformed anchors are rejected with `[E_BAD_SHAPE]` or `[E_BAD_OP]`.
-- **Legacy dialect rejected.** The native top-level `oldText`/`newText` (and `old_text`/`new_text`) dialect and `op: "replace_text"` are rejected with `[E_LEGACY_SHAPE]`. The error message tells the model to call `read` first and send `{op:"replace", start:"<HASH>", end:"<HASH>", lines:[...]}` (or `append`/`prepend` with `pos`).
+- **Legacy dialect rejected.** The native top-level `oldText`/`newText` (and `old_text`/`new_text`) dialect is rejected with `[E_LEGACY_SHAPE]`. The error message tells the model to call `read` first and send `{start:"<HASH>", end:"<HASH>", lines:[...]}`.
 
 All edits in a single call validate against the same pre-edit snapshot and apply bottom-up, so line numbers stay consistent across operations.
 
 ### Chained edits
 
-After a successful edit, the result text contains an `--- Anchors ---` block with fresh `HASH│content` references for the changed region. These can be used directly in the next `edit` call on the same file without a full re-read, provided the next edit targets the same or nearby lines. For distant changes, use `read` first.
+After a successful replace, the result text contains an `--- Anchors ---` block with fresh `HASH│content` references for the changed region. These can be used directly in the next `replace` call on the same file without a full re-read, provided the next replace targets the same or nearby lines. For distant changes, use `read` first.
 
 ### Auto-read after write
 
 After a successful `write`, the extension automatically reads the file and appends a `--- Auto-read (hashline anchors) ---` block to the result. This gives the model immediate `HASH│content` anchors for the newly written file without requiring a separate `read` call. The workflow becomes:
 
 1. `write` a file, result includes hashline anchors
-2. `edit` using those anchors directly
+2. `replace` using those anchors directly
 
 For large files (>2000 lines), the auto-read output is truncated with a pagination hint. Use `read` with `offset` to see more.
 
@@ -103,7 +103,7 @@ The post-edit diff (with `+`/`-` markers and new `HASH│content` anchors) is ex
 - **Stale anchors fail.** A hash mismatch means the file has changed since the last `read`. The error includes fresh `>>> HASH│content` lines for the affected region. The model copies the HASH portion and retries.
 - **No fallback relocation.** Mismatched anchors are never silently relocated to a "close enough" line. This trades convenience for correctness.
 - **Strict patch content.** If `lines` contains `+HASH│` display prefixes (or `-N   ` diff rows), the edit is rejected with `[E_INVALID_PATCH]`. Bare `HASH│` content (the first 5 chars of a `lines` entry looking like 4 base64 chars + `│`) is also rejected with `[E_BARE_HASH_PREFIX]`. When the suspect's prefix happens to match a real file-line anchor, the error message flags that as strong evidence the model copied an anchor from the read output.
-- **Legacy dialect rejected.** The native top-level `oldText`/`newText` (and `old_text`/`new_text`) dialect and `op: "replace_text"` are rejected with `[E_LEGACY_SHAPE]`. The error message tells the model to call `read` first and send `{op:"replace", start:"<HASH>", end:"<HASH>", lines:[...]}` (or `append`/`prepend` with `pos`).
+- **Legacy dialect rejected.** The native top-level `oldText`/`newText` (and `old_text`/`new_text`) dialect is rejected with `[E_LEGACY_SHAPE]`. The error message tells the model to call `read` first and send `{start:"<HASH>", end:"<HASH>", lines:[...]}`.
 - **Atomic writes.** Files are written via temp-file-then-rename to avoid corruption from interrupted writes. Symlink chains are resolved so the target file is updated without replacing the symlink. Hard-linked files are updated in place to preserve the shared inode. File permissions are preserved across atomic renames.
 - **Per-file mutation queue.** Edits queue by the canonical write target, so concurrent edits through different symlink paths still serialize onto the same underlying file.
 
@@ -118,7 +118,7 @@ Hashes are occurrence-aware: a discriminator prefix is mixed into the xxHash inp
 - `}` on line 5 and `}` on line 17 hash differently (1st vs 2nd occurrence of `}`).
 - `import { foo } from 'bar';` on line 3 and the same string on line 47 hash differently (1st vs 2nd occurrence).
 
-The runtime always precomputes the full per-line hash array for a file via `computeLineHashes(content)`, then looks up by line number during validation and during `read` / `edit` response formatting. There is no per-line recomputation that could disagree with what the model saw in its last read.
+The runtime always precomputes the full per-line hash array for a file via `computeLineHashes(content)`, then looks up by line number during validation and during `read` / `replace` response formatting. There is no per-line recomputation that could disagree with what the model saw in its last read.
 
 `HASH_LENGTH` and `HASH_ALPHABET` are constants at the top of `src/hashline/hash.ts`; bump the length to 5 if you ever need even more entropy.
 

package/index.ts

@@ -2,14 +2,20 @@ import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { readFile } from "fs/promises";
 import { join, isAbsolute } from "path";
 import { computeLineHashes, formatHashlineRegion } from "./src/hashline";
-import { registerEditTool } from "./src/edit";
+import { registerReplaceTool } from "./src/replace";
 import { registerReadTool } from "./src/read";
-import { normalizeToLF } from "./src/edit-diff";
+import { normalizeToLF } from "./src/replace-diff";
 import { getVisibleLines } from "./src/utils";
 
 export default function (pi: ExtensionAPI): void {
   registerReadTool(pi);
-  registerEditTool(pi);
+  registerReplaceTool(pi);
+
+  // Disable the built-in `edit` tool so the model uses `replace` instead.
+  pi.on("session_start", async (_event, ctx) => {
+    const active = pi.getActiveTools();
+    pi.setActiveTools(active.filter((t) => t !== "edit"));
+  });
 
   // Auto-read after write: append hashline read output to write results
   // so the model immediately has anchors for subsequent edits.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pi-hashline-edit-pro",
-  "version": "0.5.1",
-  "description": "Strict hashline read/edit tool override for pi-coding-agent with hash-anchored edits (4-char, 24-bit)",
+  "version": "0.6.1",
+  "description": "Strict hashline read/replace tool for pi-coding-agent with hash-anchored edits (4-char, 24-bit)",
   "main": "index.ts",
   "repository": {
     "type": "git",

package/prompts/read-guidelines.md

@@ -1,3 +1,2 @@
-- Use read before edit when you do not have current HASH anchors for the file.
-- Copy exactly the HASH (the 4 characters before the `│`); never include the `│` or line content in `pos`/`end`.
-- A HASH may contain `-` as a normal alphabet character.
+- Use `read` before `replace` when you do not have current HASH anchors for the file.
+- A HASH may contain `-` as a normal alphabet character.

package/prompts/read-snippet.md

@@ -1 +1 @@
-Read a text file with HASH│content anchors for edit (copy the HASH into `start`/`end`/`pos`)
+Read a text file and return HASH│content lines

package/prompts/read.md

@@ -1,31 +1,17 @@
-Read a text file. Each line is returned as `HASH│content`. The HASH is 4 base64 characters; the content after the `│` separator is the line verbatim. Pass the HASH (e.g. `aB3x`) into `edit`'s `start`/`end` (for `replace`) or `pos` (for `append`/`prepend`) — never include the line content.
+Read a text file. Each line is returned as `HASH│content`.
 
-HASH shape:
-- 4 characters from the URL-safe base64 alphabet `A-Za-z0-9-_` (e.g. `aB3x`, `4yN-`, `-qkl`).
-- The line number is not part of the wire format. Anchor by HASH, never by reading a line number off the rendered output.
-
-HASH → edit:
-- Copy the full 4-character HASH. Use that HASH as `start` or `end` (for `replace`) or `pos` (for `append`/`prepend`) in the next `edit` call.
-- Do not include the `│`, the line content, or surrounding whitespace. The wire format for `start`/`end`/`pos` is the HASH only.
+HASH format:
+- The HASH is 4 characters from the URL-safe base64 alphabet `A-Za-z0-9-_` (e.g. `aB3x`, `4yN-`, `-qkl`).
+- The content after the `│` separator is the line verbatim.
+- The line number is not part of the output. Use the HASH to reference lines.
 
 Pagination:
 - Large files return a truncated preview with a `nextOffset` line. Call `read` again with `offset=nextOffset` to continue.
-- For nearby follow-up edits, prefer the `--- Anchors ---` block from a previous `edit` call — fresh HASHes, cheaper than re-reading.
-- Empty files return an advisory suggesting `prepend`/`append` instead of a synthetic anchor.
-
-Error recovery:
-- `[E_STALE_ANCHOR]` — the file changed since your last read. The error includes fresh `>>> HASH│content` lines; copy the HASH portion (the 4 chars before `│`) and retry.
-- `[E_BAD_REF]` — malformed HASH. Re-read and try again with a valid HASH anchor (e.g. `aB3x`).
 
 File kinds:
 - Text files are returned as `HASH│content` lines.
-- Images (JPEG, PNG, GIF, WebP) are returned as visual attachments; the HASH-line protocol does not apply.
+- Images (JPEG, PNG, GIF, WebP) are returned as visual attachments.
 - Binary files and directories are rejected with a descriptive error.
 
 Non-UTF-8 bytes:
-- Non-UTF-8 bytes are decoded as U+FFFD. The output is flagged when this happens; editing such a file rewrites it as UTF-8. Recover the original encoding with `iconv` afterwards if it must survive.
-
-Auto-read after write:
-- After a successful `write`, the result includes a `--- Auto-read (hashline anchors) ---` block with `HASH│content` for the written file.
-- Use those anchors directly for `edit` calls without a separate `read`.
-- The auto-read output follows the same format and rules as `read` output.
+- Non-UTF-8 bytes are decoded as U+FFFD. The output is flagged when this happens.

package/prompts/replace-guidelines.md

@@ -0,0 +1,3 @@
+- Use `replace` with HASH anchors for all file changes; batch every change to one file into a single `replace` call.
+- After a successful `replace`, the returned `--- Anchors ---` block has fresh hashes for nearby follow-up replaces.
+- On `[E_STALE_ANCHOR]`, retry with the `>>>` lines quoted in the error instead of re-reading the whole file.

package/prompts/replace-snippet.md

@@ -0,0 +1 @@
+Replace lines in a text file via HASH anchors from read, batching all edits to a file in one call

package/prompts/replace.md

@@ -0,0 +1,70 @@
+Replace lines in a text file using HASH anchors from `read`.
+
+Put all operations on one file in a single `replace` call. Stack every region into the `edits` array, even when they are far apart. Anchors within one call must all come from the same pre-edit read; the runtime applies them atomically against that one snapshot.
+
+How to use:
+
+1. Call `read` to get HASH anchors:
+```
+read({ path: "src/main.ts" })
+// Returns:
+// MQXV│const x = 1;
+// ZPMQ│const y = 2;
+// VRWS│const z = 3;
+```
+
+2. Copy the 4-character HASH (before `│`) into `start`/`end`:
+```json
+{ "path": "src/main.ts", "edits": [
+  { "start": "MQXV", "end": "MQXV", "lines": ["const x = 99;"] }
+] }
+```
+
+Examples:
+
+1. Single line replace:
+```json
+{ "path": "src/main.ts", "edits": [
+  { "start": "MQXV", "end": "MQXV", "lines": ["const x = 1;"] }
+] }
+```
+
+2. Range replace (3 lines → 3 new lines):
+```json
+{ "path": "src/main.ts", "edits": [
+  { "start": "ZPMQ", "end": "VRWS", "lines": [
+    "function greet(name) {",
+    "  return `Hello, ${name}`;",
+    "}"
+  }
+] }
+```
+
+3. Multiple regions in one call (delete two non-adjacent ranges):
+```json
+{ "path": "src/server.ts", "edits": [
+  { "start": "aB3x", "end": "xY7q", "lines": [] },
+  { "start": "MQXV", "end": "ZPMQ", "lines": [] }
+] }
+```
+
+Rules:
+- `start` and `end` are required. A single-line replace is `start=X, end=X`.
+- To delete a range, use `lines: []`.
+- `start`, `end` are HASH anchors only (e.g. `aB3x`). Do not include `│` or line content.
+- `lines` is literal file content — each string becomes exactly one line in the file. No `HASH│` prefix, no `+`/`-` diff markers.
+- Don't add `""` for spacing unless you actually want a new blank line.
+- Copy anchors from the most recent `read` of the file. Do not guess or construct them.
+- All edits in one call must be non-conflicting. The runtime rejects with `[E_EDIT_CONFLICT]` if two ranges overlap.
+- If `lines` matches current content, the replace is classified as `noop` (file unchanged).
+- The `start`/`end` range is inclusive — both anchors and every line between them are replaced. If your replacement content includes lines that already exist in the file (e.g. closing brackets), make sure those lines are within your range, otherwise they will appear twice.
+
+On success, the response contains an `--- Anchors ---` block with fresh HASH anchors for the changed region. Use those for nearby follow-up replaces instead of re-reading.
+
+Auto-read after write:
+- After a successful `write`, the result includes a `--- Auto-read (hashline anchors) ---` block.
+- Use those anchors directly for `replace` calls without a separate `read`.
+
+Error recovery:
+- `[E_STALE_ANCHOR]` — file changed since last read. The error includes fresh `>>> HASH│content` lines; copy the HASH and retry.
+- `[E_BAD_REF]` — malformed HASH. Re-read and try again.

package/src/hashline/apply.ts

@@ -42,14 +42,12 @@ export function buildLineIndex(content: string): LineIndex {
 
 
 type ResolvedEditSpan = {
-	kind: "replace" | "insert";
+	kind: "replace";
 	index: number;
 	label: string;
 	start: number;
 	end: number;
 	replacement: string;
-	boundary?: number;
-	insertMode?: "append-empty-origin" | "prepend-empty-origin";
 };
 
 function assertDoesNotEmptyFile(originalContent: string, result: string): void {
@@ -71,27 +69,6 @@ function throwEditConflict(
 	);
 }
 
-function computeInsertionBoundary(
-	edit: Extract<ResolvedHashlineEdit, { op: "append" | "prepend" }>,
-	lineIndex: LineIndex,
-): number {
-	switch (edit.op) {
-		case "append": {
-			const fileLineCount = lineIndex.fileLines.length;
-			const eofBoundary =
-				lineIndex.hasTerminalNewline && fileLineCount > 0
-					? fileLineCount - 1
-					: fileLineCount;
-			return edit.pos
-				? lineIndex.hasTerminalNewline && edit.pos.line === fileLineCount
-					? eofBoundary
-					: edit.pos.line
-				: eofBoundary;
-		}
-		case "prepend":
-			return edit.pos ? edit.pos.line - 1 : 0;
-	}
-}
 
 function resolveEditToSpan(
 	edit: ResolvedHashlineEdit,
@@ -102,155 +79,64 @@ function resolveEditToSpan(
 ): ResolvedEditSpan | null {
 	const { fileLines, lineStarts, hasTerminalNewline } = lineIndex;
 
-	switch (edit.op) {
-		case "replace": {
-			const startLine = edit.start.line;
-			const endLine = edit.end.line;
-			const originalLines = fileLines.slice(startLine - 1, endLine);
-			if (
-				originalLines.length === edit.lines.length &&
-				originalLines.every(
-					(line, lineIndex) => line === edit.lines[lineIndex],
-				)
-			) {
-				noopEdits.push({
-					editIndex: index,
-					loc: edit.start.hash,
-					currentContent: originalLines.join("\n"),
-				});
-				return null;
-			}
-
-			if (edit.lines.length > 0) {
-				return {
-					kind: "replace",
-					index,
-					label: describeEdit(edit),
-					start: lineStarts[startLine - 1]!,
-					end: lineStarts[endLine - 1]! + fileLines[endLine - 1]!.length,
-					replacement: edit.lines.join("\n"),
-				};
-			}
-
-			if (startLine === 1 && endLine === fileLines.length) {
-				return {
-					kind: "replace",
-					index,
-					label: describeEdit(edit),
-					start: 0,
-					end: content.length,
-					replacement: "",
-				};
-			}
-
-			if (endLine < fileLines.length) {
-				return {
-					kind: "replace",
-					index,
-					label: describeEdit(edit),
-					start: lineStarts[startLine - 1]!,
-					end: lineStarts[endLine]!,
-					replacement: "",
-				};
-			}
-
-			return {
-				kind: "replace",
-				index,
-				label: describeEdit(edit),
-				start: Math.max(0, lineStarts[startLine - 1]! - 1),
-				end: lineStarts[endLine - 1]! + fileLines[endLine - 1]!.length,
-				replacement: "",
-			};
-		}
-		case "append": {
-			if (edit.lines.length === 0) {
-				noopEdits.push({
-					editIndex: index,
-					loc: edit.pos ? edit.pos.hash : "EOF",
-					currentContent: edit.pos
-						? (fileLines[edit.pos.line - 1] ?? "")
-						: "",
-				});
-				return null;
-			}
+	const startLine = edit.start.line;
+	const endLine = edit.end.line;
+	const originalLines = fileLines.slice(startLine - 1, endLine);
+	if (
+		originalLines.length === edit.lines.length &&
+		originalLines.every(
+			(line, lineIndex) => line === edit.lines[lineIndex],
+		)
+	) {
+		noopEdits.push({
+			editIndex: index,
+			loc: edit.start.hash,
+			currentContent: originalLines.join("\n"),
+		});
+		return null;
+	}
 
-			const insertedText = edit.lines.join("\n");
-			if (content.length === 0) {
-				return {
-					kind: "insert",
-					index,
-					label: describeEdit(edit),
-					start: 0,
-					end: 0,
-					replacement: insertedText,
-					boundary: computeInsertionBoundary(edit, lineIndex),
-					insertMode: "append-empty-origin",
-				};
-			}
+	if (edit.lines.length > 0) {
+		return {
+			kind: "replace",
+			index,
+			label: describeEdit(edit),
+			start: lineStarts[startLine - 1]!,
+			end: lineStarts[endLine - 1]! + fileLines[endLine - 1]!.length,
+			replacement: edit.lines.join("\n"),
+		};
+	}
 
-			if (!edit.pos) {
-				return {
-					kind: "insert",
-					index,
-					label: describeEdit(edit),
-					start: content.length,
-					end: content.length,
-					replacement: hasTerminalNewline
-						? `${insertedText}\n`
-						: `\n${insertedText}`,
-					boundary: computeInsertionBoundary(edit, lineIndex),
-				};
-			}
+	if (startLine === 1 && endLine === fileLines.length) {
+		return {
+			kind: "replace",
+			index,
+			label: describeEdit(edit),
+			start: 0,
+			end: content.length,
+			replacement: "",
+		};
+	}
 
-			const isSentinelAppend =
-				hasTerminalNewline && edit.pos.line === fileLines.length;
-			return {
-				kind: "insert",
-				index,
-				label: describeEdit(edit),
-				start: isSentinelAppend
-					? content.length
-					: lineStarts[edit.pos.line - 1]! +
-						fileLines[edit.pos.line - 1]!.length,
-				end: isSentinelAppend
-					? content.length
-					: lineStarts[edit.pos.line - 1]! +
-						fileLines[edit.pos.line - 1]!.length,
-				replacement: isSentinelAppend
-					? `${insertedText}\n`
-					: `\n${insertedText}`,
-				boundary: computeInsertionBoundary(edit, lineIndex),
-			};
-		}
-		case "prepend": {
-			if (edit.lines.length === 0) {
-				noopEdits.push({
-					editIndex: index,
-					loc: edit.pos ? edit.pos.hash : "BOF",
-					currentContent: edit.pos
-						? (fileLines[edit.pos.line - 1] ?? "")
-						: "",
-				});
-				return null;
-			}
-			const insertedText = edit.lines.join("\n");
-			const start = edit.pos ? lineStarts[edit.pos.line - 1]! : 0;
-			return {
-				kind: "insert",
-				index,
-				label: describeEdit(edit),
-				start,
-				end: start,
-				replacement:
-					content.length === 0 ? insertedText : `${insertedText}\n`,
-				boundary: computeInsertionBoundary(edit, lineIndex),
-				...(content.length === 0
-					? { insertMode: "prepend-empty-origin" as const }
-					: {}),
-			};
-		}
+	if (endLine < fileLines.length) {
+		return {
+			kind: "replace",
+			index,
+			label: describeEdit(edit),
+			start: lineStarts[startLine - 1]!,
+			end: lineStarts[endLine]!,
+			replacement: "",
+		};
 	}
+
+	return {
+		kind: "replace",
+		index,
+		label: describeEdit(edit),
+		start: Math.max(0, lineStarts[startLine - 1]! - 1),
+		end: lineStarts[endLine - 1]! + fileLines[endLine - 1]!.length,
+		replacement: "",
+	};
 }
 
 function assertNoConflictingSpans(spans: ResolvedEditSpan[]): void {
@@ -263,38 +149,11 @@ function assertNoConflictingSpans(spans: ResolvedEditSpan[]): void {
 		) {
 			const right = spans[rightIndex]!;
 
-			if (left.kind === "insert" && right.kind === "insert") {
-				if (left.boundary === right.boundary) {
-					throwEditConflict(
-						left,
-						right,
-						"target the same insertion boundary",
-					);
-				}
-				continue;
-			}
-
-			if (left.kind === "replace" && right.kind === "replace") {
-				if (left.start < right.end && right.start < left.end) {
-					throwEditConflict(
-						left,
-						right,
-						"overlap on the same original line range",
-					);
-				}
-				continue;
-			}
-
-			const replaceSpan = left.kind === "replace" ? left : right;
-			const insertSpan = left.kind === "insert" ? left : right;
-			if (
-				insertSpan.start >= replaceSpan.start &&
-				insertSpan.start < replaceSpan.end
-			) {
+			if (left.start < right.end && right.start < left.end) {
 				throwEditConflict(
 					left,
 					right,
-					"cannot be applied together because one inserts inside a replaced original range",
+					"overlap on the same original line range",
 				);
 			}
 		}
@@ -324,9 +183,7 @@ function resolveEditSpans(
 		}
 
 		const spanKey =
-			span.kind === "insert"
-				? `insert:${span.boundary}:${span.replacement}`
-				: `replace:${span.start}:${span.end}:${span.replacement}`;
+				`replace:${span.start}:${span.end}:${span.replacement}`;
 		if (seenSpanKeys.has(spanKey)) {
 			continue;
 		}
@@ -335,20 +192,10 @@ function resolveEditSpans(
 	}
 
 	assertNoConflictingSpans(resolvedSpans);
-
 	return [...resolvedSpans].sort((left, right) => {
 		if (right.end !== left.end) {
 			return right.end - left.end;
 		}
-		if (left.kind !== right.kind) {
-			return left.kind === "replace" ? -1 : 1;
-		}
-		if (left.kind === "insert" && right.kind === "insert") {
-			return (
-				(right.boundary ?? -1) - (left.boundary ?? -1) ||
-				left.index - right.index
-			);
-		}
 		return left.index - right.index;
 	});
 }
@@ -361,18 +208,8 @@ function assembleEditResult(
 	let result = content;
 	for (const span of spans) {
 		throwIfAborted(signal);
-		const replacement =
-			span.insertMode === "append-empty-origin"
-				? result.length === 0
-					? span.replacement
-					: `\n${span.replacement}`
-				: span.insertMode === "prepend-empty-origin"
-					? result.length === 0
-						? span.replacement
-						: `${span.replacement}\n`
-					: span.replacement;
 		result =
-			result.slice(0, span.start) + replacement + result.slice(span.end);
+			result.slice(0, span.start) + span.replacement + result.slice(span.end);
 	}
 	return result;
 }
@@ -383,7 +220,6 @@ export function applyHashlineEdits(
 	edits: import("./resolve").HashlineEdit[],
 	signal?: AbortSignal,
 	precomputedHashes?: string[],
-	filePath?: string,
 ): {
 	content: string;
 	firstChangedLine: number | undefined;
@@ -401,7 +237,6 @@ export function applyHashlineEdits(
 
 	// Normalize lines: [""] to lines: [] for deletion.
 	edits = edits.map((edit) =>
-		edit.op === "replace" &&
 		edit.lines.length === 1 &&
 		edit.lines[0] === ""
 			? { ...edit, lines: [] }
@@ -426,7 +261,7 @@ export function applyHashlineEdits(
 		);
 	}
 
-	const barePrefixWarnings = assertNoBareHashPrefixLines(edits, lineIndex.fileLines, fileHashes, filePath);
+	const barePrefixWarnings = assertNoBareHashPrefixLines(edits, lineIndex.fileLines, fileHashes);
 	warnings.push(...barePrefixWarnings);
 	maybeWarnSuspiciousUnicodeEscapePlaceholder(edits, warnings);