@oh-my-pi/pi-coding-agent 13.14.0 → 13.15.2

package/src/modes/types.ts

@@ -3,7 +3,12 @@ import type { AssistantMessage, ImageContent, Message, UsageReport } from "@oh-m
 import type { Component, Container, Loader, Spacer, Text, TUI } from "@oh-my-pi/pi-tui";
 import type { KeybindingsManager } from "../config/keybindings";
 import type { Settings } from "../config/settings";
-import type { ExtensionUIContext, ExtensionUIDialogOptions } from "../extensibility/extensions";
+import type {
+	ExtensionUIContext,
+	ExtensionUIDialogOptions,
+	ExtensionWidgetContent,
+	ExtensionWidgetOptions,
+} from "../extensibility/extensions";
 import type { CompactOptions } from "../extensibility/extensions/types";
 import type { MCPManager } from "../mcp";
 import type { AgentSession, AgentSessionEvent } from "../session/agent-session";
@@ -59,6 +64,8 @@ export interface InteractiveModeContext {
 	btwContainer: Container;
 	editor: CustomEditor;
 	editorContainer: Container;
+	hookWidgetContainerAbove: Container;
+	hookWidgetContainerBelow: Container;
 	statusLine: StatusLineComponent;
 
 	// Session access
@@ -226,7 +233,7 @@ export interface InteractiveModeContext {
 		reason: "start" | "switch" | "branch" | "tree" | "shutdown",
 		previousSessionFile?: string,
 	): Promise<void>;
-	setHookWidget(key: string, content: unknown): void;
+	setHookWidget(key: string, content: ExtensionWidgetContent, options?: ExtensionWidgetOptions): void;
 	setHookStatus(key: string, text: string | undefined): void;
 	showHookSelector(
 		title: string,

package/src/modes/utils/hotkeys-markdown.ts

@@ -1,10 +1,10 @@
-import type { AppAction, KeybindingsManager } from "../../config/keybindings";
+import type { AppKeybinding, KeybindingsManager } from "../../config/keybindings";
 
 export interface HotkeysMarkdownBindings {
 	keybindings: Pick<KeybindingsManager, "getDisplayString">;
 }
 
-function appKey(bindings: HotkeysMarkdownBindings, action: AppAction): string {
+function appKey(bindings: HotkeysMarkdownBindings, action: AppKeybinding): string {
 	return bindings.keybindings.getDisplayString(action) || "Disabled";
 }
 
@@ -26,29 +26,29 @@ export function buildHotkeysMarkdown(bindings: HotkeysMarkdownBindings): string
 		"| `Ctrl+W` / `Option+Backspace` | Delete word backwards |",
 		"| `Ctrl+U` | Delete to start of line |",
 		"| `Ctrl+K` | Delete to end of line |",
-		`| \`${appKey(bindings, "copyLine")}\` | Copy current line |`,
-		`| \`${appKey(bindings, "copyPrompt")}\` | Copy whole prompt |`,
+		`| \`${appKey(bindings, "app.clipboard.copyLine")}\` | Copy current line |`,
+		`| \`${appKey(bindings, "app.clipboard.copyPrompt")}\` | Copy whole prompt |`,
 		"",
 		"**Other**",
 		"| Key | Action |",
 		"|-----|--------|",
 		"| `Tab` | Path completion / accept autocomplete |",
-		`| \`${appKey(bindings, "interrupt")}\` | Cancel autocomplete / interrupt active work |`,
-		`| \`${appKey(bindings, "clear")}\` | Clear editor (first) / exit (second) |`,
-		`| \`${appKey(bindings, "exit")}\` | Exit (when editor is empty) |`,
-		`| \`${appKey(bindings, "suspend")}\` | Suspend to background |`,
-		`| \`${appKey(bindings, "cycleThinkingLevel")}\` | Cycle thinking level |`,
-		`| \`${appKey(bindings, "cycleModelForward")}\` | Cycle role models (slow/default/smol) |`,
-		`| \`${appKey(bindings, "cycleModelBackward")}\` | Cycle role models (temporary) |`,
+		`| \`${appKey(bindings, "app.interrupt")}\` | Cancel autocomplete / interrupt active work |`,
+		`| \`${appKey(bindings, "app.clear")}\` | Clear editor (first) / exit (second) |`,
+		`| \`${appKey(bindings, "app.exit")}\` | Exit (when editor is empty) |`,
+		`| \`${appKey(bindings, "app.suspend")}\` | Suspend to background |`,
+		`| \`${appKey(bindings, "app.thinking.cycle")}\` | Cycle thinking level |`,
+		`| \`${appKey(bindings, "app.model.cycleForward")}\` | Cycle role models (slow/default/smol) |`,
+		`| \`${appKey(bindings, "app.model.cycleBackward")}\` | Cycle role models (temporary) |`,
 		"| `Alt+P` | Select model (temporary) |",
-		`| \`${appKey(bindings, "selectModel")}\` | Select model (set roles) |`,
-		`| \`${appKey(bindings, "togglePlanMode")}\` | Toggle plan mode |`,
-		`| \`${appKey(bindings, "historySearch")}\` | Search prompt history |`,
-		`| \`${appKey(bindings, "expandTools")}\` | Toggle tool output expansion |`,
-		`| \`${appKey(bindings, "toggleThinking")}\` | Toggle thinking block visibility |`,
-		`| \`${appKey(bindings, "externalEditor")}\` | Edit message in external editor |`,
-		`| \`${appKey(bindings, "pasteImage")}\` | Paste image from clipboard |`,
-		`| \`${appKey(bindings, "toggleSTT")}\` | Toggle speech-to-text recording |`,
+		`| \`${appKey(bindings, "app.model.select")}\` | Select model (set roles) |`,
+		`| \`${appKey(bindings, "app.plan.toggle")}\` | Toggle plan mode |`,
+		`| \`${appKey(bindings, "app.history.search")}\` | Search prompt history |`,
+		`| \`${appKey(bindings, "app.tools.expand")}\` | Toggle tool output expansion |`,
+		`| \`${appKey(bindings, "app.thinking.toggle")}\` | Toggle thinking block visibility |`,
+		`| \`${appKey(bindings, "app.editor.external")}\` | Edit message in external editor |`,
+		`| \`${appKey(bindings, "app.clipboard.pasteImage")}\` | Paste image from clipboard |`,
+		`| \`${appKey(bindings, "app.stt.toggle")}\` | Toggle speech-to-text recording |`,
 		"| `#` | Open prompt actions |",
 		"| `/` | Slash commands |",
 		"| `!` | Run bash command |",

package/src/modes/utils/keybinding-matchers.ts

@@ -0,0 +1,21 @@
+import { getKeybindings, matchesKey } from "@oh-my-pi/pi-tui";
+
+/**
+ * Match the coding-agent interrupt key.
+ *
+ * Interactive mode installs a keybinding manager that exposes `app.interrupt`
+ * globally, but some isolated component tests still run with only TUI
+ * keybindings registered. In that case, fall back to raw Escape matching.
+ */
+export function matchesAppInterrupt(data: string): boolean {
+	const keybindings = getKeybindings();
+	const interruptKeys = keybindings.getKeys("app.interrupt");
+	if (interruptKeys.length > 0) {
+		return keybindings.matches(data, "app.interrupt");
+	}
+	return matchesKey(data, "escape") || matchesKey(data, "esc");
+}
+
+export function matchesSelectCancel(data: string): boolean {
+	return getKeybindings().matches(data, "tui.select.cancel");
+}

package/src/modes/utils/ui-helpers.ts

@@ -474,7 +474,7 @@ export class UiHelpers {
 				const queuedText = theme.fg("dim", `${entry.label}: ${entry.message}`);
 				this.ctx.pendingMessagesContainer.addChild(new TruncatedText(queuedText, 1, 0));
 			}
-			const dequeueKey = this.ctx.keybindings.getDisplayString("dequeue") || "Alt+Up";
+			const dequeueKey = this.ctx.keybindings.getDisplayString("app.message.dequeue") || "Alt+Up";
 			const hintText = theme.fg("dim", `${theme.tree.hook} ${dequeueKey} to edit`);
 			this.ctx.pendingMessagesContainer.addChild(new TruncatedText(hintText, 1, 0));
 		}

package/src/patch/hashline.ts

@@ -16,9 +16,12 @@ import type { HashMismatch } from "./types";
 
 export type Anchor = { line: number; hash: string };
 export type HashlineEdit =
-	| { op: "replace"; pos: Anchor; end?: Anchor; lines: string[] }
-	| { op: "append"; pos?: Anchor; lines: string[] }
-	| { op: "prepend"; pos?: Anchor; lines: string[] };
+	| { op: "replace_line"; pos: Anchor; lines: string[] }
+	| { op: "replace_range"; pos: Anchor; end: Anchor; lines: string[] }
+	| { op: "append_at"; pos: Anchor; lines: string[] }
+	| { op: "prepend_at"; pos: Anchor; lines: string[] }
+	| { op: "append_file"; lines: string[] }
+	| { op: "prepend_file"; lines: string[] };
 
 const NIBBLE_STR = "ZPMQVRWSNKTXJBYH";
 
@@ -455,18 +458,6 @@ function maybeWarnSuspiciousUnicodeEscapePlaceholder(edits: HashlineEdit[], warn
 // Edit Application
 // ═══════════════════════════════════════════════════════════════════════════
 
-const MIN_AUTOCORRECT_LENGTH = 2;
-
-function shouldAutocorrect(line: string, otherLine: string): boolean {
-	if (!line || line !== otherLine) return false;
-	line = line.trim();
-	if (line.length < MIN_AUTOCORRECT_LENGTH) {
-		// if brace, we allow
-		return line.endsWith("}") || line.endsWith(")");
-	}
-	return true;
-}
-
 /**
  * Apply an array of hashline edits to file content.
  *
@@ -513,28 +504,29 @@ export function applyHashlineEdits(
 	}
 	for (const edit of edits) {
 		switch (edit.op) {
-			case "replace": {
-				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;
+			case "replace_line": {
+				if (!validateRef(edit.pos)) continue;
+				break;
+			}
+			case "replace_range": {
+				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}`);
 				}
 				break;
 			}
-			case "append": {
-				if (edit.pos && !validateRef(edit.pos)) continue;
+			case "append_at":
+			case "prepend_at": {
+				if (!validateRef(edit.pos)) continue;
 				if (edit.lines.length === 0) {
 					edit.lines = [""]; // insert an empty line
 				}
 				break;
 			}
-			case "prepend": {
-				if (edit.pos && !validateRef(edit.pos)) continue;
+			case "append_file":
+			case "prepend_file": {
 				if (edit.lines.length === 0) {
 					edit.lines = [""]; // insert an empty line
 				}
@@ -547,6 +539,38 @@ export function applyHashlineEdits(
 	}
 	maybeAutocorrectEscapedTabIndentation(edits, warnings);
 	maybeWarnSuspiciousUnicodeEscapePlaceholder(edits, warnings);
+
+	// Warn when a replace_range/replace_line's last inserted line duplicates the next surviving line.
+	// This catches the common boundary-overreach pattern where the agent includes a closing delimiter
+	// in the replacement but sets `end` to the line before the delimiter, causing duplication.
+	for (const edit of edits) {
+		let endLine: number;
+		switch (edit.op) {
+			case "replace_line":
+				endLine = edit.pos.line;
+				break;
+			case "replace_range":
+				endLine = edit.end.line;
+				break;
+			default:
+				continue;
+		}
+		if (edit.lines.length === 0) continue;
+		const nextSurvivingIdx = endLine; // 0-indexed: endLine (1-indexed) is the next line after `end`
+		if (nextSurvivingIdx >= originalFileLines.length) continue;
+		const nextSurvivingLine = originalFileLines[nextSurvivingIdx];
+		const lastInsertedLine = edit.lines[edit.lines.length - 1];
+		const trimmedNext = nextSurvivingLine.trim();
+		const trimmedLast = lastInsertedLine.trim();
+		// Only warn for non-trivial lines to avoid false positives on blank lines or bare punctuation
+		if (trimmedLast.length > 0 && trimmedLast === trimmedNext) {
+			const tag = formatLineTag(endLine + 1, nextSurvivingLine);
+			warnings.push(
+				`Possible boundary duplication: your last replacement line \`${trimmedLast}\` is identical to the next surviving line ${tag}. ` +
+					`If you meant to replace the entire block, set \`end\` to ${tag} instead.`,
+			);
+		}
+	}
 	// Deduplicate identical edits targeting the same line(s)
 	const seenEditKeys = new Map<string, number>();
 	const dedupIndices = new Set<number>();
@@ -554,25 +578,22 @@ export function applyHashlineEdits(
 		const edit = edits[i];
 		let lineKey: string;
 		switch (edit.op) {
-			case "replace":
-				if (!edit.end) {
-					lineKey = `s:${edit.pos.line}`;
-				} else {
-					lineKey = `r:${edit.pos.line}:${edit.end.line}`;
-				}
+			case "replace_line":
+				lineKey = `s:${edit.pos.line}`;
 				break;
-			case "append":
-				if (edit.pos) {
-					lineKey = `i:${edit.pos.line}`;
-					break;
-				}
+			case "replace_range":
+				lineKey = `r:${edit.pos.line}:${edit.end.line}`;
+				break;
+			case "append_at":
+				lineKey = `i:${edit.pos.line}`;
+				break;
+			case "prepend_at":
+				lineKey = `ib:${edit.pos.line}`;
+				break;
+			case "append_file":
 				lineKey = "ieof";
 				break;
-			case "prepend":
-				if (edit.pos) {
-					lineKey = `ib:${edit.pos.line}`;
-					break;
-				}
+			case "prepend_file":
 				lineKey = "ibef";
 				break;
 		}
@@ -594,20 +615,28 @@ export function applyHashlineEdits(
 		let sortLine: number;
 		let precedence: number;
 		switch (edit.op) {
-			case "replace":
-				if (!edit.end) {
-					sortLine = edit.pos.line;
-				} else {
-					sortLine = edit.end.line;
-				}
+			case "replace_line":
+				sortLine = edit.pos.line;
+				precedence = 0;
+				break;
+			case "replace_range":
+				sortLine = edit.end.line;
 				precedence = 0;
 				break;
-			case "append":
-				sortLine = edit.pos ? edit.pos.line : fileLines.length + 1;
+			case "append_at":
+				sortLine = edit.pos.line;
 				precedence = 1;
 				break;
-			case "prepend":
-				sortLine = edit.pos ? edit.pos.line : 0;
+			case "prepend_at":
+				sortLine = edit.pos.line;
+				precedence = 2;
+				break;
+			case "append_file":
+				sortLine = fileLines.length + 1;
+				precedence = 1;
+				break;
+			case "prepend_file":
+				sortLine = 0;
 				precedence = 2;
 				break;
 		}
@@ -619,99 +648,82 @@ export function applyHashlineEdits(
 	// Apply edits bottom-up
 	for (const { edit, idx } of annotated) {
 		switch (edit.op) {
-			case "replace": {
-				if (!edit.end) {
-					const origLines = originalFileLines.slice(edit.pos.line - 1, edit.pos.line);
-					const newLines = edit.lines;
-					if (origLines.length === newLines.length && origLines.every((line, i) => line === newLines[i])) {
-						noopEdits.push({
-							editIndex: idx,
-							loc: `${edit.pos.line}#${edit.pos.hash}`,
-							current: origLines.join("\n"),
-						});
-						break;
-					}
-					fileLines.splice(edit.pos.line - 1, 1, ...newLines);
-					trackFirstChanged(edit.pos.line);
-				} else {
-					const count = edit.end.line - edit.pos.line + 1;
-					const newLines = [...edit.lines];
-					const trailingReplacementLine = newLines[newLines.length - 1]?.trimEnd();
-					const nextSurvivingLine = fileLines[edit.end.line]?.trimEnd();
-					if (
-						shouldAutocorrect(trailingReplacementLine, nextSurvivingLine) &&
-						// Safety: only correct when end-line content differs from the duplicate.
-						// If end already points to the boundary, matching next line is coincidence.
-						fileLines[edit.end.line - 1]?.trimEnd() !== trailingReplacementLine
-					) {
-						newLines.pop();
-						warnings.push(
-							`Auto-corrected range replace ${edit.pos.line}#${edit.pos.hash}-${edit.end.line}#${edit.end.hash}: removed trailing replacement line "${trailingReplacementLine}" that duplicated next surviving line`,
-						);
-					}
-					const leadingReplacementLine = newLines[0]?.trimEnd();
-					const prevSurvivingLine = fileLines[edit.pos.line - 2]?.trimEnd();
-					if (
-						shouldAutocorrect(leadingReplacementLine, prevSurvivingLine) &&
-						// Safety: only correct when pos-line content differs from the duplicate.
-						// If pos already points to the boundary, matching prev line is coincidence.
-						fileLines[edit.pos.line - 1]?.trimEnd() !== leadingReplacementLine
-					) {
-						newLines.shift();
-						warnings.push(
-							`Auto-corrected range replace ${edit.pos.line}#${edit.pos.hash}-${edit.end.line}#${edit.end.hash}: removed leading replacement line "${leadingReplacementLine}" that duplicated preceding surviving line`,
-						);
-					}
-					fileLines.splice(edit.pos.line - 1, count, ...newLines);
-					trackFirstChanged(edit.pos.line);
+			case "replace_line": {
+				const origLines = originalFileLines.slice(edit.pos.line - 1, edit.pos.line);
+				const newLines = edit.lines;
+				if (origLines.length === newLines.length && origLines.every((line, i) => line === newLines[i])) {
+					noopEdits.push({
+						editIndex: idx,
+						loc: `${edit.pos.line}#${edit.pos.hash}`,
+						current: origLines.join("\n"),
+					});
+					break;
 				}
+				fileLines.splice(edit.pos.line - 1, 1, ...newLines);
+				trackFirstChanged(edit.pos.line);
+				break;
+			}
+			case "replace_range": {
+				const count = edit.end.line - edit.pos.line + 1;
+				fileLines.splice(edit.pos.line - 1, count, ...edit.lines);
+				trackFirstChanged(edit.pos.line);
 				break;
 			}
-			case "append": {
+			case "append_at": {
 				const inserted = edit.lines;
 				if (inserted.length === 0) {
 					noopEdits.push({
 						editIndex: idx,
-						loc: edit.pos ? `${edit.pos.line}#${edit.pos.hash}` : "EOF",
-						current: edit.pos ? originalFileLines[edit.pos.line - 1] : "",
+						loc: `${edit.pos.line}#${edit.pos.hash}`,
+						current: originalFileLines[edit.pos.line - 1],
 					});
 					break;
 				}
-				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);
-						trackFirstChanged(1);
-					} else {
-						fileLines.splice(fileLines.length, 0, ...inserted);
-						trackFirstChanged(fileLines.length - inserted.length + 1);
-					}
-				}
+				fileLines.splice(edit.pos.line, 0, ...inserted);
+				trackFirstChanged(edit.pos.line + 1);
 				break;
 			}
-			case "prepend": {
+			case "prepend_at": {
 				const inserted = edit.lines;
 				if (inserted.length === 0) {
 					noopEdits.push({
 						editIndex: idx,
-						loc: edit.pos ? `${edit.pos.line}#${edit.pos.hash}` : "BOF",
-						current: edit.pos ? originalFileLines[edit.pos.line - 1] : "",
+						loc: `${edit.pos.line}#${edit.pos.hash}`,
+						current: originalFileLines[edit.pos.line - 1],
 					});
 					break;
 				}
-				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);
-					} else {
-						fileLines.splice(0, 0, ...inserted);
-					}
+				fileLines.splice(edit.pos.line - 1, 0, ...inserted);
+				trackFirstChanged(edit.pos.line);
+				break;
+			}
+			case "append_file": {
+				const inserted = edit.lines;
+				if (inserted.length === 0) {
+					noopEdits.push({ editIndex: idx, loc: "EOF", current: "" });
+					break;
+				}
+				if (fileLines.length === 1 && fileLines[0] === "") {
+					fileLines.splice(0, 1, ...inserted);
 					trackFirstChanged(1);
+				} else {
+					fileLines.splice(fileLines.length, 0, ...inserted);
+					trackFirstChanged(fileLines.length - inserted.length + 1);
+				}
+				break;
+			}
+			case "prepend_file": {
+				const inserted = edit.lines;
+				if (inserted.length === 0) {
+					noopEdits.push({ editIndex: idx, loc: "BOF", current: "" });
+					break;
+				}
+				if (fileLines.length === 1 && fileLines[0] === "") {
+					fileLines.splice(0, 1, ...inserted);
+				} else {
+					fileLines.splice(0, 0, ...inserted);
 				}
+				trackFirstChanged(1);
 				break;
 			}
 		}

package/src/patch/index.ts

@@ -174,16 +174,35 @@ export function hashlineParseText(edit: string[] | string | null): string[] {
 	return stripNewLinePrefixes(edit);
 }
 
+const linesSchema = Type.Union([
+	Type.Array(Type.String(), { description: "content (preferred format)" }),
+	Type.String(),
+	Type.Null(),
+]);
+
+const locSchema = Type.Union(
+	[
+		Type.Literal("append"),
+		Type.Literal("prepend"),
+		Type.Object({ append: Type.String({ description: "anchor" }) }),
+		Type.Object({ prepend: Type.String({ description: "anchor" }) }),
+		Type.Object({
+			line: Type.String({ description: "anchor" }),
+		}),
+		Type.Object({
+			block: Type.Object({
+				pos: Type.String({ description: "anchor" }),
+				end: Type.String({ description: "limit position" }),
+			}),
+		}),
+	],
+	{ description: "insert location" },
+);
+
 const hashlineEditSchema = Type.Object(
 	{
-		op: StringEnum(["replace", "append", "prepend"]),
-		pos: Type.Optional(Type.String({ description: "anchor" })),
-		end: Type.Optional(Type.String({ description: "limit position" })),
-		lines: Type.Union([
-			Type.Array(Type.String(), { description: "content (preferred format)" }),
-			Type.String(),
-			Type.Null(),
-		]),
+		loc: locSchema,
+		content: linesSchema,
 	},
 	{ additionalProperties: false },
 );
@@ -206,45 +225,48 @@ export type HashlineParams = Static<typeof hashlineEditParamsSchema>;
 // ═══════════════════════════════════════════════════════════════════════════
 
 /**
- * Map flat tool-schema edits (tag/end) into typed HashlineEdit objects.
+ * Map loc/content tool-schema edits into typed HashlineEdit objects.
  *
- * Resilient: as long as at least one anchor exists, we execute.
- * - replace + tag only → single-line replace
- * - replace + tag + end → range replace
- * - append + tag or end → append after that anchor
- * - prepend + tag or end → prepend before that anchor
- * - no anchors → file-level append/prepend (only for those ops)
- *
- * Unknown ops default to "replace".
+ * Each edit entry has a `loc` (where to edit) and `content` (what to insert/replace).
+ * loc can be:
+ *   - "append" / "prepend" — file-level insert
+ *   - { append: anchor } / { prepend: anchor } — insert relative to anchor
+ *   - { replace_line: anchor } — replace one line
+ *   - { replace_block: { pos, end } } — replace inclusive range
  */
 function resolveEditAnchors(edits: HashlineToolEdit[]): HashlineEdit[] {
 	const result: HashlineEdit[] = [];
 	for (const edit of edits) {
-		const lines = hashlineParseText(edit.lines);
-		const tag = edit.pos ? tryParseTag(edit.pos) : undefined;
-		const end = edit.end ? tryParseTag(edit.end) : undefined;
-
-		// Normalize op — default unknown values to "replace"
-		const op = edit.op === "append" || edit.op === "prepend" ? edit.op : "replace";
-		switch (op) {
-			case "replace": {
-				if (tag && end) {
-					result.push({ op: "replace", pos: tag, end, lines });
-				} else if (tag || end) {
-					result.push({ op: "replace", pos: tag || end!, lines });
-				} else {
-					throw new Error("Replace requires at least one anchor (tag or end).");
-				}
-				break;
-			}
-			case "append": {
-				result.push({ op: "append", pos: tag ?? end, lines });
-				break;
-			}
-			case "prepend": {
-				result.push({ op: "prepend", pos: end ?? tag, lines });
-				break;
+		const lines = hashlineParseText(edit.content);
+		const loc = edit.loc;
+
+		if (loc === "append") {
+			result.push({ op: "append_file", lines });
+		} else if (loc === "prepend") {
+			result.push({ op: "prepend_file", lines });
+		} else if (typeof loc === "object") {
+			if ("append" in loc) {
+				const anchor = tryParseTag(loc.append);
+				if (!anchor) throw new Error("append requires a valid anchor.");
+				result.push({ op: "append_at", pos: anchor, lines });
+			} else if ("prepend" in loc) {
+				const anchor = tryParseTag(loc.prepend);
+				if (!anchor) throw new Error("prepend requires a valid anchor.");
+				result.push({ op: "prepend_at", pos: anchor, lines });
+			} else if ("line" in loc) {
+				const anchor = tryParseTag(loc.line);
+				if (!anchor) throw new Error("line requires a valid anchor.");
+				result.push({ op: "replace_line", pos: anchor, lines });
+			} else if ("block" in loc) {
+				const posAnchor = tryParseTag(loc.block.pos);
+				const endAnchor = tryParseTag(loc.block.end);
+				if (!posAnchor || !endAnchor) throw new Error("block requires valid pos and end anchors.");
+				result.push({ op: "replace_range", pos: posAnchor, end: endAnchor, lines });
+			} else {
+				throw new Error("Unknown loc shape. Expected append, prepend, line, or block.");
 			}
+		} else {
+			throw new Error(`Invalid loc value: ${JSON.stringify(loc)}`);
 		}
 	}
 	return result;
@@ -552,12 +574,10 @@ export class EditTool implements AgentTool<TInput> {
 				const lines: string[] = [];
 				for (const edit of edits) {
 					// For file creation, only anchorless appends/prepends are valid
-					if ((edit.op === "append" || edit.op === "prepend") && !edit.pos && !edit.end) {
-						if (edit.op === "prepend") {
-							lines.unshift(...hashlineParseText(edit.lines));
-						} else {
-							lines.push(...hashlineParseText(edit.lines));
-						}
+					if (edit.loc === "append") {
+						lines.push(...hashlineParseText(edit.content));
+					} else if (edit.loc === "prepend") {
+						lines.unshift(...hashlineParseText(edit.content));
 					} else {
 						throw new Error(`File not found: ${path}`);
 					}
@@ -582,7 +602,7 @@ export class EditTool implements AgentTool<TInput> {
 			const originalNormalized = normalizeToLF(text);
 			let normalizedText = originalNormalized;
 
-			// Apply anchor-based edits first (replace, append, prepend)
+			// Apply anchor-based edits first (replace, append_at, prepend_at)
 			const anchorResult = applyHashlineEdits(normalizedText, anchorEdits);
 			normalizedText = anchorResult.lines;
 
@@ -612,20 +632,18 @@ export class EditTool implements AgentTool<TInput> {
 					for (const edit of anchorEdits) {
 						refs.length = 0;
 						switch (edit.op) {
-							case "replace":
-								if (edit.end) {
-									refs.push(edit.end, edit.pos);
-								} else {
-									refs.push(edit.pos);
-								}
+							case "replace_line":
+								refs.push(edit.pos);
 								break;
-							case "append":
-								if (edit.pos) refs.push(edit.pos);
+							case "replace_range":
+								refs.push(edit.end, edit.pos);
 								break;
-							case "prepend":
-								if (edit.pos) refs.push(edit.pos);
+							case "append_at":
+							case "prepend_at":
+								refs.push(edit.pos);
 								break;
-							default:
+							case "append_file":
+							case "prepend_file":
 								break;
 						}