pi-minimal 0.4.0 → 0.6.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/background.test.ts

@@ -0,0 +1,198 @@
+import assert from "node:assert/strict"
+import test from "node:test"
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent"
+import {
+	applyPoll,
+	createBackgroundState,
+	createBackgroundTracker,
+	findOrphanGroups,
+	parseEtime,
+	parsePs,
+	PS_ARGS,
+	snapshot,
+} from "../src/background.js"
+import { backgroundRows, backgroundSegment, renderBackgroundLines } from "../src/background-overlay.js"
+
+// `ps -ax -o pid=,ppid=,pgid=,etime=,command=` as macOS prints it (right-aligned numbers).
+const PI = 76737
+const SHELL = 81443
+const psBefore = `
+ ${PI} 78317 ${PI}    04:11 pi
+ 81000     1 81000 01-02:03:04 /usr/libexec/trustd --agent
+`
+const psDuring = `${psBefore}
+ ${SHELL} ${PI} ${SHELL}    00:00 /bin/bash -c (./watch.sh &); sleep 0.3
+`
+const psAfter = `${psBefore}
+ 81446     1 ${SHELL}    00:01 /bin/bash ./watch.sh
+ 81450     1 ${SHELL}    00:01 node server.js
+ 81460     1 81460    00:00 /usr/libexec/other-daemon
+`
+
+test.describe("ps parsing", () => {
+	test("parseEtime handles every format", () => {
+		assert.equal(parseEtime("05"), 5)
+		assert.equal(parseEtime("04:11"), 251)
+		assert.equal(parseEtime("01:02:03"), 3723)
+		assert.equal(parseEtime("01-02:03:04"), 86400 + 7384)
+		assert.equal(parseEtime("garbage"), 0)
+	})
+
+	test("parsePs reads pid, ppid, pgid, etime and the full command", () => {
+		const entries = parsePs(psAfter)
+		assert.deepEqual(entries.get(81446), { pid: 81446, ppid: 1, pgid: SHELL, elapsedSec: 1, command: "/bin/bash ./watch.sh" })
+		assert.equal(entries.get(81000)?.elapsedSec, 86400 + 7384)
+		assert.equal(entries.size, 5)
+	})
+})
+
+test.describe("findOrphanGroups", () => {
+	test("finds the dead tool shell's group and ignores unrelated orphans and pre-existing groups", () => {
+		const groups = findOrphanGroups(parsePs(psBefore), parsePs(psAfter))
+		assert.deepEqual([...groups], [SHELL])
+	})
+
+	test("a group whose leader is still alive is a foreground call, not background", () => {
+		const groups = findOrphanGroups(parsePs(psBefore), parsePs(`${psDuring}\n 81446     1 ${SHELL}    00:01 node server.js`))
+		assert.equal(groups.size, 0)
+	})
+
+	test("a group that existed before the call belongs to someone else", () => {
+		const before = parsePs(`${psBefore}\n 81446     1 ${SHELL}    00:10 node server.js`)
+		assert.equal(findOrphanGroups(before, parsePs(psAfter)).size, 0)
+	})
+})
+
+test.describe("applyPoll", () => {
+	test("tracks members, marks them ended when gone, forgets them after the TTL and drops empty groups", () => {
+		const state = createBackgroundState()
+		state.groups.add(SHELL)
+		let now = 100_000
+		assert.equal(applyPoll(state, parsePs(psAfter), now), true)
+		let snap = snapshot(state)
+		assert.deepEqual(snap.running.map((p) => [p.pid, p.command, p.startedAt]), [
+			[81446, "/bin/bash ./watch.sh", now - 1000],
+			[81450, "node server.js", now - 1000],
+		])
+		assert.equal(snap.ended.length, 0)
+
+		// Nothing changed: no notification.
+		assert.equal(applyPoll(state, parsePs(psAfter), now + 2000), false)
+
+		// server.js exits.
+		now += 4000
+		const onlyWatch = psAfter.split("\n").filter((line) => !line.includes("server.js")).join("\n")
+		assert.equal(applyPoll(state, parsePs(onlyWatch), now), true)
+		snap = snapshot(state)
+		assert.deepEqual(snap.running.map((p) => p.pid), [81446])
+		assert.deepEqual(snap.ended.map((p) => [p.pid, p.endedAt]), [[81450, now]])
+
+		// Everything exits; the ended entries linger for a minute, then the group is dropped.
+		now += 2000
+		assert.equal(applyPoll(state, parsePs(psBefore), now), true)
+		assert.equal(snapshot(state).running.length, 0)
+		assert.equal(snapshot(state).ended.length, 2)
+		assert.equal(state.groups.has(SHELL), true)
+		now += 61_000
+		assert.equal(applyPoll(state, parsePs(psBefore), now), true)
+		assert.equal(snapshot(state).ended.length, 0)
+		assert.equal(state.groups.size, 0)
+	})
+})
+
+test.describe("overlay rendering", () => {
+	const theme = { fg: (_c: string, t: string) => t }
+
+	test("segment shows the running count only", () => {
+		assert.equal(backgroundSegment({ running: [], ended: [] }), undefined)
+		const proc = { pid: 1, pgid: 1, command: "x", startedAt: 0 }
+		assert.equal(backgroundSegment({ running: [proc, proc], ended: [proc] }), "⚙ 2 bg")
+	})
+
+	test("rows carry status and duration; lines fit the width and mark the selection", () => {
+		const now = 1_000_000
+		const rows = backgroundRows(
+			{
+				running: [{ pid: 10, pgid: 1, command: "npm run dev", startedAt: now - 252_000 }],
+				ended: [{ pid: 11, pgid: 1, command: "tail -f app.log", startedAt: now - 40_000, endedAt: now - 8000 }],
+			},
+			now,
+		)
+		assert.deepEqual(rows, [
+			{ pid: 10, command: "npm run dev", status: "running", durationMs: 252_000 },
+			{ pid: 11, command: "tail -f app.log", status: "ended", durationMs: 32_000 },
+		])
+		const lines = renderBackgroundLines(rows, 1, 60, theme, "ctrl+b")
+		assert.equal(lines.length, 4)
+		assert.match(lines[1] ?? "", /^ {2}npm run dev\s+running\s+4m 12s$/)
+		assert.match(lines[2] ?? "", /^› tail -f app.log\s+ended\s+ran 32s$/)
+		assert.ok(lines.every((line) => line.length <= 60))
+		assert.match(lines[3] ?? "", /ctrl\+b/)
+	})
+
+	test("empty list says so", () => {
+		const lines = renderBackgroundLines([], 0, 40, theme)
+		assert.match(lines[1] ?? "", /Nothing running/)
+	})
+})
+
+test.describe("createBackgroundTracker", () => {
+	const tick = () => new Promise((resolve) => setImmediate(resolve))
+	const settle = async () => { for (let i = 0; i < 6; i++) await tick() }
+
+	function fakePi(listings: string[]) {
+		const execCalls: string[][] = []
+		const pi = {
+			async exec(command: string, args: string[]) {
+				execCalls.push([command, ...args])
+				const stdout = listings.length > 1 ? (listings.shift() as string) : (listings[0] ?? "")
+				return { stdout, stderr: "", code: 0, killed: false }
+			},
+		} as unknown as ExtensionAPI
+		return { pi, execCalls }
+	}
+
+	test("a bash call that leaves processes behind is tracked; other tools are ignored", async () => {
+		const { pi, execCalls } = fakePi([psBefore, psAfter, psAfter])
+		const killed: Array<[number, string]> = []
+		let now = 500_000
+		const tracker = createBackgroundTracker({ pi, now: () => now, killProcess: (pid, signal) => { killed.push([pid, signal]) } })
+		let changes = 0
+		tracker.onChange(() => { changes += 1 })
+
+		tracker.toolStart("c1", "read")
+		tracker.toolEnd("c1", "read")
+		await settle()
+		assert.equal(execCalls.length, 0)
+
+		tracker.toolStart("c2", "bash")
+		await settle()
+		tracker.toolEnd("c2", "bash")
+		await settle()
+		assert.deepEqual(execCalls.slice(0, 2), [["ps", ...PS_ARGS], ["ps", ...PS_ARGS]])
+		assert.equal(changes, 1)
+		assert.deepEqual(tracker.get().running.map((p) => p.pid), [81446, 81450])
+
+		assert.equal(tracker.kill(81450), true)
+		assert.equal(tracker.kill(81446, { group: true, signal: "SIGKILL" }), true)
+		assert.equal(tracker.kill(99999), false)
+		assert.deepEqual(killed, [[81450, "SIGTERM"], [-SHELL, "SIGKILL"]])
+
+		now += 3000
+		tracker.dispose()
+		assert.deepEqual(tracker.get().running.map((p) => p.pid), [81446, 81450], "get() still answers after dispose")
+	})
+
+	test("a clean bash call tracks nothing and starts no poller", async () => {
+		const { pi, execCalls } = fakePi([psBefore, psBefore])
+		const tracker = createBackgroundTracker({ pi })
+		tracker.toolStart("c1", "bash")
+		tracker.toolEnd("c1", "bash")
+		await settle()
+		assert.equal(execCalls.length, 2)
+		assert.equal(tracker.get().running.length, 0)
+		await new Promise((resolve) => setTimeout(resolve, 30))
+		assert.equal(execCalls.length, 2, "no poll scheduled")
+		tracker.dispose()
+	})
+})

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", backgroundShortcut: "ctrl+b" })
 	assert.equal(error.mock.callCount(), 0)
 })
 
