@pi-archimedes/diff 2.10.4 → 2.11.0

package/src/tools/edit.test.ts

@@ -0,0 +1,215 @@
+/**
+ * Row tests for the Archimedes `edit` presentation.
+ *
+ * These pin what an `edit` row looks like — the call row while arguments
+ * stream in, the same row with the pending diff, and the settled result line —
+ * so the move from a `registerTool()` take-over to `registerToolRenderer()` can
+ * be checked as *unchanged rendering* rather than re-derived from the code.
+ */
+
+import { describe, it, expect } from "vitest";
+import { mkdtempSync, writeFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { createEditTool } from "@earendil-works/pi-coding-agent";
+import { createEditRenderers, installEditTool } from "./edit.js";
+
+// `diff` is standalone and must not import `@pi-archimedes/core` (see
+// `src/pi-support.ts`), so the tests strip escape sequences themselves.
+const stripAnsi = (s: string) => s.replace(/\x1b\[[0-9;]*m/g, "");
+
+const theme = {
+  fg: (token: string, text?: string) =>
+    text === undefined ? `[${token}]` : `[${token}:${text}]`,
+  bold: (text: string) => `**${text}**`,
+  bg: (_token: string, text: string) => text,
+  italic: (text: string) => text,
+} as any;
+
+/** Install the resolvers and hand back the renderers pi would use for `edit`. */
+function captureTool(cwd: string, home: string) {
+  let resolved: any;
+  installEditTool(
+    {
+      registerToolRenderer: (r: any) => {
+        resolved = r("edit", () => ({ renderShell: "self" }));
+      },
+      on: () => () => {},
+    } as unknown as ExtensionAPI,
+    cwd,
+    home,
+  );
+  return resolved;
+}
+
+function makeWorkspace() {
+  const dir = mkdtempSync(path.join(tmpdir(), "diff-rows-"));
+  const file = path.join(dir, "note.txt");
+  writeFileSync(file, "one\ntwo\nthree\n");
+  return { dir, file, done: () => rmSync(dir, { recursive: true, force: true }) };
+}
+
+const rows = (component: any) => stripAnsi(component.render(80).join("\n"));
+
+/** A render context, plus a promise that resolves when the row asks to redraw. */
+function makeCtx(extra: Record<string, unknown> = {}) {
+  let wake: () => void = () => {};
+  const painted = new Promise<void>((resolve) => {
+    wake = resolve;
+  });
+  const ctx: any = {
+    state: {},
+    argsComplete: true,
+    outputPad: 1,
+    isError: false,
+    invalidate: () => wake(),
+    ...extra,
+  };
+  return { ctx, painted };
+}
+
+describe("edit tool row", () => {
+  it("shows the tool name and the home-relative path while arguments stream in", () => {
+    const { dir, file, done } = makeWorkspace();
+    try {
+      const def = captureTool(dir, dir);
+      const { ctx } = makeCtx({ argsComplete: false });
+      const out = rows(def.renderCall({ path: file, edits: [{ oldText: "two", newText: "2" }] }, theme, ctx));
+      expect(out).toContain("**edit**");
+      expect(out).toContain("note.txt");
+      // Nothing of a diff yet — the arguments are still arriving.
+      expect(out).not.toContain("two");
+    } finally {
+      done();
+    }
+  });
+
+  it("holds a diff preview under the header once the arguments are complete", () => {
+    const { dir, file, done } = makeWorkspace();
+    try {
+      const def = captureTool(dir, dir);
+      const { ctx } = makeCtx();
+      const call = def.renderCall({ path: file, edits: [{ oldText: "two", newText: "2" }] }, theme, ctx);
+      const out = rows(call);
+      expect(out).toContain("**edit**");
+      expect(out).toContain("note.txt");
+      // The preview is a slot of its own: Shiki colours it asynchronously and
+      // the row invalidates when the coloured lines land, so the first paint
+      // holds the placeholder (the coloured body is `shiki.test.ts`'s job).
+      expect(out).toContain("rendering diff…");
+    } finally {
+      done();
+    }
+  });
+
+  it("summarises a single edit on the result line, with the changed line number", () => {
+    const { dir, file, done } = makeWorkspace();
+    try {
+      const def = captureTool(dir, dir);
+      const { ctx } = makeCtx();
+      def.renderCall({ path: file, edits: [{ oldText: "two", newText: "2" }] }, theme, ctx);
+      def.renderResult(
+        { content: [{ type: "text", text: "ok" }], details: { _type: "editInfo", summary: "[+1:-1]", editLine: 2 } },
+        { expanded: false, isPartial: false },
+        theme,
+        ctx,
+      );
+      const out = rows(ctx.state.callBox);
+      expect(out).toContain("[+1:-1]");
+      expect(out).toContain("at line 2");
+    } finally {
+      done();
+    }
+  });
+
+  it("counts the edits on a multi-edit result line", () => {
+    const { dir, file, done } = makeWorkspace();
+    try {
+      const def = captureTool(dir, dir);
+      const { ctx } = makeCtx();
+      def.renderCall(
+        {
+          path: file,
+          edits: [
+            { oldText: "one", newText: "1" },
+            { oldText: "two", newText: "2" },
+          ],
+        },
+        theme,
+        ctx,
+      );
+      def.renderResult(
+        {
+          content: [{ type: "text", text: "ok" }],
+          details: { _type: "multiEditInfo", summary: "[+2:-2]", editCount: 2, diffLineCount: 4 },
+        },
+        { expanded: false, isPartial: false },
+        theme,
+        ctx,
+      );
+      const out = rows(ctx.state.callBox);
+      expect(out).toContain("2 edits");
+      expect(out).toContain("(4 diff lines)");
+    } finally {
+      done();
+    }
+  });
+
+  it("shows the failure text on an errored result", () => {
+    const { dir, file, done } = makeWorkspace();
+    try {
+      const def = captureTool(dir, dir);
+      const ctx = { state: {}, isError: true, outputPad: 1 } as any;
+      def.renderCall({ path: file, edits: [{ oldText: "two", newText: "2" }] }, theme, {
+        state: ctx.state,
+        argsComplete: false,
+        outputPad: 1,
+        isError: true,
+        invalidate: () => {},
+      });
+      def.renderResult(
+        { content: [{ type: "text", text: "oldText not found" }], details: undefined },
+        { expanded: false, isPartial: false },
+        theme,
+        ctx,
+      );
+      expect(rows(ctx.state.callBox)).toContain("oldText not found");
+    } finally {
+      done();
+    }
+  });
+});
+
+describe("edit row padding", () => {
+  // The row draws its own shell (`renderShell: "self"`), so the inset is ours to
+  // choose — but pi still tells the renderer how much tool output is padded
+  // here, and that number is what the row must respect.
+  const renderers = createEditRenderers("/project", "/home");
+  const callArgs = { path: "/project/src/a.ts", edits: [{ oldText: "x", newText: "y" }] };
+
+  function padXFor(outputPad: number): number {
+    const state: any = {};
+    renderers.renderCall!(
+      callArgs as any,
+      theme as any,
+      {
+        argsComplete: true,
+        cwd: "/project",
+        cwdOrParent: "/project",
+        hasUI: false,
+        outputPad,
+        state,
+      } as any,
+    );
+    return (state.callBox as any).paddingX;
+  }
+
+  it("keeps its own one-column inset where pi's output shell adds none", () => {
+    expect(padXFor(0)).toBe(1);
+  });
+
+  it("grows to pi's output padding when pi asks for more", () => {
+    expect(padXFor(2)).toBe(2);
+  });
+});

package/src/tools/edit.ts

@@ -1,7 +1,7 @@
-/** Edit tool override with diff rendering. */
+/** Edit tool presentation: a diff-drawing row plus the result details it reads. */
 
 import { existsSync, readFileSync } from "node:fs";
-import type { ExtensionAPI, Theme } from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI, Theme, ToolRenderers } from "@earendil-works/pi-coding-agent";
 import { Box, Spacer, Text } from "@earendil-works/pi-tui";
 import { parseDiff } from "../core/diff.js";
 import * as Ansi from "../ansi/index.js";
@@ -10,82 +10,96 @@ import { lang } from "../shiki.js";
 import { MAX_PREVIEW_LINES } from "../render/index.js";
 import { DiffComponent } from "../diff-component.js";
 
-/** Register the edit tool override. */
-export function registerEditTool(
-	pi: ExtensionAPI,
-	cwd: string,
-	home: string,
-	createEditTool: (cwd: string) => any,
-): void {
-	const sp = (p: string) => Ansi.shortPath(cwd, home, p);
-	const origEdit = createEditTool(cwd);
-
-	function getEditOperations(input: any): Array<{ oldText: string; newText: string }> {
-		if (Array.isArray(input?.edits)) {
-			return input.edits
-				.map((edit: any) => ({
-					oldText: typeof edit?.oldText === "string" ? edit.oldText : typeof edit?.old_text === "string" ? edit.old_text : "",
-					newText: typeof edit?.newText === "string" ? edit.newText : typeof edit?.new_text === "string" ? edit.new_text : "",
-				}))
-				.filter((edit: { oldText: string; newText: string }) => edit.oldText && edit.oldText !== edit.newText);
-		}
-		const oldText = typeof input?.oldText === "string" ? input.oldText : typeof input?.old_text === "string" ? input.old_text : "";
-		const newText = typeof input?.newText === "string" ? input.newText : typeof input?.new_text === "string" ? input.new_text : "";
-		return oldText && oldText !== newText ? [{ oldText, newText }] : [];
-	}
+interface EditOperation { oldText: string; newText: string }
 
-	function summarizeEditOperations(operations: Array<{ oldText: string; newText: string }>) {
-		const diffs = operations.map((edit) => parseDiff(edit.oldText, edit.newText));
-		const totalAdded = diffs.reduce((sum, diff) => sum + diff.added, 0);
-		const totalRemoved = diffs.reduce((sum, diff) => sum + diff.removed, 0);
-		return { diffs, totalAdded, totalRemoved, summary: Ansi.summarize(totalAdded, totalRemoved) };
+function getEditOperations(input: any): EditOperation[] {
+	if (Array.isArray(input?.edits)) {
+		return input.edits
+			.map((edit: any) => ({
+				oldText: typeof edit?.oldText === "string" ? edit.oldText : typeof edit?.old_text === "string" ? edit.old_text : "",
+				newText: typeof edit?.newText === "string" ? edit.newText : typeof edit?.new_text === "string" ? edit.new_text : "",
+			}))
+			.filter((edit: EditOperation) => edit.oldText && edit.oldText !== edit.newText);
 	}
+	const oldText = typeof input?.oldText === "string" ? input.oldText : typeof input?.old_text === "string" ? input.old_text : "";
+	const newText = typeof input?.newText === "string" ? input.newText : typeof input?.new_text === "string" ? input.new_text : "";
+	return oldText && oldText !== newText ? [{ oldText, newText }] : [];
+}
 
-	pi.registerTool({
-		...origEdit,
-		name: "edit",
-		renderShell: "self",
-
-		async execute(tid: string, params: any, sig: any, upd: any, ctx: any) {
-			const fp = params.path ?? params.file_path ?? "";
-			const operations = getEditOperations(params);
-			const result = await origEdit.execute(tid, params, sig, upd, ctx);
-
-			if (operations.length === 0) return result;
+function summarizeEditOperations(operations: EditOperation[]) {
+	const diffs = operations.map((edit) => parseDiff(edit.oldText, edit.newText));
+	const totalAdded = diffs.reduce((sum, diff) => sum + diff.added, 0);
+	const totalRemoved = diffs.reduce((sum, diff) => sum + diff.removed, 0);
+	return { diffs, totalAdded, totalRemoved, summary: Ansi.summarize(totalAdded, totalRemoved) };
+}
 
-			const { diffs, summary } = summarizeEditOperations(operations);
-			if (operations.length === 1) {
-				let editLine = 0;
-				try {
-					if (fp && existsSync(fp)) {
-						const f = readFileSync(fp, "utf-8");
-						const idx = f.indexOf(operations[0]!.newText);
-						if (idx >= 0) editLine = f.slice(0, idx).split("\n").length;
-					}
-				} catch { editLine = 0; }
-				(result as any).details = { _type: "editInfo", summary, editLine };
-				return result;
+/**
+ * What the `edit` row needs from a settled result, computed from the call's
+ * arguments and the file as it is now (the call has run by then). Returned as
+ * `{ details }` for pi's `tool_result` event, which may replace the result's
+ * details — the same values the row read when this package re-registered the
+ * tool and wrapped its `execute`.
+ */
+export function editResultDetails(event: {
+	input: Record<string, unknown>;
+	isError: boolean;
+}): { details: unknown } | undefined {
+	if (event.isError) return undefined;
+	const operations = getEditOperations(event.input);
+	if (operations.length === 0) return undefined;
+
+	const { diffs, summary } = summarizeEditOperations(operations);
+	if (operations.length === 1) {
+		const fp = String((event.input as any).path ?? (event.input as any).file_path ?? "");
+		let editLine = 0;
+		try {
+			if (fp && existsSync(fp)) {
+				const f = readFileSync(fp, "utf-8");
+				const idx = f.indexOf(operations[0]!.newText);
+				if (idx >= 0) editLine = f.slice(0, idx).split("\n").length;
 			}
+		} catch {
+			editLine = 0;
+		}
+		return { details: { _type: "editInfo", summary, editLine } };
+	}
 
-			(result as any).details = {
-				_type: "multiEditInfo",
-				summary,
-				editCount: operations.length,
-				diffLineCount: diffs.reduce((sum, diff) => sum + diff.lines.length, 0),
-			};
-			return result;
+	return {
+		details: {
+			_type: "multiEditInfo",
+			summary,
+			editCount: operations.length,
+			diffLineCount: diffs.reduce((sum, diff) => sum + diff.lines.length, 0),
 		},
+	};
+}
+
+/** The Archimedes `edit` renderers, closed over the paths they shorten against. */
+export function createEditRenderers(cwd: string, home: string): ToolRenderers {
+	const sp = (p: string) => Ansi.shortPath(cwd, home, p);
+
+	return {
+		renderShell: "self",
 
 		renderCall(args: any, theme: any, ctx: any) {
 			const fp = args?.path ?? args?.file_path ?? "";
 			const operations = getEditOperations(args);
 
+			// `outputPad` is the user's `outputPad` setting (0 or 1 on pi 1.2.0) and
+			// says nothing about the shell: under `renderShell: "self"` pi composes the
+			// row in a plain container and applies none of it itself, so the inset here
+			// is ours to decide. The row keeps its own one-column inset as the floor —
+			// its background is a Box, which needs the inset to read as a block — and
+			// grows to whatever pi asks for rather than hard-coding a number.
+			const padX = Math.max(1, ctx.outputPad ?? 1);
+
 			// Box with padding + background — matches built-in edit tool pattern
 			const box = ctx.state.callBox as Box | undefined;
 			if (box) {
 				box.setBgFn((s: string) => theme.bg("toolPendingBg", s));
+				box.setPaddingX(padX);
 			}
-			const shell = box ?? new Box(1, 1, (s: string) => theme.bg("toolPendingBg", s));
+			const shell = box ?? new Box(padX, 1, (s: string) => theme.bg("toolPendingBg", s));
 			if (!box) ctx.state.callBox = shell;
 
 			const hdr = `${theme.fg("toolTitle", theme.bold("edit"))} ${theme.fg("accent", sp(fp))}`;
@@ -186,5 +200,27 @@ export function registerEditTool(
 			ctx.state._resKey = key;
 			return box ? empty : t;
 		},
+	};
+}
+
+/**
+ * Draw `edit` through pi's renderer resolution and attach the result details its
+ * row reads (ADR 0029). `next()` is spread first so anything the built-in
+ * definition declares besides the two renderers — its `renderShell` today —
+ * survives resolution instead of being silently dropped by us.
+ *
+ * Called once per extension load: pi keeps a list of resolvers and event
+ * handlers per extension, so calling it from `session_start` would stack a
+ * duplicate on every `/reload`.
+ */
+export function installEditTool(pi: ExtensionAPI, cwd: string, home: string): void {
+	const renderers = createEditRenderers(cwd, home);
+	pi.registerToolRenderer((toolName, next) =>
+		toolName === "edit" ? { ...next(), ...renderers } : next(),
+	);
+	pi.on("tool_result", (event) => {
+		if (event.toolName !== "edit") return undefined;
+		return editResultDetails(event);
 	});
 }
+

package/src/tools/index.ts

@@ -1,4 +1,9 @@
-/** Tool registration — barrel re-export. */
+/** Tool presentation — barrel re-export. */
 
-export { registerWriteTool } from "./write.js";
-export { registerEditTool } from "./edit.js";
+export { installEditTool, createEditRenderers, editResultDetails } from "./edit.js";
+export {
+  installWriteTool,
+  createWriteRenderers,
+  writeResultDetails,
+  readDisplacedContent,
+} from "./write.js";

package/src/tools/register.test.ts

@@ -0,0 +1,265 @@
+/**
+ * Registration contract for the Archimedes `edit` / `write` presentation
+ * (ADR 0029).
+ *
+ * Both tools used to be re-registered with `pi.registerTool()` purely to draw
+ * them differently and to attach the diff details the renderers read. They are
+ * now a renderer resolver plus a `tool_result` handler, so these tests pin:
+ * nothing is registered, resolution answers only for the tool each installer
+ * owns, the built-in's `renderShell` choice survives resolution, and the result
+ * details the rows depend on still arrive.
+ */
+
+import { describe, it, expect } from "vitest";
+import { mkdtempSync, writeFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { Text } from "@earendil-works/pi-tui";
+import { installEditTool } from "./edit.js";
+import { installWriteTool } from "./write.js";
+
+/** A `pi` handle that records what was registered. */
+function fakePi() {
+  const renderers: ((name: string, next: () => any) => any)[] = [];
+  const handlers: Record<string, ((event: any) => any)[]> = {};
+  const pi = {
+    registerTool: (t: any) => {
+      registered.push(t);
+    },
+    registerToolRenderer: (r: (name: string, next: () => any) => any) => {
+      renderers.push(r);
+    },
+    on: (event: string, handler: (e: any) => any) => {
+      (handlers[event] ??= []).push(handler);
+      return () => {};
+    },
+  } as unknown as ExtensionAPI;
+  const registered: any[] = [];
+  return { pi, renderers, handlers, registered };
+}
+
+const NATIVE = Object.freeze({ native: true, renderShell: "default" });
+
+function resolve(
+  resolver: ((name: string, next: () => any) => any) | undefined,
+  toolName: string,
+) {
+  let nextCalls = 0;
+  const result = resolver?.(toolName, () => {
+    nextCalls++;
+    return NATIVE;
+  });
+  return { result, nextCalls };
+}
+
+function makeWorkspace(contents = "one\ntwo\nthree\n") {
+  const dir = mkdtempSync(path.join(tmpdir(), "diff-reg-"));
+  const file = path.join(dir, "note.txt");
+  writeFileSync(file, contents);
+  return { dir, file, done: () => rmSync(dir, { recursive: true, force: true }) };
+}
+
+const emit = (
+  handlers: Record<string, ((event: any) => any)[]>,
+  event: string,
+  payload: any,
+) => handlers[event]?.map((h) => h(payload)).find((r) => r !== undefined);
+
+describe("edit registration", () => {
+  it("registers no tool and resolves only `edit`", () => {
+    const { pi, renderers, registered } = fakePi();
+    installEditTool(pi, "/work", "/home");
+
+    expect(registered).toHaveLength(0);
+    expect(renderers).toHaveLength(1);
+    expect(typeof resolve(renderers[0], "edit").result).toBe("object");
+    expect(resolve(renderers[0], "write")).toEqual({ result: NATIVE, nextCalls: 1 });
+  });
+
+  it("keeps the built-in's own renderShell while replacing the renderers", () => {
+    const { pi, renderers } = fakePi();
+    installEditTool(pi, "/work", "/home");
+
+    const { result } = resolve(renderers[0], "edit");
+    expect(typeof result.renderCall).toBe("function");
+    expect(typeof result.renderResult).toBe("function");
+    // pi's edit definition draws its own shell; resolution must not lose it.
+    expect(result.renderShell).toBe("self");
+  });
+
+  it("attaches a one-edit summary and the changed line to the result", () => {
+    const { dir, file, done } = makeWorkspace("one\ntwo\nthree\n");
+    try {
+      const { pi, handlers } = fakePi();
+      installEditTool(pi, dir, dir);
+      writeFileSync(file, "one\n2\nthree\n");
+
+      const out = emit(handlers, "tool_result", {
+        type: "tool_result",
+        toolName: "edit",
+        toolCallId: "c1",
+        isError: false,
+        input: { path: file, edits: [{ oldText: "two", newText: "2" }] },
+        content: [{ type: "text", text: "ok" }],
+        details: undefined,
+      });
+
+      expect(out?.details?._type).toBe("editInfo");
+      expect(out?.details?.editLine).toBe(2);
+      expect(out?.details?.summary).toBeTruthy();
+    } finally {
+      done();
+    }
+  });
+
+  it("counts several edits in one call", () => {
+    const { dir, file, done } = makeWorkspace();
+    try {
+      const { pi, handlers } = fakePi();
+      installEditTool(pi, dir, dir);
+
+      const out = emit(handlers, "tool_result", {
+        type: "tool_result",
+        toolName: "edit",
+        toolCallId: "c2",
+        isError: false,
+        input: {
+          path: file,
+          edits: [
+            { oldText: "one", newText: "1" },
+            { oldText: "two", newText: "2" },
+          ],
+        },
+        content: [{ type: "text", text: "ok" }],
+        details: undefined,
+      });
+
+      expect(out?.details?._type).toBe("multiEditInfo");
+      expect(out?.details?.editCount).toBe(2);
+    } finally {
+      done();
+    }
+  });
+
+  it("leaves a failed edit alone", () => {
+    const { dir, file, done } = makeWorkspace();
+    try {
+      const { pi, handlers } = fakePi();
+      installEditTool(pi, dir, dir);
+
+      const out = emit(handlers, "tool_result", {
+        type: "tool_result",
+        toolName: "edit",
+        toolCallId: "c3",
+        isError: true,
+        input: { path: file, edits: [{ oldText: "nope", newText: "x" }] },
+        content: [{ type: "text", text: "oldText not found" }],
+        details: undefined,
+      });
+
+      expect(out).toBeUndefined();
+    } finally {
+      done();
+    }
+  });
+});
+
+describe("write registration", () => {
+  it("registers no tool and resolves only `write`", () => {
+    const { pi, renderers, registered } = fakePi();
+    installWriteTool(pi, "/work", "/home", Text as any);
+
+    expect(registered).toHaveLength(0);
+    expect(resolve(renderers[0], "write").result?.renderShell).toBe("default");
+    expect(resolve(renderers[0], "edit")).toEqual({ result: NATIVE, nextCalls: 1 });
+  });
+
+  it("diffs the replaced file against the content it displaces", () => {
+    const { dir, file, done } = makeWorkspace("one\ntwo\n");
+    try {
+      const { pi, handlers } = fakePi();
+      installWriteTool(pi, dir, dir, Text as any);
+
+      emit(handlers, "tool_call", {
+        type: "tool_call",
+        toolName: "write",
+        toolCallId: "w1",
+        input: { path: file, content: "one\n2\n" },
+      });
+      writeFileSync(file, "one\n2\n");
+      const out = emit(handlers, "tool_result", {
+        type: "tool_result",
+        toolName: "write",
+        toolCallId: "w1",
+        isError: false,
+        input: { path: file, content: "one\n2\n" },
+        content: [{ type: "text", text: "wrote" }],
+        details: undefined,
+      });
+
+      expect(out?.details?._type).toBe("diff");
+      expect(out?.details?.summary).toBeTruthy();
+    } finally {
+      done();
+    }
+  });
+
+  it("reports a new file by line count", () => {
+    const { dir, done } = makeWorkspace("");
+    try {
+      const fresh = path.join(dir, "fresh.txt");
+      const { pi, handlers } = fakePi();
+      installWriteTool(pi, dir, dir, Text as any);
+
+      emit(handlers, "tool_call", {
+        type: "tool_call",
+        toolName: "write",
+        toolCallId: "w2",
+        input: { path: fresh, content: "a\nb\nc\n" },
+      });
+      const out = emit(handlers, "tool_result", {
+        type: "tool_result",
+        toolName: "write",
+        toolCallId: "w2",
+        isError: false,
+        input: { path: fresh, content: "a\nb\nc\n" },
+        content: [{ type: "text", text: "wrote" }],
+        details: undefined,
+      });
+
+      expect(out?.details?._type).toBe("new");
+      expect(out?.details?.lines).toBe(4);
+    } finally {
+      done();
+    }
+  });
+
+  it("says so when the written content matches what was there", () => {
+    const { dir, file, done } = makeWorkspace("same\n");
+    try {
+      const { pi, handlers } = fakePi();
+      installWriteTool(pi, dir, dir, Text as any);
+
+      emit(handlers, "tool_call", {
+        type: "tool_call",
+        toolName: "write",
+        toolCallId: "w3",
+        input: { path: file, content: "same\n" },
+      });
+      const out = emit(handlers, "tool_result", {
+        type: "tool_result",
+        toolName: "write",
+        toolCallId: "w3",
+        isError: false,
+        input: { path: file, content: "same\n" },
+        content: [{ type: "text", text: "wrote" }],
+        details: undefined,
+      });
+
+      expect(out?.details?._type).toBe("noChange");
+    } finally {
+      done();
+    }
+  });
+});