@hank-warren/pi-statusline 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Hank Warren
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,37 @@
+# pi-statusline
+
+Replaces Pi's default footer with a compact statusline:
+
+```text
+gpt-5.6-sol | pi-extensions:main* ⇣1 | 40k/1.0m
+⑂ pi-extensions:feature/statusline* ⇣2 #7 | infra:fix/alerts #168
+019fafa7-29c0-7e99-9f82-5794d5721848
+```
+
+## What it shows
+
+- **Line 1** — active model ID, current directory basename and Git branch, and current context usage/window. A yellow `*` marks a dirty checkout and `⇣N` shows how many commits it is behind its locally known upstream ref. Unknown context usage is rendered as `?/<window>` until Pi can provide an estimate.
+- **Worktree lines** — when the session works in or sends tool calls into linked worktrees, one line shows the same branch/dirty/behind state for each worktree plus its associated PR number.
+- **Final line** — the full Pi session ID.
+
+It uses a fixed true-color palette with context warning thresholds.
+
+## Worktree/PR tracking behavior
+
+- Only worktrees touched on the active Pi session branch are included.
+- Worktree paths appearing only inside Bash heredoc payloads are ignored.
+- Merged and closed PR worktrees are hidden.
+- State is rebuilt on reload and tree navigation; deleted worktrees are pruned.
+- Git state refreshes after each turn; branches without a PR are rechecked every five seconds; existing PR metadata is cached for five minutes.
+
+PR lookups use the `gh` CLI when available and degrade gracefully without it.
+
+## Install
+
+```bash
+pi install npm:@hank-warren/pi-statusline
+```
+
+## License
+
+MIT — see [LICENSE](LICENSE).

package/index.ts

