@brimveyn/aimux 1.20.3 → 1.21.0

package/src/git/pr-status-poller.ts

@@ -0,0 +1,57 @@
+import { useEffect } from 'react'
+
+import { prStatusStore } from '../state/pr-status-store'
+import { collectPrStatus } from './pr-status'
+
+/** A run in flight is worth watching closely; a settled one barely changes. */
+const ACTIVE_INTERVAL_MS = 15_000
+const IDLE_INTERVAL_MS = 60_000
+const MAX_INTERVAL_MS = 120_000
+
+interface Options {
+  enabled: boolean
+  projectPath: string | undefined
+}
+
+/** One-shot refetch, for when an action we took just invalidated the state. */
+export async function refreshPrStatus(projectPath: string): Promise<void> {
+  prStatusStore.getState().setResult(await collectPrStatus(projectPath))
+}
+
+export function usePrStatusPolling({ enabled, projectPath }: Options): void {
+  useEffect(() => {
+    if (!enabled || !(projectPath != null && projectPath !== '')) return
+
+    prStatusStore.getState().reset()
+
+    let cancelled = false
+    let timer: ReturnType<typeof setTimeout> | null = null
+    let delay = ACTIVE_INTERVAL_MS
+
+    const schedule = () => {
+      if (cancelled) return
+      timer = setTimeout(() => void tick(), delay)
+    }
+
+    const tick = async () => {
+      const result = await collectPrStatus(projectPath)
+      if (cancelled) return
+      prStatusStore.getState().setResult(result)
+      if (result.kind === 'error') {
+        delay = Math.min(delay * 2, MAX_INTERVAL_MS)
+      } else if (result.kind === 'ok' && result.checks.some((c) => c.state === 'pending')) {
+        delay = ACTIVE_INTERVAL_MS
+      } else {
+        delay = IDLE_INTERVAL_MS
+      }
+      schedule()
+    }
+
+    void tick()
+
+    return () => {
+      cancelled = true
+      if (timer) clearTimeout(timer)
+    }
+  }, [enabled, projectPath])
+}

package/src/git/pr-status.ts

