@oh-my-pi/pi-coding-agent 12.13.0 → 12.14.0

package/src/patch/index.ts

@@ -34,7 +34,14 @@ import { enforcePlanModeWrite, resolvePlanPath } from "../tools/plan-mode-guard"
 import { applyPatch } from "./applicator";
 import { generateDiffString, generateUnifiedDiffString, replaceText } from "./diff";
 import { findMatch } from "./fuzzy";
-import { applyHashlineEdits, computeLineHash, parseLineRef } from "./hashline";
+import {
+	applyHashlineEdits,
+	computeLineHash,
+	type HashlineEdit,
+	type LineTag,
+	parseTag,
+	type ReplaceTextEdit,
+} from "./hashline";
 import { detectLineEnding, normalizeToLF, restoreLineEndings, stripBom } from "./normalize";
 import { buildNormativeUpdateInput } from "./normative";
 import { type EditToolDetails, getLspBatchRequest } from "./shared";
@@ -66,7 +73,7 @@ export {
 	computeLineHash,
 	formatHashLines,
 	HashlineMismatchError,
-	parseLineRef,
+	parseTag,
 	streamHashLinesFromLines,
 	streamHashLinesFromUtf8,
 	validateLineRef,
@@ -129,63 +136,160 @@ const patchEditSchema = Type.Object({
 export type ReplaceParams = Static<typeof replaceEditSchema>;
 export type PatchParams = Static<typeof patchEditSchema>;
 
-const hashlineSetSchema = Type.Object(
+/** Pattern matching hashline display format: `LINE#ID:CONTENT` */
+const HASHLINE_PREFIX_RE = /^\s*(?:>>>|>>)?\s*\d+#[0-9a-zA-Z]{1,16}:/;
+
+/** Pattern matching a unified-diff `+` prefix (but not `++`) */
+const DIFF_PLUS_RE = /^[+-](?![+-])/;
+
+/**
+ * Strip hashline display prefixes and diff `+` markers from replacement lines.
+ *
+ * Models frequently copy the `LINE#ID  ` prefix from read output into their
+ * replacement content, or include unified-diff `+` prefixes. Both corrupt the
+ * output file. This strips them heuristically before application.
+ */
+function stripNewLinePrefixes(lines: string[]): string[] {
+	// Detect whether the *majority* of non-empty lines carry a prefix —
+	// if only one line out of many has a match it's likely real content.
+	let hashPrefixCount = 0;
+	let diffPlusCount = 0;
+	let nonEmpty = 0;
+	for (const l of lines) {
+		if (l.length === 0) continue;
+		nonEmpty++;
+		if (HASHLINE_PREFIX_RE.test(l)) hashPrefixCount++;
+		if (DIFF_PLUS_RE.test(l)) diffPlusCount++;
+	}
+	if (nonEmpty === 0) return lines;
+
+	const stripHash = hashPrefixCount > 0 && hashPrefixCount >= nonEmpty * 0.5;
+	const stripPlus = !stripHash && diffPlusCount > 0 && diffPlusCount >= nonEmpty * 0.5;
+
+	if (!stripHash && !stripPlus) return lines;
+
+	return lines.map(l => {
+		if (stripHash) return l.replace(HASHLINE_PREFIX_RE, "");
+		if (stripPlus) return l.replace(DIFF_PLUS_RE, "");
+		return l;
+	});
+}
+
+const hashlineReplaceContentFormat = (kind: string) =>
+	Type.Union([
+		Type.Null(),
+		Type.Array(Type.String(), { description: `${kind} lines` }),
+		Type.String({ description: `${kind} line` }),
+	]);
+
+const hashlineInsertContentFormat = (kind: string) =>
+	Type.Union([
+		Type.Array(Type.String(), { description: `${kind} lines`, minItems: 1 }),
+		Type.String({ description: `${kind} line`, minLength: 1 }),
+	]);
+
+const hashlineTagFormat = (what: string) =>
+	Type.String({
+		description: `Tag identifying the ${what} in "LINE#ID" format`,
+	});
+
+function hashlineParseContent(edit: string | string[] | null): string[] {
+	if (edit === null) return [];
+	if (Array.isArray(edit)) return edit;
+	const lines = stripNewLinePrefixes(edit.split("\n"));
+	if (lines.length === 0) return [];
+	if (lines[lines.length - 1].trim() === "") return lines.slice(0, -1);
+	return lines;
+}
+
+function hashlineParseContentString(edit: string | string[] | null): string {
+	if (edit === null) return "";
+	if (Array.isArray(edit)) return edit.join("\n");
+	return edit;
+}
+
+const hashlineTargetEditSchema = Type.Object(
 	{
-		set: Type.Object({
-			ref: Type.String({ description: 'Line reference "LINE#ID"' }),
-			body: Type.Array(Type.String(), { description: "Replacement lines (empty array to delete)" }),
-		}),
+		op: Type.Literal("set"),
+		tag: hashlineTagFormat("line being replaced"),
+		content: hashlineReplaceContentFormat("Replacement"),
 	},
-	{ additionalProperties: true },
+	{ additionalProperties: false },
 );
 
-const hashlineSetRangeSchema = Type.Object(
+const hashlineAppendEditSchema = Type.Object(
 	{
-		set_range: Type.Object({
-			beg: Type.String({ description: 'Start line ref "LINE#ID"' }),
-			end: Type.String({ description: 'End line ref "LINE#ID"' }),
-			body: Type.Array(Type.String(), { description: "Replacement lines (empty array to delete)" }),
-		}),
+		op: Type.Literal("append"),
+		after: Type.Optional(hashlineTagFormat("line after which to append")),
+		content: hashlineInsertContentFormat("Appended"),
 	},
-	{ additionalProperties: true },
+	{ additionalProperties: false },
 );
-const hashlineInsertSchema = Type.Union([
-	Type.Object(
-		{
-			insert: Type.Object({
-				before: Type.Optional(Type.String({ minLength: 1, description: 'Insert before this line "LINE#ID"' })),
-				after: Type.Optional(Type.String({ minLength: 1, description: 'Insert after this line "LINE#ID"' })),
-				body: Type.Array(Type.String(), { description: "Lines to insert; must be non-empty" }),
-			}),
-		},
-		{ additionalProperties: true },
-	),
-]);
-const hashlineReplaceSchema = Type.Object(
+
+const hashlinePrependEditSchema = Type.Object(
 	{
-		replace: Type.Object({
-			old_text: Type.String({ description: "Text to find (fuzzy whitespace matching enabled)" }),
-			new_text: Type.String({ description: "Replacement text" }),
-			all: Type.Optional(Type.Boolean({ description: "Replace all occurrences (default: unique match required)" })),
-		}),
+		op: Type.Literal("prepend"),
+		before: Type.Optional(hashlineTagFormat("line before which to prepend")),
+		content: hashlineInsertContentFormat("Prepended"),
+	},
+	{ additionalProperties: false },
+);
+
+const hashlineRangeEditSchema = Type.Object(
+	{
+		op: Type.Literal("replace"),
+		first: hashlineTagFormat("first line"),
+		last: hashlineTagFormat("last line"),
+		content: hashlineReplaceContentFormat("Replacement"),
+	},
+	{ additionalProperties: false },
+);
+
+const hashlineInsertEditSchema = Type.Object(
+	{
+		op: Type.Literal("insert"),
+		before: Type.Optional(hashlineTagFormat("line before which to insert")),
+		after: Type.Optional(hashlineTagFormat("line after which to insert")),
+		content: hashlineInsertContentFormat("Inserted"),
+	},
+	{ additionalProperties: false },
+);
+
+const hashlineReplaceTextEditSchema = Type.Object(
+	{
+		op: Type.Literal("replaceText"),
+		old_text: Type.String({ description: "Text to find", minLength: 1 }),
+		new_text: hashlineReplaceContentFormat("Replacement"),
+		all: Type.Optional(Type.Boolean({ description: "Replace all occurrences" })),
 	},
-	{ additionalProperties: true },
+	{ additionalProperties: false },
 );
-const hashlineEditItemSchema = Type.Union([
-	hashlineSetSchema,
-	hashlineSetRangeSchema,
-	hashlineInsertSchema,
-	hashlineReplaceSchema,
+
+const HL_REPLACE_ENABLED = Bun.env.PI_HL_REPLACETXT === "1";
+
+const hashlineEditSpecSchema = Type.Union([
+	hashlineTargetEditSchema,
+	hashlineRangeEditSchema,
+	hashlineAppendEditSchema,
+	hashlinePrependEditSchema,
+	hashlineInsertEditSchema,
+	...(HL_REPLACE_ENABLED ? [hashlineReplaceTextEditSchema] : []),
 ]);
+
 const hashlineEditSchema = Type.Object(
 	{
 		path: Type.String({ description: "File path (relative or absolute)" }),
-		edits: Type.Array(hashlineEditItemSchema, { description: "Array of edit operations" }),
+		edits: Type.Array(hashlineEditSpecSchema, {
+			description: "Changes to apply to the file at `path`",
+			minItems: 0,
+		}),
+		delete: Type.Optional(Type.Boolean({ description: "Delete the file when true" })),
+		rename: Type.Optional(Type.String({ description: "New path if moving" })),
 	},
-	{ additionalProperties: true },
+	{ additionalProperties: false },
 );
 
-export type HashlineEdit = Static<typeof hashlineEditItemSchema>;
+export type HashlineToolEdit = Static<typeof hashlineEditSpecSchema>;
 export type HashlineParams = Static<typeof hashlineEditSchema>;
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -382,7 +486,7 @@ export class EditTool implements AgentTool<TInput> {
 			case "patch":
 				return renderPromptTemplate(patchDescription);
 			case "hashline":
-				return renderPromptTemplate(hashlineDescription);
+				return renderPromptTemplate(hashlineDescription, { allowReplaceText: HL_REPLACE_ENABLED });
 			default:
 				return renderPromptTemplate(replaceDescription);
 		}
@@ -415,46 +519,143 @@ export class EditTool implements AgentTool<TInput> {
 		// Hashline mode execution
 		// ─────────────────────────────────────────────────────────────────
 		if (this.mode === "hashline") {
-			const { path, edits } = params as HashlineParams;
+			const { path, edits, delete: deleteFile, rename } = params as HashlineParams;
 
-			enforcePlanModeWrite(this.session, path);
+			enforcePlanModeWrite(this.session, path, { op: deleteFile ? "delete" : "update", rename });
 
-			if (path.endsWith(".ipynb")) {
+			if (path.endsWith(".ipynb") && edits?.length > 0) {
 				throw new Error("Cannot edit Jupyter notebooks with the Edit tool. Use the NotebookEdit tool instead.");
 			}
 
-			// Detect wrong-format fields from models confusing edit modes
-			for (let i = 0; i < edits.length; i++) {
-				const edit = edits[i] as Record<string, unknown>;
-				if (("old_text" in edit || "new_text" in edit) && !("replace" in edit)) {
-					throw new Error(
-						`edits[${i}] contains 'old_text'/'new_text' at top level (replace mode). ` +
-							`Use {replace: {old_text, new_text}} for hashline content replace, or {set}, {set_range}, {insert}.`,
-					);
-				}
-				if ("diff" in edit) {
-					throw new Error(
-						`edits[${i}] contains 'diff' field from patch mode. ` +
-							`Hashline edits use: {set}, {set_range}, {insert}, or {replace}.`,
-					);
-				}
-				if (!("set" in edit) && !("set_range" in edit) && !("insert" in edit) && !("replace" in edit)) {
-					throw new Error(
-						`edits[${i}] must contain exactly one of: 'set', 'set_range', 'insert', or 'replace'. Got keys: [${Object.keys(edit).join(", ")}].`,
-					);
-				}
-			}
-
-			const anchorEdits = edits.filter((e): e is HashlineEdit => "set" in e || "set_range" in e || "insert" in e);
-			const replaceEdits = edits.filter(
-				(e): e is { replace: { old_text: string; new_text: string; all?: boolean } } => "replace" in e,
-			);
-
 			const absolutePath = resolvePlanPath(this.session, path);
+			const resolvedRename = rename ? resolvePlanPath(this.session, rename) : undefined;
 			const file = Bun.file(absolutePath);
 
+			if (deleteFile) {
+				if (await file.exists()) {
+					await file.unlink();
+				}
+				invalidateFsScanAfterDelete(absolutePath);
+				return {
+					content: [{ type: "text", text: `Deleted ${path}` }],
+					details: {
+						diff: "",
+						op: "delete",
+						meta: outputMeta().get(),
+					},
+				};
+			}
+
 			if (!(await file.exists())) {
-				throw new Error(`File not found: ${path}`);
+				const content: string[] = [];
+				for (const edit of edits) {
+					switch (edit.op) {
+						case "append": {
+							if (edit.after) {
+								throw new Error(`File not found: ${path}`);
+							}
+							content.push(...hashlineParseContent(edit.content));
+							break;
+						}
+						case "prepend": {
+							if (edit.before) {
+								throw new Error(`File not found: ${path}`);
+							}
+							content.unshift(...hashlineParseContent(edit.content));
+							break;
+						}
+						default: {
+							throw new Error(`File not found: ${path}`);
+						}
+					}
+				}
+				await file.write(content.join("\n"));
+				return {
+					content: [{ type: "text", text: `Created ${path}` }],
+					details: {
+						diff: "",
+						op: "create",
+						meta: outputMeta().get(),
+					},
+				};
+			}
+
+			const anchorEdits: HashlineEdit[] = [];
+			const replaceEdits: ReplaceTextEdit[] = [];
+			for (const edit of edits) {
+				switch (edit.op) {
+					case "set": {
+						const { tag, content } = edit;
+						anchorEdits.push({ op: "set", tag: parseTag(tag), content: hashlineParseContent(content) });
+						break;
+					}
+					case "replace": {
+						const { first, last, content } = edit;
+						anchorEdits.push({
+							op: "replace",
+							first: parseTag(first),
+							last: parseTag(last),
+							content: hashlineParseContent(content),
+						});
+						break;
+					}
+					case "append": {
+						const { after, content } = edit;
+						anchorEdits.push({
+							op: "append",
+							...(after ? { after: parseTag(after) } : {}),
+							content: hashlineParseContent(content),
+						});
+						break;
+					}
+					case "prepend": {
+						const { before, content } = edit;
+						anchorEdits.push({
+							op: "prepend",
+							...(before ? { before: parseTag(before) } : {}),
+							content: hashlineParseContent(content),
+						});
+						break;
+					}
+					case "insert": {
+						const { before, after, content } = edit;
+						if (before && !after) {
+							anchorEdits.push({
+								op: "prepend",
+								before: parseTag(before),
+								content: hashlineParseContent(content),
+							});
+						} else if (after && !before) {
+							anchorEdits.push({
+								op: "append",
+								after: parseTag(after),
+								content: hashlineParseContent(content),
+							});
+						} else if (before && after) {
+							anchorEdits.push({
+								op: "insert",
+								before: parseTag(before),
+								after: parseTag(after),
+								content: hashlineParseContent(content),
+							});
+						} else {
+							throw new Error(`Insert must have both before and after tags.`);
+						}
+						break;
+					}
+					case "replaceText": {
+						const { old_text, new_text, all } = edit;
+						replaceEdits.push({
+							op: "replaceText",
+							old_text: old_text,
+							new_text: hashlineParseContentString(new_text),
+							all: all ?? false,
+						});
+						break;
+					}
+					default:
+						throw new Error(`Invalid edit operation: ${JSON.stringify(edit)}`);
+				}
 			}
 
 			const rawContent = await file.text();
@@ -469,12 +670,12 @@ export class EditTool implements AgentTool<TInput> {
 
 			// Apply content-replace edits (substr-style fuzzy replace)
 			for (const r of replaceEdits) {
-				if (r.replace.old_text.length === 0) {
-					throw new Error("replace.old_text must not be empty.");
+				if (r.old_text.length === 0) {
+					throw new Error("old_text must not be empty.");
 				}
-				const rep = replaceText(normalizedContent, r.replace.old_text, r.replace.new_text, {
+				const rep = replaceText(normalizedContent, r.old_text, r.new_text, {
 					fuzzy: this.#allowFuzzy,
-					all: r.replace.all ?? false,
+					all: r.all ?? false,
 					threshold: this.#fuzzyThreshold,
 				});
 				normalizedContent = rep.content;
@@ -486,7 +687,7 @@ export class EditTool implements AgentTool<TInput> {
 				warnings: anchorResult.warnings,
 				noopEdits: anchorResult.noopEdits,
 			};
-			if (originalNormalized === result.content) {
+			if (originalNormalized === result.content && !rename) {
 				let diagnostic = `No changes made to ${path}. The edits produced identical content.`;
 				if (result.noopEdits && result.noopEdits.length > 0) {
 					const details = result.noopEdits
@@ -502,21 +703,35 @@ export class EditTool implements AgentTool<TInput> {
 					// Edits were not literally identical but heuristics normalized them back
 					const lines = result.content.split("\n");
 					const targetLines: string[] = [];
-					for (const edit of edits) {
-						const refs: string[] = [];
-						if ("set" in edit) refs.push(edit.set.ref);
-						else if ("set_range" in edit) refs.push(edit.set_range.beg, edit.set_range.end);
-						else if ("insert" in edit) {
-							if (edit.insert.after) refs.push(edit.insert.after);
-							if (edit.insert.before) refs.push(edit.insert.before);
+					const refs: LineTag[] = [];
+					for (const edit of anchorEdits) {
+						refs.length = 0;
+						switch (edit.op) {
+							case "set":
+								refs.push(edit.tag);
+								break;
+							case "replace":
+								refs.push(edit.first, edit.last);
+								break;
+							case "append":
+								if (edit.after) refs.push(edit.after);
+								break;
+							case "prepend":
+								if (edit.before) refs.push(edit.before);
+								break;
+							case "insert":
+								refs.push(edit.after, edit.before);
+								break;
+							default:
+								break;
 						}
+
 						for (const ref of refs) {
 							try {
-								const parsed = parseLineRef(ref);
-								if (parsed.line >= 1 && parsed.line <= lines.length) {
-									const lineContent = lines[parsed.line - 1];
-									const hash = computeLineHash(parsed.line, lineContent);
-									targetLines.push(`${parsed.line}#${hash}|${lineContent}`);
+								if (ref.line >= 1 && ref.line <= lines.length) {
+									const lineContent = lines[ref.line - 1];
+									const hash = computeLineHash(ref.line, lineContent);
+									targetLines.push(`${ref.line}#${hash}:${lineContent}`);
 								}
 							} catch {
 								/* skip malformed refs */
@@ -532,12 +747,25 @@ export class EditTool implements AgentTool<TInput> {
 			}
 
 			const finalContent = bom + restoreLineEndings(result.content, originalEnding);
-			const diagnostics = await this.#writethrough(absolutePath, finalContent, signal, file, batchRequest);
-			invalidateFsScanAfterWrite(absolutePath);
+			const writePath = resolvedRename ?? absolutePath;
+			const diagnostics = await this.#writethrough(
+				writePath,
+				finalContent,
+				signal,
+				Bun.file(writePath),
+				batchRequest,
+			);
+			if (resolvedRename && resolvedRename !== absolutePath) {
+				await file.unlink();
+				invalidateFsScanAfterRename(absolutePath, resolvedRename);
+			} else {
+				invalidateFsScanAfterWrite(absolutePath);
+			}
 			const diffResult = generateDiffString(originalNormalized, result.content);
 
 			const normative = buildNormativeUpdateInput({
 				path,
+				...(rename ? { rename } : {}),
 				oldContent: rawContent,
 				newContent: finalContent,
 			});
@@ -546,17 +774,20 @@ export class EditTool implements AgentTool<TInput> {
 				.diagnostics(diagnostics?.summary ?? "", diagnostics?.messages ?? [])
 				.get();
 
+			const resultText = rename ? `Updated and moved ${path} to ${rename}` : `Updated ${path}`;
 			return {
 				content: [
 					{
 						type: "text",
-						text: `Updated ${path}${result.warnings?.length ? `\n\nWarnings:\n${result.warnings.join("\n")}` : ""}`,
+						text: `${resultText}${result.warnings?.length ? `\n\nWarnings:\n${result.warnings.join("\n")}` : ""}`,
 					},
 				],
 				details: {
 					diff: diffResult.diff,
 					firstChangedLine: result.firstChangedLine ?? diffResult.firstChangedLine,
 					diagnostics,
+					op: "update",
+					rename,
 					meta,
 				},
 				$normative: normative,
@@ -602,17 +833,10 @@ export class EditTool implements AgentTool<TInput> {
 
 			// Generate diff for display
 			let diffResult = { diff: "", firstChangedLine: undefined as number | undefined };
-			let normative: PatchInput | undefined;
 			if (result.change.type === "update" && result.change.oldContent && result.change.newContent) {
 				const normalizedOld = normalizeToLF(stripBom(result.change.oldContent).text);
 				const normalizedNew = normalizeToLF(stripBom(result.change.newContent).text);
 				diffResult = generateUnifiedDiffString(normalizedOld, normalizedNew);
-				normative = buildNormativeUpdateInput({
-					path,
-					rename: effRename,
-					oldContent: result.change.oldContent,
-					newContent: result.change.newContent,
-				});
 			}
 
 			let resultText: string;
@@ -650,7 +874,6 @@ export class EditTool implements AgentTool<TInput> {
 					rename: effRename,
 					meta,
 				},
-				$normative: normative,
 			};
 		}
 

package/src/patch/shared.ts

@@ -86,10 +86,10 @@ interface EditRenderArgs {
 }
 
 type HashlineEditPreview =
-	| { set: { ref: string; body: string[] } }
-	| { set_range: { beg: string; end: string; body: string[] } }
-	| { insert: { before?: string; after?: string; body: string[] } }
-	| { replace: { old_text: string; new_text: string; all?: boolean } };
+	| { target: string; new_content: string[] }
+	| { first: string; last: string; new_content: string[] }
+	| { before?: string; after?: string; inserted_lines: string[] }
+	| { old_text: string; new_text: string; all?: boolean };
 
 /** Extended context for edit tool rendering */
 export interface EditRenderContext {
@@ -168,52 +168,35 @@ function formatStreamingHashlineEdits(edits: unknown[], uiTheme: Theme, ui: Tool
 				dst: "",
 			};
 		}
-		if ("set" in editRecord) {
-			const setLine = asRecord(editRecord.set);
+		if ("target" in editRecord) {
+			const target = typeof editRecord.target === "string" ? editRecord.target : "…";
+			const newContent = editRecord.new_content;
 			return {
-				srcLabel: `• set ${typeof setLine?.ref === "string" ? setLine.ref : "…"}`,
-				dst: Array.isArray(setLine?.body)
-					? (setLine.body as string[]).join("\n")
-					: typeof setLine?.body === "string"
-						? setLine.body
-						: "",
+				srcLabel: `• line ${target}`,
+				dst: Array.isArray(newContent) ? (newContent as string[]).join("\n") : "",
 			};
 		}
-		if ("set_range" in editRecord) {
-			const setRange = asRecord(editRecord.set_range);
-			const start = typeof setRange?.beg === "string" ? setRange.beg : "…";
-			const end = typeof setRange?.end === "string" ? setRange.end : "…";
+		if ("first" in editRecord || "last" in editRecord) {
+			const first = typeof editRecord.first === "string" ? editRecord.first : "…";
+			const last = typeof editRecord.last === "string" ? editRecord.last : "…";
+			const newContent = editRecord.new_content;
 			return {
-				srcLabel: `• set_range ${start}..${end}`,
-				dst: Array.isArray(setRange?.body)
-					? (setRange.body as string[]).join("\n")
-					: typeof setRange?.body === "string"
-						? setRange.body
-						: "",
+				srcLabel: `• range ${first}..${last}`,
+				dst: Array.isArray(newContent) ? (newContent as string[]).join("\n") : "",
 			};
 		}
-		if ("replace" in editRecord) {
-			const replace = asRecord(editRecord.replace);
-			const all = typeof replace?.all === "boolean" ? replace.all : false;
+		if ("old_text" in editRecord || "new_text" in editRecord) {
+			const all = typeof editRecord.all === "boolean" ? editRecord.all : false;
 			return {
 				srcLabel: `• replace old_text→new_text${all ? " (all)" : ""}`,
-				dst: typeof replace?.new_text === "string" ? replace.new_text : "",
+				dst: typeof editRecord.new_text === "string" ? editRecord.new_text : "",
 			};
 		}
-		if ("insert" in editRecord) {
-			const insertOp = asRecord(editRecord.insert);
-			const after = typeof insertOp?.after === "string" ? insertOp.after : undefined;
-			const before = typeof insertOp?.before === "string" ? insertOp.before : undefined;
-			const body = insertOp?.body;
-			const text = Array.isArray(body)
-				? (body as string[]).join("\n")
-				: typeof body === "string"
-					? body
-					: typeof insertOp?.text === "string"
-						? insertOp.text
-						: typeof insertOp?.content === "string"
-							? (insertOp.content as string)
-							: "";
+		if ("inserted_lines" in editRecord || "before" in editRecord || "after" in editRecord) {
+			const after = typeof editRecord.after === "string" ? editRecord.after : undefined;
+			const before = typeof editRecord.before === "string" ? editRecord.before : undefined;
+			const insertedLines = editRecord.inserted_lines;
+			const text = Array.isArray(insertedLines) ? (insertedLines as string[]).join("\n") : "";
 			const refs = [after, before].filter(Boolean).join("..") || "…";
 			return {
 				srcLabel: `• insert ${refs}`,

package/src/prompts/system/system-prompt.md

@@ -1,5 +1,5 @@
 <identity>
-Distinguished Staff Engineer.
+You are a distinguished staff engineer operating inside Oh My Pi, a Pi-based coding harness.
 
 High-agency. Principled. Decisive.
 Expertise: debugging, refactoring, system design.
@@ -172,6 +172,17 @@ Main branch: {{git.mainBranch}}
 {{/if}}
 </project>
 
+<harness>
+Oh My Pi ships internal documentation accessible via `docs://` URLs (resolved by tools like read/grep).
+- Read `docs://` to list all available documentation files
+- Read `docs://<file>.md` to read a specific doc
+
+<critical>
+- **ONLY** read docs when the user asks about omp/pi itself: its SDK, extensions, themes, skills, TUI, keybindings, or configuration.
+- When working on omp/pi topics, read the relevant docs and follow .md cross-references before implementing.
+</critical>
+</harness>
+
 {{#if skills.length}}
 <skills>
 Scan descriptions vs task domain. Skill covers output? Read `skill://<name>` first.
@@ -221,7 +232,7 @@ Notice the sequential habit:
 - Comfort in doing one thing at a time
 - Illusion that order = correctness
 - Assumption that B depends on A
-**Use Task tool when:**
+  **Use Task tool when:**
 - Editing 4+ files with no dependencies between edits
 - Investigating 2+ independent subsystems
 - Work decomposes into pieces not needing each other's results