@@ -0,0 +1,212 @@
+import { basename } from "node:path";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { truncateToWidth } from "@earendil-works/pi-tui";
+import {
+	type GitRepositoryStatus,
+	readGitStatus,
+	repoAlias,
+	type SessionWorktree,
+	SessionWorktreeTracker,
+} from "./worktrees.ts";
+
+export interface StatuslineData {
+	model: string;
+	cwd: string;
+	cwdGit: GitRepositoryStatus | null;
+	contextTokens: number | null;
+	contextWindow: number;
+	worktrees: SessionWorktree[];
+	sessionId: string;
+}
+
+const BLUE = "\x1b[38;2;0;153;255m";
+const ORANGE = "\x1b[38;2;255;176;85m";
+const GREEN = "\x1b[38;2;0;175;80m";
+const CYAN = "\x1b[38;2;86;182;194m";
+const RED = "\x1b[38;2;255;85;85m";
+const YELLOW = "\x1b[38;2;230;200;0m";
+const WHITE = "\x1b[38;2;220;220;220m";
+const MAGENTA = "\x1b[38;2;190;120;255m";
+const DIM = "\x1b[2m";
+const RESET = "\x1b[0m";
+
+function styled(style: string, text: string): string {
+	return `${style}${text}${RESET}`;
+}
+
+function contextColor(contextTokens: number, contextWindow: number): string {
+	const percent = contextWindow > 0 ? Math.floor((contextTokens * 100) / contextWindow) : 0;
+	if (percent >= 90) return RED;
+	if (percent >= 70) return YELLOW;
+	if (percent >= 50) return ORANGE;
+	return GREEN;
+}
+
+export function formatTokenCount(tokens: number): string {
+	const safeTokens = Math.max(0, Math.round(tokens));
+	if (safeTokens >= 1_000_000) return `${(safeTokens / 1_000_000).toFixed(1)}m`;
+	if (safeTokens >= 1_000) {
+		const thousands = safeTokens / 1_000;
+		return `${thousands < 10 && !Number.isInteger(thousands) ? thousands.toFixed(1) : Math.round(thousands)}k`;
+	}
+	return `${safeTokens}`;
+}
+
+function renderRepository(name: string, status: GitRepositoryStatus, nameColor = WHITE): string {
+	let part = styled(nameColor, name);
+	part += styled(DIM, ":");
+	part += styled(CYAN, status.branch);
+	if (status.dirty) part += styled(YELLOW, "*");
+	if (status.behind > 0) part += ` ${styled(ORANGE, `⇣${status.behind}`)}`;
+	return part;
+}
+
+function renderWorktreeLine(worktrees: SessionWorktree[]): string {
+	const separator = styled(DIM, " | ");
+	const parts = worktrees.map((worktree) => {
+		let part = renderRepository(repoAlias(worktree.repo), worktree);
+		if (worktree.pr !== undefined) {
+			const state = worktree.prState?.toUpperCase();
+			const color = state === "OPEN" ? GREEN : state === "MERGED" ? MAGENTA : state === "CLOSED" ? RED : DIM;
+			part += ` ${styled(color, `#${worktree.pr}`)}`;
+		}
+		return part;
+	});
+	return `${styled(DIM, "⑂")} ${parts.join(separator)}`;
+}
+
+export function renderStatusline(data: StatuslineData, width: number): string[] {
+	const lineCount = data.worktrees.length > 0 ? 3 : 2;
+	if (width <= 0) return Array.from({ length: lineCount }, () => "");
+
+	const separator = styled(DIM, " | ");
+	const used =
+		data.contextTokens === null
+			? styled(DIM, "?")
+			: styled(contextColor(data.contextTokens, data.contextWindow), formatTokenCount(data.contextTokens));
+	const context = `${used}${styled(DIM, "/")}${styled(WHITE, formatTokenCount(data.contextWindow))}`;
+	const cwd = data.cwdGit ? renderRepository(data.cwd, data.cwdGit) : styled(CYAN, data.cwd);
+	const summary = styled(BLUE, data.model) + separator + cwd + separator + context;
+
+	const lines = [truncateToWidth(summary, width)];
+	if (data.worktrees.length > 0) lines.push(truncateToWidth(renderWorktreeLine(data.worktrees), width, "…"));
+	lines.push(truncateToWidth(styled(DIM, data.sessionId), width));
+	return lines;
+}
+
+export default function statuslineExtension(pi: ExtensionAPI): void {
+	let requestRender: (() => void) | undefined;
+	let tracker: SessionWorktreeTracker | undefined;
+	let cwdGit: GitRepositoryStatus | null = null;
+	let cwdStatusAbort: AbortController | undefined;
+	let cwdStatusInFlight: Promise<void> | undefined;
+
+	const runInBackground = (operation: Promise<void>): void => {
+		operation.catch(() => {
+			// Statusline enrichment is best-effort and must never interrupt the agent.
+		});
+	};
+
+	const refreshCwdStatus = (ctx: ExtensionContext): Promise<void> => {
+		if (!cwdStatusAbort) return Promise.resolve();
+		if (cwdStatusInFlight) return cwdStatusInFlight.then(() => refreshCwdStatus(ctx));
+		const controller = cwdStatusAbort;
+		const refresh = (async () => {
+			const next = (await readGitStatus(
+				(command, args, options) => pi.exec(command, args, options),
+				ctx.cwd,
+				controller.signal,
+			)) ?? null;
+			if (controller.signal.aborted || cwdStatusAbort !== controller) return;
+			if (
+				cwdGit?.branch === next?.branch &&
+				cwdGit?.dirty === next?.dirty &&
+				cwdGit?.behind === next?.behind
+			) {
+				return;
+			}
+			cwdGit = next;
+			requestRender?.();
+		})().finally(() => {
+			if (cwdStatusInFlight === refresh) cwdStatusInFlight = undefined;
+		});
+		cwdStatusInFlight = refresh;
+		return refresh;
+	};
+
+	const resetTracker = (ctx: ExtensionContext): void => {
+		tracker?.dispose();
+		cwdStatusAbort?.abort();
+		cwdGit = null;
+		cwdStatusAbort = new AbortController();
+		cwdStatusInFlight = undefined;
+		const next = new SessionWorktreeTracker({
+			exec: (command, args, options) => pi.exec(command, args, options),
+			home: process.env.HOME ?? "",
+			onChange: () => requestRender?.(),
+		});
+		tracker = next;
+		runInBackground(refreshCwdStatus(ctx));
+		runInBackground(next.seedFromEntries(ctx.sessionManager.getBranch()));
+		runInBackground(next.includeCurrentWorktree(ctx.cwd));
+	};
+
+	pi.on("session_start", (_event, ctx) => {
+		if (ctx.mode !== "tui") return;
+
+		ctx.ui.setFooter((tui, _theme, footerData) => {
+			requestRender = () => tui.requestRender();
+			const stopBranchUpdates = footerData.onBranchChange(() => {
+				runInBackground(refreshCwdStatus(ctx));
+				tui.requestRender();
+			});
+
+			return {
+				dispose(): void {
+					stopBranchUpdates();
+					requestRender = undefined;
+				},
+				invalidate(): void {},
+				render(width: number): string[] {
+					const usage = ctx.getContextUsage();
+					const cwd = basename(ctx.cwd) || ctx.cwd;
+					const model = ctx.model?.id.split("/").pop() || "no-model";
+
+					return renderStatusline(
+						{
+							model,
+							cwd,
+							cwdGit,
+							contextTokens: usage?.tokens ?? null,
+							contextWindow: usage?.contextWindow ?? ctx.model?.contextWindow ?? 0,
+							worktrees: tracker?.getWorktrees() ?? [],
+							sessionId: ctx.sessionManager.getSessionId(),
+						},
+						width,
+					);
+				},
+			};
+		});
+
+		resetTracker(ctx);
+	});
+
+	pi.on("tool_call", (event) => {
+		if (tracker) runInBackground(tracker.observeToolInput(event.toolName, event.input));
+	});
+	pi.on("turn_end", (_event, ctx) => {
+		requestRender?.();
+		runInBackground(refreshCwdStatus(ctx));
+		if (tracker) runInBackground(tracker.refresh());
+	});
+	pi.on("model_select", () => requestRender?.());
+	pi.on("session_tree", (_event, ctx) => resetTracker(ctx));
+	pi.on("session_shutdown", () => {
+		tracker?.dispose();
+		tracker = undefined;
+		cwdStatusAbort?.abort();
+		cwdStatusAbort = undefined;
+		cwdStatusInFlight = undefined;
+		cwdGit = null;
+	});
+}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@hank-warren/pi-statusline",
+  "version": "0.1.0",
+  "description": "Compact Pi footer statusline: model ID, git branch/dirty/behind state, linked worktrees with PR numbers, context usage, and session ID.",
+  "type": "module",
+  "keywords": [
+    "pi-package",
+    "pi-extension",
+    "statusline",
+    "footer",
+    "git",
+    "coding-agent"
+  ],
+  "author": "Hank Warren",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hank-warren/pi-extensions.git",
+    "directory": "packages/pi-statusline"
+  },
+  "bugs": {
+    "url": "https://github.com/hank-warren/pi-extensions/issues"
+  },
+  "homepage": "https://github.com/hank-warren/pi-extensions/tree/main/packages/pi-statusline#readme",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "pi": {
+    "extensions": [
+      "./index.ts"
+    ]
+  },
+  "files": [
+    "index.ts",
+    "worktrees.ts",
+    "README.md",
+    "LICENSE"
+  ],
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-tui": "*"
+  }
+}