@@ -0,0 +1,227 @@
+import { runCli } from '../services/ai-usage/spawn'
+
+export type PrCheckState = 'pass' | 'fail' | 'pending' | 'skipping' | 'cancel'
+
+export interface PrCheck {
+  name: string
+  workflow: string
+  state: PrCheckState
+  url: string
+  durationMs: number | null
+}
+
+export interface PrSummary {
+  number: number
+  title: string
+  body: string
+  state: string
+  isDraft: boolean
+  base: string
+  head: string
+  reviewDecision: string
+  /** MERGEABLE | CONFLICTING | UNKNOWN */
+  mergeable: string
+  /** CLEAN | BLOCKED | BEHIND | UNSTABLE | DIRTY | DRAFT | HAS_HOOKS | UNKNOWN */
+  mergeStateStatus: string
+  additions: number
+  deletions: number
+  changedFiles: number
+  url: string
+}
+
+export type PrStatusResult =
+  | { kind: 'ok'; pr: PrSummary; checks: PrCheck[] }
+  | { kind: 'no-pr' }
+  | { kind: 'no-gh' }
+  | { kind: 'error'; message: string }
+
+const PR_VIEW_FIELDS = [
+  'number',
+  'title',
+  'body',
+  'state',
+  'isDraft',
+  'url',
+  'baseRefName',
+  'headRefName',
+  'reviewDecision',
+  'mergeable',
+  'mergeStateStatus',
+  'additions',
+  'deletions',
+  'changedFiles',
+  'statusCheckRollup',
+].join(',')
+
+const NOT_AN_ERROR = [
+  'no pull requests found',
+  'no git remotes',
+  'not a git repository',
+  'none of the git remotes',
+  'no default remote',
+]
+
+function str(value: unknown): string {
+  return typeof value === 'string' ? value : ''
+}
+
+function num(value: unknown): number {
+  return typeof value === 'number' && Number.isFinite(value) ? value : 0
+}
+
+function duration(startedAt: unknown, completedAt: unknown): number | null {
+  const start = Date.parse(str(startedAt))
+  const end = Date.parse(str(completedAt))
+  if (Number.isNaN(start) || Number.isNaN(end) || end < start) return null
+  return end - start
+}
+
+// `gh` documents these buckets for `pr checks --json bucket`; we derive the same
+// classification from the raw rollup so a single `pr view` call covers both the
+// summary and the checks.
+function checkRunState(status: string, conclusion: string): PrCheckState {
+  if (status !== 'COMPLETED') return 'pending'
+  if (conclusion === 'SUCCESS' || conclusion === 'NEUTRAL') return 'pass'
+  if (conclusion === 'SKIPPED') return 'skipping'
+  if (conclusion === 'CANCELLED') return 'cancel'
+  return 'fail'
+}
+
+function statusContextState(state: string): PrCheckState {
+  if (state === 'SUCCESS') return 'pass'
+  if (state === 'PENDING' || state === 'EXPECTED') return 'pending'
+  return 'fail'
+}
+
+function toCheck(raw: unknown): PrCheck | null {
+  if (typeof raw !== 'object' || raw === null) return null
+  const entry = raw as Record<string, unknown>
+  if (entry.__typename === 'StatusContext') {
+    const name = str(entry.context)
+    if (name === '') return null
+    return {
+      durationMs: null,
+      name,
+      state: statusContextState(str(entry.state)),
+      url: str(entry.targetUrl),
+      workflow: '',
+    }
+  }
+  const name = str(entry.name)
+  if (name === '') return null
+  return {
+    durationMs: duration(entry.startedAt, entry.completedAt),
+    name,
+    state: checkRunState(str(entry.status), str(entry.conclusion)),
+    url: str(entry.detailsUrl),
+    workflow: str(entry.workflowName),
+  }
+}
+
+export function parsePrView(raw: unknown): PrStatusResult {
+  if (typeof raw !== 'object' || raw === null) return { kind: 'no-pr' }
+  const pr = raw as Record<string, unknown>
+  if (typeof pr.number !== 'number') return { kind: 'no-pr' }
+  const rollup = Array.isArray(pr.statusCheckRollup) ? pr.statusCheckRollup : []
+  return {
+    checks: rollup.map(toCheck).filter((c): c is PrCheck => c !== null),
+    kind: 'ok',
+    pr: {
+      additions: num(pr.additions),
+      base: str(pr.baseRefName),
+      body: str(pr.body).trim(),
+      changedFiles: num(pr.changedFiles),
+      deletions: num(pr.deletions),
+      head: str(pr.headRefName),
+      isDraft: pr.isDraft === true,
+      mergeable: str(pr.mergeable),
+      mergeStateStatus: str(pr.mergeStateStatus),
+      number: pr.number,
+      reviewDecision: str(pr.reviewDecision),
+      state: str(pr.state),
+      title: str(pr.title),
+      url: str(pr.url),
+    },
+  }
+}
+
+export type PrAction = 'merge' | null
+
+export interface PrActionState {
+  label: string
+  action: PrAction
+  tone: 'ok' | 'blocked' | 'neutral'
+}
+
+/**
+ * The headline GitHub puts on the merge box, and the one action worth wiring to
+ * it. Order matters: a terminal state beats everything, then a hard blocker
+ * (conflicts, draft), then whatever the checks are doing. Anything we can't
+ * offer an action for still gets an honest label rather than a dead button.
+ */
+export function prActionState(pr: PrSummary, checks: PrCheck[]): PrActionState {
+  if (pr.state === 'MERGED') return { action: null, label: 'Merged', tone: 'neutral' }
+  if (pr.state === 'CLOSED') return { action: null, label: 'Closed', tone: 'blocked' }
+  if (pr.isDraft) return { action: null, label: 'Draft', tone: 'neutral' }
+  if (pr.mergeable === 'CONFLICTING') {
+    return { action: null, label: 'Merge conflicts', tone: 'blocked' }
+  }
+  if (checks.some((c) => c.state === 'pending')) {
+    return { action: null, label: 'Checks running', tone: 'neutral' }
+  }
+  if (pr.mergeStateStatus === 'BLOCKED') return { action: null, label: 'Blocked', tone: 'blocked' }
+  if (pr.mergeStateStatus === 'BEHIND')
+    return { action: null, label: 'Out of date', tone: 'blocked' }
+  // UNSTABLE means a non-required check failed; GitHub still lets you merge.
+  if (pr.mergeStateStatus === 'UNSTABLE') {
+    return { action: 'merge', label: 'Checks failing', tone: 'blocked' }
+  }
+  if (pr.mergeStateStatus === 'CLEAN') {
+    return { action: 'merge', label: 'Ready to merge', tone: 'ok' }
+  }
+  return { action: null, label: 'Checking…', tone: 'neutral' }
+}
+
+export interface ClampedBody {
+  text: string
+  truncated: boolean
+}
+
+/**
+ * A PR body is a whole document; a bar widget gets a preview of it. Clamping on
+ * lines alone breaks on a wall-of-text paragraph and clamping on characters
+ * alone breaks on a bullet list, so whichever limit bites first wins.
+ */
+export function clampPrBody(body: string, maxLines = 5, maxChars = 260): ClampedBody {
+  const full = body.trimEnd()
+  const lines = full.split('\n')
+  let text = lines.slice(0, maxLines).join('\n')
+  if (text.length > maxChars) {
+    const space = text.lastIndexOf(' ', maxChars)
+    // Only respect a word boundary that isn't absurdly early, else hard-cut.
+    text = text.slice(0, space > maxChars / 2 ? space : maxChars)
+  }
+  text = text.trimEnd()
+  return { text, truncated: text.length < full.length }
+}
+
+export async function collectPrStatus(cwd: string): Promise<PrStatusResult> {
+  const gh = Bun.which('gh')
+  if (gh === null) return { kind: 'no-gh' }
+
+  const result = await runCli(gh, ['pr', 'view', '--json', PR_VIEW_FIELDS], 15_000, cwd)
+  if (!result.ok) {
+    // `gh` exits non-zero for every "there is simply nothing to show" case too:
+    // no PR on the branch, no GitHub remote, or a directory that isn't a repo
+    // at all (aimux sessions can point anywhere). None of those is an error.
+    const stderr = result.stderr.toLowerCase()
+    if (NOT_AN_ERROR.some((needle) => stderr.includes(needle))) return { kind: 'no-pr' }
+    return { kind: 'error', message: (result.error ?? 'gh failed').slice(0, 200) }
+  }
+
+  try {
+    return parsePrView(JSON.parse(result.stdout))
+  } catch {
+    return { kind: 'no-pr' }
+  }
+}

