pi-minimal 0.1.0 → 0.2.2

package/src/turn-rule.ts

@@ -0,0 +1,139 @@
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent"
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui"
+import * as chrome from "./chrome.js"
+import { formatElapsed } from "./working-status.js"
+
+/** Tolerates a stale chrome module after /reload, where only CHROME_MARGIN may exist. */
+const margin = (): number => (typeof chrome.chromeMargin === "function" ? chrome.chromeMargin() : (chrome.CHROME_MARGIN ?? 1))
+
+
+export const TURN_ENTRY_TYPE = "pi-minimal.turn"
+
+export type TurnSummary = {
+  /** Epoch ms when the run finished. */
+  endedAt: number
+  /** Wall-clock duration of the run. */
+  elapsedMs: number
+  /** Number of tool executions during the run. */
+  tools: number
+  /** Whether the run ended with an error result or abort. */
+  outcome: "completed" | "aborted" | "error"
+}
+
+export function formatClock(epochMs: number): string {
+  const d = new Date(epochMs)
+  const hh = String(d.getHours()).padStart(2, "0")
+  const mm = String(d.getMinutes()).padStart(2, "0")
+  return `${hh}:${mm}`
+}
+
+export function turnLabel(summary: TurnSummary): string {
+  const parts = [formatClock(summary.endedAt), formatElapsed(summary.elapsedMs)]
+  if (summary.tools > 0) parts.push(`${summary.tools} tool${summary.tools === 1 ? "" : "s"}`)
+  if (summary.outcome === "aborted") parts.push("aborted")
+  if (summary.outcome === "error") parts.push("error")
+  return parts.join(" · ")
+}
+
+/** `── label ─────────` filling `width`; label is dropped when the row is too narrow. */
+export function ruleLine(width: number, label: string): string {
+  const lead = "── "
+  const tail = " "
+  const minRule = 4
+  if (width <= 0) return ""
+  if (visibleWidth(lead) + visibleWidth(label) + visibleWidth(tail) + minRule > width) {
+    return "─".repeat(width)
+  }
+  const shown = truncateToWidth(label, width - lead.length - tail.length - minRule, "…")
+  const rest = Math.max(minRule, width - visibleWidth(lead) - visibleWidth(shown) - visibleWidth(tail))
+  return `${lead}${shown}${tail}${"─".repeat(rest)}`
+}
+
+export function runOutcome(messages: Array<{ role?: string; stopReason?: string }> | undefined): TurnSummary["outcome"] {
+  if (!Array.isArray(messages)) return "completed"
+  for (let i = messages.length - 1; i >= 0; i -= 1) {
+    const message = messages[i]
+    if (message?.role !== "assistant") continue
+    if (message.stopReason === "aborted") return "aborted"
+    if (message.stopReason === "error") return "error"
+    return "completed"
+  }
+  return "completed"
+}
+
+export function isTurnSummary(data: unknown): data is TurnSummary {
+  if (!data || typeof data !== "object") return false
+  const d = data as Record<string, unknown>
+  return (
+    typeof d.endedAt === "number" &&
+    typeof d.elapsedMs === "number" &&
+    typeof d.tools === "number" &&
+    (d.outcome === "completed" || d.outcome === "aborted" || d.outcome === "error")
+  )
+}
+
+export function installTurnRule(pi: ExtensionAPI): () => void {
+  let ctx: ExtensionContext | undefined
+  let startedAt = 0
+  let tools = 0
+
+  if (typeof pi.registerEntryRenderer !== "function" || typeof pi.appendEntry !== "function") {
+    return () => {}
+  }
+
+  pi.registerEntryRenderer<TurnSummary>(TURN_ENTRY_TYPE, (entry, _options, theme) => {
+    if (!isTurnSummary(entry.data)) return undefined
+    const label = turnLabel(entry.data)
+    const color = entry.data.outcome === "completed" ? "borderMuted" : entry.data.outcome === "aborted" ? "warning" : "error"
+    return {
+      render(width: number): string[] {
+        const inner = Math.max(0, width - margin() * 2)
+        const rule = ruleLine(inner, label)
+        const colored = rule.replace(label, theme.fg("dim", label))
+        return ["", `${" ".repeat(margin())}${theme.fg(color, colored)}`]
+      },
+      invalidate() {},
+    }
+  })
+
+  pi.on("session_start", (_event, next) => {
+    if (next.mode !== "tui") return
+    ctx = next
+  })
+
+  pi.on("agent_start", () => {
+    startedAt = Date.now()
+    tools = 0
+  })
+
+  pi.on("tool_execution_end", () => {
+    tools += 1
+  })
+
+  pi.on("agent_end", (event) => {
+    if (!ctx || ctx.mode !== "tui" || !startedAt) return
+    const ev = event as { messages?: Array<{ role?: string; stopReason?: string }> }
+    const summary: TurnSummary = {
+      endedAt: Date.now(),
+      elapsedMs: Date.now() - startedAt,
+      tools,
+      outcome: runOutcome(ev.messages),
+    }
+    startedAt = 0
+    try {
+      pi.appendEntry(TURN_ENTRY_TYPE, summary)
+    } catch {
+      // A session that cannot accept entries just goes without the separator.
+    }
+  })
+
+  pi.on("session_shutdown", () => {
+    ctx = undefined
+    startedAt = 0
+  })
+
+  return () => {
+    ctx = undefined
+    startedAt = 0
+  }
+}