@@ -39,7 +39,7 @@ test("global false overrides default", (t) => {
 	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, editDiff: "expanded" })
+	assert.deepEqual(config, { hideGauntletWidgets: false, editDiff: "expanded", backgroundShortcut: "ctrl+b" })
 	assert.equal(error.mock.callCount(), 0)
 })
 
@@ -49,7 +49,7 @@ test("trusted project true overrides global false", (t) => {
 	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, editDiff: "expanded" })
+	assert.deepEqual(config, { hideGauntletWidgets: true, editDiff: "expanded", backgroundShortcut: "ctrl+b" })
 	assert.equal(error.mock.callCount(), 0)
 })
 
@@ -59,7 +59,7 @@ test("untrusted project false does not override global true", (t) => {
 	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, editDiff: "expanded" })
+	assert.deepEqual(config, { hideGauntletWidgets: true, editDiff: "expanded", backgroundShortcut: "ctrl+b" })
 	assert.equal(error.mock.callCount(), 0)
 })
 
@@ -69,7 +69,7 @@ test("omitted keys do not override", (t) => {
 	writeProject(cwd, JSON.stringify({}))
 	const error = t.mock.method(console, "error")
 	const config = loadPiMinimalConfig({ agentDir, cwd, projectTrusted: true })
-	assert.deepEqual(config, { hideGauntletWidgets: false, editDiff: "expanded" })
+	assert.deepEqual(config, { hideGauntletWidgets: false, editDiff: "expanded", backgroundShortcut: "ctrl+b" })
 	assert.equal(error.mock.callCount(), 0)
 })
 
