pi-minimal 0.4.0 → 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,11 +26,11 @@ 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, editDiff: "expanded" })
+	assert.deepEqual(config, { hideGauntletWidgets: false, editDiff: "expanded" })
 	assert.equal(error.mock.callCount(), 0)
 })
 

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

@@ -192,10 +192,15 @@ function editRows(expanded: boolean, result: unknown = editResult, isError = fal
 	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) => {
+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.deepEqual(editRows(false), [])
+	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$/)
@@ -227,7 +232,7 @@ test("editDiff=always shows the diff inline and editDiff=never only on request f
 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 long = longDiff(60)
 	const inline = editRows(false, long)
 	assert.equal(inline.length, 41)
 	assert.match(inline[40]!, /… 20 more lines \(ctrl\+o\)$/)
@@ -241,3 +246,31 @@ test("edit failures and results without a diff never render a diff block", (t) =
 	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")
+})