pi-minimal 0.1.0

package/src/working-status.ts

@@ -0,0 +1,214 @@
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent"
+
+export type WorkingPhase = "idle" | "thinking" | "tool" | "writing"
+
+export type WorkingSnapshot = {
+  phase: WorkingPhase
+  startedAt: number
+  now: number
+  thought?: string
+  tool?: string
+  toolCount?: number
+}
+
+type ToolArgs = {
+  command?: unknown
+  path?: unknown
+  file_path?: unknown
+  target_directory?: unknown
+  pattern?: unknown
+}
+
+type ContentPart = {
+  type?: string
+  thinking?: string
+  text?: string
+}
+
+const DETAIL_MAX = 120
+
+export function formatElapsed(ms: number): string {
+  const total = Math.max(0, Math.floor(ms / 1000))
+  const hours = Math.floor(total / 3600)
+  const minutes = Math.floor((total % 3600) / 60)
+  const seconds = total % 60
+  if (hours > 0) return `${hours}h ${minutes}m`
+  if (minutes > 0) return `${minutes}m ${seconds}s`
+  return `${seconds}s`
+}
+
+export function clipDetail(text: string, max = DETAIL_MAX): string {
+  const one = text.replace(/\s+/g, " ").trim()
+  if (one.length <= max) return one
+  if (max <= 1) return "…"
+  return `${one.slice(0, max - 1).trimEnd()}…`
+}
+
+export function lastThoughtLine(message: { content?: ContentPart[] } | undefined): string | undefined {
+  if (!Array.isArray(message?.content)) return undefined
+  let thinking = ""
+  for (const part of message.content) {
+    if (part?.type === "thinking" && typeof part.thinking === "string") {
+      thinking = part.thinking
+    }
+  }
+  const lines = thinking
+    .split("\n")
+    .map((line) => line.replace(/^[#>*\-\d.\s]+/, "").trim())
+    .filter((line) => line.length > 2)
+  if (lines.length === 0) return undefined
+  return clipDetail(lines.slice(-2).join(" · "))
+}
+
+export function summarizeTool(name: string, args: ToolArgs | undefined): string {
+  const path =
+    (typeof args?.path === "string" && args.path) ||
+    (typeof args?.file_path === "string" && args.file_path) ||
+    (typeof args?.target_directory === "string" && args.target_directory) ||
+    ""
+  const pattern = typeof args?.pattern === "string" ? args.pattern : ""
+  const command = typeof args?.command === "string" ? args.command.split("\n")[0]?.trim() ?? "" : ""
+  const base = path.split("/").filter(Boolean).slice(-2).join("/") || path
+
+  switch (name) {
+    case "bash":
+      return command ? `Running ${clipDetail(command, 56)}` : "Running"
+    case "read":
+      return base ? `Reading ${base}` : "Reading"
+    case "edit":
+      return base ? `Editing ${base}` : "Editing"
+    case "write":
+      return base ? `Writing ${base}` : "Writing"
+    case "grep":
+      return pattern ? `Grep ${clipDetail(pattern, 40)}` : "Grep"
+    case "find":
+      return pattern ? `Finding ${clipDetail(pattern, 40)}` : "Finding"
+    case "ls":
+      return base ? `Listing ${base}` : "Listing"
+    default:
+      return name || "Working"
+  }
+}
+
+export function formatWorkingMessage(snap: WorkingSnapshot): string {
+  const elapsed = formatElapsed(snap.now - snap.startedAt)
+  if (snap.phase === "tool" && snap.tool) {
+    const extra = snap.toolCount && snap.toolCount > 1 ? ` · ${snap.toolCount} tools` : ""
+    return `${snap.tool}${extra} · ${elapsed}`
+  }
+  if (snap.phase === "writing") return `Writing · ${elapsed}`
+  if (snap.thought) return `Thinking · ${snap.thought} · ${elapsed}`
+  return `Thinking · ${elapsed}`
+}
+
+export function installWorkingStatus(pi: ExtensionAPI): () => void {
+  let ctx: ExtensionContext | undefined
+  let startedAt = 0
+  let phase: WorkingPhase = "idle"
+  let thought: string | undefined
+  let lastMessage = ""
+  let timer: ReturnType<typeof setInterval> | undefined
+  const tools = new Map<string, string>()
+
+  const stop = () => {
+    if (timer) clearInterval(timer)
+    timer = undefined
+    startedAt = 0
+    phase = "idle"
+    thought = undefined
+    lastMessage = ""
+    tools.clear()
+    if (ctx?.mode === "tui") ctx.ui.setWorkingMessage()
+  }
+
+  const paint = (now = Date.now()) => {
+    if (!ctx || ctx.mode !== "tui" || phase === "idle") return
+    const next = formatWorkingMessage({
+      phase,
+      startedAt,
+      now,
+      thought,
+      tool: [...tools.values()].at(-1),
+      toolCount: tools.size,
+    })
+    if (next === lastMessage) return
+    lastMessage = next
+    ctx.ui.setWorkingMessage(next)
+  }
+
+  const startClock = () => {
+    if (!startedAt) startedAt = Date.now()
+    if (!timer) timer = setInterval(() => paint(), 1000)
+  }
+
+  pi.on("session_start", (_event, next) => {
+    if (next.mode !== "tui") return
+    ctx = next
+  })
+
+  pi.on("agent_start", () => {
+    if (!ctx || ctx.mode !== "tui") return
+    if (phase === "idle") {
+      tools.clear()
+      thought = undefined
+      lastMessage = ""
+      startedAt = Date.now()
+    }
+    if (tools.size === 0) phase = "thinking"
+    startClock()
+    paint()
+  })
+
+  pi.on("turn_start", () => {
+    if (phase === "idle") return
+    if (tools.size === 0) phase = "thinking"
+    startClock()
+    paint()
+  })
+
+  pi.on("message_update", (event) => {
+    if (phase === "idle") return
+    const ev = event as {
+      message?: { role?: string; content?: ContentPart[] }
+      assistantMessageEvent?: { type?: string }
+    }
+    if (ev.message?.role && ev.message.role !== "assistant") return
+    const kind = ev.assistantMessageEvent?.type
+    const nextThought = lastThoughtLine(ev.message)
+    if (nextThought) thought = nextThought
+    if (kind === "text_start" || kind === "text_delta" || kind === "text_end") {
+      if (tools.size === 0) phase = "writing"
+    } else if (tools.size === 0) {
+      phase = "thinking"
+    }
+    paint()
+  })
+
+  pi.on("tool_execution_start", (event) => {
+    if (phase === "idle") return
+    const ev = event as { toolCallId?: string; toolName?: string; args?: ToolArgs }
+    const id = ev.toolCallId || `${ev.toolName}-${tools.size}`
+    tools.set(id, summarizeTool(ev.toolName || "tool", ev.args))
+    phase = "tool"
+    paint()
+  })
+
+  pi.on("tool_execution_end", (event) => {
+    if (phase === "idle") return
+    const ev = event as { toolCallId?: string }
+    if (ev.toolCallId) tools.delete(ev.toolCallId)
+    phase = tools.size > 0 ? "tool" : "thinking"
+    paint()
+  })
+
+  pi.on("agent_settled", () => {
+    stop()
+  })
+
+  pi.on("session_shutdown", () => {
+    ctx = undefined
+    stop()
+  })
+
+  return stop
+}

package/test/activity.test.ts

@@ -0,0 +1,27 @@
+import assert from "node:assert/strict"
+import test from "node:test"
+import { activityBullet, rowIsRunning } from "../src/activity.js"
+
+test("rowIsRunning is false when isPartial is false", () => {
+	assert.equal(rowIsRunning({ isPartial: false }), false)
+})
+
+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), "◇")
+})