@@ -79,7 +79,7 @@ test("unknown keys do not override", (t) => {
 	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, editDiff: "expanded" })
+	assert.deepEqual(config, { hideGauntletWidgets: false, editDiff: "expanded", backgroundShortcut: "ctrl+b" })
 	assert.equal(error.mock.callCount(), 0)
 })
 
@@ -89,7 +89,7 @@ test("invalid JSON calls console.error and leaves the lower-precedence value unc
 	writeProject(cwd, "{")
 	const error = t.mock.method(console, "error")
 	const config = loadPiMinimalConfig({ agentDir, cwd, projectTrusted: true })
-	assert.deepEqual(config, { hideGauntletWidgets: false, editDiff: "expanded" })
+	assert.deepEqual(config, { hideGauntletWidgets: false, editDiff: "expanded", backgroundShortcut: "ctrl+b" })
 	assert.ok(error.mock.callCount() >= 1)
 })
 
@@ -99,7 +99,7 @@ test("non-object root calls console.error and leaves the lower-precedence value
 	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, editDiff: "expanded" })
+	assert.deepEqual(config, { hideGauntletWidgets: false, editDiff: "expanded", backgroundShortcut: "ctrl+b" })
 	assert.ok(error.mock.callCount() >= 1)
 })
 
@@ -109,7 +109,7 @@ test("non-boolean hideGauntletWidgets calls console.error and leaves the lower-p
 	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, editDiff: "expanded" })
+	assert.deepEqual(config, { hideGauntletWidgets: false, editDiff: "expanded", backgroundShortcut: "ctrl+b" })
 	assert.ok(error.mock.callCount() >= 1)
 })
 
@@ -129,7 +129,20 @@ test("an invalid editDiff value is reported and does not override", (t) => {
 	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.deepEqual(config, { hideGauntletWidgets: false, editDiff: "always", backgroundShortcut: "ctrl+b" })
 	assert.equal(error.mock.callCount(), 1)
 	assert.match(String(error.mock.calls[0]!.arguments[0]), /editDiff must be one of "always", "never", "expanded"/)
 })
