pi-minimal 0.3.1 → 0.4.0

package/CHANGELOG.md

@@ -10,6 +10,20 @@ Releases are cut automatically: when the `version` in `package.json` changes on
 
 ## [Unreleased]
 
+## [0.4.0] - 2026-10-27
+
+### Added
+
+- `editDiff` setting in `pi-minimal.json`: controls whether an `edit` row shows the
+  change itself. `"expanded"` (default) shows the unified diff in the `│`-ruled
+  block when the row is expanded with `ctrl+o`, where the bare "Successfully
+  replaced" text used to be. `"always"` shows it inline as soon as the edit lands,
+  capped at 40 lines with `… N more lines (ctrl+o)` for the rest. `"never"` keeps
+  the stats-only row. Lines use the theme's `toolDiffAdded` / `toolDiffRemoved` /
+  `toolDiffContext` colours and keep pi's line-number gutter; when one line
+  replaces one line, only the changed tokens are inverse-highlighted, as in pi's
+  own edit renderer. Failed edits and results without a diff are unchanged.
+
 ## [0.3.1] - 2026-10-25
 
 ### Added

package/README.md

@@ -49,10 +49,13 @@ The package loads JSON in this order:
 
 Project values override global values. A missing file, omitted key, or invalid value does not override the lower-precedence value.
 
-The only supported key is `hideGauntletWidgets`. It defaults to `true`.
+Supported keys:
+
+- `hideGauntletWidgets` (boolean, default `true`).
+- `editDiff` (`"always"` | `"never"` | `"expanded"`, default `"expanded"`) – when an `edit` row shows its diff. `"expanded"` puts it behind `ctrl+o`; `"always"` shows it inline as the edit lands (first 40 lines, the rest behind `ctrl+o`); `"never"` keeps the `+3 −1` stats only.
 
 ```json
-{ "hideGauntletWidgets": true }
+{ "hideGauntletWidgets": true, "editDiff": "always" }
 ```
 
 ## Optional footer activity API

package/dist/config.js

@@ -1,8 +1,10 @@
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import { CONFIG_DIR_NAME } from "@earendil-works/pi-coding-agent";
+export const EDIT_DIFF_MODES = ["always", "never", "expanded"];
 const DEFAULTS = {
     hideGauntletWidgets: true,
+    editDiff: "expanded",
 };
 export function loadPiMinimalConfig(options) {
     const config = { ...DEFAULTS };
@@ -32,14 +34,23 @@ function applyLayer(config, path) {
         console.error(`pi-minimal: expected an object in ${path}`);
         return;
     }
+    // Each key is validated on its own so one bad value does not discard the rest of the layer.
     const record = parsed;
-    if (!Object.hasOwn(record, "hideGauntletWidgets")) {
-        return;
-    }
-    const value = record.hideGauntletWidgets;
-    if (typeof value !== "boolean") {
-        console.error(`pi-minimal: hideGauntletWidgets must be a boolean in ${path}`);
-        return;
+    if (Object.hasOwn(record, "hideGauntletWidgets")) {
+        const value = record.hideGauntletWidgets;
+        if (typeof value === "boolean")
+            config.hideGauntletWidgets = value;
+        else
+            console.error(`pi-minimal: hideGauntletWidgets must be a boolean in ${path}`);
+    }
+    if (Object.hasOwn(record, "editDiff")) {
+        const value = record.editDiff;
+        if (isEditDiffMode(value))
+            config.editDiff = value;
+        else
+            console.error(`pi-minimal: editDiff must be one of ${EDIT_DIFF_MODES.map((mode) => `"${mode}"`).join(", ")} in ${path}`);
     }
-    config.hideGauntletWidgets = value;
+}
+function isEditDiffMode(value) {
+    return typeof value === "string" && EDIT_DIFF_MODES.includes(value);
 }

package/dist/index.js

@@ -7,7 +7,7 @@ import { bindFooterContributionEvents } from "./footer-contribution-events.js";
 import { installCwd } from "./cwd.js";
 import { listSiblings, parseAgentList, parseTabList } from "./herdr.js";
 import { hideGauntletWidgets } from "./tracker.js";
-import { installToolRenderers, stopLiveWatch } from "./tools.js";
+import { installToolRenderers, setEditDiffMode, stopLiveWatch } from "./tools.js";
 import { setSessionCwd } from "./tool-rows.js";
 import { applyReclaim, reclaimPolicy } from "./reclaim.js";
 import { installWorkingStatus } from "./working-status.js";
@@ -170,6 +170,7 @@ export default function piMinimalExtension(pi) {
             projectTrusted: ctx.isProjectTrusted(),
         });
         hideWidgets = config.hideGauntletWidgets;