package/test/config.test.ts

@@ -0,0 +1,114 @@
+import assert from "node:assert/strict"
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+import test, { type TestContext } from "node:test"
+import { CONFIG_DIR_NAME } from "@earendil-works/pi-coding-agent"
+import { loadPiMinimalConfig } from "../src/config.js"
+
+function setup(t: TestContext) {
+	const root = mkdtempSync(join(tmpdir(), "pi-minimal-config-"))
+	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 }
+}
+
+function writeGlobal(agentDir: string, contents: string) {
+	writeFileSync(join(agentDir, "pi-minimal.json"), contents)
+}
+
+function writeProject(cwd: string, contents: string) {
+	const dir = join(cwd, CONFIG_DIR_NAME)
+	mkdirSync(dir, { recursive: true })
+	writeFileSync(join(dir, "pi-minimal.json"), contents)
+}
+
+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.equal(error.mock.callCount(), 0)
+})
+
+test("global false overrides default", (t) => {
+	const { agentDir, cwd } = setup(t)
+	writeGlobal(agentDir, JSON.stringify({ hideGauntletWidgets: false }))
+	const error = t.mock.method(console, "error")
+	const config = loadPiMinimalConfig({ agentDir, cwd, projectTrusted: false })
+	assert.deepEqual(config, { hideGauntletWidgets: false })
+	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 }))
+	const error = t.mock.method(console, "error")
+	const config = loadPiMinimalConfig({ agentDir, cwd, projectTrusted: true })
+	assert.deepEqual(config, { hideGauntletWidgets: true })
+	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 }))
+	const error = t.mock.method(console, "error")
+	const config = loadPiMinimalConfig({ agentDir, cwd, projectTrusted: false })
+	assert.deepEqual(config, { hideGauntletWidgets: true })
+	assert.equal(error.mock.callCount(), 0)
+})
+
+test("omitted keys do not override", (t) => {
+	const { agentDir, cwd } = setup(t)
+	writeGlobal(agentDir, JSON.stringify({ hideGauntletWidgets: false }))
+	writeProject(cwd, JSON.stringify({}))
+	const error = t.mock.method(console, "error")
+	const config = loadPiMinimalConfig({ agentDir, cwd, projectTrusted: true })
+	assert.deepEqual(config, { hideGauntletWidgets: false })
+	assert.equal(error.mock.callCount(), 0)
+})
+
+test("unknown keys do not override", (t) => {
+	const { agentDir, cwd } = setup(t)
+	writeGlobal(agentDir, JSON.stringify({ hideGauntletWidgets: false }))
+	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.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 }))
+	writeProject(cwd, "{")
+	const error = t.mock.method(console, "error")
+	const config = loadPiMinimalConfig({ agentDir, cwd, projectTrusted: true })
+	assert.deepEqual(config, { hideGauntletWidgets: false })
+	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 }))
+	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.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 }))
+	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.ok(error.mock.callCount() >= 1)
+})