+
+test("backgroundShortcut accepts a key name or null and rejects other values", (t) => {
+	const { agentDir, cwd } = setup(t)
+	writeGlobal(agentDir, JSON.stringify({ backgroundShortcut: "ctrl+g" }))
+	assert.equal(loadPiMinimalConfig({ agentDir, cwd, projectTrusted: false }).backgroundShortcut, "ctrl+g")
+	writeGlobal(agentDir, JSON.stringify({ backgroundShortcut: null }))
+	assert.equal(loadPiMinimalConfig({ agentDir, cwd, projectTrusted: false }).backgroundShortcut, null)
+	const errors: string[] = []
+	t.mock.method(console, "error", (message: string) => { errors.push(message) })
+	writeGlobal(agentDir, JSON.stringify({ backgroundShortcut: 7 }))
+	assert.equal(loadPiMinimalConfig({ agentDir, cwd, projectTrusted: false }).backgroundShortcut, "ctrl+b")
+	assert.match(errors.join("\n"), /backgroundShortcut/)
+})

package/test/footer-composition.test.ts

@@ -1,6 +1,7 @@
 import assert from "node:assert/strict"
 import test from "node:test"
 import { initTheme, type ExtensionContext } from "@earendil-works/pi-coding-agent"
+import { visibleWidth } from "@earendil-works/pi-tui"
 import { installFooter } from "../src/footer.js"
 import { createFooterContributions, type ActivitySnapshot } from "../src/footer-contributions.js"
 
@@ -23,6 +24,8 @@ const data = (revision: number, motion: "spinner" | "static" = "spinner"): Activ
   revision, rows: [{ key: "1", agent: "worker", state: "running", text: "Last: tests" }], omitted: 0, motion, format: "icons",
 })
 const sources = { busy: () => false, editorText: () => "", contextPct: () => 10 }
+// eslint-disable-next-line no-control-regex
+const stripAnsi = (text: string) => text.replace(/\x1b\[[0-9;]*m/g, "")
 
 test("no contributor preserves existing footer; activity is last even while typing/busy", () => {
   const f = fixture(), registry = createFooterContributions("S1")
@@ -127,3 +130,61 @@ test("legacy task summary precedes activity", () => {
   assert.ok(lines.at(-1)?.includes("worker"))
   dispose()
 })
+
+test("background count follows the hints and survives hiding them", () => {
+  const f = fixture()
+  let bg: string | undefined = "⚙ 2 bg"
+  let listener: (() => void) | undefined
+  const bgSources = {
+    ...sources,
+    background: () => bg,
+    onBackgroundChange: (l: () => void) => { listener = l; return () => { listener = undefined } },
+    prs: () => "#24",
+  }
+  const stop = installFooter(f.ctx, bgSources)
+  const component = f.mount()
+  assert.match(stripAnsi(component.render(80)[0] ?? ""), /^ enter send.*expand tools {2}· {2}⚙ 2 bg\s+#24$/)
+  stop(); component.dispose?.()
+  const typingStop = installFooter(f.ctx, { ...bgSources, busy: () => true })
+  const typing = f.mount()
+  assert.match(typing.render(80)[0] ?? "", /^ ⚙ 2 bg\s+#24$/)
+  const before = f.renders
+  bg = undefined
+  listener?.()
+  assert.equal(f.renders, before + 1)
+  assert.deepEqual(typing.render(80).map((line) => line.trim()), ["#24"])
+  typingStop(); typing.dispose?.()
+  assert.equal(listener, undefined)
+})
+
+test("PR chips sit right-aligned on the hints line, stay when hints hide, and re-render on change", () => {
+  const f = fixture()
+  let chips: string | undefined = "#23 #22"
+  let listener: (() => void) | undefined
+  const prsSources = {
+    ...sources,
+    prs: () => chips,
+    onPrsChange: (l: () => void) => { listener = l; return () => { listener = undefined } },
+  }
+  const stop = installFooter(f.ctx, prsSources)
+  const component = f.mount()
+  const idle = component.render(80)
+  assert.equal(idle.length, 1)
+  assert.match(idle[0] ?? "", /^ \S.*send.*#23 #22$/)
+  assert.equal(visibleWidth(idle[0] ?? ""), 1 + 78, "chips are flush right within the margin")
+
+  // Typing hides the hints; the chips keep the line.
+  stop(); component.dispose?.()
+  const typingStop = installFooter(f.ctx, { ...prsSources, editorText: () => "draft" })
+  const typing = f.mount()
+  assert.deepEqual(typing.render(80).map((line) => line.trim()), ["#23 #22"])
+
+  // A change notification triggers a render; no chips, no line.
+  const before = f.renders
+  chips = undefined
+  listener?.()
+  assert.equal(f.renders, before + 1)
+  assert.deepEqual(typing.render(80), [])
+  typingStop(); typing.dispose?.()
+  assert.equal(listener, undefined, "unsubscribed on dispose")
+})

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")
+})