pi-minimal 0.4.0 → 0.6.0

package/test/index.test.ts

@@ -17,11 +17,17 @@ type SessionMode = "tui" | "rpc" | "json" | "print"
 
 const AGENT_DIR_ENV = "PI_CODING_AGENT_DIR"
 const originalHerdrEnv = process.env.HERDR_ENV
+const originalRexSession = process.env.REX_SESSION
+const originalRexBlock = process.env.REX_BLOCK
 const originalAgentDir = process.env[AGENT_DIR_ENV]
 
 function restoreEnv() {
 	if (originalHerdrEnv === undefined) delete process.env.HERDR_ENV
 	else process.env.HERDR_ENV = originalHerdrEnv
+	if (originalRexSession === undefined) delete process.env.REX_SESSION
+	else process.env.REX_SESSION = originalRexSession
+	if (originalRexBlock === undefined) delete process.env.REX_BLOCK
+	else process.env.REX_BLOCK = originalRexBlock
 	if (originalAgentDir === undefined) delete process.env[AGENT_DIR_ENV]
 	else process.env[AGENT_DIR_ENV] = originalAgentDir
 }
@@ -90,6 +96,9 @@ function createFake(options: {
 			if (command === "herdr" && args[0] === "agent") {
 				return { stdout: JSON.stringify({ result: { agents: [] } }), stderr: "", code: 0, killed: false }
 			}
+			if (command === "gh") {
+				return { stdout: "", stderr: "not a github repo", code: 1, killed: false }
+			}
 			if (command === "herdr" && args[0] === "tab") {
 				return { stdout: JSON.stringify({ result: { tabs: [] } }), stderr: "", code: 0, killed: false }
 			}
@@ -98,6 +107,12 @@ function createFake(options: {
 		registerTool(...args: unknown[]) {
 			record(registerCalls, "registerTool", args)
 		},
+		registerCommand(...args: unknown[]) {
+			record(registerCalls, "registerCommand", args)
+		},
+		registerShortcut(...args: unknown[]) {
+			record(registerCalls, "registerShortcut", args)
+		},
 		registerToolRenderer(...args: unknown[]) {
 			record(registerCalls, "registerToolRenderer", args)
 		},
@@ -132,10 +147,12 @@ 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
+		delete process.env.REX_SESSION
+		delete process.env.REX_BLOCK
 		t.after(restoreEnv)
 
 		const hideThinking = t.mock.method(SettingsManager.prototype, "setHideThinkingBlock")
@@ -155,8 +172,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,
@@ -172,6 +189,8 @@ test.describe("session chrome", { concurrency: 1 }, () => {
 		const { agentDir, cwd } = setupDirs(t)
 		process.env[AGENT_DIR_ENV] = agentDir
 		delete process.env.HERDR_ENV
+		delete process.env.REX_SESSION
+		delete process.env.REX_BLOCK
 		t.after(restoreEnv)
 
 		const { pi, allCalls, emit } = createFake({ cwd })
@@ -197,7 +216,29 @@ test.describe("session chrome", { concurrency: 1 }, () => {
 		assert.ok(firstHeader < firstReclaim, "header before reclaim")
 		assert.ok(firstFooter < firstReclaim, "footer before reclaim")
 		assert.ok(firstCwd < firstReclaim, "cwd before reclaim")
-		assert.equal(allCalls.some((call) => call.method === "registerTool"), false, "built-in tools are not re-registered")
+		assert.deepEqual(allCalls.filter((call) => call.method === "registerTool").map((call) => (call.args[0] as { name: string }).name), ["list_open_prs"], "only pi-minimal's own tool is 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
+		delete process.env.REX_SESSION
+		delete process.env.REX_BLOCK
+		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) => {
@@ -205,6 +246,8 @@ test.describe("session chrome", { concurrency: 1 }, () => {
 		writeFileSync(join(agentDir, "pi-minimal.json"), JSON.stringify({ hideGauntletWidgets: false }))
 		process.env[AGENT_DIR_ENV] = agentDir
 		delete process.env.HERDR_ENV
+		delete process.env.REX_SESSION
+		delete process.env.REX_BLOCK
 		t.after(restoreEnv)
 
 		const { pi, uiCalls, emit } = createFake({ cwd, projectTrusted: true })
@@ -223,6 +266,8 @@ test.describe("session chrome", { concurrency: 1 }, () => {
 		const { agentDir, cwd } = setupDirs(t)
 		process.env[AGENT_DIR_ENV] = agentDir
 		delete process.env.HERDR_ENV
+		delete process.env.REX_SESSION
+		delete process.env.REX_BLOCK
 		t.after(restoreEnv)
 
 		const { pi, execCalls, emit } = createFake({ cwd })
@@ -241,6 +286,8 @@ test.describe("session chrome", { concurrency: 1 }, () => {
 		const { agentDir, cwd } = setupDirs(t)
 		process.env[AGENT_DIR_ENV] = agentDir
 		process.env.HERDR_ENV = "1"
+		delete process.env.REX_SESSION
+		delete process.env.REX_BLOCK
 		t.after(restoreEnv)
 
 		const { pi, execCalls, emit } = createFake({ cwd })
@@ -249,12 +296,135 @@ test.describe("session chrome", { concurrency: 1 }, () => {
 		await emit("session_start")
 
 		assert.equal(herdrProbes(execCalls).length, 1)
+		assert.equal(execCalls.filter((call) => call.args[0] === "rex").length, 0)
+	})
+
+	test("inside Rex (REX_SESSION + REX_BLOCK) it reads the Rex session instead of herdr", async (t) => {
+		const { agentDir, cwd } = setupDirs(t)
+		process.env[AGENT_DIR_ENV] = agentDir
+		delete process.env.HERDR_ENV
+		process.env.REX_SESSION = "session:test"
+		process.env.REX_BLOCK = "block:self"
+		t.after(restoreEnv)
+
+		const { pi, execCalls, emit } = createFake({ cwd })
+		install(pi)
+		t.after(() => emit("session_shutdown"))
+		await emit("session_start")
+		await new Promise((resolve) => setTimeout(resolve, 20))
+
+		assert.equal(herdrProbes(execCalls).length, 0)
+		assert.deepEqual(
+			execCalls.filter((call) => call.args[0] === "rex").map((call) => call.args[1]),
+			[["window", "ls", "-s", "session:test", "--json"]],
+		)
+	})
+
+	test("Herdr wins when both Herdr and Rex are present", async (t) => {
+		const { agentDir, cwd } = setupDirs(t)
+		process.env[AGENT_DIR_ENV] = agentDir
+		process.env.HERDR_ENV = "1"
+		process.env.REX_SESSION = "session:test"
+		process.env.REX_BLOCK = "block:self"
+		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)
+		assert.equal(execCalls.filter((call) => call.args[0] === "rex").length, 0)
+	})
+
+	test("registers /bg and the background shortcut once, honouring backgroundShortcut", async (t) => {
+		const { agentDir, cwd } = setupDirs(t)
+		writeFileSync(join(agentDir, "pi-minimal.json"), JSON.stringify({ backgroundShortcut: "ctrl+g" }))
+		process.env[AGENT_DIR_ENV] = agentDir
+		delete process.env.HERDR_ENV
+		delete process.env.REX_SESSION
+		delete process.env.REX_BLOCK
+		t.after(restoreEnv)
+
+		const { pi, registerCalls, emit } = createFake({ cwd })
+		install(pi)
+		t.after(() => emit("session_shutdown"))
+		assert.ok(registerCalls.some((call) => call.method === "registerCommand" && call.args[0] === "bg"))
+		assert.equal(registerCalls.filter((call) => call.method === "registerShortcut").length, 0, "shortcut waits for session config")
+		await emit("session_start")
+		await emit("session_start")
+		const shortcuts = registerCalls.filter((call) => call.method === "registerShortcut")
+		assert.deepEqual(shortcuts.map((call) => call.args[0]), ["ctrl+g"])
+	})
+
+	test("a TUI session asks gh for the repo once and registers /prs", async (t) => {
+		const { agentDir, cwd } = setupDirs(t)
+		process.env[AGENT_DIR_ENV] = agentDir
+		delete process.env.HERDR_ENV
+		delete process.env.REX_SESSION
+		delete process.env.REX_BLOCK
+		t.after(restoreEnv)
+
+		const { pi, execCalls, registerCalls, emit } = createFake({ cwd })
+		install(pi)
+		t.after(() => emit("session_shutdown"))
+		assert.ok(registerCalls.some((call) => call.method === "registerCommand" && call.args[0] === "prs"))
+		await emit("session_start")
+		await new Promise((resolve) => setTimeout(resolve, 20))
+		assert.deepEqual(execCalls.filter((call) => call.args[0] === "gh").map((call) => call.args[1]), [["repo", "view", "--json", "nameWithOwner,url"]])
+	})
+
+	test("a bash call running gh pr create records the PR URL as a session entry", async (t) => {
+		const { agentDir, cwd } = setupDirs(t)
+		process.env[AGENT_DIR_ENV] = agentDir
+		delete process.env.HERDR_ENV
+		delete process.env.REX_SESSION
+		delete process.env.REX_BLOCK
+		t.after(restoreEnv)
+
+		const { pi, execCalls, registerCalls, emit } = createFake({ cwd })
+		install(pi)
+		t.after(() => emit("session_shutdown"))
+		await emit("session_start")
+		await emit("tool_execution_start", { toolCallId: "b1", toolName: "bash", args: { command: "gh pr create --fill" } })
+		await emit("tool_execution_end", {
+			toolCallId: "b1", toolName: "bash", isError: false,
+			result: { content: [{ type: "text", text: "Creating pull request…\nhttps://github.com/raviy06/pi-minimal/pull/24\n" }] },
+		})
+		await new Promise((resolve) => setTimeout(resolve, 20))
+		const entries = registerCalls.filter((call) => call.method === "appendEntry")
+		assert.deepEqual(entries.map((call) => call.args), [["pi-minimal.pr", { url: "https://github.com/raviy06/pi-minimal/pull/24" }]])
+		assert.ok(execCalls.some((call) => call.args[0] === "gh" && (call.args[1] as string[])[1] === "view"), "the PR is fetched by URL")
+	})
+
+	test("bash tool calls are inspected with ps; other tools are not", async (t) => {
+		const { agentDir, cwd } = setupDirs(t)
+		process.env[AGENT_DIR_ENV] = agentDir
+		delete process.env.HERDR_ENV
+		delete process.env.REX_SESSION
+		delete process.env.REX_BLOCK
+		t.after(restoreEnv)
+
+		const { pi, execCalls, emit } = createFake({ cwd })
+		install(pi)
+		t.after(() => emit("session_shutdown"))
+		await emit("session_start")
+		await emit("tool_execution_start", { toolCallId: "r1", toolName: "read" })
+		await emit("tool_execution_end", { toolCallId: "r1", toolName: "read" })
+		await new Promise((resolve) => setTimeout(resolve, 10))
+		assert.equal(execCalls.filter((call) => call.args[0] === "ps").length, 0)
+		await emit("tool_execution_start", { toolCallId: "b1", toolName: "bash" })
+		await emit("tool_execution_end", { toolCallId: "b1", toolName: "bash" })
+		await new Promise((resolve) => setTimeout(resolve, 10))
+		assert.equal(execCalls.filter((call) => call.args[0] === "ps").length, 2)
 	})
 
 	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
+		delete process.env.REX_SESSION
+		delete process.env.REX_BLOCK
 		t.after(restoreEnv)
 
 		const { pi, uiCalls, execCalls, emit } = createFake({ cwd, mode: "print" })
@@ -287,6 +457,8 @@ test("footer registration survives chrome reinstalls and becomes inert on shutdo
 	const { agentDir, cwd } = setupDirs(t)
 	process.env[AGENT_DIR_ENV] = agentDir
 	delete process.env.HERDR_ENV
+	delete process.env.REX_SESSION
+	delete process.env.REX_BLOCK
 	t.after(restoreEnv)
 	const { pi, emit, events, uiCalls } = createFake({ cwd })
 	install(pi)
@@ -312,6 +484,8 @@ 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
+	delete process.env.REX_SESSION
+	delete process.env.REX_BLOCK
 	t.after(restoreEnv)
 	const { pi, registerCalls, emit } = createFake({ cwd })
 	install(pi)
@@ -329,3 +503,27 @@ 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
+	delete process.env.REX_SESSION
+	delete process.env.REX_BLOCK
+	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/prs.test.ts

@@ -0,0 +1,272 @@
+import assert from "node:assert/strict"
+import test from "node:test"
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent"
+import { stripTerminalSequences } from "@earendil-works/pi-tui"
+import { filterPrs, parsePrFilter, prsToolResult } from "../src/prs-command.js"
+import {
+	ciFailing,
+	createPrSource,
+	describePr,
+	findPrUrls,
+	isPrCreateCommand,
+	parsePrList,
+	parsePrView,
+	parseRepoView,
+	PR_LIST_FIELDS,
+	prChipLabel,
+	prColor,
+	prSegment,
+	prUrlRepo,
+	type PrRepo,
+	type PullRequest,
+} from "../src/prs.js"
+
+const repo: PrRepo = { nameWithOwner: "raviy06/pi-minimal", host: "github.com", url: "https://github.com/raviy06/pi-minimal" }
+
+// Shapes from `gh pr list --json …` on github.com and on a GitHub Enterprise host.
+const ghList = JSON.stringify([
+	{
+		number: 23, title: "feat: background processes", url: "https://github.com/raviy06/pi-minimal/pull/23", isDraft: false,
+		author: { login: "raviy06" }, reviewRequests: [], reviewDecision: "",
+		statusCheckRollup: [{ state: null, conclusion: "", status: "IN_PROGRESS" }], updatedAt: "2026-10-28T13:40:00Z",
+	},
+	{
+		number: 22, title: "feat: Rex siblings", url: "https://github.com/raviy06/pi-minimal/pull/22", isDraft: true,
+		author: { login: "raviy06" }, reviewRequests: [], reviewDecision: "",
+		statusCheckRollup: [{ state: null, conclusion: "SUCCESS", status: "COMPLETED" }], updatedAt: "2026-10-28T13:30:00Z",
+	},
+	{
+		number: 21, title: "docs: glossary", url: "https://github.com/raviy06/pi-minimal/pull/21", isDraft: false,
+		author: { login: "raviy06" }, reviewRequests: [], reviewDecision: "CHANGES_REQUESTED",
+		statusCheckRollup: [], updatedAt: "2026-10-27T10:00:00Z",
+	},
+	{
+		number: 20, title: "fix: review me", url: "https://github.com/raviy06/pi-minimal/pull/20", isDraft: false,
+		author: { login: "someone" }, reviewRequests: [{ __typename: "User", login: "RaviY06" }], reviewDecision: "REVIEW_REQUIRED",
+		statusCheckRollup: [{ state: "PENDING", conclusion: null, status: null }, { state: "FAILURE", conclusion: null, status: null }], updatedAt: "2026-10-28T09:00:00Z",
+	},
+	{
+		number: 19, title: "team review", url: "https://github.com/raviy06/pi-minimal/pull/19", isDraft: false,
+		author: { login: "someone" }, reviewRequests: [{ __typename: "Team", name: "HotelTonight", slug: "hoteltonight" }], reviewDecision: "",
+		statusCheckRollup: [], updatedAt: "2026-10-28T08:00:00Z",
+	},
+	{
+		number: 18, title: "just mentioned", url: "https://github.com/raviy06/pi-minimal/pull/18", isDraft: false,
+		author: { login: "someone" }, reviewRequests: [], reviewDecision: "", statusCheckRollup: [], updatedAt: "2026-10-28T07:00:00Z",
+	},
+])
+
+test.describe("prs parsing", () => {
+	test("parseRepoView derives the host from the URL", () => {
+		assert.deepEqual(parseRepoView(JSON.stringify({ nameWithOwner: "airbnb/ht-mainapp", url: "https://git.musta.ch/airbnb/ht-mainapp" })), {
+			nameWithOwner: "airbnb/ht-mainapp", host: "git.musta.ch", url: "https://git.musta.ch/airbnb/ht-mainapp",
+		})
+		assert.throws(() => parseRepoView("{}"))
+	})
+
+	test("ciFailing reads both status contexts and check runs", () => {
+		assert.equal(ciFailing([{ state: "SUCCESS" }, { conclusion: "SUCCESS", status: "COMPLETED" }]), false)
+		assert.equal(ciFailing([{ state: "PENDING" }]), false)
+		assert.equal(ciFailing([{ state: "FAILURE" }]), true)
+		assert.equal(ciFailing([{ conclusion: "TIMED_OUT", status: "COMPLETED" }]), true)
+		assert.equal(ciFailing(null), false)
+	})
+
+	test("parsePrList keeps mine and review-requested (case-insensitive), drops mentions, sorts reviews first", () => {
+		const prs = parsePrList(ghList, repo, "raviy06")
+		assert.deepEqual(prs.map((pr) => [pr.number, pr.kind]), [[20, "review"], [23, "mine"], [22, "mine"], [21, "mine"]])
+		assert.equal(prs.find((pr) => pr.number === 20)?.ciFailing, true)
+		assert.equal(prs.find((pr) => pr.number === 22)?.isDraft, true)
+		assert.equal(prs[0]?.repo, "github.com/raviy06/pi-minimal")
+	})
+
+	test("team review requests count when my teams are known", () => {
+		const prs = parsePrList(ghList, repo, "raviy06", ["HotelTonight"])
+		assert.ok(prs.some((pr) => pr.number === 19 && pr.kind === "review"))
+	})
+})
+
+test.describe("prs display", () => {
+	const theme = { fg: (c: string, t: string) => `[${c}]${t}[/${c}]` }
+	const prs = parsePrList(ghList, repo, "raviy06")
+	const by = (n: number) => prs.find((pr) => pr.number === n) as PullRequest
+
+	test("prColor: trouble > review > draft > mine", () => {
+		assert.equal(prColor(by(20)), "error", "failing CI on a review request")
+		assert.equal(prColor(by(21)), "error", "changes requested")
+		assert.equal(prColor({ ...by(20), ciFailing: false }), "warning")
+		assert.equal(prColor(by(22)), "dim")
+		assert.equal(prColor(by(23)), "accent")
+	})
+
+	test("prSegment links each chip, colours it, and collapses the overflow", () => {
+		const segment = prSegment(prs, theme, 2, "github.com/raviy06/pi-minimal") as string
+		const esc = "\u001b"
+		assert.ok(segment.includes(`[error]${esc}]8;;https://github.com/raviy06/pi-minimal/pull/20${esc}\\#20${esc}]8;;${esc}\\[/error]`), "chip #20 is a red OSC 8 link")
+		assert.match(segment, /\[accent\].*#23.*\[\/accent\]/)
+		assert.match(segment, /\[dim\]\+2\[\/dim\]$/)
+		assert.equal(stripTerminalSequences(segment.replace(/\[\/?[a-z]+\]/g, "")), "#20 #23 +2")
+		assert.equal(prSegment([], theme), undefined)
+		assert.equal(stripTerminalSequences((prSegment(prs.slice(0, 1), theme, 4) as string).replace(/\[\/?[a-z]+\]/g, "")), "pi-minimal#20", "outside any repo the chip names its repo")
+	})
+
+	test("describePr summarises kind and trouble", () => {
+		assert.equal(describePr(by(20), "github.com/raviy06/pi-minimal"), "#20  fix: review me  · review requested · CI failing · @someone")
+		assert.equal(describePr(by(22), "github.com/raviy06/pi-minimal"), "#22  feat: Rex siblings  · draft")
+		assert.equal(describePr(by(21), "github.com/raviy06/pi-minimal"), "#21  docs: glossary  · mine · changes requested")
+	})
+
+	test("filter parsing and filtering", () => {
+		assert.equal(parsePrFilter(""), "all")
+		assert.equal(parsePrFilter("mine"), "mine")
+		assert.equal(parsePrFilter("Review extra"), "review")
+		assert.deepEqual(filterPrs(prs, "review").map((pr) => pr.number), [20])
+		assert.deepEqual(filterPrs(prs, "mine").map((pr) => pr.number), [23, 22, 21])
+	})
+})
+
+test.describe("createPrSource", () => {
+	const tick = () => new Promise((resolve) => setImmediate(resolve))
+	const settle = async () => { for (let i = 0; i < 12; i++) await tick() }
+
+	const sessionPrUrl = "https://git.musta.ch/airbnb/ht-mainapp/pull/22741"
+	const ghView = (state = "OPEN") => JSON.stringify({
+		number: 22741, title: "Make the Rails session cookie host-only", url: sessionPrUrl, isDraft: false, state,
+		author: { login: "ravi-yadav" }, reviewRequests: [], reviewDecision: "REVIEW_REQUIRED",
+		statusCheckRollup: [{ state: "FAILURE" }], updatedAt: "2026-10-28T12:00:00Z",
+	})
+
+	function fakePi(options: { repoOk?: boolean; login?: string; viewState?: string } = {}) {
+		const execCalls: string[][] = []
+		const pi = {
+			async exec(command: string, args: string[]) {
+				execCalls.push([command, ...args])
+				if (command !== "gh") return { stdout: "", stderr: "", code: 1, killed: false }
+				if (args[0] === "pr" && args[1] === "view") return { stdout: ghView(options.viewState), stderr: "", code: 0, killed: false }
+				if (args[0] === "repo") {
+					return options.repoOk === false
+						? { stdout: "", stderr: "none of the git remotes configured for this repository point to a known GitHub host", code: 1, killed: false }
+						: { stdout: JSON.stringify({ nameWithOwner: repo.nameWithOwner, url: repo.url }), stderr: "", code: 0, killed: false }
+				}
+				if (args[0] === "api") return { stdout: `${options.login ?? "raviy06"}\n`, stderr: "", code: 0, killed: false }
+				if (args[0] === "pr") return { stdout: ghList, stderr: "", code: 0, killed: false }
+				return { stdout: "", stderr: "", code: 1, killed: false }
+			},
+		} as unknown as ExtensionAPI
+		return { pi, execCalls }
+	}
+
+	test("fetches repo, viewer login (per host) and the PR list once; later refreshes reuse the repo and login", async (t) => {
+		const { pi, execCalls } = fakePi()
+		let now = 1_000_000
+		const source = createPrSource({ pi, cwd: () => "/repo", now: () => now, minIntervalMs: 60_000, pollMs: 10 * 60_000 })
+		t.after(() => source.dispose())
+		let changes = 0
+		source.onChange(() => { changes += 1 })
+		await settle()
+		assert.deepEqual(execCalls.map((c) => c.slice(0, 3)), [
+			["gh", "repo", "view"],
+			["gh", "api", "--hostname"],
+			["gh", "pr", "list"],
+		])
+		const hostnameIdx = execCalls[1]?.indexOf("--hostname") ?? -1
+		assert.ok(hostnameIdx >= 0)
+		assert.equal(execCalls[1]?.[hostnameIdx + 1], "github.com")
+		assert.ok(execCalls[2]?.includes("github.com/raviy06/pi-minimal") && execCalls[2]?.includes(PR_LIST_FIELDS))
+		assert.equal(changes, 1)
+		assert.deepEqual(source.get().prs.map((pr) => pr.number), [20, 23, 22, 21])
+		assert.equal(source.get().fetchedAt, now)
+
+		// Throttled: an event-driven refresh inside the window does nothing.
+		await source.refresh()
+		assert.equal(execCalls.length, 3)
+		// Forced: only the list is fetched again; nothing changed so no notification.
+		now += 1000
+		await source.refresh(true)
+		assert.equal(execCalls.length, 4)
+		assert.equal(execCalls[3]?.[1], "pr")
+		assert.equal(changes, 1)
+
+		const tool = prsToolResult(source, "review")
+		assert.equal(tool.repo, "raviy06/pi-minimal")
+		assert.deepEqual(tool.prs.map((pr) => pr.number), [20])
+	})
+
+	test("outside a GitHub repo the snapshot is empty with the error, and no PR list is requested", async (t) => {
+		const { pi, execCalls } = fakePi({ repoOk: false })
+		const source = createPrSource({ pi, cwd: () => "/elsewhere", pollMs: 10 * 60_000 })
+		t.after(() => source.dispose())
+		await settle()
+		assert.equal(execCalls.length, 1)
+		assert.equal(source.get().repo, undefined)
+		assert.deepEqual(source.get().prs, [])
+		assert.match(source.get().error ?? "", /known GitHub host/)
+	})
+
+	test("a PR created in this session shows up even outside any repo, is persisted via sessionPrs(), and is forgotten once merged", async (t) => {
+		const { pi, execCalls } = fakePi({ repoOk: false })
+		const source = createPrSource({ pi, cwd: () => "/elsewhere", pollMs: 10 * 60_000 })
+		t.after(() => source.dispose())
+		await settle()
+		assert.deepEqual(source.get().prs, [])
+
+		source.addSessionPr("Creating pull request…\nhttps://git.musta.ch/airbnb/ht-mainapp/pull/22741\n")
+		await settle()
+		assert.deepEqual(source.sessionPrs(), [sessionPrUrl])
+		assert.ok(execCalls.some((c) => c[1] === "pr" && c[2] === "view" && c[3] === sessionPrUrl))
+		assert.deepEqual(source.get().prs.map((pr) => [pr.number, pr.kind, pr.repo, pr.ciFailing]), [[22741, "mine", "git.musta.ch/airbnb/ht-mainapp", true]])
+		assert.equal(source.get().repo, undefined, "still not a repo here")
+
+		// Same URL again is a no-op.
+		const calls = execCalls.length
+		source.addSessionPr(sessionPrUrl)
+		await settle()
+		assert.equal(execCalls.length, calls)
+
+		// A restored session starts with the URL and fetches it on the first refresh.
+		const restored = createPrSource({ pi, cwd: () => "/elsewhere", pollMs: 10 * 60_000, sessionPrs: [sessionPrUrl] })
+		t.after(() => restored.dispose())
+		await settle()
+		assert.deepEqual(restored.get().prs.map((pr) => pr.number), [22741])
+	})
+
+	test("a session PR in the cwd repo is not listed twice; a merged one disappears", async (t) => {
+		const merged = fakePi({ viewState: "MERGED" })
+		const source = createPrSource({ pi: merged.pi, cwd: () => "/repo", pollMs: 10 * 60_000, sessionPrs: [sessionPrUrl, "https://github.com/raviy06/pi-minimal/pull/23"] })
+		t.after(() => source.dispose())
+		await settle()
+		// #23 comes from the list (so no `pr view` for it); the GHE one was merged, so it is dropped and forgotten.
+		assert.equal(merged.execCalls.filter((c) => c[1] === "pr" && c[2] === "view").length, 1)
+		assert.deepEqual(source.get().prs.map((pr) => pr.number), [20, 23, 22, 21])
+		assert.deepEqual(source.sessionPrs(), ["https://github.com/raviy06/pi-minimal/pull/23"])
+	})
+})
+
+test.describe("session PRs", () => {
+	test("PR URLs are found in gh pr create output and mapped to their repo", () => {
+		const out = "Creating pull request for ry-prs-status into main in raviy06/pi-minimal\n\nhttps://github.com/raviy06/pi-minimal/pull/24\n"
+		assert.deepEqual(findPrUrls(out), ["https://github.com/raviy06/pi-minimal/pull/24"])
+		assert.deepEqual(findPrUrls("see https://git.musta.ch/airbnb/ht-mainapp/pull/22741 and https://git.musta.ch/airbnb/ht-mainapp/pull/22741"), ["https://git.musta.ch/airbnb/ht-mainapp/pull/22741"])
+		assert.deepEqual(findPrUrls("https://github.com/raviy06/pi-minimal/issues/5"), [])
+		assert.equal(prUrlRepo("https://git.musta.ch/airbnb/ht-mainapp/pull/22741"), "git.musta.ch/airbnb/ht-mainapp")
+		assert.equal(isPrCreateCommand("cd x && gh pr create --fill"), true)
+		assert.equal(isPrCreateCommand("gt submit --stack"), true)
+		assert.equal(isPrCreateCommand("gh pr view 24"), false)
+	})
+
+	test("parsePrView keeps open PRs as mine and drops merged/closed ones", () => {
+		const url = "https://git.musta.ch/airbnb/ht-mainapp/pull/22741"
+		const raw = { number: 22741, title: "t", url, isDraft: false, author: { login: "x" }, statusCheckRollup: [], state: "OPEN" }
+		assert.equal(parsePrView(JSON.stringify(raw), url)?.kind, "mine")
+		assert.equal(parsePrView(JSON.stringify(raw), url)?.repo, "git.musta.ch/airbnb/ht-mainapp")
+		assert.equal(parsePrView(JSON.stringify({ ...raw, state: "MERGED" }), url), undefined)
+	})
+
+	test("chips outside the cwd repo carry the repo name", () => {
+		const pr = parsePrList(ghList, repo, "raviy06")[0] as PullRequest
+		assert.equal(prChipLabel(pr, "github.com/raviy06/pi-minimal"), "#20")
+		assert.equal(prChipLabel(pr, "git.musta.ch/airbnb/ht-mainapp"), "pi-minimal#20")
+		assert.equal(prChipLabel(pr, undefined), "pi-minimal#20", "no cwd repo: name the repo")
+		assert.match(describePr(pr, "git.musta.ch/airbnb/other"), /^pi-minimal#20 {2}/)
+	})
+})