package/test/activity.test.ts

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict"
 import test from "node:test"
-import { activityBullet, rowIsRunning } from "../src/activity.js"
+import { rowIsRunning } from "../src/activity.js"
 
 test("rowIsRunning is false when isPartial is false", () => {
 	assert.equal(rowIsRunning({ isPartial: false }), false)
@@ -10,18 +10,7 @@ test("rowIsRunning is true when isPartial is true", () => {
 	assert.equal(rowIsRunning({ isPartial: true }), true)
 })
 
-test("activityBullet(false, 0) returns ◆", () => {
-	assert.equal(activityBullet(false, 0), "◆")
-})
-
-test("activityBullet(false, 1) returns ◆", () => {
-	assert.equal(activityBullet(false, 1), "◆")
-})
-
-test("activityBullet(true, 0) returns ◆", () => {
-	assert.equal(activityBullet(true, 0), "◆")
-})
-
-test("activityBullet(true, 1) returns ◇", () => {
-	assert.equal(activityBullet(true, 1), "◇")
+test("rowIsRunning is false once the row is done or errored", () => {
+	assert.equal(rowIsRunning({ isPartial: true, state: { done: true } }), false)
+	assert.equal(rowIsRunning({ isPartial: true, isError: true }), false)
 })

package/test/code-box.test.ts

@@ -0,0 +1,55 @@
+import assert from "node:assert/strict"
+import test from "node:test"
+import { Markdown } from "@earendil-works/pi-tui"
+import { frameCodeLines, installCodeBox } from "../src/code-box.js"
+
+const theme = { codeBlockBorder: (s: string) => s }
+const ESC = String.fromCharCode(27)
+const stripAnsi = (s: string) => s.split(ESC).map((p, i) => (i === 0 ? p : p.replace(/^\[[0-9;]*m/, ""))).join("")
+
+test("frameCodeLines replaces fences with a closed box and keeps the trailer", () => {
+	const out = frameCodeLines(["```json", '  {"a":1}', "  ", "```", ""], "json", 20, theme)
+	assert.equal(out.length, 5)
+	assert.ok(out[0].startsWith("╭─ json ─") && out[0].endsWith("╮"))
+	assert.equal(out[1], '│ {"a":1}          │')
+	assert.equal(out[2], "│                  │")
+	assert.ok(out[3].startsWith("╰─") && out[3].endsWith("╯"))
+	for (const l of out.slice(0, 4)) assert.equal(l.length, 20, l)
+	assert.equal(out[4], "")
+})
+
+test("frameCodeLines wraps long lines inside the box", () => {
+	const out = frameCodeLines(["```", "  " + "x".repeat(30), "```"], undefined, 20, theme)
+	assert.equal(out.length, 4, out.join("\n"))
+	assert.equal(out[1], `│ ${"x".repeat(16)} │`)
+	assert.equal(out[2], `│ ${"x".repeat(14)}   │`)
+	for (const l of out) assert.equal(l.length, 20, l)
+})
+
+test("frameCodeLines handles empty blocks and missing language", () => {
+	const out = frameCodeLines(["```", "```"], undefined, 10, theme)
+	assert.deepEqual(out.map((l) => l[0]), ["╭", "│", "╰"])
+	assert.deepEqual(out.map((l) => l[l.length - 1]), ["╮", "│", "╯"])
+	assert.ok(!out[0].includes(" "), "no language label")
+	assert.deepEqual(frameCodeLines(["x"], undefined, 10, theme), ["x"])
+})
+
+test("installCodeBox patches pi-tui's Markdown renderer idempotently", () => {
+	assert.equal(installCodeBox(), true)
+	assert.equal(installCodeBox(), true)
+	// A reload re-points the installed wrapper at the current framer.
+	const slot = Symbol.for("pi-minimal.code-box.frame")
+	const slots = globalThis as unknown as Record<symbol, unknown>
+	assert.equal(slots[slot], frameCodeLines)
+	const id = (s: string) => s
+	const mdTheme = {
+		heading: id, link: id, linkUrl: id, code: id, codeBlock: id, codeBlockBorder: id, quote: id, quoteBorder: id,
+		hr: id, listBullet: id, bold: id, italic: id, underline: id, strikethrough: id,
+	}
+	const md = new Markdown("before\n\n```ts\nconst x = 1\n```\n\nafter", 0, 0, mdTheme as never)
+	const lines = md.render(40).map(stripAnsi)
+	assert.ok(lines.some((l) => l.startsWith("╭─ ts ") && l.endsWith("╮")), lines.join("\n"))
+	assert.ok(lines.some((l) => l.startsWith("│ const x = 1") && l.endsWith("│")), lines.join("\n"))
+	assert.ok(lines.some((l) => l.startsWith("╰─") && l.endsWith("╯")), lines.join("\n"))
+	assert.ok(!lines.some((l) => l.includes("```")), "no literal fences remain")
+})

package/test/footer.test.ts

@@ -0,0 +1,38 @@
+import assert from "node:assert/strict"
+import test from "node:test"
+import { visibleWidth } from "@earendil-works/pi-tui"
+import { footerHints } from "../src/footer.js"
+import { contextBand, meter, splitRow } from "../src/cwd.js"
+
+const hints = ["enter send", "shift+tab thinking"]
+
+test("footerHints show only when idle with an empty editor", () => {
+	assert.deepEqual(footerHints({ busy: () => false, editorText: () => "", contextPct: () => 10 }, hints), hints)
+	assert.deepEqual(footerHints({ busy: () => true, editorText: () => "", contextPct: () => 10 }, hints), [])
+	assert.deepEqual(footerHints({ busy: () => false, editorText: () => "hi", contextPct: () => 10 }, hints), [])
+})
+
+test("footerHints suggest /compact under context pressure", () => {
+	assert.deepEqual(footerHints({ busy: () => false, editorText: () => "", contextPct: () => 72 }, hints), [...hints, "/compact"])
+})
+
+test("contextBand thresholds", () => {
+	assert.equal(contextBand(0), "accent")
+	assert.equal(contextBand(69), "accent")
+	assert.equal(contextBand(70), "warning")
+	assert.equal(contextBand(90), "error")
+})
+
+test("meter fills proportionally", () => {
+	assert.equal(meter(0, "#", "."), "........")
+	assert.equal(meter(50, "#", "."), "####....")
+	assert.equal(meter(100, "#", "."), "########")
+})
+
+test("splitRow drops right-hand segments from the end before truncating the left", () => {
+	assert.equal(splitRow("left", ["a", "b"], 12), "left    a  b")
+	assert.equal(splitRow("left", ["aaaa", "bbbb"], 12), "left    aaaa")
+	const squeezed = splitRow("a-very-long-left", ["x"], 10)
+	assert.equal(visibleWidth(squeezed), 10)
+	assert.ok(!squeezed.includes("x"))
+})

package/test/git-state.test.ts

@@ -0,0 +1,52 @@
+import assert from "node:assert/strict"
+import test from "node:test"
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent"
+import { createGitState, formatGitState, parseBranch, parsePorcelain } from "../src/git-state.js"
+
+test("parseBranch returns the branch and treats detached HEAD as unknown", () => {
+	assert.equal(parseBranch("main\n"), "main")
+	assert.equal(parseBranch("HEAD\n"), undefined)
+	assert.equal(parseBranch(""), undefined)
+})
+
+test("parsePorcelain counts changed paths", () => {
+	assert.equal(parsePorcelain(""), 0)
+	assert.equal(parsePorcelain(" M a.ts\n?? b.ts\n"), 2)
+})
+
+test("formatGitState shows ±N only when dirty", () => {
+	assert.deepEqual(formatGitState(undefined), { branch: "", dirty: "" })
+	assert.deepEqual(formatGitState({ branch: "main", dirty: 0 }), { branch: "main", dirty: "" })
+	assert.deepEqual(formatGitState({ branch: "main", dirty: 3 }), { branch: "main", dirty: "±3" })
+})
+
+test("createGitState polls git, throttles, and notifies listeners", async () => {
+	const calls: string[][] = []
+	const pi = {
+		async exec(_cmd: string, args: string[]) {
+			calls.push(args)
+			if (args[0] === "rev-parse") return { stdout: "feature\n", stderr: "", code: 0, killed: false }
+			return { stdout: " M x\n", stderr: "", code: 0, killed: false }
+		},
+	} as unknown as ExtensionAPI
+	const git = createGitState(pi, () => "/tmp", 60_000)
+	let notified = 0
+	git.onChange(() => (notified += 1))
+	assert.equal(git.get(), undefined)
+	await git.refresh(true)
+	assert.deepEqual(git.get(), { branch: "feature", dirty: 1 })
+	assert.equal(notified, 1)
+	await git.refresh()
+	assert.equal(calls.length, 2, "throttled refresh does not re-run git")
+})
+
+test("createGitState clears state outside a repository", async () => {
+	const pi = {
+		async exec() {
+			return { stdout: "", stderr: "fatal: not a git repository", code: 128, killed: false }
+		},
+	} as unknown as ExtensionAPI
+	const git = createGitState(pi, () => "/tmp")
+	await git.refresh(true)
+	assert.equal(git.get(), undefined)
+})

package/test/index.test.ts

@@ -90,6 +90,18 @@ function createFake(options: {
 		registerTool(...args: unknown[]) {
 			record(registerCalls, "registerTool", args)
 		},
+		registerToolRenderer(...args: unknown[]) {
+			record(registerCalls, "registerToolRenderer", args)
+		},
+		registerMarkdownTransformer(...args: unknown[]) {
+			record(registerCalls, "registerMarkdownTransformer", args)
+		},
+		registerEntryRenderer(...args: unknown[]) {
+			record(registerCalls, "registerEntryRenderer", args)
+		},
+		appendEntry(...args: unknown[]) {
+			record(registerCalls, "appendEntry", args)
+		},
 	} as unknown as ExtensionAPI
 
 	const emit = async (event: string, payload: unknown = {}) => {
@@ -148,7 +160,7 @@ test.describe("session chrome", { concurrency: 1 }, () => {
 		)
 	})
 
-	test("TUI session_start installs chrome and wraps tools before the first reclaim", async (t) => {
+	test("TUI session_start installs chrome before the first reclaim and tool renderers at load", async (t) => {
 		const { agentDir, cwd } = setupDirs(t)
 		process.env[AGENT_DIR_ENV] = agentDir
 		delete process.env.HERDR_ENV
@@ -164,18 +176,20 @@ test.describe("session chrome", { concurrency: 1 }, () => {
 		const firstCwd = allCalls.findIndex(
 			(call) => call.method === "setWidget" && call.args[0] === "tw-cwd" && typeof call.args[1] === "function",
 		)
-		const firstWrap = allCalls.findIndex((call) => call.method === "registerTool")
+		const firstWrap = allCalls.findIndex((call) => call.method === "registerToolRenderer")
+		const firstSessionStart = allCalls.findIndex((call) => call.method === "setHeader")
 		const firstReclaim = allCalls.findIndex((call) => call.method === "setEditorComponent")
 
 		assert.ok(firstHeader >= 0, "header installed")
 		assert.ok(firstFooter >= 0, "footer installed")
 		assert.ok(firstCwd >= 0, "cwd installed")
-		assert.ok(firstWrap >= 0, "tools wrapped")
+		assert.ok(firstWrap >= 0, "tool renderers registered")
+		assert.ok(firstWrap < firstSessionStart, "tool renderers registered before session_start chrome (resume-safe)")
 		assert.ok(firstReclaim >= 0, "reclaim ran")
 		assert.ok(firstHeader < firstReclaim, "header before reclaim")
 		assert.ok(firstFooter < firstReclaim, "footer before reclaim")
 		assert.ok(firstCwd < firstReclaim, "cwd before reclaim")
-		assert.ok(firstWrap < firstReclaim, "wrap before reclaim")
+		assert.equal(allCalls.some((call) => call.method === "registerTool"), false, "built-in tools are not re-registered")
 	})
 
 	test("does not clear Gauntlet widgets when config disables hiding", async (t) => {
@@ -260,3 +274,25 @@ test.describe("session chrome", { concurrency: 1 }, () => {
 		)
 	})
 })
+
+test("agent_end appends a turn summary entry in TUI mode", async (t) => {
+	const { agentDir, cwd } = setupDirs(t)
+	process.env[AGENT_DIR_ENV] = agentDir
+	delete process.env.HERDR_ENV
+	t.after(restoreEnv)
+	const { pi, registerCalls, emit } = createFake({ cwd })
+	install(pi)
+	t.after(() => emit("session_shutdown"))
+	await emit("session_start")
+	await emit("agent_start")
+	await emit("tool_execution_end", { toolCallId: "a" })
+	await emit("tool_execution_end", { toolCallId: "b" })
+	await emit("agent_end", { messages: [{ role: "assistant", stopReason: "stop" }] })
+	const appended = registerCalls.filter((c) => c.method === "appendEntry")
+	assert.equal(appended.length, 1)
+	assert.equal(appended[0].args[0], "pi-minimal.turn")
+	const data = appended[0].args[1] as { tools: number; outcome: string }
+	assert.equal(data.tools, 2)
+	assert.equal(data.outcome, "completed")
+	assert.ok(registerCalls.some((c) => c.method === "registerEntryRenderer" && c.args[0] === "pi-minimal.turn"))
+})

package/test/package.test.ts

@@ -5,12 +5,13 @@ import { readFileSync } from "node:fs"
 test("package manifest exposes the committed extension", () => {
 	const pkg = JSON.parse(readFileSync("package.json", "utf8"))
 	assert.equal(pkg.name, "pi-minimal")
-	assert.equal(pkg.version, "0.1.0")
+	assert.equal(pkg.version, "0.2.2")
 	assert.equal(pkg.license, "MIT")
 	assert.equal(pkg.type, "module")
 	assert.deepEqual(pkg.engines, { node: ">=22.19.0" })
 	assert.deepEqual(pkg.keywords, ["pi-package"])
-	assert.deepEqual(pkg.pi, { extensions: ["./dist/index.js"] })
+	assert.deepEqual(pkg.repository, { type: "git", url: "git+https://github.com/raviy06/pi-minimal.git" })
+	assert.deepEqual(pkg.pi, { extensions: ["./dist/index.js"], themes: ["./themes/minimal-dark.json"] })
 	assert.deepEqual(pkg.peerDependencies, {
 		"@earendil-works/pi-coding-agent": "*",
 		"@earendil-works/pi-tui": "*",

package/test/theme.test.ts

@@ -0,0 +1,45 @@
+import assert from "node:assert/strict"
+import { readFileSync } from "node:fs"
+import { dirname, join } from "node:path"
+import test from "node:test"
+
+function builtinDarkTheme(): { colors: Record<string, string> } {
+	const path = join("node_modules/@earendil-works/pi-coding-agent/dist/modes/interactive/theme/dark.json")
+	return JSON.parse(readFileSync(path, "utf8"))
+}
+
+const theme = JSON.parse(readFileSync("themes/minimal-dark.json", "utf8")) as {
+	name: string
+	appearance: string
+	vars: Record<string, string>
+	colors: Record<string, string>
+}
+
+test("minimal-dark is named after its file and targets dark terminals", () => {
+	assert.equal(theme.name, "minimal-dark")
+	assert.equal(theme.appearance, "dark")
+	assert.ok(dirname("themes/minimal-dark.json").endsWith("themes"))
+})
+
+test("minimal-dark defines every color role the built-in dark theme defines", () => {
+	const required = Object.keys(builtinDarkTheme().colors).sort()
+	const provided = Object.keys(theme.colors).sort()
+	assert.deepEqual(provided, required)
+})
+
+test("minimal-dark variable references resolve", () => {
+	const isLiteral = (v: string) => v === "" || v.startsWith("#") || v.startsWith("okhsl(") || v.startsWith("oklch(")
+	for (const [name, value] of Object.entries(theme.vars)) {
+		if (!isLiteral(value)) assert.ok(value in theme.vars, `var ${name} -> ${value}`)
+	}
+	for (const [role, value] of Object.entries(theme.colors)) {
+		if (!isLiteral(value)) assert.ok(value in theme.vars, `color ${role} -> ${value}`)
+	}
+})
+
+test("minimal-dark frames code quietly and neutralises tool backgrounds", () => {
+	assert.equal(theme.colors.mdCodeBlockBorder, "faint")
+	assert.equal(theme.colors.mdCodeBlock, "text")
+	assert.equal(theme.colors.toolSuccessBg, theme.colors.toolPendingBg)
+	assert.notEqual(theme.colors.mdHeading, theme.colors.warning)
+})

package/test/tool-rows.test.ts

@@ -0,0 +1,109 @@
+import assert from "node:assert/strict"
+import test from "node:test"
+import { visibleWidth } from "@earendil-works/pi-tui"
+import {
+	bashBody,
+	diffStats,
+	formatDuration,
+	formatOutcome,
+	layoutRow,
+	rowGlyph,
+	shortName,
+	toolItem,
+} from "../src/tool-rows.js"
+
+const text = (s: string) => ({ content: [{ type: "text", text: s }] })
+
+test("toolItem picks the first command line for bash and a two-segment path otherwise", () => {
+	assert.equal(toolItem("bash", { command: "git status\ngit diff" }), "git status")
+	assert.equal(toolItem("read", { path: "/a/b/c/file.ts" }), "c/file.ts")
+	assert.equal(toolItem("grep", { pattern: "foo" }), "foo")
+	assert.equal(toolItem("ls", {}), "ls")
+	assert.equal(shortName("file.ts"), "file.ts")
+})
+
+test("rowGlyph encodes status and blinks only while running", () => {
+	assert.equal(rowGlyph("running", 0), "◐")
+	assert.equal(rowGlyph("running", 1), "◓")
+	assert.equal(rowGlyph("ok", 1), "✓")
+	assert.equal(rowGlyph("error", 1), "✗")
+})
+
+test("formatDuration rounds to tenths and switches to minutes", () => {
+	assert.equal(formatDuration(undefined), "")
+	assert.equal(formatDuration(40), "0s")
+	assert.equal(formatDuration(1040), "1s")
+	assert.equal(formatDuration(1250), "1.3s")
+	assert.equal(formatDuration(65_000), "1m 5s")
+})
+
+test("bashBody strips the exit status trailer and truncation note", () => {
+	const { body, exitCode } = bashBody("hello\nworld\n\nCommand exited with code 2")
+	assert.equal(body, "hello\nworld")
+	assert.equal(exitCode, 2)
+	const ok = bashBody("x\n\n[Showing lines 1-3 of 9. Full output: /tmp/x]")
+	assert.equal(ok.body, "x")
+	assert.equal(ok.exitCode, undefined)
+})
+
+test("diffStats counts hunk lines and ignores file headers", () => {
+	assert.deepEqual(diffStats("--- a\n+++ b\n@@\n-x\n+y\n+z\n ctx"), { added: 2, removed: 1 })
+})
+
+test("formatOutcome: bash success shows line count and duration", () => {
+	const out = formatOutcome("bash", {}, text("a\nb\nc"), false, 1040)
+	assert.equal(out.text, "3 lines · 1s")
+	assert.equal(out.errorLine, undefined)
+})
+
+test("formatOutcome: bash with no output says ok", () => {
+	assert.equal(formatOutcome("bash", {}, text("(no output)"), false, 200).text, "ok · 0.2s")
+})
+
+test("formatOutcome: bash failure exposes exit code and first output line", () => {
+	const out = formatOutcome("bash", {}, text("boom: bad thing\nmore\n\nCommand exited with code 1"), true, 300)
+	assert.equal(out.text, "exit 1 · 0.3s")
+	assert.equal(out.errorLine, "boom: bad thing")
+})
+
+test("formatOutcome: bash failure with no output has no error line", () => {
+	const out = formatOutcome("bash", {}, text("(no output)\n\nCommand exited with code 1"), true, 10)
+	assert.equal(out.text, "exit 1 · 0s")
+	assert.equal(out.errorLine, undefined)
+})
+
+test("formatOutcome: edit reports diff stats, write reports bytes", () => {
+	const edit = formatOutcome("edit", {}, { content: [], details: { diff: "-a\n+b\n+c" } }, false, undefined)
+	assert.deepEqual(edit.diff, { added: 2, removed: 1 })
+	assert.equal(edit.text, "")
+	const write = formatOutcome("write", { content: "x".repeat(2048) }, text("ok"), false, undefined)
+	assert.equal(write.text, "2 KB")
+})
+
+test("formatOutcome: read, grep, find summaries", () => {
+	assert.equal(formatOutcome("read", {}, text("1\n2"), false, undefined).text, "2 lines")
+	assert.equal(formatOutcome("grep", {}, text("No matches found"), false, undefined).text, "0 matches")
+	assert.equal(formatOutcome("grep", {}, text("a:1:x"), false, undefined).text, "1 match")
+	assert.equal(formatOutcome("find", {}, text("a\nb\nc"), false, undefined).text, "3 entries")
+	assert.equal(formatOutcome("ls", {}, text("a"), false, undefined).text, "1 entry")
+})
+
+test("formatOutcome: generic error carries the first line", () => {
+	const out = formatOutcome("read", {}, text("ENOENT: no such file"), true, undefined)
+	assert.equal(out.text, "failed")
+	assert.equal(out.errorLine, "ENOENT: no such file")
+})
+
+test("layoutRow keeps the outcome visible by truncating the item", () => {
+	const row = layoutRow(40, "bash", "a very long command that goes on and on forever", "34 lines · 1.0s")
+	assert.equal(row.verb, "bash ")
+	assert.equal(row.outcome, "34 lines · 1.0s")
+	assert.ok(row.item.includes("…"))
+	assert.equal(2 + 5 + 1 + visibleWidth(row.item) + row.gap + row.outcome.length, 40)
+})
+
+test("layoutRow drops the outcome when the row is too narrow", () => {
+	const row = layoutRow(20, "bash", "short", "34 lines · 1.0s")
+	assert.equal(row.outcome, "")
+	assert.equal(row.gap, 0)
+})

package/test/tools.test.ts

@@ -1,48 +1,55 @@
 import assert from "node:assert/strict"
-import { mkdirSync, mkdtempSync, rmSync } from "node:fs"
-import { tmpdir } from "node:os"
-import { join } from "node:path"
-import test, { type TestContext } from "node:test"
-import {
-	SettingsManager,
-	type ExtensionAPI,
-	type ExtensionContext,
-} from "@earendil-works/pi-coding-agent"
-import { wrapBuiltinTools } from "../src/tools.js"
+import test from "node:test"
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent"
+import { compactRenderers, installToolRenderers, isToolKind } from "../src/tools.js"
 
-const AGENT_DIR_ENV = "PI_CODING_AGENT_DIR"
-const originalAgentDir = process.env[AGENT_DIR_ENV]
-
-function restoreEnv() {
-	if (originalAgentDir === undefined) delete process.env[AGENT_DIR_ENV]
-	else process.env[AGENT_DIR_ENV] = originalAgentDir
-}
-
-function setupDirs(t: TestContext) {
-	const root = mkdtempSync(join(tmpdir(), "pi-minimal-tools-"))
-	t.after(() => rmSync(root, { recursive: true, force: true }))
-	const agentDir = join(root, "agent")
-	const cwd = join(root, "project")
-	mkdirSync(agentDir)
-	mkdirSync(cwd)
-	return { agentDir, cwd }
-}
-
-test("untrusted project does not receive projectTrusted true", (t) => {
-	const { agentDir, cwd } = setupDirs(t)
-	process.env[AGENT_DIR_ENV] = agentDir
-	t.after(restoreEnv)
+test("isToolKind recognises the built-in tools only", () => {
+	for (const name of ["bash", "read", "edit", "write", "grep", "find", "ls"]) assert.equal(isToolKind(name), true)
+	assert.equal(isToolKind("codemode"), false)
+	assert.equal(isToolKind("mcp__foo"), false)
+})
 
-	const create = t.mock.method(SettingsManager, "create")
-	const pi = { registerTool() {} } as unknown as ExtensionAPI
-	const ctx = {
-		cwd,
-		isProjectTrusted: () => false,
-	} as unknown as ExtensionContext
+test("installToolRenderers registers a resolver at load time that only claims built-in tools", () => {
+	let resolver: ((name: string, next: () => unknown) => unknown) | undefined
+	const pi = {
+		registerToolRenderer(fn: typeof resolver) {
+			resolver = fn
+		},
+	} as unknown as ExtensionAPI
+	installToolRenderers(pi)
+	assert.ok(resolver, "resolver registered synchronously, before session_start")
+	const fallback = { renderShell: "default" }
+	assert.equal(resolver!("codemode", () => fallback), fallback)
+	const mine = resolver!("bash", () => fallback) as { renderShell?: string }
+	assert.equal(mine.renderShell, "self")
+	assert.equal(typeof (mine as { renderCall?: unknown }).renderCall, "function")
+})
 
-	wrapBuiltinTools(pi, ctx)
+test("installToolRenderers is a no-op on hosts without registerToolRenderer", () => {
+	assert.doesNotThrow(() => installToolRenderers({} as ExtensionAPI))
+})
 
-	assert.equal(create.mock.callCount(), 1)
-	const options = create.mock.calls[0].arguments[2] as { projectTrusted?: boolean } | undefined
-	assert.equal(options?.projectTrusted, false)
+test("compactRenderers render a one-line row with the outcome once the result lands", () => {
+	const renderers = compactRenderers("bash")
+	const theme = { fg: (_c: string, s: string) => s } as never
+	const state: Record<string, unknown> = {}
+	const context = {
+		args: { command: "ls" },
+		toolCallId: "t1",
+		invalidate() {},
+		state,
+		isPartial: false,
+		isError: false,
+		durationMs: 1200,
+	} as never
+	const result = renderers.renderResult!(
+		{ content: [{ type: "text", text: "a\nb" }] } as never,
+		{ expanded: false, isPartial: false } as never,
+		theme,
+		context,
+	)
+	assert.ok(result)
+	const row = renderers.renderCall!({ command: "ls" } as never, theme, context)
+	const [line] = row.render(60)
+	assert.match(line, /✓ bash\s+ls\s+2 lines · 1.2s$/)
 })