@xynogen/pix-edit 0.2.16 → 0.2.18

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@xynogen/pix-edit",
-	"version": "0.2.16",
+	"version": "0.2.18",
 	"description": "Pi tool — precise text replacement edit with diff rendering",
 	"type": "module",
 	"main": "src/index.ts",
@@ -13,13 +13,16 @@
 	},
 	"files": [
 		"src",
-		"!src/**/*.test.*",
 		"README.md",
-		"LICENSE"
+		"LICENSE",
+		"skills"
 	],
 	"pi": {
 		"extensions": [
 			"src/extension.ts"
+		],
+		"skills": [
+			"./skills"
 		]
 	},
 	"keywords": [
@@ -39,8 +42,8 @@
 		"access": "public"
 	},
 	"dependencies": {
-		"@xynogen/pix-pretty": "^1.38.0",
-		"@xynogen/pix-runtime": "^0.18.0"
+		"@xynogen/pix-pretty": "^2.1.0",
+		"@xynogen/pix-runtime": "^0.20.0"
 	},
 	"peerDependencies": {
 		"typebox": "*",

package/skills/pix-edit.md

@@ -0,0 +1,46 @@
+---
+name: pix-edit
+description: How to use `edit` without retries — hash anchors from a fresh `read`, one non-overlapping batch per file, and the exact-text fallback. Use before multi-hunk edits, after an edit failed or applied only partly, or when a file may have changed.
+disable-model-invocation: true
+---
+# edit — hash-anchor edits
+
+`edit` was the second most error-prone tool in history (898 errors in 11,315 calls). Nearly all came from four causes below.
+
+## Formats
+
+Hash anchors (preferred), from the `LINE#HASH` prefixes that `read` returns:
+
+```json
+{ "path": "src/a.ts", "edits": [
+  { "op": "replace", "pos": "12#A1F", "end": "14#C03", "lines": ["new line 12", "new line 13"] },
+  { "op": "insert_after", "pos": "40#9B2", "lines": ["added"] }
+] }
+```
+
+- `op`: `replace`, `insert_before`, or `insert_after`. `end` is for `replace` only.
+- `lines` holds raw source lines: no `LINE#HASH|` prefix and no newline characters. An empty array deletes.
+
+Exact text (fallback only after a hash edit fails): `{ "oldText": "...", "newText": "..." }`. `oldText` must match exactly once.
+
+## Avoid the four common failures
+
+| Error in history | Count | Fix |
+|---|---|---|
+| "Edit without read" | 293 | `read` the region in this session before editing it. |
+| "target not found" / stale anchor | 77+ | The file changed. Use the "Current anchors" from the last edit result, or `read` again. Never guess a hash. |
+| "PARTIAL APPLY" | 100+ | Edits in one call must not overlap and must all target the original file. Split dependent changes into separate calls. |
+| schema: `edits.N` must be object / additional properties / `op` | 59 | Never mix hash and exact-text items in one call. Do not add fields such as `text` or `content`. |
+
+## Pattern
+
+1. `read` the lines you will change (use `offset`/`limit`, or `ast` `outline` then `symbol` for code).
+2. Put every independent change to that file in one `edit` call.
+3. Use the "Current anchors" in the result for the next edit to the same region.
+4. Read the "LSP after edit" note. Fix new errors before moving on.
+
+## Do not
+
+- Use `sed -i`, `perl -pi`, or a heredoc in `bash` to change files.
+- Use `write` to change a few lines of an existing file. `write` is for new files and complete rewrites.
+- Retry the same failed edit unchanged. Read the error, then fix the anchor or the format.

package/src/edit.ts

@@ -1,16 +1,3 @@
-import { constants } from "node:fs";
-import { access, readFile, writeFile } from "node:fs/promises";
-import { resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import { validateToolArguments } from "@earendil-works/pi-ai";
-import type {
-	AgentToolUpdateCallback,
-	EditToolInput,
-	ExtensionContext,
-	ToolRenderResultOptions,
-} from "@earendil-works/pi-coding-agent";
-import { withFileMutationQueue } from "@earendil-works/pi-coding-agent";
-import { resolveBaseBackground } from "@xynogen/pix-pretty/ansi";
 import { MAX_RENDER_LINES } from "@xynogen/pix-pretty/config";
 import type { ToolContext } from "@xynogen/pix-pretty/context";
 import { parseDiff } from "@xynogen/pix-pretty/diff";
@@ -22,13 +9,12 @@ import {
 	summarize,
 } from "@xynogen/pix-pretty/diff-render";
 import { lang } from "@xynogen/pix-pretty/lang";
+import { toolCallRenderer, toolCardRenderer } from "@xynogen/pix-pretty/tool-card";
 import type {
 	EditOperation,
 	EditParams,
 	EditRenderState,
 	PiPrettyApi,
-	RenderContextLike,
-	ThemeLike,
 	ToolFactory,
 	ToolResultLike,
 } from "@xynogen/pix-pretty/types";
@@ -36,28 +22,32 @@ import {
 	BODY_PAD,
 	dotJoin,
 	fillToolBackground,
-	formatToolCallTitle,
-	frameToolResult,
 	getErrorMessage,
-	getTextContent,
-	hideCollapsedToolCall,
 	isTextContent,
-	renderCollapsedToolRow,
-	renderToolError,
+	renderTitle,
 	setResultDetails,
 	termW,
-	unframeToolResult,
 } from "@xynogen/pix-pretty/utils";
-import { type CollapseState, tickCollapse } from "@xynogen/pix-runtime/collapse";
 import {
-	anchor,
-	decodeLines,
-	hashLine,
-	parseAnchor,
-	type SourceLine,
-} from "@xynogen/pix-runtime/hashline";
-import { expandHome } from "@xynogen/pix-runtime/paths";
-import { Type } from "typebox";
+	type EditInput,
+	editPath,
+	editSchema,
+	editText,
+	type HashParams,
+	prepareEditArguments,
+} from "@xynogen/pix-runtime/files";
+import type {
+	AgentToolUpdateCallback,
+	EditToolInput,
+	ExtensionContext,
+} from "@xynogen/pix-runtime/host";
+
+export {
+	editPath,
+	freshAnchors,
+	prepareEditArguments,
+	prepareHashArguments,
+} from "@xynogen/pix-runtime/files";
 
 // ── Helpers ────────────────────────────────────────────────────────────
 
@@ -95,447 +85,6 @@ export function getEditOperations(input: EditParams): EditOperation[] {
 	return oldText && oldText !== newText ? [{ oldText, newText }] : [];
 }
 
-type HashEdit = {
-	op: "replace" | "insert_before" | "insert_after";
-	pos: string;
-	end?: string;
-	lines: string[];
-};
-type HashParams = { path: string; edits: HashEdit[] };
-type ExactParams = { path: string; edits: EditOperation[] };
-type EditInput = HashParams | ExactParams;
-
-const hashFields = {
-	pos: Type.String({
-		pattern: "^[1-9][0-9]*#[0-9A-F]{3}$",
-		description: "Original LINE#HASH anchor from read",
-	}),
-	lines: Type.Array(
-		Type.String({
-			description:
-				"One literal source line per item. No newline or LINE#HASH| prefix. Empty array deletes.",
-		}),
-	),
-};
-const hashEdits = Type.Array(
-	Type.Union([
-		Type.Object(
-			{
-				op: Type.Literal("replace"),
-				...hashFields,
-				end: Type.Optional(
-					Type.String({
-						pattern: "^[1-9][0-9]*#[0-9A-F]{3}$",
-						description: "Inclusive end anchor. Omit for one line.",
-					}),
-				),
-			},
-			{ additionalProperties: false },
-		),
-		Type.Object(
-			{
-				op: Type.Union([Type.Literal("insert_before"), Type.Literal("insert_after")]),
-				...hashFields,
-			},
-			{ additionalProperties: false },
-		),
-	]),
-	{ minItems: 1 },
-);
-const exactEdits = Type.Array(
-	Type.Object(
-		{
-			oldText: Type.String({
-				minLength: 1,
-				description:
-					"Fallback only after a hash-anchor edit fails. Exact current source text; must match once.",
-			}),
-			newText: Type.String({ description: "Replacement text. Empty string deletes." }),
-		},
-		{ additionalProperties: false },
-	),
-	{ minItems: 1 },
-);
-const path = Type.String({ minLength: 1 });
-const editSchema = Type.Object(
-	{
-		path,
-		// ponytail: union whole arrays so the schema rejects mixed formats before execution.
-		edits: Type.Union([hashEdits, exactEdits], {
-			description:
-				"Try hash-anchor edits first. Use exact-text edits only after a hash-anchor edit fails. Never mix formats.",
-		}),
-	},
-	{ additionalProperties: false },
-);
-// One branch each, so a bad call reports only the errors of the format it meant.
-const hashSchema = Type.Object({ path, edits: hashEdits }, { additionalProperties: false });
-const exactSchema = Type.Object({ path, edits: exactEdits }, { additionalProperties: false });
-
-const parseJson = (value: string): unknown => {
-	try {
-		return JSON.parse(value);
-	} catch {
-		return value;
-	}
-};
-
-export function prepareHashArguments(input: unknown): unknown {
-	if (!input || typeof input !== "object" || Array.isArray(input)) return input;
-	const args = { ...input } as Record<string, unknown>;
-	if (typeof args.edits === "string") args.edits = parseJson(args.edits);
-	if (args.edits && typeof args.edits === "object" && !Array.isArray(args.edits))
-		args.edits = [args.edits];
-	// Top recorded failure: one edit item sent as a JSON string.
-	if (Array.isArray(args.edits))
-		args.edits = args.edits.map((item) => {
-			if (typeof item !== "string") return item;
-			const parsed = parseJson(item);
-			return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : item;
-		});
-	return args;
-}
-
-const EDIT_FIX = "Fix: resend only the broken field; keep one format per call.";
-
-function editFix(format: "hash" | "exact", path: string, problem: string): string {
-	if (/\.(pos|end)$/.test(path) && problem.startsWith("expected to match"))
-		return "LINE#HASH from read, hash is uppercase hex (12#A3F)";
-	if (/\.op$/.test(path)) return "op is replace, insert_before or insert_after";
-	if (/\.lines$/.test(path) && problem === "missing")
-		return "missing; add lines: [] of literal source lines ([] deletes)";
-	if (/\.lines(\.\d+)?$/.test(path)) return "lines is an array of strings, one per line";
-	if (/\.oldText$/.test(path) && problem !== "missing")
-		return "oldText is non-empty exact current source text";
-	if (problem === "unknown field") {
-		if (!path.startsWith("edits.")) return "unknown field; send only path and edits";
-		return format === "hash"
-			? "unknown field; hash items take op, pos, end?, lines"
-			: "unknown field; exact items take oldText, newText";
-	}
-	if (/^edits\.\d+$/.test(path)) return `${problem}; each edit is one object`;
-	if (path === "edits") return `${problem}; edits is a non-empty array of objects`;
-	return problem;
-}
-
-/**
- * Normalize, then check with the host validator. A bad call fails with a few
- * lines that name the field and the fix, for the format the call meant.
- */
-export function prepareEditArguments(input: unknown): unknown {
-	const args = prepareHashArguments(input);
-	const edits = (args as { edits?: unknown } | undefined)?.edits;
-	const items = Array.isArray(edits) ? edits : [];
-	const kind = (item: unknown) =>
-		item && typeof item === "object"
-			? ["op", "pos", "end", "lines"].some((k) => k in item)
-				? "hash"
-				: ["oldText", "newText"].some((k) => k in item)
-					? "exact"
-					: undefined
-			: undefined;
-	const kinds = items.map(kind);
-	const at = (k: string) => kinds.flatMap((x, i) => (x === k ? [i] : [])).join(",");
-	if (kinds.includes("hash") && kinds.includes("exact"))
-		throw new Error(
-			badArgs(
-				"edit",
-				[`- edits: mixed formats (hash at [${at("hash")}], exact at [${at("exact")}])`],
-				EDIT_FIX,
-			),
-		);
-	const format = kinds.includes("exact") ? "exact" : "hash";
-	checkArgs(
-		"edit",
-		format === "hash" ? hashSchema : exactSchema,
-		args,
-		(path, problem) => editFix(format, path, problem),
-		EDIT_FIX,
-	);
-	return args;
-}
-
-// ponytail: pix-ask has a copy of this host-error reformatter (clip/badArgs/checkArgs). Move it
-// to pix-runtime when a third tool needs it (public API addition, minor bump).
-const clip = (text: string, max: number) =>
-	text.length > max ? `${text.slice(0, max - 1)}…` : text;
-
-function badArgs(tool: string, rows: string[], footer: string): string {
-	const head =
-		rows.length > 5 ? `${tool}: ${rows.length} bad arguments, first 5` : `${tool}: bad arguments`;
-	return [head, ...rows.slice(0, 5), footer].join("\n");
-}
-
-/** Host-validate `args`; on failure throw a short field/fix list, not the full-argument echo. */
-function checkArgs(
-	tool: string,
-	schema: object,
-	args: unknown,
-	fix: (path: string, problem: string, value: unknown) => string,
-	footer: string,
-): void {
-	try {
-		validateToolArguments(
-			{ name: tool, description: "", parameters: schema },
-			{ type: "toolCall", id: "", name: tool, arguments: args as never },
-		);
-		return;
-	} catch (error) {
-		// ponytail: reads pi-ai's "  - path: problem" rows; an unknown format rethrows the host error.
-		const text = (error instanceof Error ? error.message : String(error)).split(
-			"\n\nReceived arguments:",
-		)[0];
-		const seen = new Set<string>();
-		const rows = [...(text ?? "").matchAll(/^ {2}- (\S+): (.+)$/gm)].map(
-			([, path = "", problem = ""]) => {
-				const value =
-					path === "root"
-						? args
-						: path
-								.split(".")
-								.reduce<unknown>(
-									(v, k) =>
-										v && typeof v === "object" ? (v as Record<string, unknown>)[k] : undefined,
-									args,
-								);
-				const shown =
-					value === undefined ? "" : ` ${clip(JSON.stringify(value) ?? String(value), 40)}`;
-				// State a repeated fix once, so five rows stay a few hundred bytes.
-				const advice = fix(path, problem, value);
-				const said = seen.has(advice);
-				seen.add(advice);
-				return `- ${path.replace(/\.(\d+)/g, "[$1]")}${shown}: ${said ? "same fix" : advice}`;
-			},
-		);
-		if (!rows.length) throw error;
-		throw new Error(badArgs(tool, rows, footer));
-	}
-}
-
-export function editPath(path: string, cwd: string): string {
-	let value = path.replace(/[\u00A0\u2000-\u200A\u202F\u205F\u3000]/g, " ").replace(/^@/, "");
-	if (
-		process.platform === "win32" &&
-		value.startsWith("/") &&
-		!value.startsWith("//") &&
-		!value.includes("\\")
-	) {
-		value = value.replace(
-			/^\/(?:mnt\/|cygdrive\/)?([a-z])(?:\/(.*))?$/i,
-			(_all, drive: string, tail: string | undefined) =>
-				`${drive.toUpperCase()}:\\${(tail ?? "").replaceAll("/", "\\")}`,
-		);
-	}
-	value = expandHome(value);
-	if (value.startsWith("file://")) value = fileURLToPath(value);
-	return resolve(cwd, value);
-}
-
-function applyHashEdits(bytes: Buffer, input: unknown) {
-	const args = prepareHashArguments(input) as HashParams;
-	if (
-		!args ||
-		typeof args.path !== "string" ||
-		!args.path ||
-		!Array.isArray(args.edits) ||
-		!args.edits.length
-	)
-		throw new Error("Invalid hashline edit input");
-	if (Object.keys(args).some((key) => !["path", "edits"].includes(key)))
-		throw new Error("Legacy exact-text fields are not supported");
-	const source = decodeLines(bytes);
-	// Stale/out-of-bounds anchors carry the current lines around the target so the
-	// model can retry at once instead of spending a read round-trip.
-	const nearby = (line: number) => {
-		const from = Math.max(1, Math.min(line, source.lines.length) - 2);
-		const rows = source.lines.slice(from - 1, from + 4).map((l, i) => {
-			const text = l.text.length > 200 ? `${l.text.slice(0, 200)}…` : l.text;
-			return `${anchor(from + i, l.text)}|${text}`;
-		});
-		return rows.length ? `\nCurrent lines:\n${rows.join("\n")}` : "";
-	};
-	const check = (value: unknown) => {
-		const parsed = parseAnchor(value);
-		const line = source.lines[parsed.line - 1];
-		if (!line)
-			throw new Error(
-				`Anchor out of bounds: ${String(value)} (file has ${source.lines.length} lines).${nearby(parsed.line)}`,
-			);
-		if (hashLine(line.text) !== parsed.hash)
-			throw new Error(
-				`Stale anchor: ${String(value)}. Use the current anchors below, or read again if the target moved.${nearby(parsed.line)}`,
-			);
-		return parsed.line;
-	};
-	const replacements: Array<{ start: number; end: number; lines: string[] }> = [];
-	const gaps = new Map<number, string[]>();
-	for (const edit of args.edits) {
-		if (
-			!edit ||
-			typeof edit !== "object" ||
-			Object.keys(edit).some((key) => !["op", "pos", "end", "lines"].includes(key))
-		)
-			throw new Error("Legacy or invalid edit fields");
-		if (
-			!["replace", "insert_before", "insert_after"].includes(edit.op) ||
-			!Array.isArray(edit.lines) ||
-			edit.lines.some(
-				(line) =>
-					typeof line !== "string" ||
-					/[\r\n\0]|^[1-9]\d*#[0-9A-F]{3}\|/.test(line) ||
-					/[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/u.test(line),
-			)
-		)
-			throw new Error("Invalid edit operation or source lines");
-		const start = check(edit.pos);
-		if (edit.op === "replace") {
-			const end = edit.end === undefined ? start : check(edit.end);
-			if (end < start) throw new Error("Reversed replacement range");
-			replacements.push({ start, end, lines: edit.lines });
-		} else {
-			if (edit.end !== undefined) throw new Error("end is only allowed for replace");
-			const gap = edit.op === "insert_before" ? start - 1 : start;
-			gaps.set(gap, [...(gaps.get(gap) ?? []), ...edit.lines]);
-		}
-	}
-	replacements.sort((a, b) => a.start - b.start);
-	for (let i = 0; i < replacements.length; i++) {
-		const range = replacements[i]!;
-		if (i && replacements[i - 1]!.end >= range.start)
-			throw new Error("Overlapping replacement ranges");
-		for (const gap of gaps.keys())
-			if (gap >= range.start && gap < range.end)
-				throw new Error("Insertion overlaps a replacement range");
-	}
-	const output: SourceLine[] = [];
-	// 1-based output line spans each op wrote, for the fresh anchors in the result.
-	const spans: Array<[number, number]> = [];
-	const ops: Array<EditOperation & { editLine: number }> = [];
-	const append = (lines: string[]) =>
-		output.push(...lines.map((text) => ({ text, ending: source.delimiter })));
-	let rangeIndex = 0;
-	for (let gap = 0; gap <= source.lines.length; ) {
-		const insertion = gaps.get(gap);
-		if (insertion?.length) {
-			const context = source.lines[Math.max(0, gap - 1)]!.text;
-			ops.push({
-				oldText: context,
-				newText:
-					gap === 0 ? [...insertion, context].join("\n") : [context, ...insertion].join("\n"),
-				editLine: Math.max(1, output.length + (gap === 0 ? 1 : 0)),
-			});
-			spans.push([output.length + 1, output.length + insertion.length]);
-			append(insertion);
-		}
-		if (gap === source.lines.length) break;
-		const range = replacements[rangeIndex];
-		if (range?.start === gap + 1) {
-			ops.push({
-				oldText: source.lines
-					.slice(gap, range.end)
-					.map((line) => line.text)
-					.join("\n"),
-				newText: range.lines.join("\n"),
-				editLine: output.length + 1,
-			});
-			// A deletion has no new lines; mark the line that now sits in its place.
-			spans.push([output.length + 1, output.length + Math.max(1, range.lines.length)]);
-			append(range.lines);
-			gap = range.end;
-			rangeIndex++;
-		} else {
-			output.push({ ...source.lines[gap]! });
-			gap++;
-		}
-	}
-	for (let i = 0; i < output.length; i++) {
-		if (i === output.length - 1)
-			output[i]!.ending = source.finalNewline ? output[i]!.ending || source.delimiter : "";
-		else if (!output[i]!.ending) output[i]!.ending = source.delimiter;
-	}
-	return {
-		content: source.bom + output.map((line) => line.text + line.ending).join(""),
-		ops,
-		spans,
-	};
-}
-
-function applyExactEdits(bytes: Buffer, args: ExactParams) {
-	if (Object.keys(args).some((key) => !["path", "edits"].includes(key)))
-		throw new Error("Invalid exact-text edit fields");
-	const source = decodeLines(bytes);
-	const original = source.lines.map((line) => line.text + line.ending).join("");
-	// ponytail: exact bytes only. Add newline normalization only if callers need it.
-	const ranges = args.edits
-		.map((edit) => {
-			if (
-				!edit ||
-				typeof edit !== "object" ||
-				Object.keys(edit).some((key) => !["oldText", "newText"].includes(key)) ||
-				typeof edit.oldText !== "string" ||
-				!edit.oldText ||
-				typeof edit.newText !== "string" ||
-				[edit.oldText, edit.newText].some((text) =>
-					/\0|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/u.test(text),
-				)
-			)
-				throw new Error("Invalid exact-text edit");
-			const start = original.indexOf(edit.oldText);
-			if (start < 0) throw new Error("oldText was not found. Use exact source text.");
-			if (original.indexOf(edit.oldText, start + 1) >= 0)
-				throw new Error("oldText matches more than once. Include more context.");
-			return { ...edit, start, end: start + edit.oldText.length };
-		})
-		.sort((a, b) => a.start - b.start);
-	let content = "";
-	let offset = 0;
-	const ops: Array<EditOperation & { editLine: number }> = [];
-	const spans: Array<[number, number]> = [];
-	const lineCount = (text: string) => text.match(/\r\n|\r|\n/g)?.length ?? 0;
-	for (const range of ranges) {
-		if (range.start < offset) throw new Error("Overlapping exact-text edits");
-		content += original.slice(offset, range.start);
-		const editLine = lineCount(content) + 1;
-		ops.push({ oldText: range.oldText, newText: range.newText, editLine });
-		spans.push([editLine, editLine + lineCount(range.newText)]);
-		content += range.newText;
-		offset = range.end;
-	}
-	return { content: source.bom + content + original.slice(offset), ops, spans };
-}
-
-/** Context lines around each changed span, and the cap on anchored lines per result. */
-const FRESH_CONTEXT = 2;
-const FRESH_MAX_LINES = 20;
-
-/**
- * Current `LINE#HASH|text` rows around the changed spans, so a chained edit on
- * the same file needs no `read` between calls (SWE-agent shows the edited
- * window after every edit). Gaps between spans are marked with `…`.
- */
-export function freshAnchors(content: string, spans: Array<[number, number]>): string {
-	const lines = decodeLines(Buffer.from(content, "utf8")).lines;
-	const wanted = new Set<number>();
-	for (const [from, to] of spans)
-		for (
-			let n = Math.max(1, from - FRESH_CONTEXT);
-			n <= Math.min(lines.length, to + FRESH_CONTEXT);
-			n++
-		)
-			wanted.add(n);
-	const picked = [...wanted].sort((a, b) => a - b);
-	const shown = picked.slice(0, FRESH_MAX_LINES);
-	const rows: string[] = [];
-	for (const [i, n] of shown.entries()) {
-		if (i && n !== (shown[i - 1] ?? 0) + 1) rows.push("…");
-		const text = lines[n - 1]?.text ?? "";
-		rows.push(`${anchor(n, text)}|${text.length > 200 ? `${text.slice(0, 200)}…` : text}`);
-	}
-	if (picked.length > shown.length)
-		rows.push(`… ${picked.length - shown.length} more changed lines; read for anchors`);
-	return rows.join("\n");
-}
-
 export function summarizeEditOperations(operations: EditOperation[]) {
 	const diffs = operations.map((e) => parseDiff(e.oldText, e.newText));
 	const totalAdded = diffs.reduce((sum, d) => sum + d.added, 0);
@@ -567,7 +116,7 @@ export function registerEditTool(
 		parameters: editSchema,
 		promptSnippet: "Edit with hash anchors first; exact text only after failure",
 		promptGuidelines: [
-			"For edit, try hash anchors from read first. Only if the hash-anchor edit fails, fall back to oldText/newText. If the file changed, read the affected region again before using current source text; never guess anchors or overwrite unseen changes.",
+			'For edit, try hash anchors from read first. Only if the hash-anchor edit fails, fall back to oldText/newText. If the file changed, read the affected region again before using current source text; never guess anchors or overwrite unseen changes. After a failed or partial edit, load read_skills(name="pix-edit", full=true).',
 		],
 		prepareArguments: prepareEditArguments,
 		constrainedSampling: { type: "json_schema", strict: "prefer" },
@@ -588,40 +137,18 @@ export function registerEditTool(
 			try {
 				if (!fp) throw new Error("path must be a nonempty string");
 				const absolutePath = editPath(fp, toolCtx?.cwd || cwd);
-				result = await withFileMutationQueue(absolutePath, async () => {
-					const abort = () => {
-						if (sig?.aborted) throw new Error("Operation aborted");
-					};
-					abort();
-					await access(absolutePath, constants.R_OK | constants.W_OK);
-					abort();
-					const bytes = await readFile(absolutePath);
-					abort();
-					const args = prepareHashArguments(params) as EditInput;
-					if (!Array.isArray(args.edits) || !args.edits.length)
-						throw new Error("edits must be a nonempty array");
-					const applied = args.edits.every(
-						(edit) => edit && typeof edit === "object" && "oldText" in edit,
-					)
-						? applyExactEdits(bytes, args as ExactParams)
-						: applyHashEdits(bytes, args);
-					operations = applied.ops;
-					abort();
-					// ponytail: in-place writes preserve links and mode, not crash atomicity. Use a separate atomic-write design if needed.
-					await writeFile(absolutePath, applied.content, "utf8");
-					abort();
-					const fresh = freshAnchors(applied.content, applied.spans);
-					const text = `Edited ${fp}: ${operations.length} operations.`;
-					return {
-						content: [
-							{
-								type: "text",
-								text: fresh ? `${text}\nCurrent anchors:\n${fresh}` : text,
-							},
-						],
-						details: undefined,
-					};
-				});
+				const applied = await editText(absolutePath, params, undefined, sig);
+				operations = applied.ops;
+				const text = `Edited ${fp}: ${operations.length} operations.`;
+				result = {
+					content: [
+						{
+							type: "text",
+							text: applied.fresh ? `${text}\nCurrent anchors:\n${applied.fresh}` : text,
+						},
+					],
+					details: undefined,
+				};
 			} catch (error) {
 				const text = getErrorMessage(error);
 				if (sig?.aborted || /aborted/i.test(text)) throw error;
@@ -675,71 +202,39 @@ export function registerEditTool(
 			return result;
 		},
 
-		renderCall(
-			args: EditParams & Partial<HashParams>,
-			theme: ThemeLike,
-			renderCtx: RenderContextLike<EditRenderState>,
-		) {
-			resolveBaseBackground(theme);
-			const fp = args?.path ?? args?.file_path ?? "";
-			const operations = getEditOperations(args);
-			const text = renderCtx.lastComponent ?? new TextComponent("", 0, 0);
-			if (
-				hideCollapsedToolCall(renderCtx.state as CollapseState, renderCtx.expanded, (value) =>
-					text.setText(value),
-				)
-			)
-				return text;
-			const hdr = `${formatToolCallTitle(theme, "edit", renderCtx)} ${theme.fg("dim", sp(fp))}`;
+		renderCall: toolCallRenderer<EditParams & Partial<HashParams>, EditRenderState>(
+			TextComponent,
+			(args, theme, renderCtx) => {
+				const fp = args?.path ?? args?.file_path ?? "";
+				const operations = getEditOperations(args);
+				const hdr = `${renderTitle(theme, "edit", renderCtx)} ${theme.fg("dim", sp(fp))}`;
 
-			if (Array.isArray(args.edits) && args.edits.some((edit) => "pos" in edit)) {
-				text.setText(
-					fillToolBackground(dotJoin([hdr, theme.fg("muted", `${args.edits.length} operations`)])),
+				if (Array.isArray(args.edits) && args.edits.some((edit) => "pos" in edit))
+					return fillToolBackground(
+						dotJoin([hdr, theme.fg("muted", `${args.edits.length} operations`)]),
+					);
+				if (operations.length === 0) return fillToolBackground(hdr);
+
+				const { summary } = summarizeEditOperations(operations);
+				const coloredSummary = renderDiffSummary(summary, theme);
+				const paint = (s: string) => theme.fg("muted", s);
+				const suffix = dotJoin(
+					[
+						hdr,
+						operations.length > 1 && theme.fg("muted", `${operations.length} edits`),
+						theme.fg("muted", "estimate"),
+						coloredSummary,
+					],
+					paint,
 				);
-				return text;
-			}
-			if (operations.length === 0) {
-				text.setText(fillToolBackground(hdr));
-				return text;
-			}
-
-			const { summary } = summarizeEditOperations(operations);
-			const coloredSummary = renderDiffSummary(summary, theme);
-			const paint = (s: string) => theme.fg("muted", s);
-			const suffix = dotJoin(
-				[
-					hdr,
-					operations.length > 1 && theme.fg("muted", `${operations.length} edits`),
-					theme.fg("muted", "estimate"),
-					coloredSummary,
-				],
-				paint,
-			);
-			text.setText(fillToolBackground(suffix));
-			return text;
-		},
-
-		renderResult(
-			result: ToolResultLike,
-			_opt: ToolRenderResultOptions,
-			theme: ThemeLike,
-			renderCtx: RenderContextLike<EditRenderState>,
-		) {
-			resolveBaseBackground(theme);
-			const text = unframeToolResult(renderCtx.lastComponent ?? new TextComponent("", 0, 0));
-			const d = result.details as Record<string, unknown> | undefined;
-			const isPartial = _opt?.isPartial === true;
-			const completed = () => frameToolResult(text, theme, renderCtx.isError);
-			const structuredError =
-				renderCtx.isError && (d?._type === "editInfo" || d?._type === "multiEditInfo");
-			if (renderCtx.isError && (!structuredError || isPartial)) {
-				text.setText(renderToolError(getTextContent(result) || "Error", theme));
-				return isPartial ? text : completed();
-			}
+				return fillToolBackground(suffix);
+			},
+		),
 
-			// Auto-collapse: show summary line after delay
-			const cs = renderCtx.state as CollapseState;
-			if (!isPartial && tickCollapse("edit", cs, renderCtx.invalidate, renderCtx.expanded)) {
+		renderResult: toolCardRenderer<Record<string, unknown>, EditRenderState>(TextComponent, {
+			name: "edit",
+			owns: (d) => d?._type === "editInfo" || d?._type === "multiEditInfo",
+			collapsed(d) {
 				const summary =
 					d?._type === "editInfo"
 						? (d.summary as string)
@@ -752,98 +247,85 @@ export function registerEditTool(
 					const ops = d.ops as Array<Record<string, unknown>> | undefined;
 					filePath = String(ops?.[0]?.filePath ?? "");
 				}
-				text.setText(
-					renderCollapsedToolRow(
-						theme,
-						"edit",
-						sp(filePath),
-						renderCtx.isError ? "failed" : summary,
-						renderCtx.isError ? "error" : "success",
-					),
-				);
-				return text;
-			}
-
-			if (renderCtx.isError) {
-				text.setText(renderToolError(getTextContent(result) || "Error", theme));
-				return completed();
-			}
-
-			// Single edit — full split diff
-			if (d?._type === "editInfo") {
-				const key = `ed:${diffThemeCacheKey(theme)}:${termW()}:${d.summary}:${(d.oldContent as string).length}:${(d.newContent as string).length}:${d.language ?? ""}`;
-				if (renderCtx.toolCallId) trackInvalidator(renderCtx.toolCallId, renderCtx.invalidate);
-				if (renderCtx.state._edk !== key) {
-					renderCtx.state._edk = key;
-					// ponytail: call already shows `edit <file> <summary>`; don't repeat summary+loc header — gutter carries absolute line
-					renderCtx.state._edt = `${BODY_PAD}${theme.fg("muted", "rendering diff…")}`;
-					const dc = resolveDiffColors(theme);
-					const diff = parseDiff(
-						d.oldContent as string,
-						d.newContent as string,
-						3,
-						d.editLine as number,
-					);
-					renderSplit(diff, d.language as string | undefined, MAX_RENDER_LINES, dc)
-						.then((rendered) => {
-							if (renderCtx.state._edk !== key) return;
-							renderCtx.state._edt = rendered;
-							renderCtx.invalidate();
-						})
-						.catch(() => {
-							if (renderCtx.state._edk !== key) return;
-							renderCtx.state._edt = `${BODY_PAD}${d.summary}`;
-							renderCtx.invalidate();
-						});
+				return { target: sp(filePath), summary };
+			},
+			body({ d, result, text, theme, ctx: renderCtx }) {
+				// Single edit — full split diff
+				if (d?._type === "editInfo") {
+					const key = `ed:${diffThemeCacheKey(theme)}:${termW()}:${d.summary}:${(d.oldContent as string).length}:${(d.newContent as string).length}:${d.language ?? ""}`;
+					if (renderCtx.toolCallId) trackInvalidator(renderCtx.toolCallId, renderCtx.invalidate);
+					if (renderCtx.state._edk !== key) {
+						renderCtx.state._edk = key;
+						// ponytail: call already shows `edit <file> <summary>`; don't repeat summary+loc header — gutter carries absolute line
+						renderCtx.state._edt = `${BODY_PAD}${theme.fg("muted", "rendering diff…")}`;
+						const dc = resolveDiffColors(theme);
+						const diff = parseDiff(
+							d.oldContent as string,
+							d.newContent as string,
+							3,
+							d.editLine as number,
+						);
+						renderSplit(diff, d.language as string | undefined, MAX_RENDER_LINES, dc)
+							.then((rendered) => {
+								if (renderCtx.state._edk !== key) return;
+								renderCtx.state._edt = rendered;
+								renderCtx.invalidate();
+							})
+							.catch(() => {
+								if (renderCtx.state._edk !== key) return;
+								renderCtx.state._edt = `${BODY_PAD}${d.summary}`;
+								renderCtx.invalidate();
+							});
+					}
+					text.setText(renderCtx.state._edt ?? `${BODY_PAD}${d.summary}`);
+					return undefined;
 				}
-				text.setText(renderCtx.state._edt ?? `${BODY_PAD}${d.summary}`);
-				return isPartial ? text : completed();
-			}
 
-			// Multi-edit — stacked diffs
-			if (d?._type === "multiEditInfo") {
-				const key = `med:${diffThemeCacheKey(theme)}:${termW()}:${d.summary}:${d.editCount}:${d.diffLineCount}`;
-				if (renderCtx.toolCallId) trackInvalidator(renderCtx.toolCallId, renderCtx.invalidate);
-				if (renderCtx.state._edk !== key) {
-					renderCtx.state._edk = key;
-					// ponytail: call already shows summary; render diffs directly
-					renderCtx.state._edt = `${BODY_PAD}${theme.fg("muted", "rendering diff…")}`;
-					const dc = resolveDiffColors(theme);
-					Promise.all(
-						(
-							d.ops as Array<{
-								oldContent: string;
-								newContent: string;
-								language?: string;
-								editLine?: number;
-							}>
-						).map((op) => {
-							const diff = parseDiff(op.oldContent, op.newContent, 3, op.editLine ?? 0);
-							return renderSplit(diff, op.language, MAX_RENDER_LINES, dc);
-						}),
-					)
-						.then((rendered) => {
-							if (renderCtx.state._edk !== key) return;
-							const body = rendered.join(`\n${`${BODY_PAD}${theme.fg("muted", "···")}`}\n`);
-							renderCtx.state._edt = body;
-							renderCtx.invalidate();
-						})
-						.catch(() => {
-							if (renderCtx.state._edk !== key) return;
-							renderCtx.state._edt = `${BODY_PAD}${d.editCount} edits ${d.summary}`;
-							renderCtx.invalidate();
-						});
+				// Multi-edit — stacked diffs
+				if (d?._type === "multiEditInfo") {
+					const key = `med:${diffThemeCacheKey(theme)}:${termW()}:${d.summary}:${d.editCount}:${d.diffLineCount}`;
+					if (renderCtx.toolCallId) trackInvalidator(renderCtx.toolCallId, renderCtx.invalidate);
+					if (renderCtx.state._edk !== key) {
+						renderCtx.state._edk = key;
+						// ponytail: call already shows summary; render diffs directly
+						renderCtx.state._edt = `${BODY_PAD}${theme.fg("muted", "rendering diff…")}`;
+						const dc = resolveDiffColors(theme);
+						Promise.all(
+							(
+								d.ops as Array<{
+									oldContent: string;
+									newContent: string;
+									language?: string;
+									editLine?: number;
+								}>
+							).map((op) => {
+								const diff = parseDiff(op.oldContent, op.newContent, 3, op.editLine ?? 0);
+								return renderSplit(diff, op.language, MAX_RENDER_LINES, dc);
+							}),
+						)
+							.then((rendered) => {
+								if (renderCtx.state._edk !== key) return;
+								const body = rendered.join(`\n${`${BODY_PAD}${theme.fg("muted", "···")}`}\n`);
+								renderCtx.state._edt = body;
+								renderCtx.invalidate();
+							})
+							.catch(() => {
+								if (renderCtx.state._edk !== key) return;
+								renderCtx.state._edt = `${BODY_PAD}${d.editCount} edits ${d.summary}`;
+								renderCtx.invalidate();
+							});
+					}
+					text.setText(renderCtx.state._edt ?? `${BODY_PAD}${d.editCount} edits ${d.summary}`);
+					return undefined;
 				}
-				text.setText(renderCtx.state._edt ?? `${BODY_PAD}${d.editCount} edits ${d.summary}`);
-				return isPartial ? text : completed();
-			}
 
-			const fallback = result.content?.[0];
-			const fallbackText = fallback && isTextContent(fallback) ? fallback.text : "edited";
-			text.setText(
-				fillToolBackground(`${BODY_PAD}${theme.fg("dim", String(fallbackText).slice(0, 120))}`),
-			);
-			return isPartial ? text : completed();
-		},
+				const fallback = result.content?.[0];
+				const fallbackText = fallback && isTextContent(fallback) ? fallback.text : "edited";
+				text.setText(
+					fillToolBackground(`${BODY_PAD}${theme.fg("dim", String(fallbackText).slice(0, 120))}`),
+				);
+				return undefined;
+			},
+		}),
 	});
 }

package/src/extension.ts

@@ -1,25 +1,21 @@
-import {
-	createEditToolDefinition,
-	createEditTool as createEditToolFallback,
-	type EditToolInput,
-	type ExtensionAPI,
-} from "@earendil-works/pi-coding-agent";
-import { Text } from "@earendil-works/pi-tui";
 import { CursorStore, fffState } from "@xynogen/pix-pretty/fff";
 import { attachResizeListener, trackInvalidator } from "@xynogen/pix-pretty/resize";
-import type { PiPrettyApi, ToolFactory } from "@xynogen/pix-pretty/types";
+import { Text } from "@xynogen/pix-pretty/tui";
 import { linkedShortPath, viewportTextConstructor } from "@xynogen/pix-pretty/utils";
 import { initHashline } from "@xynogen/pix-runtime/hashline";
+import {
+	createEditToolDefinition,
+	createEditTool as createEditToolFallback,
+	type ExtensionAPI,
+} from "@xynogen/pix-runtime/host";
 import { once } from "@xynogen/pix-runtime/once";
 import { homeDir } from "@xynogen/pix-runtime/paths";
 import { registerEditTool } from "./edit.ts";
 
 export default async function pixEditExtension(pi: ExtensionAPI): Promise<void> {
 	await initHashline();
-	const prettyPi = pi as unknown as PiPrettyApi;
 	once(pi, "pix-edit", () => {
-		const createEditTool = (createEditToolDefinition ??
-			createEditToolFallback) as unknown as ToolFactory<EditToolInput>;
+		const createEditTool = createEditToolDefinition ?? createEditToolFallback;
 		if (!createEditTool) return;
 
 		const cwd = process.cwd();
@@ -28,7 +24,7 @@ export default async function pixEditExtension(pi: ExtensionAPI): Promise<void>
 		attachResizeListener();
 
 		registerEditTool(
-			prettyPi,
+			pi,
 			createEditTool,
 			{
 				cwd,