package/src/index.tsx

@@ -72,8 +72,14 @@ if (command === '--help' || command === '-h' || command === 'help') {
   process.exit(await runCli([]))
 }
 
+// Sequential ON PURPOSE: @opentui/react evaluates @opentui/core as part of its
+// own module graph. Loading both concurrently races the two evaluations and
+// react's chunk can hit `class X extends TextNodeRenderable` while core is
+// still initializing (ReferenceError: cannot access before initialization).
+// react has to wait on core either way, so this costs nothing.
+const { createCliRenderer } = await import('@opentui/core')
+
 const [
-  { createCliRenderer },
   { createRoot },
   { App },
   { loadUserConfig },
@@ -82,7 +88,6 @@ const [
   { createSessionBackend },
   { maybeAutoInstallCompletion },
 ] = await Promise.all([
-  import('@opentui/core'),
   import('@opentui/react'),
   import('./app'),
   import('./config/loader'),

package/src/platform/clipboard.ts

@@ -1,13 +1,135 @@
+import { existsSync, readFileSync } from 'node:fs'
+
 import { logDebug } from '../debug/input-log'
 import { toast } from '../state/toast-store'
 
+export interface ClipboardCandidate {
+  argv: string[]
+  // powershell's Get-Clipboard emits CRLF line endings and appends a trailing
+  // newline of its own; both have to be undone to get the copied text back.
+  normalizeWindowsOutput?: boolean
+}
+
+export interface ClipboardPlatform {
+  env: Record<string, string | undefined>
+  isWsl: boolean
+  platform: string
+}
+
+const POWERSHELL_PASTE: ClipboardCandidate = {
+  argv: ['powershell.exe', '-NoProfile', '-NonInteractive', '-Command', 'Get-Clipboard'],
+  normalizeWindowsOutput: true,
+}
+
+function isSet(value: string | undefined): boolean {
+  return value !== undefined && value !== ''
+}
+
+export function detectClipboardPlatform(): ClipboardPlatform {
+  return {
+    env: process.env,
+    isWsl: detectWsl(),
+    platform: process.platform,
+  }
+}
+
+function detectWsl(): boolean {
+  if (process.platform !== 'linux') return false
+  if (isSet(process.env.WSL_DISTRO_NAME) || isSet(process.env.WSL_INTEROP)) return true
+  try {
+    return readFileSync('/proc/version', 'utf8').toLowerCase().includes('microsoft')
+  } catch {
+    return false
+  }
+}
+
+export function copyCandidates({ env, isWsl, platform }: ClipboardPlatform): ClipboardCandidate[] {
+  if (platform === 'darwin') return [{ argv: ['pbcopy'] }]
+  if (platform === 'win32') return [{ argv: ['clip'] }]
+
+  const candidates: ClipboardCandidate[] = []
+  // On WSL the Windows clipboard is the one the user pastes from, and clip.exe
+  // always reaches it. The X/Wayland bridges only exist under WSLg.
+  if (isWsl) {
+    candidates.push({ argv: ['clip.exe'] }, { argv: ['/mnt/c/Windows/System32/clip.exe'] })
+  }
+  const wayland: ClipboardCandidate = { argv: ['wl-copy'] }
+  const xorg: ClipboardCandidate[] = [
+    { argv: ['xclip', '-selection', 'clipboard'] },
+    { argv: ['xsel', '--clipboard', '--input'] },
+  ]
+  candidates.push(...(isSet(env.WAYLAND_DISPLAY) ? [wayland, ...xorg] : [...xorg, wayland]))
+  return candidates
+}
+
+export function pasteCandidates({ env, isWsl, platform }: ClipboardPlatform): ClipboardCandidate[] {
+  if (platform === 'darwin') return [{ argv: ['pbpaste'] }]
+  if (platform === 'win32') return [POWERSHELL_PASTE]
+
+  const candidates: ClipboardCandidate[] = []
+  if (isWsl) candidates.push(POWERSHELL_PASTE)
+  const wayland: ClipboardCandidate = { argv: ['wl-paste', '--no-newline'] }
+  const xorg: ClipboardCandidate[] = [
+    { argv: ['xclip', '-selection', 'clipboard', '-o'] },
+    { argv: ['xsel', '--clipboard', '--output'] },
+  ]
+  candidates.push(...(isSet(env.WAYLAND_DISPLAY) ? [wayland, ...xorg] : [...xorg, wayland]))
+  return candidates
+}
+
+function resolveCandidate(candidates: ClipboardCandidate[]): ClipboardCandidate | null {
+  for (const candidate of candidates) {
+    const [bin, ...args] = candidate.argv
+    if (bin === undefined) continue
+    let resolved: string | null
+    if (bin.includes('/')) {
+      resolved = existsSync(bin) ? bin : null
+    } else {
+      resolved = Bun.which(bin)
+    }
+    if (resolved !== null) return { ...candidate, argv: [resolved, ...args] }
+  }
+  return null
+}
+
+let cachedCopy: ClipboardCandidate | null | undefined
+let cachedPaste: ClipboardCandidate | null | undefined
+
+function copyCommand(): ClipboardCandidate | null {
+  cachedCopy ??= resolveCandidate(copyCandidates(detectClipboardPlatform()))
+  return cachedCopy
+}
+
+function pasteCommand(): ClipboardCandidate | null {
+  cachedPaste ??= resolveCandidate(pasteCandidates(detectClipboardPlatform()))
+  return cachedPaste
+}
+
+const MISSING_TOOL_MESSAGE =
+  process.platform === 'darwin'
+    ? 'Copy failed: pbcopy not found'
+    : 'Copy failed: install xclip, wl-clipboard, or xsel'
+
 export function copyToSystemClipboard(text: string): void {
+  const command = copyCommand()
+  if (!command) {
+    logDebug('platform.clipboard.noCopyCommand', { platform: process.platform })
+    toast.error(MISSING_TOOL_MESSAGE)
+    return
+  }
   try {
-    const proc = Bun.spawn(['pbcopy'], { stdin: 'pipe' })
+    const proc = Bun.spawn(command.argv, { stderr: 'pipe', stdin: 'pipe' })
     void proc.stdin.write(text)
     void proc.stdin.end()
+    void (async () => {
+      const code = await proc.exited
+      if (code === 0) return
+      logDebug('platform.clipboard.copyExit', { argv: command.argv, code })
+      toast.error('Copy failed')
+    })()
   } catch (error) {
     logDebug('platform.clipboard.copyError', {
+      argv: command.argv,
       error: error instanceof Error ? error.message : String(error),
     })
     toast.error('Copy failed')
@@ -15,15 +137,29 @@ export function copyToSystemClipboard(text: string): void {
 }
 
 export async function readFromSystemClipboard(): Promise<string> {
+  const command = pasteCommand()
+  if (!command) {
+    logDebug('platform.clipboard.noPasteCommand', { platform: process.platform })
+    return ''
+  }
   try {
-    const proc = Bun.spawn(['pbpaste'], { stdout: 'pipe' })
+    const proc = Bun.spawn(command.argv, { stderr: 'pipe', stdout: 'pipe' })
     const text = await new Response(proc.stdout).text()
-    await proc.exited
-    return text
+    const code = await proc.exited
+    if (code !== 0) {
+      logDebug('platform.clipboard.readExit', { argv: command.argv, code })
+      return ''
+    }
+    return command.normalizeWindowsOutput === true ? normalizeWindowsClipboardText(text) : text
   } catch (error) {
     logDebug('platform.clipboard.readError', {
+      argv: command.argv,
       error: error instanceof Error ? error.message : String(error),
     })
     return ''
   }
 }
+
+export function normalizeWindowsClipboardText(text: string): string {
+  return text.replaceAll('\r\n', '\n').replace(/\n$/, '')
+}

package/src/platform/open-url.ts

@@ -0,0 +1,39 @@
+import { logDebug } from '../debug/input-log'
+import { toast } from '../state/toast-store'
+import { detectClipboardPlatform } from './clipboard'
+
+/**
+ * URLs here come from the GitHub API, i.e. outside the process. Handing an
+ * arbitrary scheme to the OS opener is a code-execution path (`file://`,
+ * `javascript:`, custom app handlers), so only plain https is allowed through.
+ */
+function isSafeUrl(url: string): boolean {
+  return /^https:\/\/[^\s]+$/.test(url)
+}
+
+export function openUrlCommand(platform: string, isWsl: boolean, url: string): string[] | null {
+  if (!isSafeUrl(url)) return null
+  if (platform === 'darwin') return ['open', url]
+  // Under WSL the browser lives on the Windows side; explorer.exe is the one
+  // bridge present on every install (wslview/xdg-open often are not).
+  if (platform === 'win32' || isWsl) return ['explorer.exe', url]
+  return ['xdg-open', url]
+}
+
+export function openUrl(url: string): void {
+  const { isWsl, platform } = detectClipboardPlatform()
+  const argv = openUrlCommand(platform, isWsl, url)
+  if (!argv) {
+    logDebug('platform.openUrl.rejected', { url })
+    return
+  }
+  try {
+    Bun.spawn(argv, { stderr: 'ignore', stdin: 'ignore', stdout: 'ignore' })
+  } catch (error) {
+    logDebug('platform.openUrl.error', {
+      argv,
+      error: error instanceof Error ? error.message : String(error),
+    })
+    toast.error(`Could not open ${argv[0]}`)
+  }
+}

package/src/services/ai-usage/spawn.ts

@@ -10,9 +10,11 @@ const DEFAULT_TIMEOUT_MS = 15_000
 export async function runCli(
   command: string,
   args: string[],
-  timeoutMs: number = DEFAULT_TIMEOUT_MS
+  timeoutMs: number = DEFAULT_TIMEOUT_MS,
+  cwd?: string
 ): Promise<CliResult> {
   const proc = Bun.spawn([command, ...args], {
+    cwd,
     stderr: 'pipe',
     stdin: 'ignore',
     stdout: 'pipe',

package/src/state/bars.ts

@@ -0,0 +1,75 @@
+import type { BarSide, BarsState, BarState, BarWidget } from './types'
+
+export const BAR_MIN_WIDTH = 18
+export const BAR_MAX_WIDTH = 80
+
+/** Widget ids the app knows how to render. Unknown ids are pruned on load. */
+export const KNOWN_WIDGET_IDS = ['workspaces', 'git'] as const
+
+/** Smallest share of a bar a single widget may shrink to, as a fraction. */
+const MIN_WIDGET_SHARE = 0.1
+
+export function clampBarWidth(width: number): number {
+  return Math.min(BAR_MAX_WIDTH, Math.max(BAR_MIN_WIDTH, Math.round(width)))
+}
+
+export function visibleWidgets(bar: BarState): BarWidget[] {
+  return bar.widgets.filter((widget) => widget.visible)
+}
+
+/**
+ * The single authority on how many columns a bar occupies. Both the `Bar`
+ * component and the terminal-size computation must call this — a mismatch
+ * silently corrupts PTY columns and mouse hit-testing.
+ */
+export function getBarWidth(bar: BarState): number {
+  if (!bar.visible || visibleWidgets(bar).length === 0) return 0
+  return clampBarWidth(bar.width)
+}
+
+export function findWidgetBar(bars: BarsState, widgetId: string): BarSide | null {
+  if (bars.left.widgets.some((widget) => widget.id === widgetId)) return 'left'
+  if (bars.right.widgets.some((widget) => widget.id === widgetId)) return 'right'
+  return null
+}
+
+function totalGrow(widgets: BarWidget[]): number {
+  return widgets.reduce((sum, widget) => sum + widget.grow, 0)
+}
+
+/**
+ * Move the boundary between visible widgets `index` and `index + 1` by
+ * `deltaGrow`. Only the pair changes, so the bar's total grow is preserved and
+ * no renormalisation is ever needed — including when a widget is added.
+ */
+export function shiftBoundary(bar: BarState, index: number, deltaGrow: number): BarWidget[] {
+  const visible = visibleWidgets(bar)
+  const above = visible[index]
+  const below = visible[index + 1]
+  if (!above || !below) return bar.widgets
+
+  const min = Math.max(1, Math.round(totalGrow(visible) * MIN_WIDGET_SHARE))
+  const pair = above.grow + below.grow
+  if (pair < min * 2) return bar.widgets
+
+  const nextAbove = Math.min(pair - min, Math.max(min, Math.round(above.grow + deltaGrow)))
+  if (nextAbove === above.grow) return bar.widgets
+
+  return bar.widgets.map((widget) => {
+    if (widget.id === above.id) return { ...widget, grow: nextAbove }
+    if (widget.id === below.id) return { ...widget, grow: pair - nextAbove }
+    return widget
+  })
+}
+
+/**
+ * Convert an absolute drag position (a 0..1 fraction of the bar's body) into
+ * the grow delta `shiftBoundary` expects for that boundary.
+ */
+export function boundaryDeltaFromRatio(bar: BarState, index: number, ratio: number): number {
+  const visible = visibleWidgets(bar)
+  const target = visible[index]
+  if (!target) return 0
+  const above = visible.slice(0, index).reduce((sum, widget) => sum + widget.grow, 0)
+  return ratio * totalGrow(visible) - above - target.grow
+}

package/src/state/git-pane-sizing.ts

@@ -1,15 +1,6 @@
 export const GIT_PANE_MIN_RATIO = 0.2
 export const GIT_PANE_MAX_RATIO = 0.8
-export const GIT_PANE_MIN_WIDTH = 20
-export const GIT_PANE_MAX_WIDTH = 80
 
 export function clampGitPaneRatio(value: number): number {
   return Math.max(GIT_PANE_MIN_RATIO, Math.min(GIT_PANE_MAX_RATIO, value))
 }
-
-export function getGitPaneWidthFromRatio(ratio: number): number {
-  return Math.max(
-    GIT_PANE_MIN_WIDTH,
-    Math.min(GIT_PANE_MAX_WIDTH, Math.round(clampGitPaneRatio(ratio) * GIT_PANE_MAX_WIDTH))
-  )
-}

package/src/state/pr-status-store.ts

@@ -0,0 +1,39 @@
+import { useStore } from 'zustand'
+import { createStore } from 'zustand/vanilla'
+
+import type { PrStatusResult } from '../git/pr-status'
+
+export interface PrStatusState {
+  result: PrStatusResult | null
+  /** True once a fetch failed but we are still showing the previous good result. */
+  stale: boolean
+  setResult: (result: PrStatusResult) => void
+  reset: () => void
+}
+
+export const prStatusStore = createStore<PrStatusState>((set) => ({
+  reset: () => set({ result: null, stale: false }),
+  result: null,
+  setResult: (result: PrStatusResult) =>
+    set((state) => {
+      // A transient `gh` failure shouldn't blank a PR we already resolved — keep
+      // the last good snapshot and mark it stale instead (same contract as
+      // ai-usage-store's setSnapshot).
+      if (result.kind === 'error' && state.result?.kind === 'ok') return { stale: true }
+      return { result, stale: false }
+    }),
+  stale: false,
+}))
+
+/**
+ * The PR state row occupies its band both while the first fetch is in flight
+ * and once it resolved to a PR — anything else (no PR, no gh, error) gives the
+ * row back. Shared so the header and the row itself can never disagree and
+ * shift the layout under the user.
+ */
+export const selectPrRowVisible = (state: PrStatusState): boolean =>
+  state.result === null || state.result.kind === 'ok'
+
+export function usePrStatusStore<T>(selector: (state: PrStatusState) => T): T {
+  return useStore(prStatusStore, selector)
+}