package/worktrees.ts

@@ -0,0 +1,359 @@
+import { readFile } from "node:fs/promises";
+import { basename, join, resolve } from "node:path";
+import type { ExecResult } from "@earendil-works/pi-coding-agent";
+
+export const PR_TTL_MS = 5 * 60_000;
+export const PR_ABSENT_TTL_MS = 5_000;
+
+export interface GitRepositoryStatus {
+	branch: string;
+	dirty: boolean;
+	behind: number;
+}
+
+export interface SessionWorktree extends GitRepositoryStatus {
+	path: string;
+	repo: string;
+	pr?: number;
+	prState?: string;
+}
+
+interface CachedWorktree extends SessionWorktree {
+	prCheckedAt: number;
+}
+
+interface WorktreeMetadata {
+	path: string;
+	repo: string;
+	branch: string;
+}
+
+export interface WorktreeTrackerHost {
+	exec(
+		command: string,
+		args: string[],
+		options: { cwd?: string; timeout?: number; signal?: AbortSignal },
+	): Promise<ExecResult>;
+	home: string;
+	now?: () => number;
+	onChange?: () => void;
+}
+
+export function parseGitStatus(output: string): GitRepositoryStatus | undefined {
+	let branch: string | undefined;
+	let oid: string | undefined;
+	let behind = 0;
+	let dirty = false;
+
+	for (const line of output.split(/\r?\n/)) {
+		if (line.startsWith("# branch.oid ")) oid = line.slice("# branch.oid ".length).trim();
+		else if (line.startsWith("# branch.head ")) branch = line.slice("# branch.head ".length).trim();
+		else if (line.startsWith("# branch.ab ")) {
+			const match = line.match(/^# branch\.ab \+\d+ -(\d+)$/);
+			if (match) behind = Number.parseInt(match[1] ?? "0", 10);
+		} else if (line.length > 0 && !line.startsWith("# ")) dirty = true;
+	}
+
+	if (branch === "(detached)") branch = oid && oid !== "(initial)" ? oid.slice(0, 8) : "detached";
+	if (!branch || branch === "(unknown)") return undefined;
+	return { branch, dirty, behind };
+}
+
+export async function readGitStatus(
+	exec: WorktreeTrackerHost["exec"],
+	path: string,
+	signal?: AbortSignal,
+): Promise<GitRepositoryStatus | undefined> {
+	const result = await exec(
+		"git",
+		[
+			"--no-optional-locks",
+			"-C",
+			path,
+			"status",
+			"--porcelain=v2",
+			"--branch",
+			"--untracked-files=normal",
+			"--no-renames",
+		],
+		{ timeout: 3_000, signal },
+	);
+	return result.code === 0 ? parseGitStatus(result.stdout) : undefined;
+}
+
+function visitStrings(value: unknown, visit: (value: string) => void): void {
+	if (typeof value === "string") {
+		visit(value);
+		return;
+	}
+	if (Array.isArray(value)) {
+		for (const item of value) visitStrings(item, visit);
+		return;
+	}
+	if (!value || typeof value !== "object") return;
+	for (const item of Object.values(value)) visitStrings(item, visit);
+}
+
+export function extractWorktreePaths(value: unknown, home: string): string[] {
+	const names = new Set<string>();
+	const needle = "repos/worktrees/";
+
+	visitStrings(value, (text) => {
+		let rest = text;
+		while (true) {
+			const index = rest.indexOf(needle);
+			if (index < 0) break;
+			rest = rest.slice(index + needle.length);
+			const name = rest.match(/^[a-zA-Z0-9._-]+/)?.[0];
+			if (name) names.add(name);
+			if (rest.length === 0) break;
+			rest = rest.slice(Math.max(1, name?.length ?? 0));
+		}
+	});
+
+	return [...names].sort().map((name) => join(home, "repos", "worktrees", name));
+}
+
+function stripHeredocBodies(command: string): string {
+	const visible: string[] = [];
+	const delimiters: Array<{ value: string; stripTabs: boolean }> = [];
+
+	for (const line of command.split(/\r?\n/)) {
+		const active = delimiters[0];
+		if (active) {
+			const candidate = active.stripTabs ? line.replace(/^\t+/, "") : line;
+			if (candidate === active.value) delimiters.shift();
+			continue;
+		}
+
+		visible.push(line);
+		const pattern = /(?<!<)<<(?!<)(-?)\s*(?:'([^']+)'|"([^"]+)"|\\?([^\s;&|<>]+))/g;
+		for (const match of line.matchAll(pattern)) {
+			const value = match[2] ?? match[3] ?? match[4];
+			if (value) delimiters.push({ value, stripTabs: match[1] === "-" });
+		}
+	}
+
+	return visible.join("\n");
+}
+
+export function extractWorktreePathsFromToolCall(toolName: string, input: unknown, home: string): string[] {
+	const baseName = toolName.slice(toolName.lastIndexOf(".") + 1);
+	if (baseName !== "bash" || !input || typeof input !== "object" || Array.isArray(input)) {
+		return extractWorktreePaths(input, home);
+	}
+
+	const command = (input as { command?: unknown }).command;
+	return typeof command === "string" ? extractWorktreePaths(stripHeredocBodies(command), home) : [];
+}
+
+export function extractWorktreePathsFromEntries(entries: readonly unknown[], home: string): string[] {
+	const paths = new Set<string>();
+
+	for (const entry of entries) {
+		if (!entry || typeof entry !== "object") continue;
+		const candidate = entry as { type?: unknown; message?: unknown };
+		if (candidate.type !== "message" || !candidate.message || typeof candidate.message !== "object") continue;
+		const message = candidate.message as { role?: unknown; content?: unknown };
+		if (message.role !== "assistant" || !Array.isArray(message.content)) continue;
+
+		for (const block of message.content) {
+			if (!block || typeof block !== "object") continue;
+			const toolCall = block as { type?: unknown; name?: unknown; arguments?: unknown };
+			if (toolCall.type !== "toolCall" || typeof toolCall.name !== "string") continue;
+			for (const path of extractWorktreePathsFromToolCall(toolCall.name, toolCall.arguments, home)) paths.add(path);
+		}
+	}
+
+	return [...paths].sort();
+}
+
+export function repoAlias(repo: string): string {
+	switch (repo) {
+		case "model-runtime-engine":
+			return "mre";
+		case "frontend":
+			return "fe";
+		case "infrastructure":
+			return "infra";
+		case "platform-releases":
+			return "rel";
+		case "np-integration-testing":
+			return "tests";
+		default:
+			return repo.startsWith("platform-") ? repo.slice("platform-".length) : repo;
+	}
+}
+
+export async function readWorktreeMetadata(path: string): Promise<WorktreeMetadata | undefined> {
+	try {
+		const gitFile = await readFile(join(path, ".git"), "utf8");
+		const rawGitDir = gitFile.trim().match(/^gitdir:\s*(.+)$/)?.[1];
+		if (!rawGitDir) return undefined;
+		const gitDir = resolve(path, rawGitDir).replaceAll("\\", "/");
+		const marker = "/.git/worktrees/";
+		const markerIndex = gitDir.indexOf(marker);
+		if (markerIndex < 0) return undefined;
+
+		const head = (await readFile(join(gitDir, "HEAD"), "utf8")).trim();
+		const branch = head.startsWith("ref: refs/heads/") ? head.slice("ref: refs/heads/".length) : head.slice(0, 8);
+		if (!branch) return undefined;
+
+		return {
+			path,
+			repo: basename(gitDir.slice(0, markerIndex)),
+			branch,
+		};
+	} catch {
+		return undefined;
+	}
+}
+
+function sameDisplay(a: CachedWorktree | undefined, b: CachedWorktree): boolean {
+	return Boolean(
+		a &&
+			a.path === b.path &&
+			a.repo === b.repo &&
+			a.branch === b.branch &&
+			a.dirty === b.dirty &&
+			a.behind === b.behind &&
+			a.pr === b.pr &&
+			a.prState === b.prState,
+	);
+}
+
+export class SessionWorktreeTracker {
+	private readonly trackedPaths = new Set<string>();
+	private readonly cache = new Map<string, CachedWorktree>();
+	private readonly inFlight = new Map<string, Promise<void>>();
+	private readonly abortController = new AbortController();
+	private disposed = false;
+
+	constructor(private readonly host: WorktreeTrackerHost) {}
+
+	getWorktrees(): SessionWorktree[] {
+		return [...this.cache.values()]
+			.filter((worktree) => {
+				const state = worktree.prState?.toUpperCase();
+				return state !== "MERGED" && state !== "CLOSED";
+			})
+			.map(({ prCheckedAt: _prCheckedAt, ...worktree }) => worktree)
+			.sort((a, b) => a.path.localeCompare(b.path));
+	}
+
+	async seedFromEntries(entries: readonly unknown[]): Promise<void> {
+		for (const path of extractWorktreePathsFromEntries(entries, this.host.home)) this.trackedPaths.add(path);
+		await this.refresh();
+	}
+
+	async observeToolInput(toolName: string, input: unknown): Promise<void> {
+		const added: string[] = [];
+		for (const path of extractWorktreePathsFromToolCall(toolName, input, this.host.home)) {
+			if (this.trackedPaths.has(path)) continue;
+			this.trackedPaths.add(path);
+			added.push(path);
+		}
+		await Promise.all(added.map((path) => this.refreshPath(path)));
+	}
+
+	async includeCurrentWorktree(cwd: string): Promise<void> {
+		const result = await this.host.exec(
+			"git",
+			["--no-optional-locks", "-C", cwd, "rev-parse", "--show-toplevel", "--absolute-git-dir"],
+			{ timeout: 2_000, signal: this.abortController.signal },
+		);
+		if (this.disposed || result.code !== 0) return;
+		const [topLevel, gitDir] = result.stdout.trim().split(/\r?\n/);
+		if (!topLevel || !gitDir?.replaceAll("\\", "/").includes("/.git/worktrees/")) return;
+		const path = resolve(topLevel);
+		if (!this.trackedPaths.has(path)) this.trackedPaths.add(path);
+		await this.refreshPath(path);
+	}
+
+	async refresh(): Promise<void> {
+		await Promise.all(
+			[...this.trackedPaths].map(async (path) => {
+				const existing = this.inFlight.get(path);
+				if (existing) await existing;
+				if (!this.disposed && this.trackedPaths.has(path)) await this.refreshPath(path);
+			}),
+		);
+	}
+
+	dispose(): void {
+		this.disposed = true;
+		this.abortController.abort();
+		this.trackedPaths.clear();
+		this.cache.clear();
+	}
+
+	private refreshPath(path: string): Promise<void> {
+		const existing = this.inFlight.get(path);
+		if (existing) return existing;
+
+		const refresh = this.refreshPathUncached(path).finally(() => {
+			if (this.inFlight.get(path) === refresh) this.inFlight.delete(path);
+		});
+		this.inFlight.set(path, refresh);
+		return refresh;
+	}
+
+	private async refreshPathUncached(path: string): Promise<void> {
+		const metadata = await readWorktreeMetadata(path);
+		if (this.disposed) return;
+		if (!metadata) {
+			const changed = this.cache.delete(path);
+			this.trackedPaths.delete(path);
+			if (changed) this.host.onChange?.();
+			return;
+		}
+
+		const previous = this.cache.get(path);
+		const status = await readGitStatus(
+			(command, args, options) => this.host.exec(command, args, options),
+			path,
+			this.abortController.signal,
+		);
+		if (this.disposed) return;
+		const branch = status?.branch ?? metadata.branch;
+		const branchChanged = previous !== undefined && previous.branch !== branch;
+		let next: CachedWorktree = {
+			...metadata,
+			branch,
+			dirty: status?.dirty ?? (branchChanged ? false : (previous?.dirty ?? false)),
+			behind: status?.behind ?? (branchChanged ? 0 : (previous?.behind ?? 0)),
+			pr: branchChanged ? undefined : previous?.pr,
+			prState: branchChanged ? undefined : previous?.prState,
+			prCheckedAt: branchChanged ? 0 : (previous?.prCheckedAt ?? 0),
+		};
+		if (!sameDisplay(previous, next)) {
+			this.cache.set(path, next);
+			this.host.onChange?.();
+		}
+
+		const now = this.host.now?.() ?? Date.now();
+		const ttl = next.pr === undefined ? PR_ABSENT_TTL_MS : PR_TTL_MS;
+		if (now - next.prCheckedAt < ttl) return;
+
+		const result = await this.host.exec("gh", ["pr", "view", "--json", "number,state"], {
+			cwd: path,
+			timeout: 8_000,
+			signal: this.abortController.signal,
+		});
+		if (this.disposed) return;
+
+		if (result.code === 0) {
+			try {
+				const value = JSON.parse(result.stdout) as { number?: unknown; state?: unknown };
+				if (typeof value.number === "number") next = { ...next, pr: value.number };
+				if (typeof value.state === "string") next = { ...next, prState: value.state };
+			} catch {
+				// Keep the last known PR when gh returns malformed output.
+			}
+		}
+		next = { ...next, prCheckedAt: now };
+		const changed = !sameDisplay(this.cache.get(path), next);
+		this.cache.set(path, next);
+		if (changed) this.host.onChange?.();
+	}
+}