pi-hashline-edit-pro 0.4.3 → 0.6.0

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.
 
@@ -13,8 +13,7 @@ The original uses 2-character hashes of a 16-character alphabet, with the hash b
 This fork makes two changes that compound:
 
 1. **Bump hash length to 4 characters** of the 64-char URL-safe base64 alphabet. That gives 24 bits / 16 777 216 buckets. Birthday-paradox collisions are effectively nullified for any realistic file.
-2. **Make the hash occurrence-aware.** The hash for line N is `xxHash32("C{occurrence}:{content}")` where `occurrence` is the running count of that content string earlier in the file. Symbol-only lines use `"S{lineNumber}"` as the discriminator. Two `import {...}` statements at different positions now hash to different values, so the model can target a specific occurrence without resorting to `offset` + a small `limit` window.
-
+2. **Make the hash occurrence-aware.** The hash for line N is `xxHash32("C{occurrence}:{content}")` where `occurrence` is the running count of that content string earlier in the file. Two `import {...}` statements at different positions now hash to different values, so the model can target a specific occurrence without resorting to `offset` + a small `limit` window. All lines — including symbol-only lines like `}` — use the same occurrence-based discrimination.
 ## Installation
 
 From npm:
@@ -56,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.
 
@@ -104,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.
 
@@ -114,12 +113,12 @@ Hashes are computed with [xxhash-wasm](https://github.com/jungomi/xxhash-wasm) (
 
 The alphabet is sized for an LLM consumer. The model tokenizes, it doesn't squint at pixel glyphs, so the human-readability heuristics used by smaller hand-curated alphabets (no G/L/I/O because they look like digits, no vowels so the hash doesn't accidentally spell a word, no hex digits so it can't be confused with `0xFF`) don't apply. The full 64 chars give maximum entropy per character, with case and digits included.
 
-Hashes are occurrence-aware: a discriminator prefix is mixed into the xxHash input before the line content. Symbol-only lines (lone `}`, etc.) use `S{lineNumber}` as the discriminator; content lines use `C{occurrence}` where `occurrence` is the running count of that canonical content earlier in the file. This way:
+Hashes are occurrence-aware: a discriminator prefix is mixed into the xxHash input before the line content. All lines (including symbol-only lines like `}`) use `C{occurrence}` as the discriminator, where `occurrence` is the running count of that canonical content earlier in the file. This way:
 
-- `}` on line 5 and `}` on line 17 hash differently (different `S{...}` prefix).
-- `import { foo } from 'bar';` on line 3 and the same string on line 47 hash differently (different `C{...}` prefix, 1 vs 2).
+- `}` 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.4.3",
-  "description": "Strict hashline read/edit tool override for pi-coding-agent with hash-anchored edits (4-char, 24-bit)",
+  "version": "0.6.0",
+  "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,69 @@
+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).
+
+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;
 }
@@ -401,7 +238,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: [] }