package/test/index.test.ts

@@ -0,0 +1,262 @@
+import assert from "node:assert/strict"
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } 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 install from "../src/index.js"
+
+type Call = { method: string; args: unknown[] }
+type SessionMode = "tui" | "rpc" | "json" | "print"
+
+const AGENT_DIR_ENV = "PI_CODING_AGENT_DIR"
+const originalHerdrEnv = process.env.HERDR_ENV
+const originalAgentDir = process.env[AGENT_DIR_ENV]
+
+function restoreEnv() {
+	if (originalHerdrEnv === undefined) delete process.env.HERDR_ENV
+	else process.env.HERDR_ENV = originalHerdrEnv
+	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-session-"))
+	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 }
+}
+
+function createFake(options: {
+	mode?: SessionMode
+	cwd: string
+	projectTrusted?: boolean
+}) {
+	const handlers = new Map<string, Array<(event: unknown, ctx: ExtensionContext) => unknown>>()
+	const uiCalls: Call[] = []
+	const execCalls: Call[] = []
+	const registerCalls: Call[] = []
+	const allCalls: Call[] = []
+
+	const record = (target: Call[], method: string, args: unknown[]) => {
+		const call = { method, args }
+		target.push(call)
+		allCalls.push(call)
+	}
+
+	const ui = {
+		setHeader: (...args: unknown[]) => record(uiCalls, "setHeader", args),
+		setFooter: (...args: unknown[]) => record(uiCalls, "setFooter", args),
+		setWidget: (...args: unknown[]) => record(uiCalls, "setWidget", args),
+		setHiddenThinkingLabel: (...args: unknown[]) => record(uiCalls, "setHiddenThinkingLabel", args),
+		setWorkingIndicator: (...args: unknown[]) => record(uiCalls, "setWorkingIndicator", args),
+		setWorkingMessage: (...args: unknown[]) => record(uiCalls, "setWorkingMessage", args),
+		setEditorComponent: (...args: unknown[]) => record(uiCalls, "setEditorComponent", args),
+		setHideThinkingBlock: (...args: unknown[]) => record(uiCalls, "setHideThinkingBlock", args),
+	}
+
+	const ctx = {
+		mode: options.mode ?? "tui",
+		cwd: options.cwd,
+		isProjectTrusted: () => options.projectTrusted ?? false,
+		sessionManager: { getBranch: () => [] },
+		ui,
+	} as unknown as ExtensionContext
+
+	const pi = {
+		on(event: string, handler: (event: unknown, ctx: ExtensionContext) => unknown) {
+			const list = handlers.get(event) ?? []
+			list.push(handler)
+			handlers.set(event, list)
+			return () => {}
+		},
+		async exec(command: string, args: string[]) {
+			record(execCalls, "exec", [command, args])
+			if (command === "herdr" && args[0] === "agent") {
+				return { stdout: JSON.stringify({ result: { agents: [] } }), stderr: "", code: 0, killed: false }
+			}
+			if (command === "herdr" && args[0] === "tab") {
+				return { stdout: JSON.stringify({ result: { tabs: [] } }), stderr: "", code: 0, killed: false }
+			}
+			return { stdout: "", stderr: "", code: 1, killed: false }
+		},
+		registerTool(...args: unknown[]) {
+			record(registerCalls, "registerTool", args)
+		},
+	} as unknown as ExtensionAPI
+
+	const emit = async (event: string, payload: unknown = {}) => {
+		for (const handler of handlers.get(event) ?? []) {
+			await handler(payload, ctx)
+		}
+	}
+
+	return { pi, ctx, uiCalls, execCalls, registerCalls, allCalls, emit }
+}
+
+function widgetCalls(uiCalls: Call[], key: string): Call[] {
+	return uiCalls.filter((call) => call.method === "setWidget" && call.args[0] === key)
+}
+
+function herdrProbes(execCalls: Call[]): Call[] {
+	return execCalls.filter(
+		(call) => call.method === "exec" && call.args[0] === "herdr" && Array.isArray(call.args[1]) && call.args[1][0] === "agent",
+	)
+}
+
+test.describe("session chrome", { concurrency: 1 }, () => {
+	test("TUI session_start installs chrome and hides Gauntlet widgets by default", async (t) => {
+		const { agentDir, cwd } = setupDirs(t)
+		process.env[AGENT_DIR_ENV] = agentDir
+		delete process.env.HERDR_ENV
+		t.after(restoreEnv)
+
+		const hideThinking = t.mock.method(SettingsManager.prototype, "setHideThinkingBlock")
+		const { pi, uiCalls, execCalls, allCalls, emit } = createFake({ cwd })
+		install(pi)
+		t.after(() => emit("session_shutdown"))
+		await emit("session_start")
+
+		assert.ok(
+			uiCalls.some((call) => call.method === "setHiddenThinkingLabel" && call.args.length === 1 && call.args[0] === "◆ Thought"),
+		)
+		assert.ok(uiCalls.some((call) => call.method === "setWorkingIndicator" && call.args.length === 0))
+		assert.ok(uiCalls.some((call) => call.method === "setHeader" && typeof call.args[0] === "function"))
+		assert.ok(uiCalls.some((call) => call.method === "setFooter" && typeof call.args[0] === "function"))
+		assert.ok(
+			widgetCalls(uiCalls, "tw-cwd").some(
+				(call) => typeof call.args[1] === "function" || (call.args[1] !== undefined && call.args[1] !== null),
+			),
+		)
+		assert.ok(widgetCalls(uiCalls, "phase_tracker").some((call) => call.args[1] === undefined))
+		assert.ok(widgetCalls(uiCalls, "plan_tracker").some((call) => call.args[1] === undefined))
+		assert.equal(
+			allCalls.some((call) => call.method === "setHideThinkingBlock"),
+			false,
+		)
+		assert.equal(hideThinking.mock.callCount(), 0)
+		assert.equal(
+			execCalls.filter((call) => call.args[0] === "herdr").length,
+			0,
+		)
+	})
+
+	test("TUI session_start installs chrome and wraps tools before the first reclaim", async (t) => {
+		const { agentDir, cwd } = setupDirs(t)
+		process.env[AGENT_DIR_ENV] = agentDir
+		delete process.env.HERDR_ENV
+		t.after(restoreEnv)
+
+		const { pi, allCalls, emit } = createFake({ cwd })
+		install(pi)
+		t.after(() => emit("session_shutdown"))
+		await emit("session_start")
+
+		const firstHeader = allCalls.findIndex((call) => call.method === "setHeader")
+		const firstFooter = allCalls.findIndex((call) => call.method === "setFooter")
+		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 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(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")
+	})
+
+	test("does not clear Gauntlet widgets when config disables hiding", async (t) => {
+		const { agentDir, cwd } = setupDirs(t)
+		writeFileSync(join(agentDir, "pi-minimal.json"), JSON.stringify({ hideGauntletWidgets: false }))
+		process.env[AGENT_DIR_ENV] = agentDir
+		delete process.env.HERDR_ENV
+		t.after(restoreEnv)
+
+		const { pi, uiCalls, emit } = createFake({ cwd, projectTrusted: true })
+		install(pi)
+		t.after(() => emit("session_shutdown"))
+		await emit("session_start")
+
+		assert.equal(widgetCalls(uiCalls, "phase_tracker").length, 0)
+		assert.equal(widgetCalls(uiCalls, "plan_tracker").length, 0)
+		assert.ok(uiCalls.some((call) => call.method === "setHeader" && typeof call.args[0] === "function"))
+		assert.ok(uiCalls.some((call) => call.method === "setFooter" && typeof call.args[0] === "function"))
+		assert.ok(widgetCalls(uiCalls, "tw-cwd").length > 0)
+	})
+
+	test("does not execute herdr when HERDR_ENV is unset", async (t) => {
+		const { agentDir, cwd } = setupDirs(t)
+		process.env[AGENT_DIR_ENV] = agentDir
+		delete process.env.HERDR_ENV
+		t.after(restoreEnv)
+
+		const { pi, execCalls, emit } = createFake({ cwd })
+		install(pi)
+		t.after(() => emit("session_shutdown"))
+		await emit("session_start")
+
+		assert.equal(
+			execCalls.filter((call) => call.args[0] === "herdr").length,
+			0,
+		)
+		assert.equal(herdrProbes(execCalls).length, 0)
+	})
+
+	test("probes herdr once when HERDR_ENV is 1", async (t) => {
+		const { agentDir, cwd } = setupDirs(t)
+		process.env[AGENT_DIR_ENV] = agentDir
+		process.env.HERDR_ENV = "1"
+		t.after(restoreEnv)
+
+		const { pi, execCalls, emit } = createFake({ cwd })
+		install(pi)
+		t.after(() => emit("session_shutdown"))
+		await emit("session_start")
+
+		assert.equal(herdrProbes(execCalls).length, 1)
+	})
+
+	test("non-TUI modes install no TUI components", async (t) => {
+		const { agentDir, cwd } = setupDirs(t)
+		process.env[AGENT_DIR_ENV] = agentDir
+		delete process.env.HERDR_ENV
+		t.after(restoreEnv)
+
+		const { pi, uiCalls, execCalls, emit } = createFake({ cwd, mode: "print" })
+		install(pi)
+		t.after(() => emit("session_shutdown"))
+		await emit("session_start")
+		await emit("agent_start")
+		await emit("agent_settled")
+
+		assert.equal(
+			uiCalls.filter((call) => ["setHeader", "setFooter", "setWidget"].includes(call.method)).length,
+			0,
+		)
+		assert.equal(
+			uiCalls.filter((call) => call.method === "setHiddenThinkingLabel" || call.method === "setWorkingIndicator").length,
+			0,
+		)
+		assert.equal(
+			uiCalls.filter((call) => call.method === "setWorkingMessage").length,
+			0,
+		)
+		assert.equal(
+			execCalls.filter((call) => call.args[0] === "herdr").length,
+			0,
+		)
+	})
+})

package/test/package.test.ts

@@ -0,0 +1,18 @@
+import assert from "node:assert/strict"
+import test from "node:test"
+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.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.peerDependencies, {
+		"@earendil-works/pi-coding-agent": "*",
+		"@earendil-works/pi-tui": "*",
+	})
+})

package/test/tools.test.ts

@@ -0,0 +1,48 @@
+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"
+
+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)
+
+	const create = t.mock.method(SettingsManager, "create")
+	const pi = { registerTool() {} } as unknown as ExtensionAPI
+	const ctx = {
+		cwd,
+		isProjectTrusted: () => false,
+	} as unknown as ExtensionContext
+
+	wrapBuiltinTools(pi, ctx)
+
+	assert.equal(create.mock.callCount(), 1)
+	const options = create.mock.calls[0].arguments[2] as { projectTrusted?: boolean } | undefined
+	assert.equal(options?.projectTrusted, false)
+})