+        setEditDiffMode(config.editDiff);
         currentCwd = ctx.cwd;
         setSessionCwd(ctx.cwd);
         try {

package/dist/tools.js

@@ -2,6 +2,7 @@ import { Container, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui
 import { rowIsRunning } from "./activity.js";
 import * as chrome from "./chrome.js";
 import { callSummary, codemodeOutcome, nestedCalls, nestedItem, scriptOutput } from "./codemode-rows.js";
+import { diffWords } from "diff";
 import { createLiveWatch } from "./live-watch.js";
 import { bashBody, formatDuration, formatOutcome, layoutRow, resultText, rowGlyph, toolItem, } from "./tool-rows.js";
 /** Tolerates a stale chrome module after /reload, where only CHROME_MARGIN may exist. */
@@ -11,6 +12,13 @@ const live = createLiveWatch(400);
 const rowIndent = () => margin() + 1;
 /** Max lines of output shown when a row is expanded. */
 const EXPANDED_MAX_LINES = 400;
+/** Max diff lines shown inline under an edit row with `editDiff: "always"`; ctrl+o shows the rest. */
+const INLINE_DIFF_MAX_LINES = 40;
+let editDiffMode = "expanded";
+/** Applies the `editDiff` setting; read at session start, so a change needs a new session or /reload. */
+export function setEditDiffMode(mode) {
+    editDiffMode = mode;
+}
 export function stopLiveWatch() {
     live.stop();
 }
@@ -58,6 +66,97 @@ function outputBlock(kind, result, theme) {
         invalidate() { },
     };
 }
+function editDiffText(result) {
+    const details = result?.details;
+    return typeof details?.diff === "string" && details.diff.trim() ? details.diff : undefined;
+}
+/** pi's edit diff lines: "+123 content", "-123 content", " 123 context"; anything else (e.g. "...") is a separator. */
+function parseDiffLine(line) {
+    const match = /^([+\- ])(\s*\d*) (.*)$/.exec(line);
+    if (!match)
+        return undefined;
+    return { prefix: match[1], lineNum: match[2], content: match[3].replace(/\t/g, "   ") };
+}
+/** Word-level diff of a 1:1 replacement; changed tokens are inverted, leading indentation is left alone, as in pi. */
+function highlightPair(removed, added, theme) {
+    let out = { removed: "", added: "" };
+    let firstRemoved = true;
+    let firstAdded = true;
+    for (const part of diffWords(removed, added)) {
+        if (part.removed || part.added) {
+            const key = part.removed ? "removed" : "added";
+            let value = part.value;
+            if (part.removed ? firstRemoved : firstAdded) {
+                const ws = /^(\s*)/.exec(value)?.[1] ?? "";
+                value = value.slice(ws.length);
+                out = { ...out, [key]: out[key] + ws };
+                if (part.removed)
+                    firstRemoved = false;
+                else
+                    firstAdded = false;
+            }
+            if (value)
+                out = { ...out, [key]: out[key] + theme.inverse(value) };
+        }
+        else {
+            out = { removed: out.removed + part.value, added: out.added + part.value };
+        }
+    }
+    return out;
+}
+/** Colours pi's edit diff like pi does: theme diff colours per line, inverse on changed tokens of single-line replacements. */
+function colorDiffLines(lines, theme) {
+    const out = [];
+    for (let i = 0; i < lines.length;) {
+        const parsed = parseDiffLine(lines[i]);
+        if (!parsed) {
+            out.push(theme.fg("toolDiffContext", lines[i]));
+            i++;
+            continue;
+        }
+        if (parsed.prefix === " ") {
+            out.push(theme.fg("toolDiffContext", ` ${parsed.lineNum} ${parsed.content}`));
+            i++;
+            continue;
+        }
+        const removed = [];
+        const added = [];
+        for (let p = parseDiffLine(lines[i] ?? ""); p?.prefix === "-"; p = parseDiffLine(lines[++i] ?? ""))
+            removed.push(p);
+        for (let p = parseDiffLine(lines[i] ?? ""); p?.prefix === "+"; p = parseDiffLine(lines[++i] ?? ""))
+            added.push(p);
+        if (removed.length === 1 && added.length === 1) {
+            const pair = highlightPair(removed[0].content, added[0].content, theme);
+            out.push(theme.fg("toolDiffRemoved", `-${removed[0].lineNum} ${pair.removed}`));
+            out.push(theme.fg("toolDiffAdded", `+${added[0].lineNum} ${pair.added}`));
+            continue;
+        }
+        for (const line of removed)
+            out.push(theme.fg("toolDiffRemoved", `-${line.lineNum} ${line.content}`));
+        for (const line of added)
+            out.push(theme.fg("toolDiffAdded", `+${line.lineNum} ${line.content}`));
+    }
+    return out;
+}
+/** The edit's diff in the `│`-ruled block. Inline views are capped; expanded views show up to the usual limit. */
+function diffBlock(diff, theme, expanded) {
+    const all = diff.replace(/\n$/, "").split("\n");
+    const max = expanded ? EXPANDED_MAX_LINES : INLINE_DIFF_MAX_LINES;
+    const lines = colorDiffLines(all.length > max ? all.slice(0, max) : all, theme);
+    const hidden = all.length - lines.length;
+    const indent = " ".repeat(rowIndent() + 2);
+    const rule = theme.fg("borderMuted", "│");
+    return {
+        render(width) {
+            const inner = Math.max(0, width - indent.length - 2);
+            const out = lines.map((line) => `${indent}${rule} ${truncateToWidth(line, inner)}`);
+            if (hidden > 0)
+                out.push(`${indent}${rule} ${theme.fg("dim", `… ${hidden} more lines${expanded ? "" : " (ctrl+o)"}`)}`);
+            return out;
+        },
+        invalidate() { },
+    };
+}
 function errorLineBlock(line, theme) {
     if (!line)
         return undefined;
@@ -149,10 +248,15 @@ export function compactRenderers(kind) {
                 live.unwatch(liveId(renderContext, toolItem(kind, renderContext.args)));
             }
             const container = new Container();
+            const expanded = Boolean(options.expanded);
             const errorLine = errorLineBlock(renderContext.state.outcome?.errorLine, theme);
-            if (errorLine && !options.expanded)
+            if (errorLine && !expanded)
                 container.addChild(errorLine);
-            if (options.expanded)
+            const diff = kind === "edit" && !renderContext.isError && !renderContext.isPartial ? editDiffText(typedResult) : undefined;
+            const showDiff = diff !== undefined && (editDiffMode === "always" || (editDiffMode === "expanded" && expanded));
+            if (showDiff)
+                container.addChild(diffBlock(diff, theme, expanded));
+            else if (expanded)
                 container.addChild(outputBlock(kind, typedResult, theme));
             return container;
         },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-minimal",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "license": "MIT",
   "type": "module",
   "private": false,
@@ -44,5 +44,8 @@
     "test": "tsc -p tsconfig.tests.json && node --test test-dist/test/*.test.js",
     "lint": "eslint .",
     "typecheck": "tsc -p tsconfig.json --noEmit"
+  },
+  "dependencies": {
+    "diff": "^8.0.4"
   }
 }

