@oh-my-pi/pi-coding-agent 13.0.1 → 13.1.0

package/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 ## [Unreleased]
 
+## [13.1.0] - 2026-02-23
+### Breaking Changes
+
+- Renamed `file` parameter to `path` in replace, patch, and hashline edit operations
+
+### Added
+
+- Added clarification in hashline edit documentation that the `end` tag must include closing braces/brackets when replacing blocks to prevent syntax errors
+
+### Changed
+
+- Restructured task tool documentation for clarity, moving parameter definitions into a dedicated section and consolidating guidance on context, assignments, and parallelization
+- Reformatted system prompt template to use markdown headings instead of XML tags for skills, preloaded skills, and rules sections
+- Renamed `deviceScaleFactor` parameter to `device_scale_factor` in browser viewport configuration for consistency with snake_case naming convention
+- Moved intent field documentation from per-tool JSON schema descriptions into a single system prompt block, reducing token overhead proportional to tool count
+
 ## [13.0.1] - 2026-02-22
 ### Changed
 

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "13.0.1",
+	"version": "13.1.0",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://github.com/can1357/oh-my-pi",
 	"author": "Can Boluk",
@@ -41,12 +41,12 @@
 	},
 	"dependencies": {
 		"@mozilla/readability": "^0.6",
-		"@oh-my-pi/omp-stats": "13.0.1",
-		"@oh-my-pi/pi-agent-core": "13.0.1",
-		"@oh-my-pi/pi-ai": "13.0.1",
-		"@oh-my-pi/pi-natives": "13.0.1",
-		"@oh-my-pi/pi-tui": "13.0.1",
-		"@oh-my-pi/pi-utils": "13.0.1",
+		"@oh-my-pi/omp-stats": "13.1.0",
+		"@oh-my-pi/pi-agent-core": "13.1.0",
+		"@oh-my-pi/pi-ai": "13.1.0",
+		"@oh-my-pi/pi-natives": "13.1.0",
+		"@oh-my-pi/pi-tui": "13.1.0",
+		"@oh-my-pi/pi-utils": "13.1.0",
 		"@sinclair/typebox": "^0.34",
 		"@xterm/headless": "^6.0",
 		"ajv": "^8.18",

package/scripts/format-prompts.ts

@@ -6,7 +6,7 @@
  * 1. No blank line before list items
  * 2. No blank line after opening XML tag or Handlebars block
  * 3. No blank line before closing XML tag or Handlebars block
- * 4. Strip leading whitespace from closing XML tags and Handlebars (lines starting with {{)
+ * 4. Strip leading whitespace from top-level closing XML tags (opened at col 0) and Handlebars (lines starting with {{)
  * 5. Compact markdown tables (remove padding)
  * 6. Collapse 2+ blank lines to single blank line
  * 7. Trim trailing whitespace (preserve indentation)
@@ -62,9 +62,17 @@ function compactTableSep(line: string): string {
 }
 
 function formatPrompt(content: string): string {
+	// Replace common ascii ellipsis and arrow patterns with their unicode equivalents
+	content = content
+		.replace(/\.{3}/g, "…")
+		.replace(/->/g, "→")
+		.replace(/<-/g, "←")
+		.replace(/<->/g, "↔");
 	const lines = content.split("\n");
 	const result: string[] = [];
 	let inCodeBlock = false;
+	// Stack of tag names whose opening tag was at column 0 (top-level)
+	const topLevelTags: string[] = [];
 
 	for (let i = 0; i < lines.length; i++) {
 		let line = lines[i];
@@ -83,8 +91,30 @@ function formatPrompt(content: string): string {
 			continue;
 		}
 
-		// Strip leading whitespace from closing XML tags and Handlebars
-		if (CLOSING_XML.test(trimmed) || trimmed.startsWith("{{")) {
+		// Track top-level XML opening tags for depth-aware indent stripping
+		const isOpeningXml =
+			OPENING_XML.test(trimmed) && !trimmed.endsWith("/>");
+		if (isOpeningXml && line.length === trimmed.length) {
+			// Opening tag at column 0 — track as top-level
+			const match = OPENING_XML.exec(trimmed);
+			if (match) topLevelTags.push(match[1]);
+		}
+
+		// Strip leading whitespace from top-level closing XML tags and Handlebars
+		const closingMatch = CLOSING_XML.exec(trimmed);
+		if (closingMatch) {
+			const tagName = closingMatch[1];
+			if (
+				topLevelTags.length > 0 &&
+				topLevelTags[topLevelTags.length - 1] === tagName
+			) {
+				// Closing tag matches a top-level opener — strip indent
+				line = trimmed;
+				topLevelTags.pop();
+			} else {
+				line = line.trimEnd();
+			}
+		} else if (trimmed.startsWith("{{")) {
 			line = trimmed;
 		} else if (TABLE_SEP.test(trimmed)) {
 			// Compact table separator

package/src/commit/prompts/analysis-system.md

@@ -7,8 +7,8 @@ Classify git diff into conventional commit format.
 ## 1. Determine Scope
 
 Apply scope when 60%+ line changes target single component:
-- 150 lines in src/api/, 30 in src/lib.rs -> "api"
-- 50 lines in src/api/, 50 in src/types/ -> null (50/50 split)
+- 150 lines in src/api/, 30 in src/lib.rs → "api"
+- 50 lines in src/api/, 50 in src/types/ → null (50/50 split)
 
 Use null for: cross-cutting changes, project-wide refactoring.
 
@@ -32,7 +32,7 @@ Group 3+ similar changes: "Updated 5 test files for new API." (not five bullets)
 
 Issue references inline: (#123), (#123, #456), (#123-#125).
 
-Priority: user-visible -> perf/security -> architecture -> internal.
+Priority: user-visible → perf/security → architecture → internal.
 
 Exclude: import changes, whitespace, formatting, trivial renames, debug prints, comment-only, file moves without modification.
 

package/src/commit/prompts/changelog-system.md

@@ -30,9 +30,9 @@ Good:
 - Changed default timeout from 30s to 60s for slow connections
 
 Bad:
-- **cli**: Added dry-run flag -> redundant scope prefix
-- Added new feature. -> vague, trailing period
-- Refactored parser internals -> not user-visible
+- **cli**: Added dry-run flag → redundant scope prefix
+- Added new feature. → vague, trailing period
+- Refactored parser internals → not user-visible
 
 Breaking Changes:
 - Removed legacy auth flow; users must re-authenticate with OAuth tokens

package/src/commit/prompts/summary-system.md

@@ -23,15 +23,15 @@ Output: ONLY description after "{{ commit_type }}{{ scope_prefix }}:"; max {{ ch
 </verb-reference>
 <examples>
 feat | TLS encryption added to HTTP client for MITM prevention
--> added TLS support to prevent man-in-the-middle attacks
+→ added TLS support to prevent man-in-the-middle attacks
 refactor | Consolidated HTTP transport into unified builder pattern
--> migrated HTTP transport to unified builder API
+→ migrated HTTP transport to unified builder API
 fix | Race condition in connection pool causing exhaustion under load
--> corrected race condition causing connection pool exhaustion
+→ corrected race condition causing connection pool exhaustion
 perf | Batch processing optimized to reduce memory allocations
--> eliminated allocation overhead in batch processing
+→ eliminated allocation overhead in batch processing
 build | Updated serde to fix CVE-2024-1234
--> upgraded serde to 1.0.200 for CVE-2024-1234
+→ upgraded serde to 1.0.200 for CVE-2024-1234
 </examples>
 <banned-words>
 comprehensive, various, several, improved, enhanced, quickly, simply, basically, this change, this commit, now

package/src/extensibility/custom-tools/wrapper.ts

@@ -14,6 +14,7 @@ export class CustomToolAdapter<TParams extends TSchema = TSchema, TDetails = any
 	declare label: string;
 	declare description: string;
 	declare parameters: TParams;
+	readonly strict = true;
 
 	constructor(
 		private tool: CustomTool<TParams, TDetails>,

package/src/extensibility/extensions/wrapper.ts

@@ -17,6 +17,7 @@ export class RegisteredToolAdapter implements AgentTool<any, any, any> {
 	declare description: string;
 	declare parameters: any;
 	declare label: string;
+	declare strict: boolean;
 
 	renderCall?: (args: any, options: any, theme: any) => any;
 	renderResult?: (result: any, options: any, theme: any, args?: any) => any;
@@ -83,6 +84,7 @@ export class ExtensionToolWrapper<TParameters extends TSchema = TSchema, TDetail
 	declare description: string;
 	declare parameters: TParameters;
 	declare label: string;
+	declare strict: boolean;
 
 	constructor(
 		private tool: AgentTool<TParameters, TDetails>,

package/src/extensibility/hooks/tool-wrapper.ts

@@ -22,6 +22,7 @@ export class HookToolWrapper<TParameters extends TSchema = TSchema, TDetails = u
 	declare description: string;
 	declare parameters: TParameters;
 	declare label: string;
+	declare strict: boolean;
 
 	constructor(
 		private tool: AgentTool<TParameters, TDetails>,

package/src/lsp/index.ts

@@ -866,6 +866,7 @@ export class LspTool implements AgentTool<typeof lspSchema, LspToolDetails, Them
 	readonly label = "LSP";
 	readonly description: string;
 	readonly parameters = lspSchema;
+	readonly strict = true;
 	readonly renderCall = renderCall;
 	readonly renderResult = renderResult;
 	readonly mergeCallAndResult = true;

package/src/patch/diff.ts

@@ -414,11 +414,11 @@ export async function computeHashlineDiff(
 		const normalizedContent = normalizeToLF(content);
 
 		const result = applyHashlineEdits(normalizedContent, edits);
-		if (normalizedContent === result.content) {
+		if (normalizedContent === result.lines) {
 			return { error: `No changes would be made to ${path}. The edits produce identical content.` };
 		}
 
-		return generateDiffString(normalizedContent, result.content);
+		return generateDiffString(normalizedContent, result.lines);
 	} catch (err) {
 		return { error: err instanceof Error ? err.message : String(err) };
 	}

package/src/patch/hashline.ts

@@ -1,26 +1,24 @@
 /**
- * Hashline edit mode — a line-addressable edit format using content hashes.
+ * Hashline edit mode — a line-addressable edit format using text hashes.
  *
  * Each line in a file is identified by its 1-indexed line number and a short
- * hexadecimal hash derived from the normalized line content (xxHash32, truncated to 2
+ * hexadecimal hash derived from the normalized line text (xxHash32, truncated to 2
  * hex chars).
  * The combined `LINE#ID` reference acts as both an address and a staleness check:
  * if the file has changed since the caller last read it, hash mismatches are caught
  * before any mutation occurs.
  *
- * Displayed format: `LINENUM#HASH:CONTENT`
+ * Displayed format: `LINENUM#HASH:TEXT`
  * Reference format: `"LINENUM#HASH"` (e.g. `"5#aa"`)
  */
 
 import type { HashMismatch } from "./types";
 
-export type LineTag = { line: number; hash: string };
+export type Anchor = { line: number; hash: string };
 export type HashlineEdit =
-	| { op: "replace"; tag: LineTag; content: string[] }
-	| { op: "replace"; first: LineTag; last: LineTag; content: string[] }
-	| { op: "append"; after?: LineTag; content: string[] }
-	| { op: "prepend"; before?: LineTag; content: string[] }
-	| { op: "insert"; after: LineTag; before: LineTag; content: string[] };
+	| { op: "replace"; pos: Anchor; end?: Anchor; lines: string[] }
+	| { op: "append"; pos?: Anchor; lines: string[] }
+	| { op: "prepend"; pos?: Anchor; lines: string[] };
 
 const NIBBLE_STR = "ZPMQVRWSNKTXJBYH";
 
@@ -30,12 +28,14 @@ const DICT = Array.from({ length: 256 }, (_, i) => {
 	return `${NIBBLE_STR[h]}${NIBBLE_STR[l]}`;
 });
 
+const RE_SIGNIFICANT = /[\p{L}\p{N}]/u;
+
 /**
  * Compute a short hexadecimal hash of a single line.
  *
- * Uses xxHash32 on a whitespace-normalized line, truncated to {@link HASH_LEN}
- * hex characters. The `idx` parameter is accepted for compatibility with older
- * call sites, but is not currently mixed into the hash.
+ * Uses xxHash32 on a whitespace-normalized line, truncated to 2 chars from
+ * {@link NIBBLE_STR}. For lines containing no alphanumeric characters (only
+ * punctuation/symbols/whitespace), the line number is mixed in to reduce hash collisions.
  * The line input should not include a trailing newline.
  */
 export function computeLineHash(idx: number, line: string): string {
@@ -43,23 +43,27 @@ export function computeLineHash(idx: number, line: string): string {
 		line = line.slice(0, -1);
 	}
 	line = line.replace(/\s+/g, "");
-	void idx; // Might use line, but for now, let's not.
-	return DICT[Bun.hash.xxHash32(line) & 0xff];
+
+	let seed = 0;
+	if (!RE_SIGNIFICANT.test(line)) {
+		seed = idx;
+	}
+	return DICT[Bun.hash.xxHash32(line, seed) & 0xff];
 }
 
 /**
- * Formats a tag given the line number and content.
+ * Formats a tag given the line number and text.
  */
-export function formatLineTag(line: number, content: string): string {
-	return `${line}#${computeLineHash(line, content)}`;
+export function formatLineTag(line: number, lines: string): string {
+	return `${line}#${computeLineHash(line, lines)}`;
 }
 
 /**
- * Format file content with hashline prefixes for display.
+ * Format file text with hashline prefixes for display.
  *
- * Each line becomes `LINENUM#HASH:CONTENT` where LINENUM is 1-indexed.
+ * Each line becomes `LINENUM#HASH:TEXT` where LINENUM is 1-indexed.
  *
- * @param content - Raw file content string
+ * @param text - Raw file text string
  * @param startLine - First line number (1-indexed, defaults to 1)
  * @returns Formatted string with one hashline-prefixed line per input line
  *
@@ -69,8 +73,8 @@ export function formatLineTag(line: number, content: string): string {
  * // "1#HH:function hi() {\n2#HH:  return;\n3#HH:}"
  * ```
  */
-export function formatHashLines(content: string, startLine = 1): string {
-	const lines = content.split("\n");
+export function formatHashLines(text: string, startLine = 1): string {
+	const lines = text.split("\n");
 	return lines
 		.map((line, i) => {
 			const num = startLine + i;
@@ -375,14 +379,14 @@ export class HashlineMismatchError extends Error {
 			}
 			prevLine = lineNum;
 
-			const content = fileLines[lineNum - 1];
-			const hash = computeLineHash(lineNum, content);
+			const text = fileLines[lineNum - 1];
+			const hash = computeLineHash(lineNum, text);
 			const prefix = `${lineNum}#${hash}`;
 
 			if (mismatchSet.has(lineNum)) {
-				lines.push(`>>> ${prefix}:${content}`);
+				lines.push(`>>> ${prefix}:${text}`);
 			} else {
-				lines.push(`    ${prefix}:${content}`);
+				lines.push(`    ${prefix}:${text}`);
 			}
 		}
 		return lines.join("\n");
@@ -415,7 +419,7 @@ export function validateLineRef(ref: { line: number; hash: string }, fileLines:
  * Apply an array of hashline edits to file content.
  *
  * Each edit operation identifies target lines directly (`replace`,
- * `insert`). Line references are resolved via {@link parseTag}
+ * `append`, `prepend`). Line references are resolved via {@link parseTag}
  * and hashes validated before any mutation.
  *
  * Edits are sorted bottom-up (highest effective line first) so earlier
@@ -424,22 +428,22 @@ export function validateLineRef(ref: { line: number; hash: string }, fileLines:
  * @returns The modified content and the 1-indexed first changed line number
  */
 export function applyHashlineEdits(
-	content: string,
+	text: string,
 	edits: HashlineEdit[],
 ): {
-	content: string;
+	lines: string;
 	firstChangedLine: number | undefined;
 	warnings?: string[];
-	noopEdits?: Array<{ editIndex: number; loc: string; currentContent: string }>;
+	noopEdits?: Array<{ editIndex: number; loc: string; current: string }>;
 } {
 	if (edits.length === 0) {
-		return { content, firstChangedLine: undefined };
+		return { lines: text, firstChangedLine: undefined };
 	}
 
-	const fileLines = content.split("\n");
+	const fileLines = text.split("\n");
 	const originalFileLines = [...fileLines];
 	let firstChangedLine: number | undefined;
-	const noopEdits: Array<{ editIndex: number; loc: string; currentContent: string }> = [];
+	const noopEdits: Array<{ editIndex: number; loc: string; current: string }> = [];
 
 	// Pre-validate: collect all hash mismatches before mutating
 	const mismatches: HashMismatch[] = [];
@@ -457,42 +461,30 @@ export function applyHashlineEdits(
 	for (const edit of edits) {
 		switch (edit.op) {
 			case "replace": {
-				if ("tag" in edit) {
-					if (!validateRef(edit.tag)) continue;
-				} else {
-					if (edit.first.line > edit.last.line) {
-						throw new Error(`Range start line ${edit.first.line} must be <= end line ${edit.last.line}`);
-					}
-					const startValid = validateRef(edit.first);
-					const endValid = validateRef(edit.last);
+				if (edit.end) {
+					const startValid = validateRef(edit.pos);
+					const endValid = validateRef(edit.end);
 					if (!startValid || !endValid) continue;
+					if (edit.pos.line > edit.end.line) {
+						throw new Error(`Range start line ${edit.pos.line} must be <= end line ${edit.end.line}`);
+					}
+				} else {
+					if (!validateRef(edit.pos)) continue;
 				}
 				break;
 			}
 			case "append": {
-				if (edit.content.length === 0) {
-					throw new Error('Insert-after edit (src "N#HH..") requires non-empty dst');
+				if (edit.pos && !validateRef(edit.pos)) continue;
+				if (edit.lines.length === 0) {
+					edit.lines = [""]; // insert an empty line
 				}
-				if (edit.after && !validateRef(edit.after)) continue;
 				break;
 			}
 			case "prepend": {
-				if (edit.content.length === 0) {
-					throw new Error('Insert-before edit (src "N#HH..") requires non-empty dst');
-				}
-				if (edit.before && !validateRef(edit.before)) continue;
-				break;
-			}
-			case "insert": {
-				if (edit.content.length === 0) {
-					throw new Error('Insert-between edit (src "A#HH.. B#HH..") requires non-empty dst');
-				}
-				if (edit.before.line <= edit.after.line) {
-					throw new Error(`insert requires after (${edit.after.line}) < before (${edit.before.line})`);
+				if (edit.pos && !validateRef(edit.pos)) continue;
+				if (edit.lines.length === 0) {
+					edit.lines = [""]; // insert an empty line
 				}
-				const afterValid = validateRef(edit.after);
-				const beforeValid = validateRef(edit.before);
-				if (!afterValid || !beforeValid) continue;
 				break;
 			}
 		}
@@ -508,31 +500,28 @@ export function applyHashlineEdits(
 		let lineKey: string;
 		switch (edit.op) {
 			case "replace":
-				if ("tag" in edit) {
-					lineKey = `s:${edit.tag.line}`;
+				if (!edit.end) {
+					lineKey = `s:${edit.pos.line}`;
 				} else {
-					lineKey = `r:${edit.first.line}:${edit.last.line}`;
+					lineKey = `r:${edit.pos.line}:${edit.end.line}`;
 				}
 				break;
 			case "append":
-				if (edit.after) {
-					lineKey = `i:${edit.after.line}`;
+				if (edit.pos) {
+					lineKey = `i:${edit.pos.line}`;
 					break;
 				}
 				lineKey = "ieof";
 				break;
 			case "prepend":
-				if (edit.before) {
-					lineKey = `ib:${edit.before.line}`;
+				if (edit.pos) {
+					lineKey = `ib:${edit.pos.line}`;
 					break;
 				}
 				lineKey = "ibef";
 				break;
-			case "insert":
-				lineKey = `ix:${edit.after.line}:${edit.before.line}`;
-				break;
 		}
-		const dstKey = `${lineKey}:${edit.content.join("\n")}`;
+		const dstKey = `${lineKey}:${edit.lines.join("\n")}`;
 		if (seenEditKeys.has(dstKey)) {
 			dedupIndices.add(i);
 		} else {
@@ -551,25 +540,21 @@ export function applyHashlineEdits(
 		let precedence: number;
 		switch (edit.op) {
 			case "replace":
-				if ("tag" in edit) {
-					sortLine = edit.tag.line;
+				if (!edit.end) {
+					sortLine = edit.pos.line;
 				} else {
-					sortLine = edit.last.line;
+					sortLine = edit.end.line;
 				}
 				precedence = 0;
 				break;
 			case "append":
-				sortLine = edit.after ? edit.after.line : fileLines.length + 1;
+				sortLine = edit.pos ? edit.pos.line : fileLines.length + 1;
 				precedence = 1;
 				break;
 			case "prepend":
-				sortLine = edit.before ? edit.before.line : 0;
+				sortLine = edit.pos ? edit.pos.line : 0;
 				precedence = 2;
 				break;
-			case "insert":
-				sortLine = edit.before.line;
-				precedence = 3;
-				break;
 		}
 		return { edit, idx, sortLine, precedence };
 	});
@@ -580,40 +565,40 @@ export function applyHashlineEdits(
 	for (const { edit, idx } of annotated) {
 		switch (edit.op) {
 			case "replace": {
-				if ("tag" in edit) {
-					const origLines = originalFileLines.slice(edit.tag.line - 1, edit.tag.line);
-					const newLines = edit.content;
+				if (!edit.end) {
+					const origLines = originalFileLines.slice(edit.pos.line - 1, edit.pos.line);
+					const newLines = edit.lines;
 					if (origLines.every((line, i) => line === newLines[i])) {
 						noopEdits.push({
 							editIndex: idx,
-							loc: `${edit.tag.line}#${edit.tag.hash}`,
-							currentContent: origLines.join("\n"),
+							loc: `${edit.pos.line}#${edit.pos.hash}`,
+							current: origLines.join("\n"),
 						});
 						break;
 					}
-					fileLines.splice(edit.tag.line - 1, 1, ...newLines);
-					trackFirstChanged(edit.tag.line);
+					fileLines.splice(edit.pos.line - 1, 1, ...newLines);
+					trackFirstChanged(edit.pos.line);
 				} else {
-					const count = edit.last.line - edit.first.line + 1;
-					const newLines = edit.content;
-					fileLines.splice(edit.first.line - 1, count, ...newLines);
-					trackFirstChanged(edit.first.line);
+					const count = edit.end.line - edit.pos.line + 1;
+					const newLines = edit.lines;
+					fileLines.splice(edit.pos.line - 1, count, ...newLines);
+					trackFirstChanged(edit.pos.line);
 				}
 				break;
 			}
 			case "append": {
-				const inserted = edit.content;
+				const inserted = edit.lines;
 				if (inserted.length === 0) {
 					noopEdits.push({
 						editIndex: idx,
-						loc: edit.after ? `${edit.after.line}#${edit.after.hash}` : "EOF",
-						currentContent: edit.after ? originalFileLines[edit.after.line - 1] : "",
+						loc: edit.pos ? `${edit.pos.line}#${edit.pos.hash}` : "EOF",
+						current: edit.pos ? originalFileLines[edit.pos.line - 1] : "",
 					});
 					break;
 				}
-				if (edit.after) {
-					fileLines.splice(edit.after.line, 0, ...inserted);
-					trackFirstChanged(edit.after.line + 1);
+				if (edit.pos) {
+					fileLines.splice(edit.pos.line, 0, ...inserted);
+					trackFirstChanged(edit.pos.line + 1);
 				} else {
 					if (fileLines.length === 1 && fileLines[0] === "") {
 						fileLines.splice(0, 1, ...inserted);
@@ -626,18 +611,18 @@ export function applyHashlineEdits(
 				break;
 			}
 			case "prepend": {
-				const inserted = edit.content;
+				const inserted = edit.lines;
 				if (inserted.length === 0) {
 					noopEdits.push({
 						editIndex: idx,
-						loc: edit.before ? `${edit.before.line}#${edit.before.hash}` : "BOF",
-						currentContent: edit.before ? originalFileLines[edit.before.line - 1] : "",
+						loc: edit.pos ? `${edit.pos.line}#${edit.pos.hash}` : "BOF",
+						current: edit.pos ? originalFileLines[edit.pos.line - 1] : "",
 					});
 					break;
 				}
-				if (edit.before) {
-					fileLines.splice(edit.before.line - 1, 0, ...inserted);
-					trackFirstChanged(edit.before.line);
+				if (edit.pos) {
+					fileLines.splice(edit.pos.line - 1, 0, ...inserted);
+					trackFirstChanged(edit.pos.line);
 				} else {
 					if (fileLines.length === 1 && fileLines[0] === "") {
 						fileLines.splice(0, 1, ...inserted);
@@ -648,27 +633,11 @@ export function applyHashlineEdits(
 				}
 				break;
 			}
-			case "insert": {
-				const afterLine = originalFileLines[edit.after.line - 1];
-				const beforeLine = originalFileLines[edit.before.line - 1];
-				const inserted = edit.content;
-				if (inserted.length === 0) {
-					noopEdits.push({
-						editIndex: idx,
-						loc: `${edit.after.line}#${edit.after.hash}..${edit.before.line}#${edit.before.hash}`,
-						currentContent: `${afterLine}\n${beforeLine}`,
-					});
-					break;
-				}
-				fileLines.splice(edit.before.line - 1, 0, ...inserted);
-				trackFirstChanged(edit.before.line);
-				break;
-			}
 		}
 	}
 
 	return {
-		content: fileLines.join("\n"),
+		lines: fileLines.join("\n"),
 		firstChangedLine,
 		...(noopEdits.length > 0 ? { noopEdits } : {}),
 	};