pi-minimal 0.3.1 → 0.5.0

package/src/tracker.ts

@@ -3,18 +3,24 @@ import type { ExtensionContext } from "@earendil-works/pi-coding-agent"
 const PHASES = ["brainstorm", "plan", "implement", "verify", "ship"] as const
 type PhaseName = (typeof PHASES)[number]
 type PhaseStatus = "pending" | "in_progress" | "complete" | "skipped"
-type TaskStatus = "pending" | "in_progress" | "complete" | "failed"
+/** pi-gauntlet's task statuses; distinct from the footer contribution API's `ActivityTask.status`. */
+type GauntletTaskStatus = "pending" | "in_progress" | "complete" | "failed"
 
 type PhaseMap = Record<PhaseName, { status: PhaseStatus; substep?: string | null }>
 
-type Task = { name: string; status: TaskStatus }
+type Task = { name: string; status: GauntletTaskStatus }
 
-export type TrackerSnapshot = {
+/**
+ * What pi-gauntlet last reported on this session branch, read from its `phase_tracker` and
+ * `plan_tracker` tool results. A projection of another extension's history, not a contribution:
+ * nothing is registered or versioned, so it is only as stable as those tools' `details` shapes.
+ */
+export type GauntletProjection = {
   phases?: PhaseMap
   tasks?: Task[]
 }
 
-function readSnapshot(ctx: ExtensionContext): TrackerSnapshot {
+export function readGauntletProjection(ctx: ExtensionContext): GauntletProjection {
   let phases: PhaseMap | undefined
   let tasks: Task[] | undefined
   for (const entry of ctx.sessionManager.getBranch()) {
@@ -47,7 +53,7 @@ export function formatTrackerLines(
   ctx: ExtensionContext,
   theme: { fg: (name: string, s: string) => string },
 ): string[] {
-  const { phases, tasks } = readSnapshot(ctx)
+  const { phases, tasks } = readGauntletProjection(ctx)
   const lines: string[] = []
   if (phases && phaseActive(phases)) {
     const parts = PHASES.map((p) => {

package/src/working-status.ts

@@ -206,8 +206,9 @@ export function installWorkingStatus(pi: ExtensionAPI): () => void {
   })
 
   pi.on("session_shutdown", () => {
-    ctx = undefined
+    // Clear the message while ctx is still known; dropping ctx first left it on screen.
     stop()
+    ctx = undefined
   })
 
   return stop

package/test/config.test.ts

@@ -26,89 +26,110 @@ function writeProject(cwd: string, contents: string) {
 	writeFileSync(join(dir, "pi-minimal.json"), contents)
 }
 
-test("defaults hideGauntletWidgets to true", (t) => {
+test("defaults hideGauntletWidgets to false", (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: false, 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/footer-contribution-events.test.ts

@@ -65,3 +65,18 @@ test("shutdown removes listeners, invalidates handles and emits unavailable once
   assert.equal(fresh.result, undefined)
   assert.deepEqual(handle.publish({}), { ok: false, code: "disposed" })
 })
+
+test("the plan slot accepts both its name and the legacy alias, and advertises all three", () => {
+  const events = bus(), registry = createFooterContributions()
+  let ready: { slots: string[] } | undefined
+  events.on(FOOTER_EVENTS.ready, (value) => { ready = value as { slots: string[] } })
+  bindFooterContributionEvents(events, registry, "S1", "tui")
+  assert.ok(ready)
+  assert.deepEqual(ready!.slots, ["activity", "plan", "summary"])
+  const viaPlan: RegisterRequest = { ...request(), slot: "plan", owner: "a" }
+  events.emit(FOOTER_EVENTS.register, viaPlan)
+  assert.ok(viaPlan.result?.ok)
+  const viaSummary: RegisterRequest = { ...request(), slot: "summary", owner: "b" }
+  events.emit(FOOTER_EVENTS.register, viaSummary)
+  assert.deepEqual(viaSummary.result, { ok: false, code: "occupied" }, "both names address the same slot")
+})

package/test/git-state.test.ts

@@ -50,3 +50,38 @@ test("createGitState clears state outside a repository", async () => {
 	await git.refresh(true)
 	assert.equal(git.get(), undefined)
 })
+
+test("createGitState reads cwd once per refresh, drops results after dispose, and isolates listener errors", async () => {
+	const cwds: string[] = []
+	let resolveStatus!: (value: unknown) => void
+	const pi = {
+		async exec(_cmd: string, args: string[], opts: { cwd: string }) {
+			cwds.push(opts.cwd)
+			if (args[0] === "rev-parse") return { stdout: "main\n", stderr: "", code: 0, killed: false }
+			return new Promise(resolve => { resolveStatus = resolve })
+		},
+	} as unknown as ExtensionAPI
+	let dir = "/a"
+	const git = createGitState(pi, () => dir)
+	let notified = 0
+	git.onChange(() => { throw new Error("boom") })
+	git.onChange(() => { notified++ })
+	const pending = git.refresh(true)
+	await new Promise(resolve => setImmediate(resolve))
+	dir = "/b"
+	resolveStatus({ stdout: " M x\n", stderr: "", code: 0, killed: false })
+	await pending
+	assert.deepEqual(cwds, ["/a", "/a"], "both commands use the directory read at refresh start")
+	assert.deepEqual(git.get(), { branch: "main", dirty: 1 })
+	assert.equal(notified, 1, "a throwing listener does not block the next one")
+
+	const late = git.refresh(true)
+	await new Promise(resolve => setImmediate(resolve))
+	git.dispose()
+	resolveStatus({ stdout: "", stderr: "", code: 0, killed: false })
+	await late
+	assert.deepEqual(git.get(), { branch: "main", dirty: 1 }, "a result landing after dispose is ignored")
+	assert.equal(notified, 1)
+	await git.refresh(true)
+	assert.deepEqual(cwds.length, 4, "no new commands after dispose")
+})

package/test/index.test.ts

@@ -132,7 +132,7 @@ function herdrProbes(execCalls: Call[]): Call[] {
 }
 
 test.describe("session chrome", { concurrency: 1 }, () => {
-	test("TUI session_start installs chrome and hides Gauntlet widgets by default", async (t) => {
+	test("TUI session_start installs chrome and leaves Gauntlet widgets alone by default", async (t) => {
 		const { agentDir, cwd } = setupDirs(t)
 		process.env[AGENT_DIR_ENV] = agentDir
 		delete process.env.HERDR_ENV
@@ -155,8 +155,8 @@ test.describe("session chrome", { concurrency: 1 }, () => {
 				(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(widgetCalls(uiCalls, "phase_tracker").length, 0)
+		assert.equal(widgetCalls(uiCalls, "plan_tracker").length, 0)
 		assert.equal(
 			allCalls.some((call) => call.method === "setHideThinkingBlock"),
 			false,
@@ -200,6 +200,26 @@ test.describe("session chrome", { concurrency: 1 }, () => {
 		assert.equal(allCalls.some((call) => call.method === "registerTool"), false, "built-in tools are not re-registered")
 	})
 
+	test("clears Gauntlet widgets on every chrome reassertion when hiding is opted in, and never on a timer", async (t) => {
+		const { agentDir, cwd } = setupDirs(t)
+		writeFileSync(join(agentDir, "pi-minimal.json"), JSON.stringify({ hideGauntletWidgets: true }))
+		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")
+		await new Promise(resolve => setTimeout(resolve, 60))
+		const afterSettle = widgetCalls(uiCalls, "phase_tracker").length
+		assert.ok(afterSettle >= 1, "hidden at session_start")
+		await new Promise(resolve => setTimeout(resolve, 450))
+		assert.equal(widgetCalls(uiCalls, "phase_tracker").length, afterSettle, "no steal interval")
+		await emit("turn_end")
+		assert.equal(widgetCalls(uiCalls, "phase_tracker").length, afterSettle + 1, "hidden again on turn_end")
+	})
+
 	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 }))
@@ -329,3 +349,25 @@ test("agent_end appends a turn summary entry in TUI mode", async (t) => {
 	assert.equal(data.outcome, "completed")
 	assert.ok(registerCalls.some((c) => c.method === "registerEntryRenderer" && c.args[0] === "pi-minimal.turn"))
 })
+
+test("a second session_start disposes the first session's chrome and the stale one cannot draw", async (t) => {
+	const { agentDir, cwd } = setupDirs(t)
+	process.env[AGENT_DIR_ENV] = agentDir
+	delete process.env.HERDR_ENV
+	t.after(restoreEnv)
+	const { pi, emit, events, uiCalls } = createFake({ cwd })
+	install(pi)
+	t.after(() => emit("session_shutdown"))
+	await emit("session_start")
+	const first: RegisterRequest = { version: 1, owner: "a", sessionId: "S1", slot: "activity" }
+	events.emit(FOOTER_EVENTS.register, first)
+	assert.ok(first.result?.ok)
+	await emit("session_start")
+	assert.equal(first.result.registration.publish({ revision: 1, rows: [], omitted: 0, motion: "static", format: "icons" }).ok, false, "old registration is revoked")
+	const second: RegisterRequest = { version: 1, owner: "a", sessionId: "S1", slot: "activity" }
+	events.emit(FOOTER_EVENTS.register, second)
+	assert.ok(second.result?.ok, "the new session accepts a fresh registration")
+	const count = uiCalls.length
+	await new Promise(resolve => setTimeout(resolve, 70))
+	assert.ok(uiCalls.length >= count, "settle callbacks of the live session still run")
+})

package/test/tools.test.ts

@@ -10,6 +10,7 @@ import {
 	genericVerb,
 	installToolRenderers,
 	isToolKind,
+	setEditDiffMode,
 	stopLiveWatch,
 } from "../src/tools.js"
 
@@ -176,3 +177,100 @@ 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())
+}
+
+const longDiff = (n: number) => ({ content: [{ type: "text", text: "ok" }], details: { diff: Array.from({ length: n }, (_, i) => `+${i + 1} line ${i}`).join("\n") } })
+
+test("editDiff=expanded (default) shows small diffs inline and larger ones only behind ctrl+o", (t) => {
+	t.after(() => setEditDiffMode("expanded"))
+	setEditDiffMode("expanded")
+	assert.equal(editRows(false).length, 4, "a 4-line diff is shown without ctrl+o")
+	assert.equal(editRows(false, longDiff(8)).length, 8, "8 lines is still small")
+	assert.deepEqual(editRows(false, longDiff(9)), [], "9 lines waits for ctrl+o")
+	assert.equal(editRows(true, longDiff(9)).length, 9)
+	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 = longDiff(60)
+	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>")))
+})
+
+test("write rows show the written content on ctrl+o and nothing when collapsed", () => {
+	const renderers = compactRenderers("write")
+	const content = Array.from({ length: 450 }, (_, i) => `line ${i}`).join("\n")
+	const context = { args: { path: "a.ts", content }, toolCallId: "w1", invalidate() {}, state: {}, isPartial: false, isError: false, durationMs: 100 } as never
+	const result = { content: [{ type: "text", text: "Successfully wrote to a.ts" }] } as never
+	const collapsed = renderers.renderResult!(result, { expanded: false } as never, plainTheme, context).render(80)
+	assert.deepEqual(collapsed, [])
+	const expanded = renderers.renderResult!(result, { expanded: true } as never, plainTheme, context).render(80).map((l) => l.trimEnd())
+	assert.equal(expanded.length, 401)
+	assert.match(expanded[0]!, /│ line 0$/)
+	assert.match(expanded[400]!, /… 50 more lines$/)
+	const failed = { args: { path: "a.ts", content }, toolCallId: "w2", invalidate() {}, state: {}, isPartial: false, isError: true, durationMs: 100 } as never
+	const err = renderers.renderResult!({ content: [{ type: "text", text: "EACCES" }] } as never, { expanded: true } as never, plainTheme, failed).render(80)
+	assert.ok(err.every((l) => !l.includes("line 0")), "a failed write shows its error, not the content")
+})
+
+test("createRowRenderers keeps one live key per row across call and result", () => {
+	const renderers = compactRenderers("bash")
+	const state: Record<string, unknown> = {}
+	const call = { args: { command: "sleep 1" }, invalidate() {}, state, isPartial: true }
+	renderers.renderCall!({ command: "sleep 1" } as never, plainTheme, call as never)
+	assert.equal(state.liveId, "bash:sleep 1")
+	renderers.renderResult!({ content: [{ type: "text", text: "" }] } as never, { expanded: false } as never, plainTheme, { ...call, isPartial: false } as never)
+	assert.equal(state.liveId, "bash:sleep 1")
+	assert.equal((state as { running?: boolean }).running, false)
+	stopLiveWatch()
+})

package/test/working-status.test.ts

@@ -0,0 +1,53 @@
+import assert from "node:assert/strict"
+import test from "node:test"
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent"
+import { installWorkingStatus } from "../src/working-status.js"
+
+function fixture() {
+	const handlers = new Map<string, (event: unknown, ctx: ExtensionContext) => void>()
+	const messages: Array<string | undefined> = []
+	const ctx = { mode: "tui", ui: { setWorkingMessage: (text?: string) => { messages.push(text) } } } as unknown as ExtensionContext
+	const pi = { on: (name: string, handler: (event: unknown, ctx: ExtensionContext) => void) => { handlers.set(name, handler) } } as unknown as ExtensionAPI
+	const stop = installWorkingStatus(pi)
+	const emit = (name: string, event: unknown = {}) => handlers.get(name)!(event, ctx)
+	return { emit, messages, stop }
+}
+
+test("working status walks thinking → tool → thinking → writing and clears when the agent settles", (t) => {
+	t.mock.timers.enable({ apis: ["setInterval", "Date"] })
+	const f = fixture()
+	f.emit("session_start")
+	f.emit("agent_start")
+	assert.match(f.messages.at(-1)!, /^Thinking · /)
+	f.emit("tool_execution_start", { toolCallId: "t1", toolName: "bash", args: { command: "ls -la" } })
+	assert.match(f.messages.at(-1)!, /^Running ls -la/)
+	f.emit("tool_execution_end", { toolCallId: "t1" })
+	assert.match(f.messages.at(-1)!, /^Thinking · /)
+	f.emit("message_update", { message: { role: "assistant", content: [] }, assistantMessageEvent: { type: "text_delta" } })
+	assert.match(f.messages.at(-1)!, /^Writing/)
+	f.emit("agent_settled")
+	assert.equal(f.messages.at(-1), undefined, "settling clears the message")
+	f.stop()
+})
+
+test("events before session_start or after settle are ignored", () => {
+	const f = fixture()
+	f.emit("agent_start")
+	assert.deepEqual(f.messages, [])
+	f.emit("session_start")
+	f.emit("tool_execution_start", { toolCallId: "x", toolName: "read" })
+	assert.deepEqual(f.messages, [], "a tool without an active run does not paint")
+	f.stop()
+})
+
+test("session_shutdown clears the working message while the context is still known", (t) => {
+	t.mock.timers.enable({ apis: ["setInterval", "Date"] })
+	const f = fixture()
+	f.emit("session_start")
+	f.emit("agent_start")
+	assert.ok(f.messages.at(-1))
+	f.emit("session_shutdown")
+	assert.equal(f.messages.at(-1), undefined, "shutdown must call setWorkingMessage() to clear")
+	f.emit("agent_start")
+	assert.equal(f.messages.at(-1), undefined, "no painting after shutdown dropped the context")
+})