package/release-notes.md

@@ -1,31 +1,23 @@
 ### Added
-- Compact rows for tools that bring no renderer of their own, such as most MCP tools and
-  `subagents_enable`: `✓ mcp   re_mcp · query_prometheus query=… step=1m   12 lines · 1.4s`.
-  The verb is `mcp`, `agent` (subagent tools) or `tool`; up to three scalar arguments show as
-  `key=value`; a short single-line result shows verbatim, otherwise a line count. Failures show
-  their first line underneath; `ctrl+o` shows the full result. Tools that draw themselves
-  (the `subagent` live view, pi-gauntlet's trackers) keep their own renderer.
 
-### Changed
-- Bash rows drop `cd <session cwd> && ` and shorten other `cd <dir> && ` prefixes to the
-  directory name (`pi-subagents › sed -n …`), so the part that differs between rows is visible
-  and the outcome column stays put. Multi-line commands such as heredocs say how many lines follow
-  (`python3 - <<'EOF' · +4 lines`).
-- The thinking gutter `┊` now runs down every line of a thinking paragraph, including lines the
-  terminal wraps: paragraphs are pre-wrapped to the content width the host renders at (re-done on
-  resize). Previously only the first line of each paragraph had it, so wrapped thinking sat flush
-  with prose. Inline code stays whole; lists, quotes and fenced code are untouched.
-- The task tracker line is a segmented bar coloured by status (`Tasks ▰▰▰▰▱ 4/5`) instead of a
-  run of check marks; past 12 tasks it scales to 10 segments.
+- `editDiff` setting in `pi-minimal.json`: controls whether an `edit` row shows the
+  change itself. `"expanded"` (default) shows the unified diff in the `│`-ruled
+  block when the row is expanded with `ctrl+o`, where the bare "Successfully
+  replaced" text used to be. `"always"` shows it inline as soon as the edit lands,
+  capped at 40 lines with `… N more lines (ctrl+o)` for the rest. `"never"` keeps
+  the stats-only row. Lines use the theme's `toolDiffAdded` / `toolDiffRemoved` /
+  `toolDiffContext` colours and keep pi's line-number gutter; when one line
+  replaces one line, only the changed tokens are inverse-highlighted, as in pi's
+  own edit renderer. Failed edits and results without a diff are unchanged.
 
 ## What's Changed
-* feat: compact rows for renderer-less tools, shorter bash items, task bar, wrapped thinking gutter (0.3.1) by @raviy06 in https://github.com/raviy06/pi-minimal/pull/17
+* feat: editDiff setting — show edit diffs always, never, or behind ctrl+o (0.4.0) by @raviy06 in https://github.com/raviy06/pi-minimal/pull/18
 
 
-**Full Changelog**: https://github.com/raviy06/pi-minimal/compare/v0.3.0...v0.3.1
+**Full Changelog**: https://github.com/raviy06/pi-minimal/compare/v0.3.1...v0.4.0
 
 ---
 **Install / upgrade**
 ```bash
-pi install npm:pi-minimal@0.3.1   # or: pi update --extensions
+pi install npm:pi-minimal@0.4.0   # or: pi update --extensions
 ```

package/src/config.ts

@@ -2,12 +2,18 @@ import { readFileSync } from "node:fs"
 import { join } from "node:path"
 import { CONFIG_DIR_NAME } from "@earendil-works/pi-coding-agent"
 
+/** When an `edit` row shows its diff: inline as soon as the edit lands, never, or only while expanded with ctrl+o. */
+export type EditDiffMode = "always" | "never" | "expanded"
+export const EDIT_DIFF_MODES: readonly EditDiffMode[] = ["always", "never", "expanded"]
+
 export type PiMinimalConfig = {
 	hideGauntletWidgets: boolean
+	editDiff: EditDiffMode
 }
 
 const DEFAULTS: PiMinimalConfig = {
 	hideGauntletWidgets: true,
+	editDiff: "expanded",
 }
 
 export function loadPiMinimalConfig(options: {
@@ -44,16 +50,20 @@ function applyLayer(config: PiMinimalConfig, path: string): void {
 		return
 	}
 
+	// Each key is validated on its own so one bad value does not discard the rest of the layer.
 	const record = parsed as Record<string, unknown>
-	if (!Object.hasOwn(record, "hideGauntletWidgets")) {
-		return
+	if (Object.hasOwn(record, "hideGauntletWidgets")) {
+		const value = record.hideGauntletWidgets
+		if (typeof value === "boolean") config.hideGauntletWidgets = value
+		else console.error(`pi-minimal: hideGauntletWidgets must be a boolean in ${path}`)
 	}
-
-	const value = record.hideGauntletWidgets
-	if (typeof value !== "boolean") {
-		console.error(`pi-minimal: hideGauntletWidgets must be a boolean in ${path}`)
-		return
+	if (Object.hasOwn(record, "editDiff")) {
+		const value = record.editDiff
+		if (isEditDiffMode(value)) config.editDiff = value
+		else console.error(`pi-minimal: editDiff must be one of ${EDIT_DIFF_MODES.map((mode) => `"${mode}"`).join(", ")} in ${path}`)
 	}
+}
 
-	config.hideGauntletWidgets = value
+function isEditDiffMode(value: unknown): value is EditDiffMode {
+	return typeof value === "string" && (EDIT_DIFF_MODES as readonly string[]).includes(value)
 }

package/src/index.ts

@@ -7,7 +7,7 @@ import { bindFooterContributionEvents } from "./footer-contribution-events.js"
 import { installCwd } from "./cwd.js"
 import { listSiblings, parseAgentList, parseTabList, type Sibling } from "./herdr.js"
 import { hideGauntletWidgets } from "./tracker.js"
-import { installToolRenderers, stopLiveWatch } from "./tools.js"
+import { installToolRenderers, setEditDiffMode, stopLiveWatch } from "./tools.js"
 import { setSessionCwd } from "./tool-rows.js"
 import { applyReclaim, reclaimPolicy, type ReclaimReason } from "./reclaim.js"
 import { installWorkingStatus } from "./working-status.js"
@@ -167,6 +167,7 @@ export default function piMinimalExtension(pi: ExtensionAPI): void {
       projectTrusted: ctx.isProjectTrusted(),
     })
     hideWidgets = config.hideGauntletWidgets
+    setEditDiffMode(config.editDiff)
     currentCwd = ctx.cwd
     setSessionCwd(ctx.cwd)
     try {

package/src/tools.ts

@@ -3,6 +3,8 @@ import { Container, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui
 import { rowIsRunning } from "./activity.js"
 import * as chrome from "./chrome.js"
 import { callSummary, codemodeOutcome, nestedCalls, nestedItem, scriptOutput, type NestedCall } from "./codemode-rows.js"
+import { diffWords } from "diff"
+import type { EditDiffMode } from "./config.js"
 import { createLiveWatch } from "./live-watch.js"
 import {
   bashBody,
@@ -51,6 +53,15 @@ const live = createLiveWatch(400)
 const rowIndent = () => margin() + 1
 /** Max lines of output shown when a row is expanded. */
 const EXPANDED_MAX_LINES = 400
+/** Max diff lines shown inline under an edit row with `editDiff: "always"`; ctrl+o shows the rest. */
+const INLINE_DIFF_MAX_LINES = 40
+
+let editDiffMode: EditDiffMode = "expanded"
+
+/** Applies the `editDiff` setting; read at session start, so a change needs a new session or /reload. */
+export function setEditDiffMode(mode: EditDiffMode): void {
+  editDiffMode = mode
+}
 
 export function stopLiveWatch(): void {
   live.stop()
@@ -98,6 +109,86 @@ function outputBlock(kind: ToolKind, result: ToolResultLike | undefined, theme:
   }
 }
 
+function editDiffText(result: ToolResultLike | undefined): string | undefined {
+  const details = result?.details as { diff?: unknown } | undefined
+  return typeof details?.diff === "string" && details.diff.trim() ? details.diff : undefined
+}
+
+type DiffLine = { prefix: "+" | "-" | " "; lineNum: string; content: string }
+
+/** pi's edit diff lines: "+123 content", "-123 content", " 123 context"; anything else (e.g. "...") is a separator. */
+function parseDiffLine(line: string): DiffLine | undefined {
+  const match = /^([+\- ])(\s*\d*) (.*)$/.exec(line)
+  if (!match) return undefined
+  return { prefix: match[1] as DiffLine["prefix"], lineNum: match[2]!, content: match[3]!.replace(/\t/g, "   ") }
+}
+
+/** Word-level diff of a 1:1 replacement; changed tokens are inverted, leading indentation is left alone, as in pi. */
+function highlightPair(removed: string, added: string, theme: Theme): { removed: string; added: string } {
+  let out = { removed: "", added: "" }
+  let firstRemoved = true
+  let firstAdded = true
+  for (const part of diffWords(removed, added)) {
+    if (part.removed || part.added) {
+      const key = part.removed ? "removed" : "added"
+      let value = part.value
+      if (part.removed ? firstRemoved : firstAdded) {
+        const ws = /^(\s*)/.exec(value)?.[1] ?? ""
+        value = value.slice(ws.length)
+        out = { ...out, [key]: out[key] + ws }
+        if (part.removed) firstRemoved = false
+        else firstAdded = false
+      }
+      if (value) out = { ...out, [key]: out[key] + theme.inverse(value) }
+    } else {
+      out = { removed: out.removed + part.value, added: out.added + part.value }
+    }
+  }
+  return out
+}
+
+/** Colours pi's edit diff like pi does: theme diff colours per line, inverse on changed tokens of single-line replacements. */
+function colorDiffLines(lines: string[], theme: Theme): string[] {
+  const out: string[] = []
+  for (let i = 0; i < lines.length; ) {
+    const parsed = parseDiffLine(lines[i]!)
+    if (!parsed) { out.push(theme.fg("toolDiffContext", lines[i]!)); i++; continue }
+    if (parsed.prefix === " ") { out.push(theme.fg("toolDiffContext", ` ${parsed.lineNum} ${parsed.content}`)); i++; continue }
+    const removed: DiffLine[] = []
+    const added: DiffLine[] = []
+    for (let p = parseDiffLine(lines[i] ?? ""); p?.prefix === "-"; p = parseDiffLine(lines[++i] ?? "")) removed.push(p)
+    for (let p = parseDiffLine(lines[i] ?? ""); p?.prefix === "+"; p = parseDiffLine(lines[++i] ?? "")) added.push(p)
+    if (removed.length === 1 && added.length === 1) {
+      const pair = highlightPair(removed[0]!.content, added[0]!.content, theme)
+      out.push(theme.fg("toolDiffRemoved", `-${removed[0]!.lineNum} ${pair.removed}`))
+      out.push(theme.fg("toolDiffAdded", `+${added[0]!.lineNum} ${pair.added}`))
+      continue
+    }
+    for (const line of removed) out.push(theme.fg("toolDiffRemoved", `-${line.lineNum} ${line.content}`))
+    for (const line of added) out.push(theme.fg("toolDiffAdded", `+${line.lineNum} ${line.content}`))
+  }
+  return out
+}
+
+/** The edit's diff in the `│`-ruled block. Inline views are capped; expanded views show up to the usual limit. */
+function diffBlock(diff: string, theme: Theme, expanded: boolean) {
+  const all = diff.replace(/\n$/, "").split("\n")
+  const max = expanded ? EXPANDED_MAX_LINES : INLINE_DIFF_MAX_LINES
+  const lines = colorDiffLines(all.length > max ? all.slice(0, max) : all, theme)
+  const hidden = all.length - lines.length
+  const indent = " ".repeat(rowIndent() + 2)
+  const rule = theme.fg("borderMuted", "│")
+  return {
+    render(width: number): string[] {
+      const inner = Math.max(0, width - indent.length - 2)
+      const out = lines.map((line) => `${indent}${rule} ${truncateToWidth(line, inner)}`)
+      if (hidden > 0) out.push(`${indent}${rule} ${theme.fg("dim", `… ${hidden} more lines${expanded ? "" : " (ctrl+o)"}`)}`)
+      return out
+    },
+    invalidate() {},
+  }
+}
+
 function errorLineBlock(line: string | undefined, theme: Theme) {
   if (!line) return undefined
   const indent = " ".repeat(rowIndent() + 2)
@@ -195,9 +286,13 @@ export function compactRenderers(kind: ToolKind): ToolRenderers {
         live.unwatch(liveId(renderContext, toolItem(kind, renderContext.args)))
       }
       const container = new Container()
+      const expanded = Boolean((options as RenderOptions).expanded)
       const errorLine = errorLineBlock(renderContext.state.outcome?.errorLine, theme)
-      if (errorLine && !(options as RenderOptions).expanded) container.addChild(errorLine)
-      if ((options as RenderOptions).expanded) container.addChild(outputBlock(kind, typedResult, theme))
+      if (errorLine && !expanded) container.addChild(errorLine)
+      const diff = kind === "edit" && !renderContext.isError && !renderContext.isPartial ? editDiffText(typedResult) : undefined
+      const showDiff = diff !== undefined && (editDiffMode === "always" || (editDiffMode === "expanded" && expanded))
+      if (showDiff) container.addChild(diffBlock(diff, theme, expanded))
+      else if (expanded) container.addChild(outputBlock(kind, typedResult, theme))
       return container
     },
   }

package/test/config.test.ts

@@ -30,85 +30,106 @@ test("defaults hideGauntletWidgets to true", (t) => {
 	const { agentDir, cwd } = setup(t)
 	const error = t.mock.method(console, "error")
 	const config = loadPiMinimalConfig({ agentDir, cwd, projectTrusted: true })
-	assert.deepEqual(config, { hideGauntletWidgets: true })
+	assert.deepEqual(config, { hideGauntletWidgets: true, editDiff: "expanded" })
 	assert.equal(error.mock.callCount(), 0)
 })
 
 test("global false overrides default", (t) => {
 	const { agentDir, cwd } = setup(t)
-	writeGlobal(agentDir, JSON.stringify({ hideGauntletWidgets: false }))
+	writeGlobal(agentDir, JSON.stringify({ hideGauntletWidgets: false, editDiff: "expanded" }))
 	const error = t.mock.method(console, "error")
 	const config = loadPiMinimalConfig({ agentDir, cwd, projectTrusted: false })
-	assert.deepEqual(config, { hideGauntletWidgets: false })
+	assert.deepEqual(config, { hideGauntletWidgets: false, editDiff: "expanded" })
 	assert.equal(error.mock.callCount(), 0)
 })
 
 test("trusted project true overrides global false", (t) => {
 	const { agentDir, cwd } = setup(t)
-	writeGlobal(agentDir, JSON.stringify({ hideGauntletWidgets: false }))
-	writeProject(cwd, JSON.stringify({ hideGauntletWidgets: true }))
+	writeGlobal(agentDir, JSON.stringify({ hideGauntletWidgets: false, editDiff: "expanded" }))
+	writeProject(cwd, JSON.stringify({ hideGauntletWidgets: true, editDiff: "expanded" }))
 	const error = t.mock.method(console, "error")
 	const config = loadPiMinimalConfig({ agentDir, cwd, projectTrusted: true })
-	assert.deepEqual(config, { hideGauntletWidgets: true })
+	assert.deepEqual(config, { hideGauntletWidgets: true, editDiff: "expanded" })
 	assert.equal(error.mock.callCount(), 0)
 })
 
 test("untrusted project false does not override global true", (t) => {
 	const { agentDir, cwd } = setup(t)
-	writeGlobal(agentDir, JSON.stringify({ hideGauntletWidgets: true }))
-	writeProject(cwd, JSON.stringify({ hideGauntletWidgets: false }))
+	writeGlobal(agentDir, JSON.stringify({ hideGauntletWidgets: true, editDiff: "expanded" }))
+	writeProject(cwd, JSON.stringify({ hideGauntletWidgets: false, editDiff: "expanded" }))
 	const error = t.mock.method(console, "error")
 	const config = loadPiMinimalConfig({ agentDir, cwd, projectTrusted: false })
-	assert.deepEqual(config, { hideGauntletWidgets: true })
+	assert.deepEqual(config, { hideGauntletWidgets: true, editDiff: "expanded" })
 	assert.equal(error.mock.callCount(), 0)
 })
 
 test("omitted keys do not override", (t) => {
 	const { agentDir, cwd } = setup(t)
-	writeGlobal(agentDir, JSON.stringify({ hideGauntletWidgets: false }))
+	writeGlobal(agentDir, JSON.stringify({ hideGauntletWidgets: false, editDiff: "expanded" }))
 	writeProject(cwd, JSON.stringify({}))
 	const error = t.mock.method(console, "error")
 	const config = loadPiMinimalConfig({ agentDir, cwd, projectTrusted: true })
-	assert.deepEqual(config, { hideGauntletWidgets: false })
+	assert.deepEqual(config, { hideGauntletWidgets: false, editDiff: "expanded" })
 	assert.equal(error.mock.callCount(), 0)
 })
 
 test("unknown keys do not override", (t) => {
 	const { agentDir, cwd } = setup(t)
-	writeGlobal(agentDir, JSON.stringify({ hideGauntletWidgets: false }))
+	writeGlobal(agentDir, JSON.stringify({ hideGauntletWidgets: false, editDiff: "expanded" }))
 	writeProject(cwd, JSON.stringify({ extra: true }))
 	const error = t.mock.method(console, "error")
 	const config = loadPiMinimalConfig({ agentDir, cwd, projectTrusted: true })
-	assert.deepEqual(config, { hideGauntletWidgets: false })
+	assert.deepEqual(config, { hideGauntletWidgets: false, editDiff: "expanded" })
 	assert.equal(error.mock.callCount(), 0)
 })
 
 test("invalid JSON calls console.error and leaves the lower-precedence value unchanged", (t) => {
 	const { agentDir, cwd } = setup(t)
-	writeGlobal(agentDir, JSON.stringify({ hideGauntletWidgets: false }))
+	writeGlobal(agentDir, JSON.stringify({ hideGauntletWidgets: false, editDiff: "expanded" }))
 	writeProject(cwd, "{")
 	const error = t.mock.method(console, "error")
 	const config = loadPiMinimalConfig({ agentDir, cwd, projectTrusted: true })
-	assert.deepEqual(config, { hideGauntletWidgets: false })
+	assert.deepEqual(config, { hideGauntletWidgets: false, editDiff: "expanded" })
 	assert.ok(error.mock.callCount() >= 1)
 })
 
 test("non-object root calls console.error and leaves the lower-precedence value unchanged", (t) => {
 	const { agentDir, cwd } = setup(t)
-	writeGlobal(agentDir, JSON.stringify({ hideGauntletWidgets: false }))
+	writeGlobal(agentDir, JSON.stringify({ hideGauntletWidgets: false, editDiff: "expanded" }))
 	writeProject(cwd, JSON.stringify(["hideGauntletWidgets", false]))
 	const error = t.mock.method(console, "error")
 	const config = loadPiMinimalConfig({ agentDir, cwd, projectTrusted: true })
-	assert.deepEqual(config, { hideGauntletWidgets: false })
+	assert.deepEqual(config, { hideGauntletWidgets: false, editDiff: "expanded" })
 	assert.ok(error.mock.callCount() >= 1)
 })
 
 test("non-boolean hideGauntletWidgets calls console.error and leaves the lower-precedence value unchanged", (t) => {
 	const { agentDir, cwd } = setup(t)
-	writeGlobal(agentDir, JSON.stringify({ hideGauntletWidgets: false }))
+	writeGlobal(agentDir, JSON.stringify({ hideGauntletWidgets: false, editDiff: "expanded" }))
 	writeProject(cwd, JSON.stringify({ hideGauntletWidgets: "yes" }))
 	const error = t.mock.method(console, "error")
 	const config = loadPiMinimalConfig({ agentDir, cwd, projectTrusted: true })
-	assert.deepEqual(config, { hideGauntletWidgets: false })
+	assert.deepEqual(config, { hideGauntletWidgets: false, editDiff: "expanded" })
 	assert.ok(error.mock.callCount() >= 1)
 })
+
+test("editDiff accepts always, never and expanded, layered like other keys", (t) => {
+	const { agentDir, cwd } = setup(t)
+	writeGlobal(agentDir, JSON.stringify({ editDiff: "always" }))
+	writeProject(cwd, JSON.stringify({ editDiff: "never" }))
+	const error = t.mock.method(console, "error")
+	assert.equal(loadPiMinimalConfig({ agentDir, cwd, projectTrusted: false }).editDiff, "always")
+	assert.equal(loadPiMinimalConfig({ agentDir, cwd, projectTrusted: true }).editDiff, "never")
+	assert.equal(error.mock.callCount(), 0)
+})
+
+test("an invalid editDiff value is reported and does not override", (t) => {
+	const { agentDir, cwd } = setup(t)
+	writeGlobal(agentDir, JSON.stringify({ editDiff: "always", hideGauntletWidgets: false }))
+	writeProject(cwd, JSON.stringify({ editDiff: "sometimes" }))
+	const error = t.mock.method(console, "error")
+	const config = loadPiMinimalConfig({ agentDir, cwd, projectTrusted: true })
+	assert.deepEqual(config, { hideGauntletWidgets: false, editDiff: "always" })
+	assert.equal(error.mock.callCount(), 1)
+	assert.match(String(error.mock.calls[0]!.arguments[0]), /editDiff must be one of "always", "never", "expanded"/)
+})

package/test/tools.test.ts

@@ -10,6 +10,7 @@ import {
 	genericVerb,
 	installToolRenderers,
 	isToolKind,
+	setEditDiffMode,
 	stopLiveWatch,
 } from "../src/tools.js"
 
@@ -176,3 +177,67 @@ test("generic renderer draws one row, an error line on failure, and output on ex
 	const open = r.renderResult!({ content: [{ type: "text", text: "a\nb" }] } as never, { expanded: true, isPartial: false } as never, plainTheme, context as never)
 	assert.deepEqual(open.render(90).map((l) => l.trim()), ["│ a", "│ b"])
 })
+
+// pi's edit tool emits its own line-numbered form, not a unified diff: "+123 content", "-123 content", " 123 context", "..." between hunks.
+const EDIT_DIFF = " 1 context\n-2 const a = old(x)\n+2 const a = fresh(x)\n 3 context"
+const editResult = { content: [{ type: "text", text: "Successfully replaced 1 block(s)" }], details: { diff: EDIT_DIFF } }
+function editRows(expanded: boolean, result: unknown = editResult, isError = false): string[] {
+	const renderers = compactRenderers("edit")
+	const context = { args: { path: "a.ts" }, toolCallId: "e1", invalidate() {}, state: {}, isPartial: false, isError, durationMs: 100 } as never
+	const theme = {
+		fg: (c: string, s: string) => (c.startsWith("toolDiff") ? `<${c.slice(8).toLowerCase()}>${s}` : s),
+		inverse: (s: string) => `[${s}]`,
+	} as never
+	const block = renderers.renderResult!(result as never, { expanded, isPartial: false } as never, theme, context)
+	return block.render(80).map((line) => line.trimEnd())
+}
+
+test("editDiff=expanded (default) shows the diff only behind ctrl+o, in the theme's diff colours", (t) => {
+	t.after(() => setEditDiffMode("expanded"))
+	setEditDiffMode("expanded")
+	assert.deepEqual(editRows(false), [])
+	const rows = editRows(true)
+	assert.equal(rows.length, 4)
+	assert.match(rows[0]!, /│ <context> 1 context$/)
+	assert.match(rows[1]!, /│ <removed>-2 const a = /)
+	assert.match(rows[2]!, /│ <added>\+2 const a = /)
+	assert.ok(rows.every((row) => !row.includes("Successfully replaced")), "the diff replaces the result text")
+})
+
+test("a one-line replacement highlights only the changed tokens with inverse", (t) => {
+	t.after(() => setEditDiffMode("expanded"))
+	setEditDiffMode("expanded")
+	const [, removed, added] = editRows(true)
+	assert.match(removed!, /-2 const a = \[old\]\(x\)$/)
+	assert.match(added!, /\+2 const a = \[fresh\]\(x\)$/)
+	const multi = editRows(true, { content: [], details: { diff: "-1 a\n-2 b\n+1 c" } })
+	assert.ok(multi.every((row) => !row.includes("[")), "blocks that are not 1:1 are not token-highlighted")
+})
+
+test("editDiff=always shows the diff inline and editDiff=never only on request falls back to the result text", (t) => {
+	t.after(() => setEditDiffMode("expanded"))
+	setEditDiffMode("always")
+	assert.equal(editRows(false).length, 4)
+	assert.equal(editRows(true).length, 4)
+	setEditDiffMode("never")
+	assert.deepEqual(editRows(false), [])
+	assert.match(editRows(true)[0]!, /│ Successfully replaced 1 block\(s\)$/)
+})
+
+test("editDiff=always truncates a long inline diff and leaves the full diff to ctrl+o", (t) => {
+	t.after(() => setEditDiffMode("expanded"))
+	setEditDiffMode("always")
+	const long = { content: [{ type: "text", text: "ok" }], details: { diff: Array.from({ length: 60 }, (_, i) => `+${i + 1} line ${i}`).join("\n") } }
+	const inline = editRows(false, long)
+	assert.equal(inline.length, 41)
+	assert.match(inline[40]!, /… 20 more lines \(ctrl\+o\)$/)
+	assert.equal(editRows(true, long).length, 60)
+})
+
+test("edit failures and results without a diff never render a diff block", (t) => {
+	t.after(() => setEditDiffMode("expanded"))
+	setEditDiffMode("always")
+	assert.deepEqual(editRows(false, { content: [{ type: "text", text: "edited" }] }), [])
+	const failed = editRows(false, { content: [{ type: "text", text: "oldText not found" }] }, true)
+	assert.ok(failed.every((row) => !row.includes("<removed>")))
+})