From 73aede7227a64288ae0d4f837419607b9f177c69 Mon Sep 17 00:00:00 2001
From: Laurent Guitton <laurent.guitton@dendreo.com>
Date: Thu, 9 Jul 2026 21:22:30 +0200
Subject: [PATCH 01/18] docs: add design spec for PR badge background
 prefetch/cache

Mirrors the PR #113 git-log caching pattern for the PR badge path,
which today caps at 10 open PRs and never drains further pages.
---
 .../2026-07-09-pr-badge-prefetch-design.md    | 157 ++++++++++++++++++
 1 file changed, 157 insertions(+)
 create mode 100644 docs/superpowers/specs/2026-07-09-pr-badge-prefetch-design.md

diff --git a/docs/superpowers/specs/2026-07-09-pr-badge-prefetch-design.md b/docs/superpowers/specs/2026-07-09-pr-badge-prefetch-design.md
new file mode 100644
index 00000000..34a2504e
--- /dev/null
+++ b/docs/superpowers/specs/2026-07-09-pr-badge-prefetch-design.md
@@ -0,0 +1,157 @@
+# PR badges — background prefetch & cache (git-log style)
+
+## Problem
+
+The branch-badge path (`#<number>` shown on branches with an open PR, in `BranchSelector.vue`) only ever loads the first page of open PRs. `usePrPanel.ts::ensurePrsLoaded()` is a one-shot guard: it calls `loadPrs()` exactly once per repo, which fetches `PAGE_SIZE = 10` open PRs at offset 0, and never calls the existing `loadMorePrs()` pagination. Any repo with more than 10 open PRs — or where the relevant PR isn't within `gh`'s first 10 by creation order — silently gets no badge. There is no cache-based instant restore either: every repo (re)open starts the one page-of-10 fetch again from a cold state (aside from the 24h localStorage SWR cache in `usePrCache.ts`, which caches only whatever was fetched, i.e. still just 10 PRs).
+
+This mirrors the git-log pagination bug fixed in PR #113 ("Cache the Git log and prefetch pages", `apps/desktop/src/composables/useGitRepo.ts`), and should get the same treatment: a background prefetch loop that drains further pages after the first paint, plus an in-memory cache keyed by repo so a repeat visit restores instantly when nothing changed upstream.
+
+## Goals
+
+- Branch badges reflect open PRs beyond the first 10, up to a bounded ceiling, without blocking the UI.
+- Repeat visits to a repo (branch popover reopened, tab switch back) restore the previously-drained PR list instantly from an in-memory cache when nothing has changed on GitHub, instead of re-fetching.
+- Cache invalidation is signal-based (like git log's head-hash), not purely time-based: detect that something changed upstream, then redrain.
+- Do not blow up API/subprocess cost — both Rust list-fetch paths (`gh` CLi and REST) paginate naively (`offset+limit` then slice, re-walking from the start on every call), so a naive one-page-at-a-time background drain would multiply cost roughly quadratically as more pages are pulled.
+
+## Non-goals
+
+- Closed/merged PRs — badges stay scoped to `state: "open"`, matching current behavior.
+- Cursor-based GraphQL pagination in the Rust layer (`gh_list_prs_inner` / `rest_list_prs`) — that's a separate, already-tracked TODO (Phase 2 / v2.9 comments in `gh.rs` and `github_api.rs`). This feature works within the existing naive pagination, just calls it less often and in bigger jumps.
+- Non-GitHub forges (GitLab, Bitbucket, Azure) get the background-drain fix (the actual breadth bug) but not the instant-paint freshness shortcut — see "Forge scope" below.
+- Any change to the PR *detail* view, PR panel's own manual pagination/scroll UX, or `usePrCache.ts`'s existing localStorage SWR layer (kept as-is, unchanged).
+
+## Existing pieces (no changes except noted)
+
+- `apps/desktop/src/composables/usePrPanel.ts` — singleton PR-panel state. Relevant existing bits:
+  - `PAGE_SIZE = 10`, `hasMore`, `loadingMore`, `loadPrs()`, `loadMorePrs()` — foreground pagination.
+  - `_prsEnsured` flag + `ensurePrsLoaded()` — the one-shot badge-population entry point, called from `BranchSelector.vue`'s popover open and from `App.vue`'s graph-mode entry.
+  - `cache.invalidateLists(cwd)` already called from `createPr()` and `mergePr()` (localStorage SWR invalidation on mutation).
+- `apps/desktop/src/composables/usePrCache.ts` — localStorage SWR cache, 24h TTL, `listKey(cwd, filterState)`. Untouched by this feature; the new in-memory cache sits alongside it, the same way `useGitRepo.ts`'s `LOG_CACHE` module-level `Map` sits alongside no other cache.
+- `apps/desktop/src-tauri/src/commands/gh.rs::gh_list_prs_inner` and `apps/desktop/src-tauri/src/commands/github_api.rs::rest_list_prs` — both take `(cwd, state, limit, offset)` and implement naive pagination: fetch `offset + limit` items from the start, then slice off the first `offset`. `rest_list_prs` already requests `sort=updated&direction=desc` from the GitHub REST API; `gh_list_prs_inner` (the `gh` CLI path, used when no token is configured in Settings) passes no sort flag, so `gh pr list`'s default order applies (creation descending).
+- `apps/desktop/src-tauri/src/commands/github_api.rs::rest_pr_count` and `gh.rs::gh_pr_count_inner` — existing cheap "how many PRs match this state" functions (REST: `/search/issues?...&per_page=1`, reads `total_count`; CLI: separate GraphQL count query). Both already exist and are reused as-is by the freshness signal below.
+
+## Architecture
+
+### In-memory cache (new)
+
+A module-level `Map` in `usePrPanel.ts`, analogous to `useGitRepo.ts`'s `LOG_CACHE`:
+
+```ts
+const PR_LIST_CACHE = new Map<string, {
+  prs: PullRequest[];
+  hasMore: boolean;
+  topSignal: { number: number; updatedAt: string; openCount: number } | null;
+}>();
+```
+
+Keyed by `cwd` only (not by filter state — this cache is scoped to the badge path, which is always `state: "open"`).
+
+### Background prefetch (new)
+
+`prefetchOpenPrs()`, called from `ensurePrsLoaded()` right after the first page loads successfully:
+
+```ts
+const BG_PAGE = 100;           // bigger than PAGE_SIZE=10 — see cost note below
+const PREFETCH_CEILING = 300;  // matches the existing dev-server REST cap (3×100 pages)
+
+async function prefetchOpenPrs() {
+  const token = ++_prPrefetchToken;
+  const repo = cwd.value;
+  const live = () =>
+    _prPrefetchToken === token && cwd.value === repo && filterState.value === "open";
+  while (live() && hasMore.value && prs.value.length < PREFETCH_CEILING) {
+    await whenIdle();
+    if (!live()) return;
+    await loadMoreThroughBg(BG_PAGE); // loadMorePrs, parametrized with BG_PAGE instead of PAGE_SIZE
+  }
+  if (live() && !hasMore.value) {
+    PR_LIST_CACHE.set(repo, {
+      prs: prs.value.slice(),
+      hasMore: false,
+      topSignal: await fetchFreshnessSignal(repo),
+    });
+  }
+}
+```
+
+- `whenIdle()` — extracted from `useGitRepo.ts` into a new shared `apps/desktop/src/composables/useIdleSchedule.ts` (or `utils/idle.ts`) so both composables use the same `requestIdleCallback` (timeout 300ms) + `setTimeout(32ms)` fallback, instead of duplicating it.
+- `loadMoreThroughBg(pageSize)` is `loadMorePrs()` generalized to take a page size parameter (default `PAGE_SIZE` for the existing scroll-driven foreground calls, `BG_PAGE` for background prefetch), otherwise identical: same `loadingMore`/`hasMore`/`refreshing` guards, same dedup-by-`number` logic.
+- A capped drain (`PREFETCH_CEILING` reached while `hasMore` is still true) is **not** written to `PR_LIST_CACHE` as "complete" — mirrors git log's ceiling behavior, so the badge path simply has partial coverage on pathologically large PR counts rather than falsely claiming completeness.
+- Cancellation: `_prPrefetchToken` + `live()` bail out a stale prefetch if the repo changes, or a manual action (`createPr`/`mergePr`) invalidates mid-drain.
+
+**Cost note:** because `loadMorePrs`'s underlying Rust call re-fetches `offset+limit` items from scratch every time, a naive 10-at-a-time background drain to a 300-PR ceiling would issue calls at offsets 10, 20, …, 290 with limits 20, 30, …, 300 — summing to ~4,650 PR items fetched from GitHub to populate 300 badges (~15× overhead). Using `BG_PAGE = 100` instead means 3 background calls (offsets 10, 110, 210; limits 110, 210, 310) summing to ~630 items (~2× overhead) — bounded and acceptable.
+
+### Cache read / fast path (new)
+
+`ensurePrsLoaded()` changes from "one-shot forever" to "cheap-checked on every call, throttled":
+
+1. If `PR_LIST_CACHE` has an entry for `cwd.value` **and** it's been at least 30s since the last check (new `_lastFreshnessCheck` timestamp, throttling repeated popover toggles the way `_lastPoll` already throttles the visibility-change catch-up in this same file): call `fetchFreshnessSignal(cwd.value)` (new, see below).
+   - Signal matches cached `topSignal` → restore instantly: `prs.value = cached.prs; hasMore.value = false`. No page-1 fetch, no prefetch loop.
+   - Signal differs, or the probe itself errors → treat cache as stale: delete the entry, fall through to the normal `loadPrs()` first-page fetch + `prefetchOpenPrs()`.
+2. No cache entry → normal `loadPrs()` first-page fetch, then kick off `prefetchOpenPrs()` in the background (same as today's flow, just no longer stopping after page 1).
+
+This replaces the current `if (!cwd.value || _prsEnsured || prs.value.length > 0) return;` one-shot guard.
+
+### Invalidation signal — `fetchFreshnessSignal(cwd)`
+
+A single lightweight probe combining two cheap existing/near-existing calls:
+
+- **Most-recently-updated open PR** — `{ number, updatedAt }`. On the REST/token path, `rest_list_prs(cwd, "open", 1, 0, token)` already sorts `updated desc`, so this is a free `per_page=1` call, no Rust change needed. On the `gh` CLI path, `gh_list_prs_inner` has no sort flag (`gh pr list`'s default is creation-descending) — the new dedicated command adds `-S "sort:updated-desc"` **only** for this probe, without touching the main list fetch's ordering.
+- **Open PR count** — reuses the existing `rest_pr_count` / `gh_pr_count_inner` as-is. Needed because a PR transitioning from open → closed drops out of the "state=open" results entirely, so "the top-updated PR is unchanged" alone wouldn't catch that case.
+
+New Rust command bundling both, mirroring the existing token/CLI branch in `gh_list_prs_inner`:
+
+```rust
+#[tauri::command]
+pub(crate) async fn gh_pr_freshness_signal(cwd: String) -> Result<Option<PrFreshnessSignal>, String>
+```
+
+```rust
+pub(crate) struct PrFreshnessSignal {
+    number: i64,
+    updated_at: String,
+    open_count: i64,
+}
+```
+
+- Token path: `rest_list_prs(&cwd, "open", 1, 0, &token)` for the top PR + `rest_pr_count(&cwd, "open", &token)` for the count.
+- `gh` CLI path: `gh pr list --state open --json number,updatedAt --limit 1 -S "sort:updated-desc"` for the top PR + existing `gh_pr_count_inner(cwd, "open")` for the count. Reuses `gh_fork_upstream` for `--repo` resolution, same as `gh_list_prs_inner`.
+- Returns `None` if there are zero open PRs (rather than erroring) so the frontend can treat "empty repo" as a valid, cacheable state.
+
+Frontend wiring, following the existing convention that PR-specific commands are wrapped in `apps/desktop/src/utils/backend-pr.ts` (not the general `backend.ts`, despite `AGENTS.md`'s general rule — this repo's PR domain already deviates that way, e.g. `ghListPrs`, and this stays consistent with its neighbors rather than fixing that inconsistency as a drive-by):
+
+```ts
+export async function ghPrFreshnessSignal(cwd: string): Promise<PrFreshnessSignal | null>
+```
+
+Plus the matching `dev-server.mjs` route (`GET /api/gh-pr-freshness`), per the project's dev-server-parity convention for every new `#[tauri::command]`.
+
+### Invalidation call sites
+
+`PR_LIST_CACHE.delete(cwd.value)` added at the same two places `cache.invalidateLists(cwd.value)` already fires: `createPr()` and `mergePr()`. No new call sites invented — this stays consistent with what already counts as "the PR list changed" in this file today. (`convertDraftToReady`, comment/review actions don't touch list membership and don't invalidate today either.)
+
+## Forge scope
+
+`usePrPanel.ts` is forge-agnostic (`forge.value.listPRs(...)`), so the background-drain fix (the actual breadth bug) applies to every forge (GitHub, GitLab, Bitbucket, Azure) via the existing `loadMorePrs()` abstraction — no forge-specific code needed there.
+
+The freshness-signal fast path is GitHub-only for this iteration (`gh_pr_freshness_signal` has no GitLab/Bitbucket/Azure equivalent). For those forges, `fetchFreshnessSignal()` returns `null` (no signal available), so `ensurePrsLoaded()` always falls through to the normal fetch-and-prefetch path — same behavior as before this feature, just now with a full drain instead of stopping at 10. This is not a new gap; those forges never had an instant-restore path before either.
+
+## Edge cases
+
+- **Freshness probe fails (network error, `gh` missing, etc.):** treated as "cache stale" — fall through to the normal path rather than trusting possibly-outdated cached data indefinitely.
+- **Prefetch in flight when the user switches repos:** `live()` check bails out; no stale writes into `PR_LIST_CACHE` or `prs.value` for the wrong repo.
+- **Prefetch in flight when `createPr`/`mergePr` invalidates:** same `live()` guard (token bump) stops the in-flight drain from re-populating the cache with data that's about to be stale anyway; the subsequent `loadPrs()` call from those actions' own refresh starts a fresh drain.
+- **Repo with zero open PRs:** `gh_pr_freshness_signal` returns `None`; cached as `topSignal: null`, `prs: []`, `hasMore: false` — a valid, stable, cacheable state (repeat visits don't re-probe more than the 30s throttle).
+- **Ceiling hit (>300 open open PRs):** not cached as complete; every `ensurePrsLoaded()` call redoes the fetch-and-prefetch path (no instant restore) for that repo, same as before this feature for such repos, but at least drains to 300 instead of 10.
+
+## Testing
+
+- `usePrPanel.test.ts` (existing or new, mocking the injected forge provider, consistent with how forge/API calls — as opposed to the git layer — are already mocked in this codebase's PR tests, e.g. `2026-07-01-branch-selector-pr-search-design.md`'s testing section):
+  - First `ensurePrsLoaded()` on a repo with >10 open PRs drains to completion (mocked `listPRs` returning multiple pages) and populates `PR_LIST_CACHE`.
+  - Second `ensurePrsLoaded()` call within the 30s throttle window, freshness signal unchanged → restores from cache with zero `listPRs` calls.
+  - Freshness signal count mismatch (simulating a PR closing) → cache invalidated, full redrain.
+  - Prefetch cancels cleanly on repo switch mid-drain (no writes to the new repo's slot from the stale token).
+  - `createPr()` / `mergePr()` clear `PR_LIST_CACHE` for the repo.
+  - Ceiling behavior: drain stops at `PREFETCH_CEILING`, not cached as complete.
+- Rust: unit test for `gh_pr_freshness_signal` covering both the token/REST branch and the `gh` CLI branch (mocked subprocess/HTTP as existing Rust PR command tests already do), plus the zero-open-PRs `None` case.
+- `pnpm test:parity` — no new parity coverage needed; `gh_pr_freshness_signal` isn't a deterministic git command, it's a GitHub API passthrough, same category as the existing `gh_list_prs` (not currently in the parity suite either, per the earlier investigation).

From fd17043132bf19ecfdd7d837e5f20bdcb9786a3b Mon Sep 17 00:00:00 2001
From: Laurent Guitton <laurent.guitton@dendreo.com>
Date: Thu, 9 Jul 2026 21:46:14 +0200
Subject: [PATCH 02/18] docs: add implementation plan for PR badge background
 prefetch/cache

Task-by-task plan implementing the approved design: shared idle-schedule
util extraction, background drain loop, Rust freshness-signal command
(REST + gh CLI paths), TS wrapper, dev-server route, and in-memory cache
wiring with invalidation.
---
 .../plans/2026-07-09-pr-badge-prefetch.md     | 1332 +++++++++++++++++
 1 file changed, 1332 insertions(+)
 create mode 100644 docs/superpowers/plans/2026-07-09-pr-badge-prefetch.md

diff --git a/docs/superpowers/plans/2026-07-09-pr-badge-prefetch.md b/docs/superpowers/plans/2026-07-09-pr-badge-prefetch.md
new file mode 100644
index 00000000..1653ddd2
--- /dev/null
+++ b/docs/superpowers/plans/2026-07-09-pr-badge-prefetch.md
@@ -0,0 +1,1332 @@
+# PR Badge Background Prefetch & Cache — Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Branch badges (`#<number>` on branches with an open PR) reflect open PRs beyond the current hard cap of 10, via a git-log-style (PR #113) background prefetch + in-memory cache, without multiplying the cost of the Rust layer's naive `offset+limit` pagination.
+
+**Architecture:** `usePrPanel.ts`'s `ensurePrsLoaded()` gets a background drain loop (`prefetchOpenPrs()`, idle-scheduled, bigger page jumps) that continues past the first page, plus a per-session in-memory `PR_LIST_CACHE` keyed by repo. A new lightweight Rust command (`gh_pr_freshness_signal`) lets the cache be validated cheaply (one small GitHub call) instead of redrained on every repo visit. Non-GitHub forges get the drain (the actual breadth fix) but not the instant-cache-restore shortcut.
+
+**Tech Stack:** Vue 3 Composition API (`<script setup>` not applicable — plain composables), Vitest/jsdom, Rust (Tauri 2 commands), Node `dev-server.mjs` (browser dev-mode backend mock).
+
+## Global Constraints
+
+- Package manager: pnpm only (never npm/yarn) — `apps/desktop/package.json`'s `test` script is `vitest run`.
+- No shell string interpolation for any spawned process — always `.arg()`/`.args([...])` per argument (`AGENTS.md`).
+- Every new `#[tauri::command]` needs its typed TypeScript wrapper (in `backend-pr.ts`, following this PR-domain's existing convention) **and** a `dev-server.mjs` route in the same change (`AGENTS.md`, `apps/desktop/CLAUDE.md`).
+- No unconditional polling — this feature adds no new `setInterval`; the prefetch loop is a bounded, self-terminating drain, not a poll (`apps/desktop/CLAUDE.md` perf invariants).
+- No hardcoded user-facing strings — N/A for this plan: no new UI copy is introduced (pure data-fetching change).
+- `packages/core` must stay Node-free — N/A, this plan never touches `packages/core`.
+- Never edit version files by hand — N/A, this plan doesn't touch versioning.
+- Diff-parsing space-prefix gotcha — N/A, no diff parsing in this plan.
+
+---
+
+## File Structure
+
+| File | Responsibility |
+|---|---|
+| `apps/desktop/src/utils/idleSchedule.ts` (new) | Shared `whenIdle()` helper — idle-scheduled resume so background work never blocks input. Extracted out of `useGitRepo.ts` so `usePrPanel.ts` can reuse the exact same scheduling primitive instead of duplicating it. |
+| `apps/desktop/src/utils/__tests__/idleSchedule.test.ts` (new) | Unit tests for `whenIdle()`. |
+| `apps/desktop/src/composables/useGitRepo.ts` (modify) | Remove the inline `whenIdle()` definition, import the shared one instead. No behavior change. |
+| `apps/desktop/src/composables/usePrPanel.ts` (modify) | Core of this feature: generalized `loadMorePrs(pageSize)`, new `prefetchOpenPrs()` background drain, new in-memory `PR_LIST_CACHE`, rewritten `ensurePrsLoaded()` fast path, cache invalidation in `createPr()`/`mergePr()`. |
+| `apps/desktop/src/composables/__tests__/usePrPanel.test.ts` (new) | Unit tests for the drain loop, cache restore, invalidation, and cancellation. |
+| `apps/desktop/src-tauri/src/types.rs` (modify) | New `PrFreshnessSignal` struct. |
+| `apps/desktop/src-tauri/src/commands/github_api.rs` (modify) | New `rest_pr_freshness_signal()` (REST/token path) + pure, unit-tested `top_pr_from_rest_json()` helper. |
+| `apps/desktop/src-tauri/src/commands/gh.rs` (modify) | New `gh_pr_freshness_signal` Tauri command (branches token vs `gh` CLI) + pure, unit-tested `top_pr_from_cli_json()` helper. |
+| `apps/desktop/src-tauri/src/lib.rs` (modify) | Register the new command in `invoke_handler!`. |
+| `apps/desktop/src/utils/backend-pr.ts` (modify) | New `ghPrFreshnessSignal()` typed wrapper + `PrFreshnessSignal` TS interface. |
+| `apps/desktop/src/utils/__tests__/backend-pr.test.ts` (modify) | New tests for `ghPrFreshnessSignal()`, appended to the existing file (same mocking convention already used there for `ghCurrentUser`). |
+| `apps/desktop/dev-server.mjs` (modify) | New `GET /api/gh-pr-freshness` route mirroring the Rust command, for browser dev-mode (`pnpm dev:web`). |
+
+Task order: the shared idle util (Task 1) and the core drain loop (Task 2) land first since they fix the actual user-reported bug (breadth) and need no Rust changes. The Rust command + wrapper + route (Tasks 3–6) come next. The in-memory cache + freshness fast path + invalidation (Task 7) lands last since it depends on both the drain loop and the TS wrapper.
+
+---
+
+### Task 1: Shared idle-scheduling helper
+
+**Files:**
+- Create: `apps/desktop/src/utils/idleSchedule.ts`
+- Modify: `apps/desktop/src/composables/useGitRepo.ts:1` (add import), `apps/desktop/src/composables/useGitRepo.ts:626-633` (delete the inline `whenIdle` definition)
+- Test: `apps/desktop/src/utils/__tests__/idleSchedule.test.ts`
+
+**Interfaces:**
+- Produces: `whenIdle(): Promise<void>` — resolves on `requestIdleCallback` (timeout 300ms) if available, else `setTimeout(resolve, 32)`. Used by Task 2's `prefetchOpenPrs()`.
+
+- [ ] **Step 1: Write the failing test**
+
+Create `apps/desktop/src/utils/__tests__/idleSchedule.test.ts`:
+
+```ts
+import { describe, it, expect, vi, afterEach } from "vitest";
+import { whenIdle } from "../idleSchedule";
+
+describe("whenIdle", () => {
+  afterEach(() => {
+    vi.unstubAllGlobals();
+  });
+
+  it("resolves via requestIdleCallback when available", async () => {
+    const ric = vi.fn((cb: () => void) => cb());
+    vi.stubGlobal("requestIdleCallback", ric);
+    await whenIdle();
+    expect(ric).toHaveBeenCalledTimes(1);
+  });
+
+  it("falls back to setTimeout when requestIdleCallback is unavailable", async () => {
+    vi.stubGlobal("requestIdleCallback", undefined);
+    await expect(whenIdle()).resolves.toBeUndefined();
+  });
+});
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `cd apps/desktop && pnpm test -- src/utils/__tests__/idleSchedule.test.ts`
+Expected: FAIL — `Cannot find module '../idleSchedule'` (file doesn't exist yet).
+
+- [ ] **Step 3: Write minimal implementation**
+
+Create `apps/desktop/src/utils/idleSchedule.ts`:
+
+```ts
+/**
+ * Resolve on the next idle slice so background paging never blocks input.
+ * Falls back to a short timeout when `requestIdleCallback` isn't available
+ * (older browsers, some webview engines).
+ */
+export function whenIdle(): Promise<void> {
+  return new Promise((resolve) => {
+    const ric = (globalThis as {
+      requestIdleCallback?: (cb: () => void, o?: { timeout: number }) => void;
+    }).requestIdleCallback;
+    if (typeof ric === "function") ric(() => resolve(), { timeout: 300 });
+    else setTimeout(resolve, 32);
+  });
+}
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `cd apps/desktop && pnpm test -- src/utils/__tests__/idleSchedule.test.ts`
+Expected: PASS (2 tests).
+
+- [ ] **Step 5: Refactor `useGitRepo.ts` to use the shared helper**
+
+In `apps/desktop/src/composables/useGitRepo.ts`, change line 1 from:
+
+```ts
+import { ref, computed, watch } from "vue";
+```
+
+to:
+
+```ts
+import { ref, computed, watch } from "vue";
+import { whenIdle } from "../utils/idleSchedule";
+```
+
+Then delete the inline definition at lines 626-633:
+
+```ts
+  /** Resolve on the next idle slice so background paging never blocks input. */
+  function whenIdle(): Promise<void> {
+    return new Promise((resolve) => {
+      const ric = (globalThis as { requestIdleCallback?: (cb: () => void, o?: { timeout: number }) => void }).requestIdleCallback;
+      if (typeof ric === "function") ric(() => resolve(), { timeout: 300 });
+      else setTimeout(resolve, 32);
+    });
+  }
+
+```
+
+(Delete the whole block including the doc comment and the trailing blank line — `prefetchAllPages()` right below it, which calls `whenIdle()`, is otherwise unchanged.)
+
+- [ ] **Step 6: Verify nothing broke**
+
+Run: `cd apps/desktop && pnpm test`
+Expected: PASS — same pass count as before this change (no test exercises `useGitRepo.ts`'s prefetch directly today, so this is primarily a compile/typecheck check). Also run:
+
+Run: `cd apps/desktop && pnpm build`
+Expected: PASS — `vue-tsc` typecheck succeeds (confirms the import resolves and no unused-import lint fires on the removed inline function).
+
+- [ ] **Step 7: Commit**
+
+```bash
+git add apps/desktop/src/utils/idleSchedule.ts apps/desktop/src/utils/__tests__/idleSchedule.test.ts apps/desktop/src/composables/useGitRepo.ts
+git commit -m "refactor: extract whenIdle() into a shared idleSchedule util"
+```
+
+---
+
+### Task 2: Background prefetch drain loop for PR badges
+
+**Files:**
+- Modify: `apps/desktop/src/composables/usePrPanel.ts` (imports, constants near line 180, `loadMorePrs` at lines 484-516, new `prefetchOpenPrs`, `ensurePrsLoaded` at lines 1060-1077)
+- Test: Create `apps/desktop/src/composables/__tests__/usePrPanel.test.ts`
+
+**Interfaces:**
+- Consumes: `whenIdle()` from Task 1 (`../utils/idleSchedule`).
+- Produces: `prefetchOpenPrs(): Promise<void>` (module-internal, not part of the composable's returned object) — later consumed by Task 7's cache-write logic. `loadMorePrs(pageSize: number = PAGE_SIZE): Promise<void>` — same exported name/behavior as today when called with no argument (existing scroll-driven callers are unaffected).
+
+- [ ] **Step 1: Write the failing test**
+
+Create `apps/desktop/src/composables/__tests__/usePrPanel.test.ts`:
+
+```ts
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { ref, nextTick } from "vue";
+
+vi.mock("../../utils/backend", () => ({
+  gitRemoteInfo: vi.fn(async () => null),
+  gitFileCount: vi.fn(async () => 0),
+  ghForkInfo: vi.fn(async () => ({ isFork: false, origin: "", parent: "" })),
+}));
+
+const listPRs = vi.fn();
+vi.mock("../forge/useForge", () => ({
+  forgeFromRemoteInfo: vi.fn(() => ({ name: "github", listPRs })),
+  githubProvider: { name: "github", listPRs },
+}));
+
+import { usePrPanel } from "../usePrPanel";
+import { _resetPrCacheForTesting } from "../usePrCache";
+
+function makePr(n: number) {
+  return {
+    number: n, title: `PR ${n}`, state: "open", author: "me", branch: `feat-${n}`,
+    base: "main", draft: false, createdAt: "2026-01-01T00:00:00Z",
+    updatedAt: "2026-01-01T00:00:00Z", url: `https://x/${n}`, additions: 0,
+    deletions: 0, labels: [], assignees: [], reviewRequested: [], reviewDecision: "",
+    mergeStateStatus: "", checksRollup: "", commentCount: 0,
+  };
+}
+
+/** Simulates the Rust layer's naive `offset+limit` pagination over `total` PRs. */
+function pagedListPRs(total: number) {
+  return vi.fn(async (_cwd: string, opts: { limit: number; offset: number }) => {
+    const { limit, offset } = opts;
+    if (offset >= total) return [];
+    const count = Math.min(limit, total - offset);
+    return Array.from({ length: count }, (_, i) => makePr(offset + i + 1));
+  });
+}
+
+describe("usePrPanel — background prefetch drain", () => {
+  beforeEach(() => {
+    localStorage.clear();
+    _resetPrCacheForTesting();
+    listPRs.mockReset();
+    vi.useFakeTimers();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it("drains beyond the first PAGE_SIZE=10 page in the background", async () => {
+    listPRs.mockImplementation(pagedListPRs(45));
+    const panel = usePrPanel(ref("/repo"));
+    await panel.ensurePrsLoaded();
+    expect(panel.prs.value).toHaveLength(10);
+    expect(panel.hasMore.value).toBe(true);
+
+    await vi.advanceTimersByTimeAsync(40); // one whenIdle() tick → a BG_PAGE=100 hop
+
+    expect(panel.prs.value).toHaveLength(45);
+    expect(panel.hasMore.value).toBe(false);
+  });
+
+  it("stops the drain when the repo changes mid-prefetch", async () => {
+    listPRs.mockImplementation(pagedListPRs(500));
+    const cwd = ref("/repo-a");
+    const panel = usePrPanel(cwd);
+    await panel.ensurePrsLoaded();
+    expect(panel.prs.value).toHaveLength(10);
+    expect(listPRs).toHaveBeenCalledTimes(1);
+
+    cwd.value = "/repo-b";
+    await nextTick(); // let the cwd watcher reset state before the drain resumes
+    await vi.advanceTimersByTimeAsync(40);
+
+    // The stale prefetch for /repo-a must not issue a second call.
+    expect(listPRs).toHaveBeenCalledTimes(1);
+  });
+});
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `cd apps/desktop && pnpm test -- src/composables/__tests__/usePrPanel.test.ts`
+Expected: FAIL on the first test — `panel.prs.value` has length 10 but never grows to 45 (no background drain exists yet), timeout or assertion failure.
+
+- [ ] **Step 3: Generalize `loadMorePrs` to accept a page size**
+
+In `apps/desktop/src/composables/usePrPanel.ts`, replace the `loadMorePrs` function (currently lines 484-516):
+
+```ts
+  async function loadMorePrs() {
+    if (!cwd.value || loadingMore.value || !hasMore.value || loading.value || refreshing.value) return;
+    if (!(await requireOnline("gh pr list (more)"))) {
+      hasMore.value = false;
+      return;
+    }
+    loadingMore.value = true;
+    try {
+      const page = await forge.value.listPRs(cwd.value, { state: filterState.value, limit: PAGE_SIZE, offset: prs.value.length });
+      if (page.length === 0) {
+        hasMore.value = false;
+      } else {
+        const seen = new Set(prs.value.map((p) => p.number));
+        for (const pr of page) {
+          if (!seen.has(pr.number)) prs.value.push(pr);
+        }
+        hasMore.value = page.length >= PAGE_SIZE;
+      }
+    } catch (e) {
+      console.warn("[usePrPanel] loadMorePrs failed:", e);
+      hasMore.value = false;
+    } finally {
+      loadingMore.value = false;
+    }
+  }
+```
+
+with:
+
+```ts
+  async function loadMorePrs(pageSize: number = PAGE_SIZE) {
+    if (!cwd.value || loadingMore.value || !hasMore.value || loading.value || refreshing.value) return;
+    if (!(await requireOnline("gh pr list (more)"))) {
+      hasMore.value = false;
+      return;
+    }
+    loadingMore.value = true;
+    try {
+      const page = await forge.value.listPRs(cwd.value, { state: filterState.value, limit: pageSize, offset: prs.value.length });
+      if (page.length === 0) {
+        hasMore.value = false;
+      } else {
+        const seen = new Set(prs.value.map((p) => p.number));
+        for (const pr of page) {
+          if (!seen.has(pr.number)) prs.value.push(pr);
+        }
+        hasMore.value = page.length >= pageSize;
+      }
+    } catch (e) {
+      console.warn("[usePrPanel] loadMorePrs failed:", e);
+      hasMore.value = false;
+    } finally {
+      loadingMore.value = false;
+    }
+  }
+```
+
+(Only `PAGE_SIZE` → `pageSize` param, in the signature and the two usages inside the body. Every existing call site calls `loadMorePrs()` with no argument, so behavior is unchanged for them.)
+
+- [ ] **Step 4: Add prefetch constants and `prefetchOpenPrs()`**
+
+In `apps/desktop/src/composables/usePrPanel.ts`, add the import at the top (near the other relative imports, e.g. right after the `usePrCache` import):
+
+```ts
+import { usePrCache, listKey, detailKey } from "./usePrCache";
+import { whenIdle } from "../utils/idleSchedule";
+```
+
+Then, right after the existing pagination block (currently lines 171-182):
+
+```ts
+  const PAGE_SIZE = 10;
+  const hasMore = ref(true);
+  const loadingMore = ref(false);
+```
+
+add:
+
+```ts
+
+  // ─── Background prefetch (badge path) ───────────────────────────────────
+  // Bigger than PAGE_SIZE so the naive offset+limit Rust pagination
+  // (gh_list_prs_inner / rest_list_prs re-fetch offset+limit items from
+  // scratch on every call) issues only a handful of background round trips
+  // instead of one per 10 PRs.
+  const BG_PAGE = 100;
+  // Ceiling on the automatic background drain — matches the dev-server REST
+  // route's existing 3x100-page cap. Beyond this the badge path just has
+  // partial coverage for that repo; ensurePrsLoaded() keeps retrying on
+  // future calls rather than falsely treating an incomplete list as done.
+  const PREFETCH_CEILING = 300;
+  let _prPrefetchToken = 0;
+```
+
+Then add the new function right after `loadMorePrs`:
+
+```ts
+
+  /**
+   * Lazily drain the rest of the open-PR list in the background after the
+   * first page paints, so branch badges cover more than PAGE_SIZE PRs.
+   * Idle-scheduled (never blocks input) and cancellable if the repo changes
+   * or the filter leaves "open" mid-drain.
+   */
+  async function prefetchOpenPrs() {
+    if (filterState.value !== "open") return;
+    const token = ++_prPrefetchToken;
+    const repo = cwd.value;
+    if (!repo) return;
+    const live = () =>
+      cwd.value === repo && token === _prPrefetchToken && filterState.value === "open";
+    while (live() && hasMore.value && prs.value.length < PREFETCH_CEILING) {
+      await whenIdle();
+      if (!live()) return;
+      await loadMorePrs(BG_PAGE);
+    }
+  }
+```
+
+- [ ] **Step 5: Wire the drain into `ensurePrsLoaded()`**
+
+In `apps/desktop/src/composables/usePrPanel.ts`, change the `ensurePrsLoaded` function (currently lines 1066-1077) from:
+
+```ts
+  async function ensurePrsLoaded() {
+    if (!cwd.value || _prsEnsured || prs.value.length > 0) return;
+    _prsEnsured = true;
+    const cachedRemote = cache.getRemote(cwd.value);
+    if (cachedRemote) {
+      remote.value = cachedRemote.remote;
+      loadRemote();
+    } else {
+      await loadRemote();
+    }
+    await loadPrs();
+  }
+```
+
+to:
+
+```ts
+  async function ensurePrsLoaded() {
+    if (!cwd.value || _prsEnsured || prs.value.length > 0) return;
+    _prsEnsured = true;
+    const cachedRemote = cache.getRemote(cwd.value);
+    if (cachedRemote) {
+      remote.value = cachedRemote.remote;
+      loadRemote();
+    } else {
+      await loadRemote();
+    }
+    await loadPrs();
+    void prefetchOpenPrs();
+  }
+```
+
+(Task 7 will rewrite this function further to add the in-memory cache fast path — this step only adds the drain.)
+
+- [ ] **Step 6: Run test to verify it passes**
+
+Run: `cd apps/desktop && pnpm test -- src/composables/__tests__/usePrPanel.test.ts`
+Expected: PASS (2 tests).
+
+- [ ] **Step 7: Commit**
+
+```bash
+git add apps/desktop/src/composables/usePrPanel.ts apps/desktop/src/composables/__tests__/usePrPanel.test.ts
+git commit -m "fix: drain open-PR pages in the background so branch badges aren't capped at 10"
+```
+
+---
+
+### Task 3: Rust — `PrFreshnessSignal` struct + REST freshness helper
+
+**Files:**
+- Modify: `apps/desktop/src-tauri/src/types.rs` (insert after line 359, the end of the `PullRequest` struct)
+- Modify: `apps/desktop/src-tauri/src/commands/github_api.rs` (new functions after `rest_list_prs`, currently ending at line 504; new tests in the existing `#[cfg(test)] mod tests` block, currently starting at line 1527)
+
+**Interfaces:**
+- Produces: `pub struct PrFreshnessSignal { number: i64, updated_at: String, open_count: i64 }` (types.rs). `pub(crate) fn rest_pr_freshness_signal(cwd: &str, token: &str) -> Result<Option<PrFreshnessSignal>, String>` (github_api.rs) — consumed by Task 4.
+
+- [ ] **Step 1: Write the failing test**
+
+In `apps/desktop/src-tauri/src/commands/github_api.rs`, inside the existing `#[cfg(test)] mod tests { use super::*; use serde_json::json;` block (starts at line 1527), add these two tests right after the `bearer_config_keeps_token_in_header_directive` test (the last one in the file):
+
+```rust
+    #[test]
+    fn top_pr_from_rest_json_reads_first_sorted_entry() {
+        let raw = vec![
+            json!({"number": 88, "updated_at": "2026-07-09T10:00:00Z"}),
+            json!({"number": 3, "updated_at": "2026-01-01T00:00:00Z"}),
+        ];
+        assert_eq!(
+            top_pr_from_rest_json(&raw),
+            Some((88, "2026-07-09T10:00:00Z".to_string()))
+        );
+    }
+
+    #[test]
+    fn top_pr_from_rest_json_empty_list_is_none() {
+        assert_eq!(top_pr_from_rest_json(&[]), None);
+    }
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `cd apps/desktop/src-tauri && cargo test top_pr_from_rest_json`
+Expected: FAIL — compile error, `cannot find function 'top_pr_from_rest_json' in this scope`.
+
+- [ ] **Step 3: Implement the struct and the REST helper**
+
+In `apps/desktop/src-tauri/src/types.rs`, insert this right after the `PullRequest` struct's closing brace (after line 359, before the `GhPrAuthor` struct):
+
+```rust
+
+/// Cheap signal used to detect whether a repo's open-PR list has changed
+/// since it was last fully drained and cached (`usePrPanel.ts`'s
+/// `PR_LIST_CACHE`), without re-fetching the whole list. Two facts, since
+/// neither alone catches every kind of change: the most-recently-updated
+/// open PR (catches edits/comments/new PRs) and the open PR count (catches
+/// a PR closing, which drops it out of the "state=open" results entirely
+/// without changing who's "most recently updated").
+#[derive(Serialize)]
+pub struct PrFreshnessSignal {
+    pub number: i64,
+    pub updated_at: String,
+    pub open_count: i64,
+}
+```
+
+In `apps/desktop/src-tauri/src/commands/github_api.rs`, insert this right after `rest_list_prs`'s closing brace (after line 504, before the `rest_rollup_for_sha` doc comment):
+
+```rust
+
+/// Pure extraction of `(number, updated_at)` from a REST `GET .../pulls` JSON
+/// array already sorted `updated desc` — the first element is the signal.
+/// Split out from `rest_pr_freshness_signal` so it's unit-testable without an
+/// HTTP call (mirrors `json_to_pr`'s separation of parsing from I/O).
+fn top_pr_from_rest_json(raw: &[serde_json::Value]) -> Option<(i64, String)> {
+    let top = raw.first()?;
+    let updated_at = js(top, "updated_at");
+    if updated_at.is_empty() {
+        return None;
+    }
+    Some((ji(top, "number"), updated_at))
+}
+
+/// Cheap "has the open-PR list changed?" probe: the single most-recently
+/// updated open PR (`per_page=1&sort=updated&direction=desc`, no per-PR
+/// enrichment — unlike `rest_list_prs` this never calls the detail/check-runs
+/// endpoints) plus the open PR count (`rest_pr_count`, already a single
+/// `/search/issues` call). `Ok(None)` means the repo currently has zero open
+/// PRs.
+pub(crate) fn rest_pr_freshness_signal(cwd: &str, token: &str) -> Result<Option<PrFreshnessSignal>, String> {
+    let base = base_owner_repo(cwd, token).unwrap_or_else(|_| {
+        let (o, r) = owner_repo(cwd).unwrap_or_default();
+        format!("{}/{}", o, r)
+    });
+    let raw: Vec<serde_json::Value> = api_json_cached(
+        &format!(
+            "{}/repos/{}/pulls?state=open&per_page=1&page=1&sort=updated&direction=desc",
+            API_BASE, base
+        ),
+        token,
+    )?
+    .as_array()
+    .cloned()
+    .unwrap_or_default();
+    let (number, updated_at) = match top_pr_from_rest_json(&raw) {
+        Some(pair) => pair,
+        None => return Ok(None),
+    };
+    let open_count = rest_pr_count(cwd, "open", token)?;
+    Ok(Some(PrFreshnessSignal { number, updated_at, open_count }))
+}
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `cd apps/desktop/src-tauri && cargo test top_pr_from_rest_json`
+Expected: PASS (2 tests).
+
+- [ ] **Step 5: Verify the crate still builds**
+
+Run: `cd apps/desktop/src-tauri && cargo build`
+Expected: PASS — no warnings about `rest_pr_freshness_signal` being unused yet is expected (Rust warns on unused `pub(crate)` items only if truly unreferenced anywhere; Task 4 references it in the same build before this is committed, so build the two tasks' code together if warnings appear here).
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add apps/desktop/src-tauri/src/types.rs apps/desktop/src-tauri/src/commands/github_api.rs
+git commit -m "feat(rust): add PrFreshnessSignal + REST freshness probe for PR badge cache"
+```
+
+---
+
+### Task 4: Rust — `gh` CLI freshness helper, Tauri command, registration
+
+**Files:**
+- Modify: `apps/desktop/src-tauri/src/commands/gh.rs` (new functions after `gh_pr_count`, currently ending at line 250; new test module at end of file, after line 1401)
+- Modify: `apps/desktop/src-tauri/src/lib.rs:400` (register the command)
+
+**Interfaces:**
+- Consumes: `github_api::rest_pr_freshness_signal` (Task 3), `github_api::settings_github_token()`, `gh_fork_upstream()`, `gh_pr_count_inner()`, `hidden_cmd()` (all pre-existing in this file).
+- Produces: `#[tauri::command] pub(crate) async fn gh_pr_freshness_signal(cwd: String) -> Result<Option<PrFreshnessSignal>, String>` — consumed by Task 5's TS wrapper via IPC name `"gh_pr_freshness_signal"`.
+
+- [ ] **Step 1: Write the failing test**
+
+In `apps/desktop/src-tauri/src/commands/gh.rs`, append this new test module at the end of the file (after the closing brace of the existing `gh_list_issues_tests` module, i.e. at the very end of the file, past line 1401):
+
+```rust
+
+#[cfg(test)]
+mod gh_pr_freshness_tests {
+    use super::*;
+    use serde_json::json;
+
+    #[test]
+    fn top_pr_from_cli_json_reads_first_entry() {
+        let raw = vec![json!({"number": 12, "updatedAt": "2026-07-09T09:00:00Z"})];
+        assert_eq!(
+            top_pr_from_cli_json(&raw),
+            Some((12, "2026-07-09T09:00:00Z".to_string()))
+        );
+    }
+
+    #[test]
+    fn top_pr_from_cli_json_empty_list_is_none() {
+        assert_eq!(top_pr_from_cli_json(&[]), None);
+    }
+
+    #[test]
+    fn top_pr_from_cli_json_missing_updated_at_is_none() {
+        let raw = vec![json!({"number": 12})];
+        assert_eq!(top_pr_from_cli_json(&raw), None);
+    }
+}
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `cd apps/desktop/src-tauri && cargo test top_pr_from_cli_json`
+Expected: FAIL — compile error, `cannot find function 'top_pr_from_cli_json' in this scope`.
+
+- [ ] **Step 3: Implement the CLI helper and the command**
+
+In `apps/desktop/src-tauri/src/commands/gh.rs`, insert this right after `gh_pr_count`'s closing brace (after line 250, before `gh_create_pr_inner`):
+
+```rust
+
+/// Pure extraction of `(number, updated_at)` from `gh pr list --json
+/// number,updatedAt` output (already `--limit 1 -S "sort:updated-desc"`
+/// sorted) — the gh CLI's JSON keys are camelCase, unlike the REST API's
+/// snake_case, so this can't share `top_pr_from_rest_json` in github_api.rs.
+fn top_pr_from_cli_json(raw: &[serde_json::Value]) -> Option<(i64, String)> {
+    let top = raw.first()?;
+    let updated_at = top.get("updatedAt").and_then(|v| v.as_str())?.to_string();
+    let number = top.get("number").and_then(|v| v.as_i64())?;
+    Some((number, updated_at))
+}
+
+fn gh_pr_freshness_signal_inner(cwd: String) -> Result<Option<PrFreshnessSignal>, String> {
+    if let Some(tok) = github_api::settings_github_token() {
+        return github_api::rest_pr_freshness_signal(&cwd, &tok);
+    }
+    // No sort flag is used by the main gh_list_prs_inner list fetch (its
+    // order doesn't matter there) — this probe needs updated-desc
+    // specifically, via a `-S` search-query sort, requested only here.
+    let target_repo = gh_fork_upstream(&cwd);
+    let mut cmd = hidden_cmd("gh");
+    cmd.args([
+        "pr", "list",
+        "--state", "open",
+        "--json", "number,updatedAt",
+        "--limit", "1",
+        "-S", "sort:updated-desc",
+    ]);
+    if let Some(ref nwo) = target_repo {
+        cmd.args(["--repo", nwo]);
+    }
+    let output = cmd
+        .current_dir(&cwd)
+        .output()
+        .map_err(|e| format!("Failed to run gh pr list (freshness signal): {}", e))?;
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        return Err(format!("gh pr list (freshness signal) failed: {}", stderr));
+    }
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    let raw: Vec<serde_json::Value> = serde_json::from_str(stdout.trim())
+        .map_err(|e| format!("Failed to parse freshness signal output: {}", e))?;
+    let (number, updated_at) = match top_pr_from_cli_json(&raw) {
+        Some(pair) => pair,
+        None => return Ok(None),
+    };
+    let open_count = gh_pr_count_inner(cwd, "open".to_string())?;
+    Ok(Some(PrFreshnessSignal { number, updated_at, open_count }))
+}
+
+/// Cheap "has the open-PR list changed?" probe for the branch-badge
+/// background-drain cache (`usePrPanel.ts`'s `PR_LIST_CACHE`). See
+/// `PrFreshnessSignal`'s doc comment for why two facts are needed.
+#[tauri::command]
+pub(crate) async fn gh_pr_freshness_signal(cwd: String) -> Result<Option<PrFreshnessSignal>, String> {
+    tauri::async_runtime::spawn_blocking(move || gh_pr_freshness_signal_inner(cwd))
+        .await
+        .map_err(|e| e.to_string())?
+}
+```
+
+- [ ] **Step 4: Register the command in `lib.rs`**
+
+In `apps/desktop/src-tauri/src/lib.rs`, change line 400 from:
+
+```rust
+            commands::gh::gh_pr_count,
+```
+
+to:
+
+```rust
+            commands::gh::gh_pr_count,
+            commands::gh::gh_pr_freshness_signal,
+```
+
+- [ ] **Step 5: Run test to verify it passes**
+
+Run: `cd apps/desktop/src-tauri && cargo test top_pr_from_cli_json`
+Expected: PASS (3 tests).
+
+- [ ] **Step 6: Verify the whole crate builds**
+
+Run: `cd apps/desktop/src-tauri && cargo build`
+Expected: PASS, no errors.
+
+Run: `cd apps/desktop/src-tauri && cargo test`
+Expected: PASS — full existing Rust test suite plus the 5 new tests from Tasks 3-4 all green.
+
+- [ ] **Step 7: Commit**
+
+```bash
+git add apps/desktop/src-tauri/src/commands/gh.rs apps/desktop/src-tauri/src/lib.rs
+git commit -m "feat(rust): add gh_pr_freshness_signal Tauri command (gh CLI path)"
+```
+
+---
+
+### Task 5: TypeScript wrapper — `ghPrFreshnessSignal`
+
+**Files:**
+- Modify: `apps/desktop/src/utils/backend-pr.ts` (insert after `ghPrCount`, currently ending at line 235)
+- Modify: `apps/desktop/src/utils/__tests__/backend-pr.test.ts` (append new `describe` block after the existing one, currently ending at line 62)
+
+**Interfaces:**
+- Consumes: `gh_pr_freshness_signal` Tauri command (Task 4) via `tauriInvoke`; `GET /api/gh-pr-freshness` dev-server route (Task 6) via `devFetch`.
+- Produces: `export interface PrFreshnessSignal { number: number; updatedAt: string; openCount: number }` and `export async function ghPrFreshnessSignal(cwd: string): Promise<PrFreshnessSignal | null>` — consumed by Task 7's `usePrPanel.ts`.
+
+- [ ] **Step 1: Write the failing test**
+
+In `apps/desktop/src/utils/__tests__/backend-pr.test.ts`, append this new `describe` block at the end of the file (after the closing `});` of `describe("ghCurrentUser caching", ...)`, currently at line 62):
+
+```ts
+
+describe("ghPrFreshnessSignal", () => {
+  beforeEach(() => {
+    vi.resetModules();
+    devFetch.mockReset();
+    tauriInvoke.mockReset();
+    tauri = false;
+  });
+
+  it("maps the Tauri command's snake_case response to camelCase", async () => {
+    tauri = true;
+    tauriInvoke.mockResolvedValue({ number: 88, updated_at: "2026-07-09T10:00:00Z", open_count: 12 });
+    const { ghPrFreshnessSignal } = await import("../backend-pr");
+    await expect(ghPrFreshnessSignal("/repo")).resolves.toEqual({
+      number: 88, updatedAt: "2026-07-09T10:00:00Z", openCount: 12,
+    });
+  });
+
+  it("returns null when the Tauri command reports zero open PRs", async () => {
+    tauri = true;
+    tauriInvoke.mockResolvedValue(null);
+    const { ghPrFreshnessSignal } = await import("../backend-pr");
+    await expect(ghPrFreshnessSignal("/repo")).resolves.toBeNull();
+  });
+
+  it("returns null instead of throwing when the probe fails", async () => {
+    tauri = true;
+    tauriInvoke.mockRejectedValue(new Error("network down"));
+    const { ghPrFreshnessSignal } = await import("../backend-pr");
+    await expect(ghPrFreshnessSignal("/repo")).resolves.toBeNull();
+  });
+
+  it("dev-server branch maps the JSON response to camelCase", async () => {
+    tauri = false;
+    devFetch.mockResolvedValue(mockRes({
+      ok: true,
+      json: { number: 5, updated_at: "2026-01-01T00:00:00Z", open_count: 2 },
+    }));
+    const { ghPrFreshnessSignal } = await import("../backend-pr");
+    await expect(ghPrFreshnessSignal("/repo")).resolves.toEqual({
+      number: 5, updatedAt: "2026-01-01T00:00:00Z", openCount: 2,
+    });
+  });
+});
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `cd apps/desktop && pnpm test -- src/utils/__tests__/backend-pr.test.ts`
+Expected: FAIL — `ghPrFreshnessSignal` is not exported from `../backend-pr`.
+
+- [ ] **Step 3: Implement the wrapper**
+
+In `apps/desktop/src/utils/backend-pr.ts`, insert this right after `ghPrCount`'s closing brace (after line 235, before the "Minimal branch shape for the publish guard" comment):
+
+```ts
+
+/** Signal returned by `gh_pr_freshness_signal` — see the Rust doc comment on `PrFreshnessSignal`. */
+export interface PrFreshnessSignal {
+  number: number;
+  updatedAt: string;
+  openCount: number;
+}
+
+/**
+ * Cheap "has the open-PR list changed?" probe for the branch-badge
+ * background-drain cache (`usePrPanel.ts`'s `PR_LIST_CACHE`). GitHub-only —
+ * other forges have no equivalent yet, so their badge path always falls
+ * through to a normal fetch-and-drain instead of an instant cache restore.
+ *
+ * Returns `null` when the repo currently has zero open PRs, or when the
+ * probe itself fails (the caller treats that the same as "cache stale,
+ * redrain").
+ */
+export async function ghPrFreshnessSignal(cwd: string): Promise<PrFreshnessSignal | null> {
+  try {
+    if (isTauri()) {
+      const raw = await tauriInvoke<{ number: number; updated_at: string; open_count: number } | null>(
+        "gh_pr_freshness_signal",
+        { cwd },
+      );
+      return raw ? { number: raw.number, updatedAt: raw.updated_at, openCount: raw.open_count } : null;
+    }
+    const res = await devFetch(`${DEV_SERVER}/api/gh-pr-freshness?cwd=${encodeURIComponent(cwd)}`);
+    if (!res.ok) return null;
+    const data = await res.json();
+    if (!data || typeof data.number !== "number") return null;
+    return { number: data.number, updatedAt: data.updated_at, openCount: data.open_count ?? 0 };
+  } catch {
+    return null;
+  }
+}
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `cd apps/desktop && pnpm test -- src/utils/__tests__/backend-pr.test.ts`
+Expected: PASS (all tests in the file, including the 4 new ones).
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add apps/desktop/src/utils/backend-pr.ts apps/desktop/src/utils/__tests__/backend-pr.test.ts
+git commit -m "feat: add ghPrFreshnessSignal TS wrapper for the PR badge cache"
+```
+
+---
+
+### Task 6: `dev-server.mjs` route
+
+**Files:**
+- Modify: `apps/desktop/dev-server.mjs` (new route between the `gh-pr-count` route, ending at line 2967, and the `gh-create-pr` route starting at line 2969; startup route-list log around line 6200)
+
+**Interfaces:**
+- Produces: `GET /api/gh-pr-freshness?cwd=<path>` → JSON body `{ number, updated_at, open_count }` or `null`. Consumed by Task 5's `ghPrFreshnessSignal` (already implemented — no code changes needed there, this task just makes the endpoint it calls actually exist for `pnpm dev:web`).
+
+- [ ] **Step 1: Add the route**
+
+In `apps/desktop/dev-server.mjs`, insert this right after the `gh-pr-count` route's closing brace (after line 2967, before the `// POST /api/gh-create-pr` comment at line 2969):
+
+```js
+
+    // GET /api/gh-pr-freshness?cwd=<path>
+    // Cheap "has the open-PR list changed?" probe for the branch-badge
+    // background-drain cache (mirrors Rust `gh_pr_freshness_signal`): the
+    // single most-recently-updated open PR plus the open PR count. Returns
+    // null when the repo has zero open PRs or the token/remote can't be
+    // resolved — the frontend treats that the same as "cache stale, redrain".
+    if (url.pathname === "/api/gh-pr-freshness" && req.method === "GET") {
+      const cwd = url.searchParams.get("cwd");
+      if (!cwd) return jsonResponse(req, res, { error: "Missing cwd" }, 400);
+      try {
+        const token = getGithubToken();
+        if (!token) return jsonResponse(req, res, null);
+        const nwo = getRepoNwo(resolve(cwd));
+        if (!nwo) return jsonResponse(req, res, null);
+        const topResp = await githubFetch(`/repos/${nwo}/pulls?state=open&per_page=1&page=1&sort=updated&direction=desc`, token);
+        if (!topResp.ok) return jsonResponse(req, res, null);
+        const topData = await topResp.json();
+        if (!Array.isArray(topData) || topData.length === 0) return jsonResponse(req, res, null);
+        // Count via the same Link-header trick as /api/gh-pr-count.
+        const countResp = await githubFetch(`/repos/${nwo}/pulls?state=open&per_page=1`, token);
+        let openCount = topData.length;
+        if (countResp.ok) {
+          const linkHeader = countResp.headers.get("link") || "";
+          const m = linkHeader.match(/<[^>]*[?&]page=(\d+)[^>]*>;\s*rel="last"/);
+          if (m) openCount = parseInt(m[1], 10);
+        }
+        return jsonResponse(req, res, {
+          number: topData[0].number,
+          updated_at: topData[0].updated_at,
+          open_count: openCount,
+        });
+      } catch (err) {
+        console.error("[gh-pr-freshness]", err.message);
+        return jsonResponse(req, res, null);
+      }
+    }
+```
+
+- [ ] **Step 2: Add the route to the startup log**
+
+In `apps/desktop/dev-server.mjs`, right after the line (around 6200):
+
+```js
+    console.log(`    GET  /api/gh-pr-count?cwd=<path>&state=<state>`);
+```
+
+add:
+
+```js
+    console.log(`    GET  /api/gh-pr-freshness?cwd=<path>`);
+```
+
+- [ ] **Step 3: Smoke-test the route manually**
+
+Run: `cd apps/desktop && pnpm dev:server`
+Expected: server starts and prints the route list including the new line, no crash on boot (`node dev-server.mjs` syntax-checks the file as part of starting). Stop the server after confirming the log line appears (Ctrl+C).
+
+- [ ] **Step 4: Commit**
+
+```bash
+git add apps/desktop/dev-server.mjs
+git commit -m "feat: add /api/gh-pr-freshness dev-server route"
+```
+
+---
+
+### Task 7: In-memory cache, freshness fast path, and invalidation
+
+**Files:**
+- Modify: `apps/desktop/src/composables/usePrPanel.ts` (imports; new cache block near the Task 2 constants; `prefetchOpenPrs` cache-write; new `fetchPrFreshnessSignal`; rewritten `ensurePrsLoaded`; `watch(cwd, ...)` at lines 708-715; `createPr` at lines 718-746; `mergePr` at lines 789-803)
+- Modify: `apps/desktop/src/composables/__tests__/usePrPanel.test.ts` (extend the mocks from Task 2, add new tests)
+
+**Interfaces:**
+- Consumes: `ghPrFreshnessSignal` (Task 5) from `../utils/backend`; `whenIdle` (Task 1); `prefetchOpenPrs`/`loadMorePrs` (Task 2).
+- Produces: no new exports — this task changes `ensurePrsLoaded()`'s internal behavior only. Its returned signature is unchanged.
+
+- [ ] **Step 1: Write the failing tests**
+
+In `apps/desktop/src/composables/__tests__/usePrPanel.test.ts`, change the top-of-file mocks from:
+
+```ts
+vi.mock("../../utils/backend", () => ({
+  gitRemoteInfo: vi.fn(async () => null),
+  gitFileCount: vi.fn(async () => 0),
+  ghForkInfo: vi.fn(async () => ({ isFork: false, origin: "", parent: "" })),
+}));
+
+const listPRs = vi.fn();
+vi.mock("../forge/useForge", () => ({
+  forgeFromRemoteInfo: vi.fn(() => ({ name: "github", listPRs })),
+  githubProvider: { name: "github", listPRs },
+}));
+```
+
+to:
+
+```ts
+const ghPrFreshnessSignal = vi.fn();
+vi.mock("../../utils/backend", () => ({
+  gitRemoteInfo: vi.fn(async () => null),
+  gitFileCount: vi.fn(async () => 0),
+  ghForkInfo: vi.fn(async () => ({ isFork: false, origin: "", parent: "" })),
+  ghPrFreshnessSignal: (...args: unknown[]) => ghPrFreshnessSignal(...args),
+}));
+
+const listPRs = vi.fn();
+const createPR = vi.fn();
+const mergePR = vi.fn();
+vi.mock("../forge/useForge", () => ({
+  forgeFromRemoteInfo: vi.fn(() => ({ name: "github", listPRs, createPR, mergePR })),
+  githubProvider: { name: "github", listPRs, createPR, mergePR },
+}));
+```
+
+Then add a `beforeEach` reset for the two new mocks inside the existing `describe("usePrPanel — background prefetch drain", ...)` block's `beforeEach`, changing:
+
+```ts
+  beforeEach(() => {
+    localStorage.clear();
+    _resetPrCacheForTesting();
+    listPRs.mockReset();
+    vi.useFakeTimers();
+  });
+```
+
+to:
+
+```ts
+  beforeEach(() => {
+    localStorage.clear();
+    _resetPrCacheForTesting();
+    listPRs.mockReset();
+    createPR.mockReset();
+    mergePR.mockReset();
+    ghPrFreshnessSignal.mockReset();
+    vi.useFakeTimers();
+  });
+```
+
+Then append these new tests at the end of the `describe("usePrPanel — background prefetch drain", ...)` block, right before its closing `});`:
+
+```ts
+
+  it("restores instantly from the in-memory cache when the freshness signal is unchanged", async () => {
+    listPRs.mockImplementation(pagedListPRs(15));
+    ghPrFreshnessSignal.mockResolvedValue({ number: 15, updatedAt: "t1", openCount: 15 });
+    const panel = usePrPanel(ref("/repo"));
+
+    await panel.ensurePrsLoaded();
+    await vi.advanceTimersByTimeAsync(40); // drain completes, cache is written
+    expect(panel.prs.value).toHaveLength(15);
+    const callsAfterFirstDrain = listPRs.mock.calls.length;
+
+    await panel.ensurePrsLoaded(); // e.g. branch popover reopened
+    expect(panel.prs.value).toHaveLength(15);
+    expect(listPRs.mock.calls.length).toBe(callsAfterFirstDrain); // no new fetch — restored from cache
+    // Called twice total: once when prefetchOpenPrs() wrote the cache after
+    // the first drain, once for this second call's freshness recheck.
+    expect(ghPrFreshnessSignal).toHaveBeenCalledTimes(2);
+  });
+
+  it("redrains when the freshness signal changes (e.g. a PR opened elsewhere)", async () => {
+    listPRs.mockImplementation(pagedListPRs(15));
+    ghPrFreshnessSignal.mockResolvedValue({ number: 15, updatedAt: "t1", openCount: 15 });
+    const panel = usePrPanel(ref("/repo"));
+
+    await panel.ensurePrsLoaded();
+    await vi.advanceTimersByTimeAsync(40);
+    expect(panel.prs.value).toHaveLength(15);
+
+    listPRs.mockImplementation(pagedListPRs(16));
+    ghPrFreshnessSignal.mockResolvedValue({ number: 16, updatedAt: "t2", openCount: 16 });
+
+    await panel.ensurePrsLoaded();
+    await vi.advanceTimersByTimeAsync(40);
+    expect(panel.prs.value).toHaveLength(16);
+  });
+
+  it("createPr() invalidates the cache so the next ensurePrsLoaded() redrains", async () => {
+    listPRs.mockImplementation(pagedListPRs(15));
+    ghPrFreshnessSignal.mockResolvedValue({ number: 15, updatedAt: "t1", openCount: 15 });
+    const panel = usePrPanel(ref("/repo"));
+
+    await panel.ensurePrsLoaded();
+    await vi.advanceTimersByTimeAsync(40);
+    expect(panel.prs.value).toHaveLength(15);
+
+    createPR.mockResolvedValue(makePr(16));
+    panel.newPrTitle.value = "New PR";
+    listPRs.mockImplementation(pagedListPRs(16)); // the repo now has 16 open PRs
+    await panel.createPr();
+    const callsAfterCreate = listPRs.mock.calls.length;
+
+    ghPrFreshnessSignal.mockResolvedValue({ number: 16, updatedAt: "t2", openCount: 16 });
+    await panel.ensurePrsLoaded();
+    await vi.advanceTimersByTimeAsync(40);
+
+    // A stale pre-createPr cache entry must NOT be trusted — it must redrain.
+    expect(listPRs.mock.calls.length).toBeGreaterThan(callsAfterCreate);
+    expect(panel.prs.value).toHaveLength(16);
+  });
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `cd apps/desktop && pnpm test -- src/composables/__tests__/usePrPanel.test.ts`
+Expected: FAIL on the 3 new tests — no in-memory cache exists yet, so every `ensurePrsLoaded()` call after the first is a no-op (today's one-shot `_prsEnsured` guard), `ghPrFreshnessSignal` is never called, and `panel.prs.value` never changes on the second call in any of the 3 new tests.
+
+- [ ] **Step 3: Add the import, cache map, and constants**
+
+In `apps/desktop/src/composables/usePrPanel.ts`, add `ghPrFreshnessSignal` and its type to the big import block from `"../utils/backend"` (near `ghForkInfo`, `type ForkInfo`):
+
+```ts
+  ghForkInfo,
+  type ForkInfo,
+  ghPrFreshnessSignal,
+  type PrFreshnessSignal,
+} from "../utils/backend";
+```
+
+Then, right after the `BG_PAGE`/`PREFETCH_CEILING`/`_prPrefetchToken` block added in Task 2, add:
+
+```ts
+
+  // ─── In-memory list cache (badge path) ──────────────────────────────────
+  // Mirrors useGitRepo.ts's LOG_CACHE/prefetchAllPages pattern (PR #113).
+  // Declared inside usePrPanel() — a singleton instantiated once in App.vue,
+  // same as LOG_CACHE — so its lifetime matches the app session, and each
+  // fresh usePrPanel() call (e.g. in a test) starts with an empty cache.
+  interface PrListCacheEntry {
+    prs: PullRequest[];
+    hasMore: boolean;
+    topSignal: PrFreshnessSignal | null;
+  }
+  const PR_LIST_CACHE = new Map<string, PrListCacheEntry>();
+  // Throttles the freshness re-probe on repeated ensurePrsLoaded() calls
+  // (branch popover reopened, graph mode re-entered) so rapid toggling
+  // doesn't fire a GitHub request every time.
+  const FRESHNESS_RECHECK_MS = 30_000;
+  let _lastFreshnessCheck = 0;
+
+  /**
+   * GitHub-only cheap freshness probe (see `ghPrFreshnessSignal`'s doc
+   * comment). Other forges have no equivalent yet — `null` here just means
+   * "no signal available", which `ensurePrsLoaded()` treats as a cache miss.
+   */
+  async function fetchPrFreshnessSignal(repo: string): Promise<PrFreshnessSignal | null> {
+    if (forge.value.name !== "github") return null;
+    try {
+      return await ghPrFreshnessSignal(repo);
+    } catch {
+      return null;
+    }
+  }
+```
+
+- [ ] **Step 4: Write the drained list to the cache in `prefetchOpenPrs`**
+
+In `apps/desktop/src/composables/usePrPanel.ts`, change `prefetchOpenPrs` (added in Task 2) from:
+
+```ts
+  async function prefetchOpenPrs() {
+    if (filterState.value !== "open") return;
+    const token = ++_prPrefetchToken;
+    const repo = cwd.value;
+    if (!repo) return;
+    const live = () =>
+      cwd.value === repo && token === _prPrefetchToken && filterState.value === "open";
+    while (live() && hasMore.value && prs.value.length < PREFETCH_CEILING) {
+      await whenIdle();
+      if (!live()) return;
+      await loadMorePrs(BG_PAGE);
+    }
+  }
+```
+
+to:
+
+```ts
+  async function prefetchOpenPrs() {
+    if (filterState.value !== "open") return;
+    const token = ++_prPrefetchToken;
+    const repo = cwd.value;
+    if (!repo) return;
+    const live = () =>
+      cwd.value === repo && token === _prPrefetchToken && filterState.value === "open";
+    while (live() && hasMore.value && prs.value.length < PREFETCH_CEILING) {
+      await whenIdle();
+      if (!live()) return;
+      await loadMorePrs(BG_PAGE);
+    }
+    // Only cache a fully-drained list (reached the true end before the
+    // ceiling), and only for GitHub (the only forge with a freshness
+    // signal) — a ceiling-capped or signal-less list stays uncached so
+    // ensurePrsLoaded() keeps retrying instead of trusting an incomplete or
+    // unvalidatable snapshot forever.
+    if (live() && !hasMore.value && forge.value.name === "github") {
+      const topSignal = await fetchPrFreshnessSignal(repo);
+      if (live()) {
+        PR_LIST_CACHE.set(repo, { prs: prs.value.slice(), hasMore: false, topSignal });
+      }
+    }
+  }
+```
+
+- [ ] **Step 5: Rewrite `ensurePrsLoaded()`**
+
+In `apps/desktop/src/composables/usePrPanel.ts`, change `ensurePrsLoaded` (from Task 2) from:
+
+```ts
+  async function ensurePrsLoaded() {
+    if (!cwd.value || _prsEnsured || prs.value.length > 0) return;
+    _prsEnsured = true;
+    const cachedRemote = cache.getRemote(cwd.value);
+    if (cachedRemote) {
+      remote.value = cachedRemote.remote;
+      loadRemote();
+    } else {
+      await loadRemote();
+    }
+    await loadPrs();
+    void prefetchOpenPrs();
+  }
+```
+
+to:
+
+```ts
+  async function ensurePrsLoaded() {
+    if (!cwd.value || filterState.value !== "open") return;
+    const repo = cwd.value;
+    const cached = PR_LIST_CACHE.get(repo);
+    if (cached) {
+      const now = Date.now();
+      if (now - _lastFreshnessCheck < FRESHNESS_RECHECK_MS) return; // recently confirmed fresh
+      _lastFreshnessCheck = now;
+      const signal = await fetchPrFreshnessSignal(repo);
+      if (cwd.value !== repo) return; // repo changed while the probe was in flight
+      const unchanged =
+        (signal === null && cached.topSignal === null) ||
+        (signal !== null &&
+          cached.topSignal !== null &&
+          signal.number === cached.topSignal.number &&
+          signal.updatedAt === cached.topSignal.updatedAt &&
+          signal.openCount === cached.topSignal.openCount);
+      if (unchanged) {
+        prs.value = cached.prs;
+        hasMore.value = false;
+        return;
+      }
+      // Stale (or the probe errored) — drop the cache and fall through to a
+      // full redrain below, UNCONDITIONALLY: this branch must not be gated
+      // by the `_prsEnsured`/`prs.value.length` check below, or a repo whose
+      // cache just went stale would keep showing the stale list forever
+      // (`_prsEnsured` stays true and `prs.value` stays non-empty even
+      // though nothing is being redrained).
+      PR_LIST_CACHE.delete(repo);
+    } else if (_prsEnsured && prs.value.length > 0) {
+      // No cache yet, but this session already loaded (or is loading/
+      // draining) this repo's open PRs — matches the original one-shot
+      // guard for the "mid-drain, not yet cached" window.
+      return;
+    }
+    _prsEnsured = true;
+    const cachedRemote = cache.getRemote(cwd.value);
+    if (cachedRemote) {
+      remote.value = cachedRemote.remote;
+      loadRemote();
+    } else {
+      await loadRemote();
+    }
+    await loadPrs();
+    void prefetchOpenPrs();
+  }
+```
+
+- [ ] **Step 6: Reset the freshness-check throttle on repo switch**
+
+In `apps/desktop/src/composables/usePrPanel.ts`, change the `watch(cwd, ...)` handler (currently lines 708-715) from:
+
+```ts
+  watch(cwd, (newCwd) => {
+    selectedPr.value = null;
+    prs.value = [];
+    remote.value = null;
+    _prsEnsured = false;
+    resetDetail();
+    if (newCwd && panelMounted.value) init();
+  });
+```
+
+to:
+
+```ts
+  watch(cwd, (newCwd) => {
+    selectedPr.value = null;
+    prs.value = [];
+    remote.value = null;
+    _prsEnsured = false;
+    _lastFreshnessCheck = 0;
+    resetDetail();
+    if (newCwd && panelMounted.value) init();
+  });
+```
+
+- [ ] **Step 7: Invalidate the cache on `createPr()` and `mergePr()`**
+
+In `apps/desktop/src/composables/usePrPanel.ts`, inside `createPr()`, change:
+
+```ts
+      cache.invalidateLists(cwd.value);
+      await loadPrs();
+    } catch (err: any) { error.value = err.message; }
+    finally { isCreating.value = false; }
+  }
+```
+
+to:
+
+```ts
+      cache.invalidateLists(cwd.value);
+      PR_LIST_CACHE.delete(cwd.value);
+      _prsEnsured = false;
+      await loadPrs();
+    } catch (err: any) { error.value = err.message; }
+    finally { isCreating.value = false; }
+  }
+```
+
+Inside `mergePr()`, change:
+
+```ts
+      cache.invalidateDetail(cwd.value, mergingPr.value.number);
+      cache.invalidateLists(cwd.value);
+      mergingPr.value = null;
+      await loadPrs();
+    } catch (err: any) { error.value = err.message; }
+  }
+```
+
+to:
+
+```ts
+      cache.invalidateDetail(cwd.value, mergingPr.value.number);
+      cache.invalidateLists(cwd.value);
+      PR_LIST_CACHE.delete(cwd.value);
+      _prsEnsured = false;
+      mergingPr.value = null;
+      await loadPrs();
+    } catch (err: any) { error.value = err.message; }
+  }
+```
+
+- [ ] **Step 8: Run test to verify it passes**
+
+Run: `cd apps/desktop && pnpm test -- src/composables/__tests__/usePrPanel.test.ts`
+Expected: PASS (all 5 tests in the file — the 2 from Task 2 plus the 3 new ones).
+
+- [ ] **Step 9: Run the full frontend test suite and typecheck**
+
+Run: `cd apps/desktop && pnpm test`
+Expected: PASS — no regressions in other composables (in particular `usePrCache.test.ts`, `useBranchPrSearch.test.ts`, `useLaunchpadPrs.test.ts`, which all touch adjacent PR-panel code paths).
+
+Run: `cd apps/desktop && pnpm build`
+Expected: PASS — `vue-tsc` typecheck succeeds (confirms `PrFreshnessSignal`/`ghPrFreshnessSignal` types line up between `backend-pr.ts` and `usePrPanel.ts`).
+
+- [ ] **Step 10: Commit**
+
+```bash
+git add apps/desktop/src/composables/usePrPanel.ts apps/desktop/src/composables/__tests__/usePrPanel.test.ts
+git commit -m "feat: cache drained open-PR lists and validate them via a cheap freshness signal"
+```
+
+---
+
+## Post-implementation checklist
+
+- [ ] `cd apps/desktop/src-tauri && cargo test` — full Rust suite green.
+- [ ] `cd apps/desktop && pnpm test` — full Vitest suite green.
+- [ ] `cd apps/desktop && pnpm build` — typecheck + Vite build green.
+- [ ] `cd apps/desktop && pnpm dev:web` — manually open a repo with >10 open PRs (or point at a public repo with many open PRs) in the branch selector popover; confirm badges appear for branches beyond the first 10, and that reopening the popover a second time doesn't trigger a visible re-fetch delay.
+- [ ] Confirm `docs/superpowers/specs/2026-07-09-pr-badge-prefetch-design.md`'s stated scope was fully implemented: open-PRs only (no closed/merged), GitHub-only freshness fast path, other forges get the breadth fix only.

From 650f3f103394c8c2ce76d0898c6531d7c1a8d24c Mon Sep 17 00:00:00 2001
From: Laurent Guitton <laurent.guitton@dendreo.com>
Date: Thu, 9 Jul 2026 23:34:34 +0200
Subject: [PATCH 03/18] refactor: extract whenIdle() into a shared idleSchedule
 util

---
 apps/desktop/src/composables/useGitRepo.ts    | 10 +---------
 .../src/utils/__tests__/idleSchedule.test.ts  | 20 +++++++++++++++++++
 apps/desktop/src/utils/idleSchedule.ts        | 14 +++++++++++++
 3 files changed, 35 insertions(+), 9 deletions(-)
 create mode 100644 apps/desktop/src/utils/__tests__/idleSchedule.test.ts
 create mode 100644 apps/desktop/src/utils/idleSchedule.ts

diff --git a/apps/desktop/src/composables/useGitRepo.ts b/apps/desktop/src/composables/useGitRepo.ts
index db91d0e3..c1e58848 100644
--- a/apps/desktop/src/composables/useGitRepo.ts
+++ b/apps/desktop/src/composables/useGitRepo.ts
@@ -1,4 +1,5 @@
 import { ref, computed, watch } from "vue";
+import { whenIdle } from "../utils/idleSchedule";
 import {
   getGitStatus,
   getGitDiff,
@@ -623,15 +624,6 @@ export function useGitRepo(opts: { confirm?: ConfirmFn } = {}) {
     );
   }
 
-  /** Resolve on the next idle slice so background paging never blocks input. */
-  function whenIdle(): Promise<void> {
-    return new Promise((resolve) => {
-      const ric = (globalThis as { requestIdleCallback?: (cb: () => void, o?: { timeout: number }) => void }).requestIdleCallback;
-      if (typeof ric === "function") ric(() => resolve(), { timeout: 300 });
-      else setTimeout(resolve, 32);
-    });
-  }
-
   /**
    * Lazily page the rest of the history in the background, appending as it
    * goes, then cache the complete log. Cancels if the repo changes, the view
diff --git a/apps/desktop/src/utils/__tests__/idleSchedule.test.ts b/apps/desktop/src/utils/__tests__/idleSchedule.test.ts
new file mode 100644
index 00000000..e65fb352
--- /dev/null
+++ b/apps/desktop/src/utils/__tests__/idleSchedule.test.ts
@@ -0,0 +1,20 @@
+import { describe, it, expect, vi, afterEach } from "vitest";
+import { whenIdle } from "../idleSchedule";
+
+describe("whenIdle", () => {
+  afterEach(() => {
+    vi.unstubAllGlobals();
+  });
+
+  it("resolves via requestIdleCallback when available", async () => {
+    const ric = vi.fn((cb: () => void) => cb());
+    vi.stubGlobal("requestIdleCallback", ric);
+    await whenIdle();
+    expect(ric).toHaveBeenCalledTimes(1);
+  });
+
+  it("falls back to setTimeout when requestIdleCallback is unavailable", async () => {
+    vi.stubGlobal("requestIdleCallback", undefined);
+    await expect(whenIdle()).resolves.toBeUndefined();
+  });
+});
diff --git a/apps/desktop/src/utils/idleSchedule.ts b/apps/desktop/src/utils/idleSchedule.ts
new file mode 100644
index 00000000..d1b6d948
--- /dev/null
+++ b/apps/desktop/src/utils/idleSchedule.ts
@@ -0,0 +1,14 @@
+/**
+ * Resolve on the next idle slice so background paging never blocks input.
+ * Falls back to a short timeout when `requestIdleCallback` isn't available
+ * (older browsers, some webview engines).
+ */
+export function whenIdle(): Promise<void> {
+  return new Promise((resolve) => {
+    const ric = (globalThis as {
+      requestIdleCallback?: (cb: () => void, o?: { timeout: number }) => void;
+    }).requestIdleCallback;
+    if (typeof ric === "function") ric(() => resolve(), { timeout: 300 });
+    else setTimeout(resolve, 32);
+  });
+}

From 9b0812827d1afe44f3a93213d132d96c29b44bfd Mon Sep 17 00:00:00 2001
From: Laurent Guitton <laurent.guitton@dendreo.com>
Date: Fri, 10 Jul 2026 00:05:44 +0200
Subject: [PATCH 04/18] fix: drain open-PR pages in the background so branch
 badges aren't capped at 10

---
 .../composables/__tests__/usePrPanel.test.ts  | 85 +++++++++++++++++++
 apps/desktop/src/composables/usePrPanel.ts    | 41 ++++++++-
 2 files changed, 123 insertions(+), 3 deletions(-)
 create mode 100644 apps/desktop/src/composables/__tests__/usePrPanel.test.ts

diff --git a/apps/desktop/src/composables/__tests__/usePrPanel.test.ts b/apps/desktop/src/composables/__tests__/usePrPanel.test.ts
new file mode 100644
index 00000000..d8828493
--- /dev/null
+++ b/apps/desktop/src/composables/__tests__/usePrPanel.test.ts
@@ -0,0 +1,85 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { ref, nextTick } from "vue";
+
+// `listPRs` must be created via `vi.hoisted()`: usePrPanel.ts's import chain is
+// long enough that Vitest evaluates the "../forge/useForge" mock factory before
+// a plain top-level `const listPRs = vi.fn()` in this file would have run,
+// throwing "Cannot access 'listPRs' before initialization". `vi.hoisted()`
+// guarantees the initializer runs first regardless of import graph shape.
+const { listPRs } = vi.hoisted(() => ({ listPRs: vi.fn() }));
+
+vi.mock("../../utils/backend", () => ({
+  gitRemoteInfo: vi.fn(async () => null),
+  gitFileCount: vi.fn(async () => 0),
+  ghForkInfo: vi.fn(async () => ({ isFork: false, origin: "", parent: "" })),
+}));
+
+vi.mock("../forge/useForge", () => ({
+  forgeFromRemoteInfo: vi.fn(() => ({ name: "github", listPRs })),
+  githubProvider: { name: "github", listPRs },
+}));
+
+import { usePrPanel } from "../usePrPanel";
+import { _resetPrCacheForTesting } from "../usePrCache";
+
+function makePr(n: number) {
+  return {
+    number: n, title: `PR ${n}`, state: "open", author: "me", branch: `feat-${n}`,
+    base: "main", draft: false, createdAt: "2026-01-01T00:00:00Z",
+    updatedAt: "2026-01-01T00:00:00Z", url: `https://x/${n}`, additions: 0,
+    deletions: 0, labels: [], assignees: [], reviewRequested: [], reviewDecision: "",
+    mergeStateStatus: "", checksRollup: "", commentCount: 0,
+  };
+}
+
+/** Simulates the Rust layer's naive `offset+limit` pagination over `total` PRs. */
+function pagedListPRs(total: number) {
+  return vi.fn(async (_cwd: string, opts: { limit: number; offset: number }) => {
+    const { limit, offset } = opts;
+    if (offset >= total) return [];
+    const count = Math.min(limit, total - offset);
+    return Array.from({ length: count }, (_, i) => makePr(offset + i + 1));
+  });
+}
+
+describe("usePrPanel — background prefetch drain", () => {
+  beforeEach(() => {
+    localStorage.clear();
+    _resetPrCacheForTesting();
+    listPRs.mockReset();
+    vi.useFakeTimers();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it("drains beyond the first PAGE_SIZE=10 page in the background", async () => {
+    listPRs.mockImplementation(pagedListPRs(45));
+    const panel = usePrPanel(ref("/repo"));
+    await panel.ensurePrsLoaded();
+    expect(panel.prs.value).toHaveLength(10);
+    expect(panel.hasMore.value).toBe(true);
+
+    await vi.advanceTimersByTimeAsync(40); // one whenIdle() tick → a BG_PAGE=100 hop
+
+    expect(panel.prs.value).toHaveLength(45);
+    expect(panel.hasMore.value).toBe(false);
+  });
+
+  it("stops the drain when the repo changes mid-prefetch", async () => {
+    listPRs.mockImplementation(pagedListPRs(500));
+    const cwd = ref("/repo-a");
+    const panel = usePrPanel(cwd);
+    await panel.ensurePrsLoaded();
+    expect(panel.prs.value).toHaveLength(10);
+    expect(listPRs).toHaveBeenCalledTimes(1);
+
+    cwd.value = "/repo-b";
+    await nextTick(); // let the cwd watcher reset state before the drain resumes
+    await vi.advanceTimersByTimeAsync(40);
+
+    // The stale prefetch for /repo-a must not issue a second call.
+    expect(listPRs).toHaveBeenCalledTimes(1);
+  });
+});
diff --git a/apps/desktop/src/composables/usePrPanel.ts b/apps/desktop/src/composables/usePrPanel.ts
index 273d959b..52274bed 100644
--- a/apps/desktop/src/composables/usePrPanel.ts
+++ b/apps/desktop/src/composables/usePrPanel.ts
@@ -30,6 +30,7 @@ import {
 } from "../utils/backend";
 import { forgeFromRemoteInfo, githubProvider } from "./forge/useForge";
 import { usePrCache, listKey, detailKey } from "./usePrCache";
+import { whenIdle } from "../utils/idleSchedule";
 import { getPersistedDiffMode, type DiffMode } from "../utils/diffMode";
 import { requireOnline } from "../utils/networkGuard";
 import { t } from "./useI18n";
@@ -181,6 +182,19 @@ export function usePrPanel(cwd: Ref<string>, opts: PrPanelOptions = {}) {
   const hasMore = ref(true);
   const loadingMore = ref(false);
 
+  // ─── Background prefetch (badge path) ───────────────────────────────────
+  // Bigger than PAGE_SIZE so the naive offset+limit Rust pagination
+  // (gh_list_prs_inner / rest_list_prs re-fetch offset+limit items from
+  // scratch on every call) issues only a handful of background round trips
+  // instead of one per 10 PRs.
+  const BG_PAGE = 100;
+  // Ceiling on the automatic background drain — matches the dev-server REST
+  // route's existing 3x100-page cap. Beyond this the badge path just has
+  // partial coverage for that repo; ensurePrsLoaded() keeps retrying on
+  // future calls rather than falsely treating an incomplete list as done.
+  const PREFETCH_CEILING = 300;
+  let _prPrefetchToken = 0;
+
   // ─── Computed ──────────────────────────────────────────
   const commentsForFile = computed<PrReviewComment[]>(() =>
     selectedDiffFile.value
@@ -481,7 +495,7 @@ export function usePrPanel(cwd: Ref<string>, opts: PrPanelOptions = {}) {
    * Phase 2 (v2.9) will replace this with a cursor-based GraphQL query,
    * making the dedup + slice cost go away.
    */
-  async function loadMorePrs() {
+  async function loadMorePrs(pageSize: number = PAGE_SIZE) {
     // Guard on `refreshing` too: during SWR revalidation the cached list is on
     // screen with `loading` false, so without this the pagination sentinel
     // fires a second `listPRs` (e.g. offset 4) concurrently with the in-flight
@@ -493,7 +507,7 @@ export function usePrPanel(cwd: Ref<string>, opts: PrPanelOptions = {}) {
     }
     loadingMore.value = true;
     try {
-      const page = await forge.value.listPRs(cwd.value, { state: filterState.value, limit: PAGE_SIZE, offset: prs.value.length });
+      const page = await forge.value.listPRs(cwd.value, { state: filterState.value, limit: pageSize, offset: prs.value.length });
       if (page.length === 0) {
         hasMore.value = false;
       } else {
@@ -503,7 +517,7 @@ export function usePrPanel(cwd: Ref<string>, opts: PrPanelOptions = {}) {
         for (const pr of page) {
           if (!seen.has(pr.number)) prs.value.push(pr);
         }
-        hasMore.value = page.length >= PAGE_SIZE;
+        hasMore.value = page.length >= pageSize;
       }
     } catch (e) {
       // Don't surface scroll-load errors as a banner — silent stop is
@@ -515,6 +529,26 @@ export function usePrPanel(cwd: Ref<string>, opts: PrPanelOptions = {}) {
     }
   }
 
+  /**
+   * Lazily drain the rest of the open-PR list in the background after the
+   * first page paints, so branch badges cover more than PAGE_SIZE PRs.
+   * Idle-scheduled (never blocks input) and cancellable if the repo changes
+   * or the filter leaves "open" mid-drain.
+   */
+  async function prefetchOpenPrs() {
+    if (filterState.value !== "open") return;
+    const token = ++_prPrefetchToken;
+    const repo = cwd.value;
+    if (!repo) return;
+    const live = () =>
+      cwd.value === repo && token === _prPrefetchToken && filterState.value === "open";
+    while (live() && hasMore.value && prs.value.length < PREFETCH_CEILING) {
+      await whenIdle();
+      if (!live()) return;
+      await loadMorePrs(BG_PAGE);
+    }
+  }
+
   function resetDetail() {
     prDetail.value = null;
     prChecks.value = [];
@@ -1074,6 +1108,7 @@ export function usePrPanel(cwd: Ref<string>, opts: PrPanelOptions = {}) {
       await loadRemote();
     }
     await loadPrs();
+    void prefetchOpenPrs();
   }
 
   return {

From 16051a9f2f26d786a62e36a33e73fe90692dba21 Mon Sep 17 00:00:00 2001
From: Laurent Guitton <laurent.guitton@dendreo.com>
Date: Fri, 10 Jul 2026 00:12:12 +0200
Subject: [PATCH 05/18] fix: cancel in-flight PR prefetch on any cwd change,
 not just a fresh prefetchOpenPrs() call

---
 .../composables/__tests__/usePrPanel.test.ts  | 23 +++++++++++++++++++
 apps/desktop/src/composables/usePrPanel.ts    |  1 +
 2 files changed, 24 insertions(+)

diff --git a/apps/desktop/src/composables/__tests__/usePrPanel.test.ts b/apps/desktop/src/composables/__tests__/usePrPanel.test.ts
index d8828493..44b67ec3 100644
--- a/apps/desktop/src/composables/__tests__/usePrPanel.test.ts
+++ b/apps/desktop/src/composables/__tests__/usePrPanel.test.ts
@@ -82,4 +82,27 @@ describe("usePrPanel — background prefetch drain", () => {
     // The stale prefetch for /repo-a must not issue a second call.
     expect(listPRs).toHaveBeenCalledTimes(1);
   });
+
+  it("stops the drain after an A→B→A round-trip during an in-flight prefetch", async () => {
+    listPRs.mockImplementation(pagedListPRs(500));
+    const cwd = ref("/repo-a");
+    const panel = usePrPanel(cwd);
+    await panel.ensurePrsLoaded();
+    expect(panel.prs.value).toHaveLength(10);
+    expect(listPRs).toHaveBeenCalledTimes(1);
+
+    // Round-trip back to /repo-a before the in-flight prefetch's whenIdle()
+    // resolves. The cwd watcher must invalidate the original loop's token on
+    // *both* hops, so cwd.value being back to "/repo-a" alone isn't enough
+    // for the stale loop's `live()` check to pass.
+    cwd.value = "/repo-b";
+    await nextTick();
+    cwd.value = "/repo-a";
+    await nextTick();
+
+    await vi.advanceTimersByTimeAsync(40);
+
+    // The original repo-a prefetch loop must not resume issuing fetches.
+    expect(listPRs).toHaveBeenCalledTimes(1);
+  });
 });
diff --git a/apps/desktop/src/composables/usePrPanel.ts b/apps/desktop/src/composables/usePrPanel.ts
index 52274bed..f4fbbd3e 100644
--- a/apps/desktop/src/composables/usePrPanel.ts
+++ b/apps/desktop/src/composables/usePrPanel.ts
@@ -744,6 +744,7 @@ export function usePrPanel(cwd: Ref<string>, opts: PrPanelOptions = {}) {
     prs.value = [];
     remote.value = null;
     _prsEnsured = false;
+    ++_prPrefetchToken; // invalidate any in-flight background prefetch for the old repo
     resetDetail();
     if (newCwd && panelMounted.value) init();
   });

From 2116df6ec310c7e2ffc669c666d49ebfd250fb63 Mon Sep 17 00:00:00 2001
From: Laurent Guitton <laurent.guitton@dendreo.com>
Date: Fri, 10 Jul 2026 00:16:36 +0200
Subject: [PATCH 06/18] feat(rust): add PrFreshnessSignal + REST freshness
 probe for PR badge cache

---
 .../src-tauri/src/commands/github_api.rs      | 59 +++++++++++++++++++
 apps/desktop/src-tauri/src/types.rs           | 14 +++++
 2 files changed, 73 insertions(+)

diff --git a/apps/desktop/src-tauri/src/commands/github_api.rs b/apps/desktop/src-tauri/src/commands/github_api.rs
index 01617c5c..77ea9de1 100644
--- a/apps/desktop/src-tauri/src/commands/github_api.rs
+++ b/apps/desktop/src-tauri/src/commands/github_api.rs
@@ -503,6 +503,48 @@ pub(crate) fn rest_list_prs(
     Ok(prs)
 }
 
+/// Pure extraction of `(number, updated_at)` from a REST `GET .../pulls` JSON
+/// array already sorted `updated desc` — the first element is the signal.
+/// Split out from `rest_pr_freshness_signal` so it's unit-testable without an
+/// HTTP call (mirrors `json_to_pr`'s separation of parsing from I/O).
+fn top_pr_from_rest_json(raw: &[serde_json::Value]) -> Option<(i64, String)> {
+    let top = raw.first()?;
+    let updated_at = js(top, "updated_at");
+    if updated_at.is_empty() {
+        return None;
+    }
+    Some((ji(top, "number"), updated_at))
+}
+
+/// Cheap "has the open-PR list changed?" probe: the single most-recently
+/// updated open PR (`per_page=1&sort=updated&direction=desc`, no per-PR
+/// enrichment — unlike `rest_list_prs` this never calls the detail/check-runs
+/// endpoints) plus the open PR count (`rest_pr_count`, already a single
+/// `/search/issues` call). `Ok(None)` means the repo currently has zero open
+/// PRs.
+pub(crate) fn rest_pr_freshness_signal(cwd: &str, token: &str) -> Result<Option<PrFreshnessSignal>, String> {
+    let base = base_owner_repo(cwd, token).unwrap_or_else(|_| {
+        let (o, r) = owner_repo(cwd).unwrap_or_default();
+        format!("{}/{}", o, r)
+    });
+    let raw: Vec<serde_json::Value> = api_json_cached(
+        &format!(
+            "{}/repos/{}/pulls?state=open&per_page=1&page=1&sort=updated&direction=desc",
+            API_BASE, base
+        ),
+        token,
+    )?
+    .as_array()
+    .cloned()
+    .unwrap_or_default();
+    let (number, updated_at) = match top_pr_from_rest_json(&raw) {
+        Some(pair) => pair,
+        None => return Ok(None),
+    };
+    let open_count = rest_pr_count(cwd, "open", token)?;
+    Ok(Some(PrFreshnessSignal { number, updated_at, open_count }))
+}
+
 /// Aggregate the check-runs of commit `sha` in `repo` ("owner/name") into a
 /// single rollup state: `FAILURE` / `PENDING` / `SUCCESS`, or `""` when the
 /// commit has no checks configured. Best effort — any HTTP error yields `""`.
@@ -1619,4 +1661,21 @@ mod tests {
             "header = \"Authorization: Bearer ghp_abc123\"\n"
         );
     }
+
+    #[test]
+    fn top_pr_from_rest_json_reads_first_sorted_entry() {
+        let raw = vec![
+            json!({"number": 88, "updated_at": "2026-07-09T10:00:00Z"}),
+            json!({"number": 3, "updated_at": "2026-01-01T00:00:00Z"}),
+        ];
+        assert_eq!(
+            top_pr_from_rest_json(&raw),
+            Some((88, "2026-07-09T10:00:00Z".to_string()))
+        );
+    }
+
+    #[test]
+    fn top_pr_from_rest_json_empty_list_is_none() {
+        assert_eq!(top_pr_from_rest_json(&[]), None);
+    }
 }
diff --git a/apps/desktop/src-tauri/src/types.rs b/apps/desktop/src-tauri/src/types.rs
index 9e9141d8..2634d0d5 100644
--- a/apps/desktop/src-tauri/src/types.rs
+++ b/apps/desktop/src-tauri/src/types.rs
@@ -358,6 +358,20 @@ pub struct PullRequest {
     pub comment_count: i64,
 }
 
+/// Cheap signal used to detect whether a repo's open-PR list has changed
+/// since it was last fully drained and cached (`usePrPanel.ts`'s
+/// `PR_LIST_CACHE`), without re-fetching the whole list. Two facts, since
+/// neither alone catches every kind of change: the most-recently-updated
+/// open PR (catches edits/comments/new PRs) and the open PR count (catches
+/// a PR closing, which drops it out of the "state=open" results entirely
+/// without changing who's "most recently updated").
+#[derive(Serialize)]
+pub struct PrFreshnessSignal {
+    pub number: i64,
+    pub updated_at: String,
+    pub open_count: i64,
+}
+
 #[derive(Deserialize)]
 pub struct GhPrAuthor {
     /// `None` when the original author has been deleted on GitHub, or for

From 943e61cc0fa0db00477cba4b61fe097044b71cb4 Mon Sep 17 00:00:00 2001
From: Laurent Guitton <laurent.guitton@dendreo.com>
Date: Fri, 10 Jul 2026 00:22:00 +0200
Subject: [PATCH 07/18] feat(rust): add gh_pr_freshness_signal Tauri command
 (gh CLI path)

---
 apps/desktop/src-tauri/src/commands/gh.rs | 85 +++++++++++++++++++++++
 apps/desktop/src-tauri/src/lib.rs         |  1 +
 2 files changed, 86 insertions(+)

diff --git a/apps/desktop/src-tauri/src/commands/gh.rs b/apps/desktop/src-tauri/src/commands/gh.rs
index 0fa45592..ad6ed339 100644
--- a/apps/desktop/src-tauri/src/commands/gh.rs
+++ b/apps/desktop/src-tauri/src/commands/gh.rs
@@ -249,6 +249,65 @@ pub(crate) async fn gh_pr_count(cwd: String, state: String) -> Result<i64, Strin
         .map_err(|e| e.to_string())?
 }
 
+/// Pure extraction of `(number, updated_at)` from `gh pr list --json
+/// number,updatedAt` output (already `--limit 1 -S "sort:updated-desc"`
+/// sorted) — the gh CLI's JSON keys are camelCase, unlike the REST API's
+/// snake_case, so this can't share `top_pr_from_rest_json` in github_api.rs.
+fn top_pr_from_cli_json(raw: &[serde_json::Value]) -> Option<(i64, String)> {
+    let top = raw.first()?;
+    let updated_at = top.get("updatedAt").and_then(|v| v.as_str())?.to_string();
+    let number = top.get("number").and_then(|v| v.as_i64())?;
+    Some((number, updated_at))
+}
+
+fn gh_pr_freshness_signal_inner(cwd: String) -> Result<Option<PrFreshnessSignal>, String> {
+    if let Some(tok) = github_api::settings_github_token() {
+        return github_api::rest_pr_freshness_signal(&cwd, &tok);
+    }
+    // No sort flag is used by the main gh_list_prs_inner list fetch (its
+    // order doesn't matter there) — this probe needs updated-desc
+    // specifically, via a `-S` search-query sort, requested only here.
+    let target_repo = gh_fork_upstream(&cwd);
+    let mut cmd = hidden_cmd("gh");
+    cmd.args([
+        "pr", "list",
+        "--state", "open",
+        "--json", "number,updatedAt",
+        "--limit", "1",
+        "-S", "sort:updated-desc",
+    ]);
+    if let Some(ref nwo) = target_repo {
+        cmd.args(["--repo", nwo]);
+    }
+    let output = cmd
+        .current_dir(&cwd)
+        .output()
+        .map_err(|e| format!("Failed to run gh pr list (freshness signal): {}", e))?;
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        return Err(format!("gh pr list (freshness signal) failed: {}", stderr));
+    }
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    let raw: Vec<serde_json::Value> = serde_json::from_str(stdout.trim())
+        .map_err(|e| format!("Failed to parse freshness signal output: {}", e))?;
+    let (number, updated_at) = match top_pr_from_cli_json(&raw) {
+        Some(pair) => pair,
+        None => return Ok(None),
+    };
+    let open_count = gh_pr_count_inner(cwd, "open".to_string())?;
+    Ok(Some(PrFreshnessSignal { number, updated_at, open_count }))
+}
+
+/// Cheap "has the open-PR list changed?" probe for the branch-badge
+/// background-drain cache (`usePrPanel.ts`'s `PR_LIST_CACHE`). See
+/// `PrFreshnessSignal`'s doc comment for why two facts are needed.
+#[tauri::command]
+pub(crate) async fn gh_pr_freshness_signal(cwd: String) -> Result<Option<PrFreshnessSignal>, String> {
+    tauri::async_runtime::spawn_blocking(move || gh_pr_freshness_signal_inner(cwd))
+        .await
+        .map_err(|e| e.to_string())?
+}
+
 fn gh_create_pr_inner(
     cwd: String,
     title: String,
@@ -1399,3 +1458,29 @@ mod gh_list_issues_tests {
         assert_eq!(issues[0].milestone, "v1");
     }
 }
+
+#[cfg(test)]
+mod gh_pr_freshness_tests {
+    use super::*;
+    use serde_json::json;
+
+    #[test]
+    fn top_pr_from_cli_json_reads_first_entry() {
+        let raw = vec![json!({"number": 12, "updatedAt": "2026-07-09T09:00:00Z"})];
+        assert_eq!(
+            top_pr_from_cli_json(&raw),
+            Some((12, "2026-07-09T09:00:00Z".to_string()))
+        );
+    }
+
+    #[test]
+    fn top_pr_from_cli_json_empty_list_is_none() {
+        assert_eq!(top_pr_from_cli_json(&[]), None);
+    }
+
+    #[test]
+    fn top_pr_from_cli_json_missing_updated_at_is_none() {
+        let raw = vec![json!({"number": 12})];
+        assert_eq!(top_pr_from_cli_json(&raw), None);
+    }
+}
diff --git a/apps/desktop/src-tauri/src/lib.rs b/apps/desktop/src-tauri/src/lib.rs
index 9214c9b1..2ace1f24 100644
--- a/apps/desktop/src-tauri/src/lib.rs
+++ b/apps/desktop/src-tauri/src/lib.rs
@@ -398,6 +398,7 @@ pub fn run() {
             commands::ops::git_remote_info,
             commands::gh::gh_list_prs,
             commands::gh::gh_pr_count,
+            commands::gh::gh_pr_freshness_signal,
             commands::gh::gh_create_pr,
             commands::gh::gh_list_reviewer_candidates,
             commands::gh::gh_branches,

From e9f898ae119ef190e488c49745306aed27e19f00 Mon Sep 17 00:00:00 2001
From: Laurent Guitton <laurent.guitton@dendreo.com>
Date: Fri, 10 Jul 2026 00:26:29 +0200
Subject: [PATCH 08/18] feat: add ghPrFreshnessSignal TS wrapper for the PR
 badge cache

---
 .../src/utils/__tests__/backend-pr.test.ts    | 44 +++++++++++++++++++
 apps/desktop/src/utils/backend-pr.ts          | 36 +++++++++++++++
 2 files changed, 80 insertions(+)

diff --git a/apps/desktop/src/utils/__tests__/backend-pr.test.ts b/apps/desktop/src/utils/__tests__/backend-pr.test.ts
index 478a0258..8332b0ca 100644
--- a/apps/desktop/src/utils/__tests__/backend-pr.test.ts
+++ b/apps/desktop/src/utils/__tests__/backend-pr.test.ts
@@ -60,3 +60,47 @@ describe("ghCurrentUser caching", () => {
     await expect(ghCurrentUser()).rejects.toThrow(/500.*rate limit/);
   });
 });
+
+describe("ghPrFreshnessSignal", () => {
+  beforeEach(() => {
+    vi.resetModules();
+    devFetch.mockReset();
+    tauriInvoke.mockReset();
+    tauri = false;
+  });
+
+  it("maps the Tauri command's snake_case response to camelCase", async () => {
+    tauri = true;
+    tauriInvoke.mockResolvedValue({ number: 88, updated_at: "2026-07-09T10:00:00Z", open_count: 12 });
+    const { ghPrFreshnessSignal } = await import("../backend-pr");
+    await expect(ghPrFreshnessSignal("/repo")).resolves.toEqual({
+      number: 88, updatedAt: "2026-07-09T10:00:00Z", openCount: 12,
+    });
+  });
+
+  it("returns null when the Tauri command reports zero open PRs", async () => {
+    tauri = true;
+    tauriInvoke.mockResolvedValue(null);
+    const { ghPrFreshnessSignal } = await import("../backend-pr");
+    await expect(ghPrFreshnessSignal("/repo")).resolves.toBeNull();
+  });
+
+  it("returns null instead of throwing when the probe fails", async () => {
+    tauri = true;
+    tauriInvoke.mockRejectedValue(new Error("network down"));
+    const { ghPrFreshnessSignal } = await import("../backend-pr");
+    await expect(ghPrFreshnessSignal("/repo")).resolves.toBeNull();
+  });
+
+  it("dev-server branch maps the JSON response to camelCase", async () => {
+    tauri = false;
+    devFetch.mockResolvedValue(mockRes({
+      ok: true,
+      json: { number: 5, updated_at: "2026-01-01T00:00:00Z", open_count: 2 },
+    }));
+    const { ghPrFreshnessSignal } = await import("../backend-pr");
+    await expect(ghPrFreshnessSignal("/repo")).resolves.toEqual({
+      number: 5, updatedAt: "2026-01-01T00:00:00Z", openCount: 2,
+    });
+  });
+});
diff --git a/apps/desktop/src/utils/backend-pr.ts b/apps/desktop/src/utils/backend-pr.ts
index 270ed47c..69d24ec6 100644
--- a/apps/desktop/src/utils/backend-pr.ts
+++ b/apps/desktop/src/utils/backend-pr.ts
@@ -234,6 +234,42 @@ export async function ghPrCount(cwd: string, state: string = "open"): Promise<nu
   }
 }
 
+/** Signal returned by `gh_pr_freshness_signal` — see the Rust doc comment on `PrFreshnessSignal`. */
+export interface PrFreshnessSignal {
+  number: number;
+  updatedAt: string;
+  openCount: number;
+}
+
+/**
+ * Cheap "has the open-PR list changed?" probe for the branch-badge
+ * background-drain cache (`usePrPanel.ts`'s `PR_LIST_CACHE`). GitHub-only —
+ * other forges have no equivalent yet, so their badge path always falls
+ * through to a normal fetch-and-drain instead of an instant cache restore.
+ *
+ * Returns `null` when the repo currently has zero open PRs, or when the
+ * probe itself fails (the caller treats that the same as "cache stale,
+ * redrain").
+ */
+export async function ghPrFreshnessSignal(cwd: string): Promise<PrFreshnessSignal | null> {
+  try {
+    if (isTauri()) {
+      const raw = await tauriInvoke<{ number: number; updated_at: string; open_count: number } | null>(
+        "gh_pr_freshness_signal",
+        { cwd },
+      );
+      return raw ? { number: raw.number, updatedAt: raw.updated_at, openCount: raw.open_count } : null;
+    }
+    const res = await devFetch(`${DEV_SERVER}/api/gh-pr-freshness?cwd=${encodeURIComponent(cwd)}`);
+    if (!res.ok) return null;
+    const data = await res.json();
+    if (!data || typeof data.number !== "number") return null;
+    return { number: data.number, updatedAt: data.updated_at, openCount: data.open_count ?? 0 };
+  } catch {
+    return null;
+  }
+}
+
 // Minimal branch shape for the publish guard — only the fields it reads.
 interface BranchPublishInfo {
   name: string;

From abd56ec9be89e7ffd7771945eb29ef565e7831bd Mon Sep 17 00:00:00 2001
From: Laurent Guitton <laurent.guitton@dendreo.com>
Date: Fri, 10 Jul 2026 00:31:28 +0200
Subject: [PATCH 09/18] feat: add /api/gh-pr-freshness dev-server route

---
 apps/desktop/dev-server.mjs | 38 +++++++++++++++++++++++++++++++++++++
 1 file changed, 38 insertions(+)

diff --git a/apps/desktop/dev-server.mjs b/apps/desktop/dev-server.mjs
index d2f876c9..4e695696 100644
--- a/apps/desktop/dev-server.mjs
+++ b/apps/desktop/dev-server.mjs
@@ -2966,6 +2966,43 @@ async function handleRequest(req, res) {
       }
     }
 
+    // GET /api/gh-pr-freshness?cwd=<path>
+    // Cheap "has the open-PR list changed?" probe for the branch-badge
+    // background-drain cache (mirrors Rust `gh_pr_freshness_signal`): the
+    // single most-recently-updated open PR plus the open PR count. Returns
+    // null when the repo has zero open PRs or the token/remote can't be
+    // resolved — the frontend treats that the same as "cache stale, redrain".
+    if (url.pathname === "/api/gh-pr-freshness" && req.method === "GET") {
+      const cwd = url.searchParams.get("cwd");
+      if (!cwd) return jsonResponse(req, res, { error: "Missing cwd" }, 400);
+      try {
+        const token = getGithubToken();
+        if (!token) return jsonResponse(req, res, null);
+        const nwo = getRepoNwo(resolve(cwd));
+        if (!nwo) return jsonResponse(req, res, null);
+        const topResp = await githubFetch(`/repos/${nwo}/pulls?state=open&per_page=1&page=1&sort=updated&direction=desc`, token);
+        if (!topResp.ok) return jsonResponse(req, res, null);
+        const topData = await topResp.json();
+        if (!Array.isArray(topData) || topData.length === 0) return jsonResponse(req, res, null);
+        // Count via the same Link-header trick as /api/gh-pr-count.
+        const countResp = await githubFetch(`/repos/${nwo}/pulls?state=open&per_page=1`, token);
+        let openCount = topData.length;
+        if (countResp.ok) {
+          const linkHeader = countResp.headers.get("link") || "";
+          const m = linkHeader.match(/<[^>]*[?&]page=(\d+)[^>]*>;\s*rel="last"/);
+          if (m) openCount = parseInt(m[1], 10);
+        }
+        return jsonResponse(req, res, {
+          number: topData[0].number,
+          updated_at: topData[0].updated_at,
+          open_count: openCount,
+        });
+      } catch (err) {
+        console.error("[gh-pr-freshness]", err.message);
+        return jsonResponse(req, res, null);
+      }
+    }
+
     // POST /api/gh-create-pr
     // Body: { cwd, title, body, base?, head?, draft?, reviewers? }
     // Creates the PR via REST, then requests reviewers in a second call
@@ -6198,6 +6235,7 @@ server.listen(PORT, "127.0.0.1", () => {
   console.log(`    GET  /api/git-log?cwd=<path>&count=<n>&all=<bool>`);
   console.log(`    GET  /api/gh-list-prs?cwd=<path>&state=<state>`);
   console.log(`    GET  /api/gh-pr-count?cwd=<path>&state=<state>`);
+  console.log(`    GET  /api/gh-pr-freshness?cwd=<path>`);
   console.log(`    POST /api/gh-create-pr  { cwd, title, body, base?, draft?, reviewers? }`);
   console.log(`    GET  /api/gh-reviewer-candidates?cwd=<path>`);
   console.log(`    GET  /api/gh-pr-detail?cwd=<path>&number=<n>`);

From 688c6c4c9555fedf5aaacf44d89e59ea1199ea8c Mon Sep 17 00:00:00 2001
From: Laurent Guitton <laurent.guitton@dendreo.com>
Date: Fri, 10 Jul 2026 00:40:03 +0200
Subject: [PATCH 10/18] feat: cache drained open-PR lists and validate them via
 a cheap freshness signal

---
 .../composables/__tests__/usePrPanel.test.ts  | 84 +++++++++++++++++--
 apps/desktop/src/composables/usePrPanel.ts    | 84 ++++++++++++++++++-
 2 files changed, 159 insertions(+), 9 deletions(-)

diff --git a/apps/desktop/src/composables/__tests__/usePrPanel.test.ts b/apps/desktop/src/composables/__tests__/usePrPanel.test.ts
index 44b67ec3..189fdd68 100644
--- a/apps/desktop/src/composables/__tests__/usePrPanel.test.ts
+++ b/apps/desktop/src/composables/__tests__/usePrPanel.test.ts
@@ -1,22 +1,28 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
 import { ref, nextTick } from "vue";
 
-// `listPRs` must be created via `vi.hoisted()`: usePrPanel.ts's import chain is
-// long enough that Vitest evaluates the "../forge/useForge" mock factory before
-// a plain top-level `const listPRs = vi.fn()` in this file would have run,
-// throwing "Cannot access 'listPRs' before initialization". `vi.hoisted()`
-// guarantees the initializer runs first regardless of import graph shape.
-const { listPRs } = vi.hoisted(() => ({ listPRs: vi.fn() }));
+// All of these must be created via `vi.hoisted()`: usePrPanel.ts's import
+// chain is long enough that Vitest evaluates the mock factories below before
+// a plain top-level `const x = vi.fn()` in this file would have run, throwing
+// "Cannot access 'x' before initialization". `vi.hoisted()` guarantees the
+// initializers run first regardless of import graph shape.
+const { listPRs, createPR, mergePR, ghPrFreshnessSignal } = vi.hoisted(() => ({
+  listPRs: vi.fn(),
+  createPR: vi.fn(),
+  mergePR: vi.fn(),
+  ghPrFreshnessSignal: vi.fn(),
+}));
 
 vi.mock("../../utils/backend", () => ({
   gitRemoteInfo: vi.fn(async () => null),
   gitFileCount: vi.fn(async () => 0),
   ghForkInfo: vi.fn(async () => ({ isFork: false, origin: "", parent: "" })),
+  ghPrFreshnessSignal: (...args: unknown[]) => ghPrFreshnessSignal(...args),
 }));
 
 vi.mock("../forge/useForge", () => ({
-  forgeFromRemoteInfo: vi.fn(() => ({ name: "github", listPRs })),
-  githubProvider: { name: "github", listPRs },
+  forgeFromRemoteInfo: vi.fn(() => ({ name: "github", listPRs, createPR, mergePR })),
+  githubProvider: { name: "github", listPRs, createPR, mergePR },
 }));
 
 import { usePrPanel } from "../usePrPanel";
@@ -47,6 +53,9 @@ describe("usePrPanel — background prefetch drain", () => {
     localStorage.clear();
     _resetPrCacheForTesting();
     listPRs.mockReset();
+    createPR.mockReset();
+    mergePR.mockReset();
+    ghPrFreshnessSignal.mockReset();
     vi.useFakeTimers();
   });
 
@@ -105,4 +114,63 @@ describe("usePrPanel — background prefetch drain", () => {
     // The original repo-a prefetch loop must not resume issuing fetches.
     expect(listPRs).toHaveBeenCalledTimes(1);
   });
+
+  it("restores instantly from the in-memory cache when the freshness signal is unchanged", async () => {
+    listPRs.mockImplementation(pagedListPRs(15));
+    ghPrFreshnessSignal.mockResolvedValue({ number: 15, updatedAt: "t1", openCount: 15 });
+    const panel = usePrPanel(ref("/repo"));
+
+    await panel.ensurePrsLoaded();
+    await vi.advanceTimersByTimeAsync(40); // drain completes, cache is written
+    expect(panel.prs.value).toHaveLength(15);
+    const callsAfterFirstDrain = listPRs.mock.calls.length;
+
+    await panel.ensurePrsLoaded(); // e.g. branch popover reopened
+    expect(panel.prs.value).toHaveLength(15);
+    expect(listPRs.mock.calls.length).toBe(callsAfterFirstDrain); // no new fetch — restored from cache
+    // Called twice total: once when prefetchOpenPrs() wrote the cache after
+    // the first drain, once for this second call's freshness recheck.
+    expect(ghPrFreshnessSignal).toHaveBeenCalledTimes(2);
+  });
+
+  it("redrains when the freshness signal changes (e.g. a PR opened elsewhere)", async () => {
+    listPRs.mockImplementation(pagedListPRs(15));
+    ghPrFreshnessSignal.mockResolvedValue({ number: 15, updatedAt: "t1", openCount: 15 });
+    const panel = usePrPanel(ref("/repo"));
+
+    await panel.ensurePrsLoaded();
+    await vi.advanceTimersByTimeAsync(40);
+    expect(panel.prs.value).toHaveLength(15);
+
+    listPRs.mockImplementation(pagedListPRs(16));
+    ghPrFreshnessSignal.mockResolvedValue({ number: 16, updatedAt: "t2", openCount: 16 });
+
+    await panel.ensurePrsLoaded();
+    await vi.advanceTimersByTimeAsync(40);
+    expect(panel.prs.value).toHaveLength(16);
+  });
+
+  it("createPr() invalidates the cache so the next ensurePrsLoaded() redrains", async () => {
+    listPRs.mockImplementation(pagedListPRs(15));
+    ghPrFreshnessSignal.mockResolvedValue({ number: 15, updatedAt: "t1", openCount: 15 });
+    const panel = usePrPanel(ref("/repo"));
+
+    await panel.ensurePrsLoaded();
+    await vi.advanceTimersByTimeAsync(40);
+    expect(panel.prs.value).toHaveLength(15);
+
+    createPR.mockResolvedValue(makePr(16));
+    panel.newPrTitle.value = "New PR";
+    listPRs.mockImplementation(pagedListPRs(16)); // the repo now has 16 open PRs
+    await panel.createPr();
+    const callsAfterCreate = listPRs.mock.calls.length;
+
+    ghPrFreshnessSignal.mockResolvedValue({ number: 16, updatedAt: "t2", openCount: 16 });
+    await panel.ensurePrsLoaded();
+    await vi.advanceTimersByTimeAsync(40);
+
+    // A stale pre-createPr cache entry must NOT be trusted — it must redrain.
+    expect(listPRs.mock.calls.length).toBeGreaterThan(callsAfterCreate);
+    expect(panel.prs.value).toHaveLength(16);
+  });
 });
diff --git a/apps/desktop/src/composables/usePrPanel.ts b/apps/desktop/src/composables/usePrPanel.ts
index f4fbbd3e..a3459c84 100644
--- a/apps/desktop/src/composables/usePrPanel.ts
+++ b/apps/desktop/src/composables/usePrPanel.ts
@@ -27,6 +27,8 @@ import {
   type PrFileHistory,
   ghForkInfo,
   type ForkInfo,
+  ghPrFreshnessSignal,
+  type PrFreshnessSignal,
 } from "../utils/backend";
 import { forgeFromRemoteInfo, githubProvider } from "./forge/useForge";
 import { usePrCache, listKey, detailKey } from "./usePrCache";
@@ -195,6 +197,37 @@ export function usePrPanel(cwd: Ref<string>, opts: PrPanelOptions = {}) {
   const PREFETCH_CEILING = 300;
   let _prPrefetchToken = 0;
 
+  // ─── In-memory list cache (badge path) ──────────────────────────────────
+  // Mirrors useGitRepo.ts's LOG_CACHE/prefetchAllPages pattern (PR #113).
+  // Declared inside usePrPanel() — a singleton instantiated once in App.vue,
+  // same as LOG_CACHE — so its lifetime matches the app session, and each
+  // fresh usePrPanel() call (e.g. in a test) starts with an empty cache.
+  interface PrListCacheEntry {
+    prs: PullRequest[];
+    hasMore: boolean;
+    topSignal: PrFreshnessSignal | null;
+  }
+  const PR_LIST_CACHE = new Map<string, PrListCacheEntry>();
+  // Throttles the freshness re-probe on repeated ensurePrsLoaded() calls
+  // (branch popover reopened, graph mode re-entered) so rapid toggling
+  // doesn't fire a GitHub request every time.
+  const FRESHNESS_RECHECK_MS = 30_000;
+  let _lastFreshnessCheck = 0;
+
+  /**
+   * GitHub-only cheap freshness probe (see `ghPrFreshnessSignal`'s doc
+   * comment). Other forges have no equivalent yet — `null` here just means
+   * "no signal available", which `ensurePrsLoaded()` treats as a cache miss.
+   */
+  async function fetchPrFreshnessSignal(repo: string): Promise<PrFreshnessSignal | null> {
+    if (forge.value.name !== "github") return null;
+    try {
+      return await ghPrFreshnessSignal(repo);
+    } catch {
+      return null;
+    }
+  }
+
   // ─── Computed ──────────────────────────────────────────
   const commentsForFile = computed<PrReviewComment[]>(() =>
     selectedDiffFile.value
@@ -547,6 +580,17 @@ export function usePrPanel(cwd: Ref<string>, opts: PrPanelOptions = {}) {
       if (!live()) return;
       await loadMorePrs(BG_PAGE);
     }
+    // Only cache a fully-drained list (reached the true end before the
+    // ceiling), and only for GitHub (the only forge with a freshness
+    // signal) — a ceiling-capped or signal-less list stays uncached so
+    // ensurePrsLoaded() keeps retrying instead of trusting an incomplete or
+    // unvalidatable snapshot forever.
+    if (live() && !hasMore.value && forge.value.name === "github") {
+      const topSignal = await fetchPrFreshnessSignal(repo);
+      if (live()) {
+        PR_LIST_CACHE.set(repo, { prs: prs.value.slice(), hasMore: false, topSignal });
+      }
+    }
   }
 
   function resetDetail() {
@@ -744,6 +788,7 @@ export function usePrPanel(cwd: Ref<string>, opts: PrPanelOptions = {}) {
     prs.value = [];
     remote.value = null;
     _prsEnsured = false;
+    _lastFreshnessCheck = 0;
     ++_prPrefetchToken; // invalidate any in-flight background prefetch for the old repo
     resetDetail();
     if (newCwd && panelMounted.value) init();
@@ -775,6 +820,8 @@ export function usePrPanel(cwd: Ref<string>, opts: PrPanelOptions = {}) {
       newPrTitle.value = ""; newPrBody.value = ""; newPrDraft.value = false;
       newPrReviewers.value = [];
       cache.invalidateLists(cwd.value);
+      PR_LIST_CACHE.delete(cwd.value);
+      _prsEnsured = false;
       await loadPrs();
     } catch (err: any) { error.value = err.message; }
     finally { isCreating.value = false; }
@@ -832,6 +879,8 @@ export function usePrPanel(cwd: Ref<string>, opts: PrPanelOptions = {}) {
       success.value = t("pr.success.prMerged", mergingPr.value.number);
       cache.invalidateDetail(cwd.value, mergingPr.value.number);
       cache.invalidateLists(cwd.value);
+      PR_LIST_CACHE.delete(cwd.value);
+      _prsEnsured = false;
       mergingPr.value = null;
       await loadPrs();
     } catch (err: any) { error.value = err.message; }
@@ -1099,7 +1148,40 @@ export function usePrPanel(cwd: Ref<string>, opts: PrPanelOptions = {}) {
    * SWR-cached list fetch. No-op once done for the current repo (until switch).
    */
   async function ensurePrsLoaded() {
-    if (!cwd.value || _prsEnsured || prs.value.length > 0) return;
+    if (!cwd.value || filterState.value !== "open") return;
+    const repo = cwd.value;
+    const cached = PR_LIST_CACHE.get(repo);
+    if (cached) {
+      const now = Date.now();
+      if (now - _lastFreshnessCheck < FRESHNESS_RECHECK_MS) return; // recently confirmed fresh
+      _lastFreshnessCheck = now;
+      const signal = await fetchPrFreshnessSignal(repo);
+      if (cwd.value !== repo) return; // repo changed while the probe was in flight
+      const unchanged =
+        (signal === null && cached.topSignal === null) ||
+        (signal !== null &&
+          cached.topSignal !== null &&
+          signal.number === cached.topSignal.number &&
+          signal.updatedAt === cached.topSignal.updatedAt &&
+          signal.openCount === cached.topSignal.openCount);
+      if (unchanged) {
+        prs.value = cached.prs;
+        hasMore.value = false;
+        return;
+      }
+      // Stale (or the probe errored) — drop the cache and fall through to a
+      // full redrain below, UNCONDITIONALLY: this branch must not be gated
+      // by the `_prsEnsured`/`prs.value.length` check below, or a repo whose
+      // cache just went stale would keep showing the stale list forever
+      // (`_prsEnsured` stays true and `prs.value` stays non-empty even
+      // though nothing is being redrained).
+      PR_LIST_CACHE.delete(repo);
+    } else if (_prsEnsured && prs.value.length > 0) {
+      // No cache yet, but this session already loaded (or is loading/
+      // draining) this repo's open PRs — matches the original one-shot
+      // guard for the "mid-drain, not yet cached" window.
+      return;
+    }
     _prsEnsured = true;
     const cachedRemote = cache.getRemote(cwd.value);
     if (cachedRemote) {

From 75145e97aeafdc883752726dea081de7e2356d74 Mon Sep 17 00:00:00 2001
From: Laurent Guitton <laurent.guitton@dendreo.com>
Date: Fri, 10 Jul 2026 10:31:21 +0200
Subject: [PATCH 11/18] docs: add design spec for wiring the AppDock PR count
 badge
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Reuses the already-built but unwired getPRCount()/ghPrCount() forge
abstraction as a cheap, per-repo-open ping — independent of the
branch-badge prefetch/cache work.
---
 .../2026-07-10-pr-dock-badge-count-design.md  | 97 +++++++++++++++++++
 1 file changed, 97 insertions(+)
 create mode 100644 docs/superpowers/specs/2026-07-10-pr-dock-badge-count-design.md

diff --git a/docs/superpowers/specs/2026-07-10-pr-dock-badge-count-design.md b/docs/superpowers/specs/2026-07-10-pr-dock-badge-count-design.md
new file mode 100644
index 00000000..da6940e2
--- /dev/null
+++ b/docs/superpowers/specs/2026-07-10-pr-dock-badge-count-design.md
@@ -0,0 +1,97 @@
+# PR dock badge — cheap count on repo open
+
+## Problem
+
+`AppDock.vue` already has a `prCount?: number` prop (line 24) used to badge the "prs" dock item (line 83: `if (id === "prs") return props.prCount || undefined;`), but nothing in `App.vue` ever passes it — the prop is dead. Similarly, every `ForgeProvider` implements `getPRCount(cwd, state)` (backed by `ghPrCount` → Rust `gh_pr_count` → a single cheap REST `/search/issues?...&per_page=1` call or GraphQL `totalCount` query, per forge), but nothing calls it anywhere in the app today.
+
+Meanwhile, the PR list view's own header count (`PrListSidebar.vue:102`, `totalCount = computed(() => panel.displayedPrs.value.length)`) only ever reflects however many PRs are *currently loaded* into `prs.value` — 10 by default, more after the background drain (see `2026-07-09-pr-badge-prefetch-design.md`), fewer if a user filter is active — never the true total open-PR count.
+
+## Goals
+
+- Wire the existing, unused `AppDock` `prCount` prop to a real open-PR count, refreshed via a single cheap call when a repo becomes active — independent of whether the user has ever opened the branch-selector popover, graph mode, or the PR list view.
+- Reuse the existing forge-abstracted `getPRCount()` — works across all 4 forges (GitHub/GitLab/Bitbucket/Azure), not just GitHub.
+- Keep the PR list view's own count/list behavior exactly as it is today (10 + scroll pagination, `totalCount` = loaded count) — this spec does not change `PrListSidebar.vue`'s list rendering.
+- The PR list view's manual refresh button also refreshes the dock count, so both stay in sync after an explicit user-initiated refresh.
+
+## Non-goals
+
+- No changes to the PR list's own pagination, its `totalCount` pill, or its filter behavior.
+- No changes to the branch-badge background-drain/cache work from `2026-07-09-pr-badge-prefetch-design.md` — this is a separate, independent counter.
+- The dock count always reflects `state: "open"` — it does not follow the PR list view's active filter (open/closed/all). If the user is viewing "closed" PRs in the list, the dock badge still shows the open count.
+- No automatic periodic refresh of the dock count (no new polling) — it updates only on repo-open/switch and on the PR list's manual refresh button.
+
+## Architecture
+
+### New state in `usePrPanel.ts`
+
+```ts
+const dockPrCount = ref<number | null>(null);
+
+async function refreshDockPrCount() {
+  if (!cwd.value) return;
+  try {
+    dockPrCount.value = await forge.value.getPRCount(cwd.value, "open");
+  } catch {
+    // ghPrCount already swallows failures to 0 at the wrapper level; this
+    // catch is just defense-in-depth against a forge implementation that
+    // doesn't.
+    dockPrCount.value = 0;
+  }
+}
+```
+
+Exposed in the composable's returned object alongside the existing `prs`/`hasMore`/etc.
+
+### Trigger — repo open/switch
+
+Called from the existing `watch(cwd, (newCwd) => { ... })` handler (the same one that resets `_prsEnsured`/`_lastFreshnessCheck`/`prs.value` today), unconditionally — NOT gated by `panelMounted` the way `init()` is. This is intentional: `panelMounted` gating exists to avoid the *heavy*, per-PR-enriched list fetch (`gh_list_prs`) firing on every repo open (the v2.8.5 boot-perf fix); `getPRCount` is a single, cheap, unenriched call with a fundamentally different cost profile, so it doesn't need the same gate.
+
+```ts
+watch(cwd, (newCwd) => {
+  selectedPr.value = null;
+  prs.value = [];
+  remote.value = null;
+  _prsEnsured = false;
+  _lastFreshnessCheck = 0;
+  dockPrCount.value = null;
+  resetDetail();
+  if (newCwd) void refreshDockPrCount();
+  if (newCwd && panelMounted.value) init();
+});
+```
+
+### Wiring into `AppDock`
+
+`App.vue`'s existing `<AppDock v-if="hasRepo" :view-mode="viewMode" :changes-count="repoFiles.length" ...>` gains one more prop:
+
+```vue
+<AppDock ... :pr-count="prPanel.dockPrCount.value ?? undefined" />
+```
+
+(`?? undefined` because `AppDock`'s prop type is `number | undefined`, and `null` is our "not yet loaded" sentinel — this mirrors how `changesCount`/other counts are already passed.)
+
+### PR list view refresh button
+
+`PrListSidebar.vue:148`, currently `@click="panel.loadPrs"`, becomes a small inline handler that fires both:
+
+```ts
+function refreshList() {
+  panel.loadPrs();
+  panel.refreshDockPrCount();
+}
+```
+
+```vue
+<button ... @click="refreshList" ...>
+```
+
+## Edge cases
+
+- **No remote/forge configured:** `forge.value` still resolves to a default provider (as it does today for `loadPrs`); `getPRCount` on that provider is expected to fail gracefully to `0` exactly as `ghPrCount` already documents ("never throw... dashboard renders 0").
+- **Repo switch while a count fetch is in flight:** no explicit cancellation token needed — the next `watch(cwd, ...)` firing already resets `dockPrCount.value = null` before the new fetch starts, and a late-resolving stale fetch would overwrite it with a stale number. This is the same class of harmless race the existing `loadRemote()` already has (no token there either) — consistent with existing precedent, not a new gap introduced here. If this proves visible in practice, a future pass can add a cheap repo-snapshot guard (same `repo` capture pattern used elsewhere in this file), but it's not needed for this iteration.
+- **Offline:** `getPRCount` implementations don't currently route through `requireOnline()` the way `loadPrs`/`loadMorePrs` do; a failed network call is expected to resolve to `0` via the same graceful-failure path, not hang or throw.
+
+## Testing
+
+- `usePrPanel.test.ts` (extend the existing file from the prefetch-cache work): mock `forge.getPRCount`, assert `refreshDockPrCount()` populates `dockPrCount`, assert the `cwd` watcher calls it on repo switch, assert a `getPRCount` rejection resolves `dockPrCount` to `0` rather than throwing.
+- Manual check via `pnpm dev:web`: open a repo with open PRs, confirm the dock's "prs" item shows a numeric badge without ever opening the branch popover or the PR view; click the PR view's refresh button and confirm the dock badge updates alongside the list.

From dc844327b319bcafe5ea444f85f1c5726e9c1050 Mon Sep 17 00:00:00 2001
From: Laurent Guitton <laurent.guitton@dendreo.com>
Date: Fri, 10 Jul 2026 10:32:51 +0200
Subject: [PATCH 12/18] docs: correct spec - AppDock pr-count is already wired,
 just to the wrong source

---
 .../specs/2026-07-10-pr-dock-badge-count-design.md        | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/docs/superpowers/specs/2026-07-10-pr-dock-badge-count-design.md b/docs/superpowers/specs/2026-07-10-pr-dock-badge-count-design.md
index da6940e2..720145bb 100644
--- a/docs/superpowers/specs/2026-07-10-pr-dock-badge-count-design.md
+++ b/docs/superpowers/specs/2026-07-10-pr-dock-badge-count-design.md
@@ -2,7 +2,7 @@
 
 ## Problem
 
-`AppDock.vue` already has a `prCount?: number` prop (line 24) used to badge the "prs" dock item (line 83: `if (id === "prs") return props.prCount || undefined;`), but nothing in `App.vue` ever passes it — the prop is dead. Similarly, every `ForgeProvider` implements `getPRCount(cwd, state)` (backed by `ghPrCount` → Rust `gh_pr_count` → a single cheap REST `/search/issues?...&per_page=1` call or GraphQL `totalCount` query, per forge), but nothing calls it anywhere in the app today.
+`AppDock.vue` already has a `prCount?: number` prop (line 24) used to badge the "prs" dock item (line 83: `if (id === "prs") return props.prCount || undefined;`), and `App.vue` already passes it (`App.vue:3347`, `:pr-count="prPanel.prs.value.length"`) — but bound to `prs.value.length`, i.e. however many PRs currently happen to be loaded into `usePrPanel`'s badge-path list. That list is populated lazily (only once the user opens the branch-selector popover or enters graph mode — see `2026-07-09-pr-badge-prefetch-design.md`), so the dock badge reads `0` until one of those interactions happens, and even afterward it reflects "loaded so far" (10, or up to 300 after the background drain), never the true total. Separately, every `ForgeProvider` implements `getPRCount(cwd, state)` (backed by `ghPrCount` → Rust `gh_pr_count` → a single cheap REST `/search/issues?...&per_page=1` call or GraphQL `totalCount` query, per forge), but nothing calls it anywhere in the app today.
 
 Meanwhile, the PR list view's own header count (`PrListSidebar.vue:102`, `totalCount = computed(() => panel.displayedPrs.value.length)`) only ever reflects however many PRs are *currently loaded* into `prs.value` — 10 by default, more after the background drain (see `2026-07-09-pr-badge-prefetch-design.md`), fewer if a user filter is active — never the true total open-PR count.
 
@@ -62,13 +62,13 @@ watch(cwd, (newCwd) => {
 
 ### Wiring into `AppDock`
 
-`App.vue`'s existing `<AppDock v-if="hasRepo" :view-mode="viewMode" :changes-count="repoFiles.length" ...>` gains one more prop:
+`App.vue:3347` already passes `:pr-count="prPanel.prs.value.length"` to `<AppDock>` — this changes to read from the new cheap-count ref instead of the loaded-list length:
 
 ```vue
-<AppDock ... :pr-count="prPanel.dockPrCount.value ?? undefined" />
+:pr-count="prPanel.dockPrCount.value ?? undefined"
 ```
 
-(`?? undefined` because `AppDock`'s prop type is `number | undefined`, and `null` is our "not yet loaded" sentinel — this mirrors how `changesCount`/other counts are already passed.)
+(`?? undefined` because `AppDock`'s prop type is `number | undefined`, and `null` is our "not yet loaded" sentinel.)
 
 ### PR list view refresh button
 

From a1a3e71b12696334ab2e068adcd736e4545e5bbf Mon Sep 17 00:00:00 2001
From: Laurent Guitton <laurent.guitton@dendreo.com>
Date: Fri, 10 Jul 2026 10:34:17 +0200
Subject: [PATCH 13/18] docs: add implementation plan for wiring the AppDock PR
 count badge

---
 .../plans/2026-07-10-pr-dock-badge-count.md   | 335 ++++++++++++++++++
 1 file changed, 335 insertions(+)
 create mode 100644 docs/superpowers/plans/2026-07-10-pr-dock-badge-count.md

diff --git a/docs/superpowers/plans/2026-07-10-pr-dock-badge-count.md b/docs/superpowers/plans/2026-07-10-pr-dock-badge-count.md
new file mode 100644
index 00000000..73efbcbd
--- /dev/null
+++ b/docs/superpowers/plans/2026-07-10-pr-dock-badge-count.md
@@ -0,0 +1,335 @@
+# PR Dock Badge Count Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** The app dock's "prs" badge shows the true total open-PR count for the active repo (via a single cheap `getPRCount()` call at repo-open), instead of however many PRs happen to be loaded into the branch-badge list — which today reads `0` until the user has opened the branch-selector popover or graph mode.
+
+**Architecture:** A new `dockPrCount` ref + `refreshDockPrCount()` function in `usePrPanel.ts`, populated via the already-existing, forge-abstracted `getPRCount()` (works across GitHub/GitLab/Bitbucket/Azure), triggered on repo open/switch and on the PR list view's manual refresh button. `App.vue`'s existing `:pr-count` binding is redirected from `prPanel.prs.value.length` to this new ref.
+
+**Tech Stack:** Vue 3 Composition API, Vitest/jsdom.
+
+## Global Constraints
+
+- No new Rust or IPC surface — `getPRCount()`/`ghPrCount()`/`gh_pr_count` already exist end-to-end across all 4 forge providers; this plan only adds frontend wiring.
+- No new `setInterval`/polling — the count refreshes only on repo-open/switch and on the PR list's manual refresh button (`apps/desktop/CLAUDE.md` perf invariants: no unconditional polling).
+- No changes to `PrListSidebar.vue`'s list rendering, pagination, or its own `totalCount` header pill — those stay exactly as they are today.
+- The dock count always reflects `state: "open"` — it does not follow the PR list view's active filter.
+- Composables vs components separation: the new IPC-calling logic (`refreshDockPrCount`) lives in `usePrPanel.ts` (a composable), not in `App.vue` or `PrListSidebar.vue` (components) — per `apps/desktop/src/CLAUDE.md`'s architecture rule.
+
+---
+
+## File Structure
+
+| File | Responsibility |
+|---|---|
+| `apps/desktop/src/composables/usePrPanel.ts` (modify) | New `dockPrCount` ref + `refreshDockPrCount()` function; wired into the existing `watch(cwd, ...)` handler; exposed in the returned object. |
+| `apps/desktop/src/composables/__tests__/usePrPanel.test.ts` (modify) | New tests for `refreshDockPrCount()`'s success/failure behavior and its trigger on repo switch. |
+| `apps/desktop/src/App.vue` (modify) | Redirect the existing `:pr-count` binding from `prPanel.prs.value.length` to `prPanel.dockPrCount.value ?? undefined`. |
+| `apps/desktop/src/components/PrListSidebar.vue` (modify) | New `refreshList()` handler that calls both `panel.loadPrs()` and `panel.refreshDockPrCount()`; the refresh button's `@click` is redirected to it. |
+
+Task order: Task 1 (composable logic, independently testable) lands first; Task 2 (UI wiring, no automated test surface) depends on Task 1's `dockPrCount`/`refreshDockPrCount` existing.
+
+---
+
+### Task 1: `dockPrCount` state + `refreshDockPrCount()` in `usePrPanel.ts`
+
+**Files:**
+- Modify: `apps/desktop/src/composables/usePrPanel.ts:88` (add `dockPrCount` ref near `prs`), `:447` (add `refreshDockPrCount` near `loadPrs`), `:786-795` (wire into the `watch(cwd, ...)` handler), `:1197-1227` (add to the returned object)
+- Test: `apps/desktop/src/composables/__tests__/usePrPanel.test.ts` (extend the existing file from the PR-badge-prefetch plan)
+
+**Interfaces:**
+- Consumes: `forge` (existing computed, `usePrPanel.ts:81`, resolves to the active `ForgeProvider`), `cwd` (existing `Ref<string>` param).
+- Produces: `dockPrCount: Ref<number | null>` and `refreshDockPrCount(): Promise<void>` on the composable's returned object — consumed by Task 2's `App.vue`/`PrListSidebar.vue` changes.
+
+- [ ] **Step 1: Write the failing tests**
+
+The test file already has this mock setup from the PR-badge-prefetch plan (`docs/superpowers/plans/2026-07-09-pr-badge-prefetch.md`, Tasks 2/7):
+
+```ts
+const listPRs = vi.fn();
+const createPR = vi.fn();
+const mergePR = vi.fn();
+vi.mock("../forge/useForge", () => ({
+  forgeFromRemoteInfo: vi.fn(() => ({ name: "github", listPRs, createPR, mergePR })),
+  githubProvider: { name: "github", listPRs, createPR, mergePR },
+}));
+```
+
+Add a `getPRCount` mock alongside the existing ones — change this block to:
+
+```ts
+const listPRs = vi.fn();
+const createPR = vi.fn();
+const mergePR = vi.fn();
+const getPRCount = vi.fn();
+vi.mock("../forge/useForge", () => ({
+  forgeFromRemoteInfo: vi.fn(() => ({ name: "github", listPRs, createPR, mergePR, getPRCount })),
+  githubProvider: { name: "github", listPRs, createPR, mergePR, getPRCount },
+}));
+```
+
+In the existing `beforeEach` inside `describe("usePrPanel — background prefetch drain", ...)`, add a reset for the new mock — change:
+
+```ts
+  beforeEach(() => {
+    localStorage.clear();
+    _resetPrCacheForTesting();
+    listPRs.mockReset();
+    createPR.mockReset();
+    mergePR.mockReset();
+    ghPrFreshnessSignal.mockReset();
+    vi.useFakeTimers();
+  });
+```
+
+to:
+
+```ts
+  beforeEach(() => {
+    localStorage.clear();
+    _resetPrCacheForTesting();
+    listPRs.mockReset();
+    createPR.mockReset();
+    mergePR.mockReset();
+    getPRCount.mockReset();
+    ghPrFreshnessSignal.mockReset();
+    vi.useFakeTimers();
+  });
+```
+
+Then append these two new tests at the end of the `describe("usePrPanel — background prefetch drain", ...)` block, right before its closing `});`:
+
+```ts
+
+  it("refreshDockPrCount() populates dockPrCount from the forge's getPRCount", async () => {
+    getPRCount.mockResolvedValue(7);
+    const panel = usePrPanel(ref("/repo"));
+    expect(panel.dockPrCount.value).toBeNull();
+    await panel.refreshDockPrCount();
+    expect(panel.dockPrCount.value).toBe(7);
+    expect(getPRCount).toHaveBeenCalledWith("/repo", "open");
+  });
+
+  it("refreshDockPrCount() resolves to 0 instead of throwing when getPRCount rejects", async () => {
+    getPRCount.mockRejectedValue(new Error("network down"));
+    const panel = usePrPanel(ref("/repo"));
+    await panel.refreshDockPrCount();
+    expect(panel.dockPrCount.value).toBe(0);
+  });
+
+  it("switching repos resets dockPrCount and triggers a fresh refresh for the new repo", async () => {
+    getPRCount.mockResolvedValue(3);
+    const cwd = ref("/repo-a");
+    const panel = usePrPanel(cwd);
+    await panel.refreshDockPrCount();
+    expect(panel.dockPrCount.value).toBe(3);
+
+    getPRCount.mockResolvedValue(9);
+    cwd.value = "/repo-b";
+    await nextTick(); // flush the cwd watcher
+    await nextTick(); // flush the watcher's own fire-and-forget refreshDockPrCount() call
+
+    expect(getPRCount).toHaveBeenCalledWith("/repo-b", "open");
+    expect(panel.dockPrCount.value).toBe(9);
+  });
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+Run: `cd apps/desktop && pnpm test -- src/composables/__tests__/usePrPanel.test.ts`
+Expected: FAIL — `panel.dockPrCount` and `panel.refreshDockPrCount` are `undefined` (property doesn't exist on the returned object yet).
+
+- [ ] **Step 3: Add `dockPrCount` and `refreshDockPrCount`**
+
+In `apps/desktop/src/composables/usePrPanel.ts`, right after line 88 (`const prs = ref<PullRequest[]>([]);`), add:
+
+```ts
+  // ─── Dock badge count (cheap, independent of the badge-path list) ──────
+  // Reflects the true total open-PR count via a single cheap forge call,
+  // not `prs.value.length` (which only reflects however much of the
+  // branch-badge list has been loaded — see usePrCache's SWR list and
+  // the background prefetch in this same file). `null` = not yet fetched.
+  const dockPrCount = ref<number | null>(null);
+```
+
+Then, right after the `loadPrs` function's closing brace (the function currently ends at line ~468, right before the `loadMorePrs` doc comment), add:
+
+```ts
+
+  /**
+   * Refresh the dock's PR badge count via a single cheap forge call
+   * (`getPRCount`, backed by a `/search/issues?...&per_page=1`-style REST
+   * call or GraphQL `totalCount` query per forge — no per-PR enrichment).
+   * Independent of `loadPrs`/`ensurePrsLoaded`: this can run even if the
+   * user has never opened the branch popover, graph mode, or the PR view.
+   */
+  async function refreshDockPrCount() {
+    if (!cwd.value) return;
+    try {
+      dockPrCount.value = await forge.value.getPRCount(cwd.value, "open");
+    } catch {
+      // Defense-in-depth: ghPrCount's own implementations already swallow
+      // failures to 0, but don't assume every forge does.
+      dockPrCount.value = 0;
+    }
+  }
+```
+
+- [ ] **Step 4: Wire into the `cwd` watcher**
+
+In `apps/desktop/src/composables/usePrPanel.ts`, change the `watch(cwd, ...)` handler (currently lines 786-795) from:
+
+```ts
+  watch(cwd, (newCwd) => {
+    selectedPr.value = null;
+    prs.value = [];
+    remote.value = null;
+    _prsEnsured = false;
+    _lastFreshnessCheck = 0;
+    ++_prPrefetchToken; // invalidate any in-flight background prefetch for the old repo
+    resetDetail();
+    if (newCwd && panelMounted.value) init();
+  });
+```
+
+to:
+
+```ts
+  watch(cwd, (newCwd) => {
+    selectedPr.value = null;
+    prs.value = [];
+    remote.value = null;
+    _prsEnsured = false;
+    _lastFreshnessCheck = 0;
+    ++_prPrefetchToken; // invalidate any in-flight background prefetch for the old repo
+    dockPrCount.value = null;
+    resetDetail();
+    if (newCwd) void refreshDockPrCount();
+    if (newCwd && panelMounted.value) init();
+  });
+```
+
+(`refreshDockPrCount()` is called unconditionally on any real repo — NOT gated by `panelMounted.value` the way `init()` is. `panelMounted` gating exists specifically to avoid the heavy, per-PR-enriched `gh_list_prs` firing on every repo open; `getPRCount` is a single, unenriched call with a fundamentally different, much cheaper cost profile, so it doesn't need that gate.)
+
+- [ ] **Step 5: Expose in the returned object**
+
+In `apps/desktop/src/composables/usePrPanel.ts`, in the `return { ... }` block (currently lines 1197-1226), change:
+
+```ts
+    // Pagination (v2.8.5)
+    hasMore, loadingMore,
+```
+
+to:
+
+```ts
+    // Pagination (v2.8.5)
+    hasMore, loadingMore,
+    // Dock badge count
+    dockPrCount, refreshDockPrCount,
+```
+
+- [ ] **Step 6: Run tests to verify they pass**
+
+Run: `cd apps/desktop && pnpm test -- src/composables/__tests__/usePrPanel.test.ts`
+Expected: PASS (all tests in the file, including the 3 new ones).
+
+- [ ] **Step 7: Run the full suite and typecheck**
+
+Run: `cd apps/desktop && pnpm test`
+Expected: PASS — no regressions elsewhere.
+
+Run: `cd apps/desktop && pnpm build`
+Expected: PASS — `vue-tsc` typecheck succeeds.
+
+- [ ] **Step 8: Commit**
+
+```bash
+git add apps/desktop/src/composables/usePrPanel.ts apps/desktop/src/composables/__tests__/usePrPanel.test.ts
+git commit -m "feat: add cheap dockPrCount refresh independent of the branch-badge list"
+```
+
+---
+
+### Task 2: Wire the dock badge and the PR view's refresh button
+
+**Files:**
+- Modify: `apps/desktop/src/App.vue:3347`
+- Modify: `apps/desktop/src/components/PrListSidebar.vue:21` (add handler), `:148` (redirect the refresh button's `@click`)
+
+**Interfaces:**
+- Consumes: `dockPrCount: Ref<number | null>` and `refreshDockPrCount(): Promise<void>` from Task 1, both already present on `PrPanelState` (the type returned by `usePrPanel`, used as `inject<PrPanelState>(PR_PANEL_KEY)!` in `PrListSidebar.vue` and referenced as `prPanel` in `App.vue`).
+
+- [ ] **Step 1: Redirect the dock badge's data source**
+
+In `apps/desktop/src/App.vue`, change line 3347 from:
+
+```vue
+        :pr-count="prPanel.prs.value.length" :terminal-active="showTerminal" :files-active="showFiles"
+```
+
+to:
+
+```vue
+        :pr-count="prPanel.dockPrCount.value ?? undefined" :terminal-active="showTerminal" :files-active="showFiles"
+```
+
+- [ ] **Step 2: Add the combined refresh handler in `PrListSidebar.vue`**
+
+In `apps/desktop/src/components/PrListSidebar.vue`, right after line 21 (`const openSettings = inject(OPEN_SETTINGS_KEY, undefined);`), add:
+
+```ts
+
+/** Manual refresh: reload both the PR list and the dock's total-count badge together. */
+function refreshList() {
+  panel.loadPrs();
+  panel.refreshDockPrCount();
+}
+```
+
+- [ ] **Step 3: Redirect the refresh button**
+
+In `apps/desktop/src/components/PrListSidebar.vue`, change line 148 from:
+
+```vue
+          @click="panel.loadPrs"
+```
+
+to:
+
+```vue
+          @click="refreshList"
+```
+
+- [ ] **Step 4: Verify the build**
+
+Run: `cd apps/desktop && pnpm test`
+Expected: PASS — no test exercises this template wiring directly (no automated test surface for this step; see Step 5 for manual verification), so this run just confirms no regression elsewhere.
+
+Run: `cd apps/desktop && pnpm build`
+Expected: PASS — `vue-tsc` typecheck succeeds (confirms `refreshList`/`prPanel.dockPrCount` resolve correctly in both templates).
+
+- [ ] **Step 5: Manual verification**
+
+Run: `cd apps/desktop && pnpm dev:web`
+Expected: dev server starts. Open the app in a browser, open a repo that has open PRs on GitHub (or another connected forge), and confirm:
+- The dock's "prs" item shows a numeric badge WITHOUT ever opening the branch-selector popover, entering graph mode, or opening the PR list view.
+- Switching to a different repo tab updates the badge to that repo's own open-PR count.
+- Opening the PR list view and clicking its refresh button updates both the list and the dock badge.
+
+Stop the dev server after verifying (Ctrl+C) — don't leave it running.
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add apps/desktop/src/App.vue apps/desktop/src/components/PrListSidebar.vue
+git commit -m "feat: show the true open-PR count on the dock badge, independent of the loaded branch-badge list"
+```
+
+---
+
+## Post-implementation checklist
+
+- [ ] `cd apps/desktop && pnpm test` — full Vitest suite green.
+- [ ] `cd apps/desktop && pnpm build` — typecheck + Vite build green.
+- [ ] Manual check via `pnpm dev:web` per Task 2 Step 5, on a repo with open PRs on each of at least GitHub (required) — GitLab/Bitbucket/Azure if convenient, since `getPRCount` is forge-abstracted and this plan doesn't add forge-specific code.

From 58bd0febb5a0f408d857d4c0424a402b276c2b69 Mon Sep 17 00:00:00 2001
From: Laurent Guitton <laurent.guitton@dendreo.com>
Date: Fri, 10 Jul 2026 10:38:30 +0200
Subject: [PATCH 14/18] feat: add cheap dockPrCount refresh independent of the
 branch-badge list

---
 .../composables/__tests__/usePrPanel.test.ts  | 40 +++++++++++++++++--
 apps/desktop/src/composables/usePrPanel.ts    | 28 +++++++++++++
 2 files changed, 65 insertions(+), 3 deletions(-)

diff --git a/apps/desktop/src/composables/__tests__/usePrPanel.test.ts b/apps/desktop/src/composables/__tests__/usePrPanel.test.ts
index 189fdd68..cd0d644e 100644
--- a/apps/desktop/src/composables/__tests__/usePrPanel.test.ts
+++ b/apps/desktop/src/composables/__tests__/usePrPanel.test.ts
@@ -6,10 +6,11 @@ import { ref, nextTick } from "vue";
 // a plain top-level `const x = vi.fn()` in this file would have run, throwing
 // "Cannot access 'x' before initialization". `vi.hoisted()` guarantees the
 // initializers run first regardless of import graph shape.
-const { listPRs, createPR, mergePR, ghPrFreshnessSignal } = vi.hoisted(() => ({
+const { listPRs, createPR, mergePR, getPRCount, ghPrFreshnessSignal } = vi.hoisted(() => ({
   listPRs: vi.fn(),
   createPR: vi.fn(),
   mergePR: vi.fn(),
+  getPRCount: vi.fn(),
   ghPrFreshnessSignal: vi.fn(),
 }));
 
@@ -21,8 +22,8 @@ vi.mock("../../utils/backend", () => ({
 }));
 
 vi.mock("../forge/useForge", () => ({
-  forgeFromRemoteInfo: vi.fn(() => ({ name: "github", listPRs, createPR, mergePR })),
-  githubProvider: { name: "github", listPRs, createPR, mergePR },
+  forgeFromRemoteInfo: vi.fn(() => ({ name: "github", listPRs, createPR, mergePR, getPRCount })),
+  githubProvider: { name: "github", listPRs, createPR, mergePR, getPRCount },
 }));
 
 import { usePrPanel } from "../usePrPanel";
@@ -55,6 +56,7 @@ describe("usePrPanel — background prefetch drain", () => {
     listPRs.mockReset();
     createPR.mockReset();
     mergePR.mockReset();
+    getPRCount.mockReset();
     ghPrFreshnessSignal.mockReset();
     vi.useFakeTimers();
   });
@@ -173,4 +175,36 @@ describe("usePrPanel — background prefetch drain", () => {
     expect(listPRs.mock.calls.length).toBeGreaterThan(callsAfterCreate);
     expect(panel.prs.value).toHaveLength(16);
   });
+
+  it("refreshDockPrCount() populates dockPrCount from the forge's getPRCount", async () => {
+    getPRCount.mockResolvedValue(7);
+    const panel = usePrPanel(ref("/repo"));
+    expect(panel.dockPrCount.value).toBeNull();
+    await panel.refreshDockPrCount();
+    expect(panel.dockPrCount.value).toBe(7);
+    expect(getPRCount).toHaveBeenCalledWith("/repo", "open");
+  });
+
+  it("refreshDockPrCount() resolves to 0 instead of throwing when getPRCount rejects", async () => {
+    getPRCount.mockRejectedValue(new Error("network down"));
+    const panel = usePrPanel(ref("/repo"));
+    await panel.refreshDockPrCount();
+    expect(panel.dockPrCount.value).toBe(0);
+  });
+
+  it("switching repos resets dockPrCount and triggers a fresh refresh for the new repo", async () => {
+    getPRCount.mockResolvedValue(3);
+    const cwd = ref("/repo-a");
+    const panel = usePrPanel(cwd);
+    await panel.refreshDockPrCount();
+    expect(panel.dockPrCount.value).toBe(3);
+
+    getPRCount.mockResolvedValue(9);
+    cwd.value = "/repo-b";
+    await nextTick(); // flush the cwd watcher
+    await nextTick(); // flush the watcher's own fire-and-forget refreshDockPrCount() call
+
+    expect(getPRCount).toHaveBeenCalledWith("/repo-b", "open");
+    expect(panel.dockPrCount.value).toBe(9);
+  });
 });
diff --git a/apps/desktop/src/composables/usePrPanel.ts b/apps/desktop/src/composables/usePrPanel.ts
index a3459c84..f71c9f94 100644
--- a/apps/desktop/src/composables/usePrPanel.ts
+++ b/apps/desktop/src/composables/usePrPanel.ts
@@ -86,6 +86,12 @@ export function usePrPanel(cwd: Ref<string>, opts: PrPanelOptions = {}) {
   const forgeLabel = computed(() => FORGE_LABELS[forge.value.name] ?? "Web");
 
   const prs = ref<PullRequest[]>([]);
+  // ─── Dock badge count (cheap, independent of the badge-path list) ──────
+  // Reflects the true total open-PR count via a single cheap forge call,
+  // not `prs.value.length` (which only reflects however much of the
+  // branch-badge list has been loaded — see usePrCache's SWR list and
+  // the background prefetch in this same file). `null` = not yet fetched.
+  const dockPrCount = ref<number | null>(null);
   const loading = ref(false);
   // SWR: true while a background revalidation runs over cached data already on
   // screen. Distinct from `loading` (cold load, full-page spinner).
@@ -514,6 +520,24 @@ export function usePrPanel(cwd: Ref<string>, opts: PrPanelOptions = {}) {
     }
   }
 
+  /**
+   * Refresh the dock's PR badge count via a single cheap forge call
+   * (`getPRCount`, backed by a `/search/issues?...&per_page=1`-style REST
+   * call or GraphQL `totalCount` query per forge — no per-PR enrichment).
+   * Independent of `loadPrs`/`ensurePrsLoaded`: this can run even if the
+   * user has never opened the branch popover, graph mode, or the PR view.
+   */
+  async function refreshDockPrCount() {
+    if (!cwd.value) return;
+    try {
+      dockPrCount.value = await forge.value.getPRCount(cwd.value, "open");
+    } catch {
+      // Defense-in-depth: ghPrCount's own implementations already swallow
+      // failures to 0, but don't assume every forge does.
+      dockPrCount.value = 0;
+    }
+  }
+
   /**
    * Append the next page of PRs to the existing list.
    * Idempotent guards:
@@ -790,7 +814,9 @@ export function usePrPanel(cwd: Ref<string>, opts: PrPanelOptions = {}) {
     _prsEnsured = false;
     _lastFreshnessCheck = 0;
     ++_prPrefetchToken; // invalidate any in-flight background prefetch for the old repo
+    dockPrCount.value = null;
     resetDetail();
+    if (newCwd) void refreshDockPrCount();
     if (newCwd && panelMounted.value) init();
   });
 
@@ -1212,6 +1238,8 @@ export function usePrPanel(cwd: Ref<string>, opts: PrPanelOptions = {}) {
     hotspots, hotspotsLoading, totalRepoFiles, fileHistory, fileHistoryLoading,
     // Pagination (v2.8.5)
     hasMore, loadingMore,
+    // Dock badge count
+    dockPrCount, refreshDockPrCount,
     // Computed
     forge, forgeLabel,
     commentsForFile, commentCount, mergeReadiness, mergeBlocked, mergeBlockedReason, selectedDiff, displayedPrs,

From 6f5efba9f996ab2cb933d8a0120267ce1d2cd6d4 Mon Sep 17 00:00:00 2001
From: Laurent Guitton <laurent.guitton@dendreo.com>
Date: Fri, 10 Jul 2026 10:54:06 +0200
Subject: [PATCH 15/18] fix: discard stale getPRCount results from a repo the
 user already navigated away from

---
 .../composables/__tests__/usePrPanel.test.ts  | 22 +++++++++++++++++++
 apps/desktop/src/composables/usePrPanel.ts    | 10 +++++++--
 2 files changed, 30 insertions(+), 2 deletions(-)

diff --git a/apps/desktop/src/composables/__tests__/usePrPanel.test.ts b/apps/desktop/src/composables/__tests__/usePrPanel.test.ts
index cd0d644e..c75b4901 100644
--- a/apps/desktop/src/composables/__tests__/usePrPanel.test.ts
+++ b/apps/desktop/src/composables/__tests__/usePrPanel.test.ts
@@ -207,4 +207,26 @@ describe("usePrPanel — background prefetch drain", () => {
     expect(getPRCount).toHaveBeenCalledWith("/repo-b", "open");
     expect(panel.dockPrCount.value).toBe(9);
   });
+
+  it("discards a stale getPRCount result if the repo changed before it resolved", async () => {
+    let resolveA!: (n: number) => void;
+    const pendingA = new Promise<number>((resolve) => { resolveA = resolve; });
+    getPRCount.mockImplementationOnce(() => pendingA); // repo-a's call: stays pending
+    const cwd = ref("/repo-a");
+    const panel = usePrPanel(cwd);
+    void panel.refreshDockPrCount(); // fire, in flight, not yet resolved
+
+    getPRCount.mockResolvedValueOnce(9); // repo-b's call: resolves immediately
+    cwd.value = "/repo-b";
+    await nextTick(); // flush the cwd watcher, which resets dockPrCount and fires its own refresh for repo-b
+    await nextTick(); // let repo-b's refresh resolve and apply
+    expect(panel.dockPrCount.value).toBe(9);
+
+    resolveA(3); // repo-a's stale call finally resolves, after repo-b already applied
+    await nextTick();
+    await nextTick();
+
+    // Must NOT have been overwritten by the late, stale repo-a result.
+    expect(panel.dockPrCount.value).toBe(9);
+  });
 });
diff --git a/apps/desktop/src/composables/usePrPanel.ts b/apps/desktop/src/composables/usePrPanel.ts
index f71c9f94..508e7d4f 100644
--- a/apps/desktop/src/composables/usePrPanel.ts
+++ b/apps/desktop/src/composables/usePrPanel.ts
@@ -529,12 +529,18 @@ export function usePrPanel(cwd: Ref<string>, opts: PrPanelOptions = {}) {
    */
   async function refreshDockPrCount() {
     if (!cwd.value) return;
+    const repo = cwd.value;
     try {
-      dockPrCount.value = await forge.value.getPRCount(cwd.value, "open");
+      const count = await forge.value.getPRCount(repo, "open");
+      // Discard a stale result if the repo changed while this call was in
+      // flight — otherwise a slow response for a repo the user already
+      // navigated away from can silently overwrite a newer, correct count
+      // with nothing to correct it afterward (no polling on this value).
+      if (cwd.value === repo) dockPrCount.value = count;
     } catch {
       // Defense-in-depth: ghPrCount's own implementations already swallow
       // failures to 0, but don't assume every forge does.
-      dockPrCount.value = 0;
+      if (cwd.value === repo) dockPrCount.value = 0;
     }
   }
 

From 57ab78e909fdb4bdc9289a32412f0bcdcf386b80 Mon Sep 17 00:00:00 2001
From: Laurent Guitton <laurent.guitton@dendreo.com>
Date: Fri, 10 Jul 2026 11:04:12 +0200
Subject: [PATCH 16/18] feat: show the true open-PR count on the dock badge,
 independent of the loaded branch-badge list

---
 apps/desktop/src/App.vue                      | 2 +-
 apps/desktop/src/components/PrListSidebar.vue | 8 +++++++-
 2 files changed, 8 insertions(+), 2 deletions(-)

diff --git a/apps/desktop/src/App.vue b/apps/desktop/src/App.vue
index 9c6e91ed..b378a7d8 100644
--- a/apps/desktop/src/App.vue
+++ b/apps/desktop/src/App.vue
@@ -3344,7 +3344,7 @@ onUnmounted(() => {
 
       <!-- Floating bottom-center navigation dock -->
       <AppDock v-if="hasRepo" :view-mode="viewMode" :changes-count="repoFiles.length"
-        :pr-count="prPanel.prs.value.length" :terminal-active="showTerminal" :files-active="showFiles"
+        :pr-count="prPanel.dockPrCount.value ?? undefined" :terminal-active="showTerminal" :files-active="showFiles"
         @change-view="onViewModeChange" @toggle-terminal="toggleTerminal()" @toggle-files="toggleFiles()" />
     </div>
 
diff --git a/apps/desktop/src/components/PrListSidebar.vue b/apps/desktop/src/components/PrListSidebar.vue
index bb89c8b8..63c973ab 100644
--- a/apps/desktop/src/components/PrListSidebar.vue
+++ b/apps/desktop/src/components/PrListSidebar.vue
@@ -20,6 +20,12 @@ const { t } = useI18n();
 const panel = inject<PrPanelState>(PR_PANEL_KEY)!;
 const openSettings = inject(OPEN_SETTINGS_KEY, undefined);
 
+/** Manual refresh: reload both the PR list and the dock's total-count badge together. */
+function refreshList() {
+  panel.loadPrs();
+  panel.refreshDockPrCount();
+}
+
 // ─── Lazy pagination sentinel (v2.8.5 §E) ─────────────────
 // IntersectionObserver watches a 1px element at the bottom of the list;
 // when it enters the viewport, we ask the panel for the next page.
@@ -145,7 +151,7 @@ function setUserFilter(mode: 'all' | 'assigned' | 'reviews') {
         <button
           v-else
           class="pls-icon-btn"
-          @click="panel.loadPrs"
+          @click="refreshList"
           :title="t('pr.list.refresh')"
           aria-label="Refresh"
         >

From 4e8a622860c5c3a871820eba841b8170ae7d4e8b Mon Sep 17 00:00:00 2001
From: Laurent Guitton <laurent.guitton@dendreo.com>
Date: Fri, 10 Jul 2026 11:18:19 +0200
Subject: [PATCH 17/18] fix: seed remote from cache on repo switch so
 dockPrCount resolves the correct forge, not always GitHub

---
 .../composables/__tests__/usePrPanel.test.ts  | 25 ++++++++++++++++++-
 apps/desktop/src/composables/usePrPanel.ts    |  2 +-
 2 files changed, 25 insertions(+), 2 deletions(-)

diff --git a/apps/desktop/src/composables/__tests__/usePrPanel.test.ts b/apps/desktop/src/composables/__tests__/usePrPanel.test.ts
index c75b4901..e22eacef 100644
--- a/apps/desktop/src/composables/__tests__/usePrPanel.test.ts
+++ b/apps/desktop/src/composables/__tests__/usePrPanel.test.ts
@@ -27,7 +27,8 @@ vi.mock("../forge/useForge", () => ({
 }));
 
 import { usePrPanel } from "../usePrPanel";
-import { _resetPrCacheForTesting } from "../usePrCache";
+import { _resetPrCacheForTesting, usePrCache } from "../usePrCache";
+import { forgeFromRemoteInfo } from "../forge/useForge";
 
 function makePr(n: number) {
   return {
@@ -229,4 +230,26 @@ describe("usePrPanel — background prefetch drain", () => {
     // Must NOT have been overwritten by the late, stale repo-a result.
     expect(panel.dockPrCount.value).toBe(9);
   });
+
+  it("resolves the correct forge (not always GitHub) on repo-open when the repo was previously cached", async () => {
+    const gitlabGetPRCount = vi.fn().mockResolvedValue(4);
+    (forgeFromRemoteInfo as ReturnType<typeof vi.fn>).mockReturnValueOnce({
+      name: "gitlab", listPRs, createPR, mergePR, getPRCount: gitlabGetPRCount,
+    });
+    usePrCache().setRemote("/repo-b", {
+      name: "origin", url: "https://gitlab.com/x/y.git", provider: "gitlab", owner: "x", repo: "y",
+    });
+
+    const cwd = ref("/repo-a");
+    const panel = usePrPanel(cwd);
+    cwd.value = "/repo-b";
+    await nextTick(); // flush the cwd watcher
+    await nextTick(); // flush the watcher's fire-and-forget refreshDockPrCount() call
+
+    // The cached remote must resolve the gitlab provider, not fall through
+    // to the default githubProvider, before refreshDockPrCount() reads `forge`.
+    expect(gitlabGetPRCount).toHaveBeenCalledWith("/repo-b", "open");
+    expect(getPRCount).not.toHaveBeenCalled();
+    expect(panel.dockPrCount.value).toBe(4);
+  });
 });
diff --git a/apps/desktop/src/composables/usePrPanel.ts b/apps/desktop/src/composables/usePrPanel.ts
index 508e7d4f..952ae44d 100644
--- a/apps/desktop/src/composables/usePrPanel.ts
+++ b/apps/desktop/src/composables/usePrPanel.ts
@@ -816,7 +816,7 @@ export function usePrPanel(cwd: Ref<string>, opts: PrPanelOptions = {}) {
   watch(cwd, (newCwd) => {
     selectedPr.value = null;
     prs.value = [];
-    remote.value = null;
+    remote.value = cache.getRemote(newCwd)?.remote ?? null;
     _prsEnsured = false;
     _lastFreshnessCheck = 0;
     ++_prPrefetchToken; // invalidate any in-flight background prefetch for the old repo

From 2673f3f49b7dd74aa075d784e8d80717b5322b24 Mon Sep 17 00:00:00 2001
From: Laurent Guitton <laurent.guitton@dendreo.com>
Date: Fri, 10 Jul 2026 16:04:15 +0200
Subject: [PATCH 18/18] docs(roadmap): note 3 deferred follow-ups from the PR
 badge/dock-count work
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Multi-forge freshness parity, cursor-based PR-list pagination (already
flagged in-code as Phase 2/v2.9), and a dock badge staleness indicator —
all deliberately deferred, none blocking PR #125.
---
 ROADMAP.md | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/ROADMAP.md b/ROADMAP.md
index abf9ff34..f5c5d680 100644
--- a/ROADMAP.md
+++ b/ROADMAP.md
@@ -186,6 +186,9 @@ _Veille du 2026-06-24 sur 6 clients/outils (Snipara, GitDriv, GitUp, GitX-dev, A
 
 - **In-app folder-browser + right-click "Scope here"** — follow-up to v2.21.0 Monorepo Scope: a recursive working-tree folder panel where right-clicking a folder scopes to it. Ad-hoc scoping already ships via the picker's "Custom folder…"; this in-tree gesture is deferred (the existing `FolderDiffTree` is a *diff* tree — the wrong substrate — and is unmounted).
 - **Today Phase 3 — active mutations** — deferred remainder of the Today inbox (shipped v3.0.0): real nudge / auto-merge actions from the inbox, and a direct jump from "Resolve" into the conflict resolver (today routes to in-app PR review). Note: Phase 2's filter-chips + group-by model was superseded by the fixed-section inbox (see `useLaunchpadInbox.ts`).
+- **Multi-forge PR-freshness signal parity** — follow-up to the branch-badge background-prefetch/cache work (PR #125): GitLab/Bitbucket/Azure already get the breadth fix (background drain past the first page), but not the cheap freshness-signal instant-cache-restore fast path — GitHub-only today, since the other three don't yet have an equivalent cheap "most-recently-updated PR" query built. Deferred until there's real non-GitHub usage pressure.
+- **Cursor-based PR-list pagination (Rust)** — already flagged in-code as Phase 2/v2.9 (`gh_list_prs_inner`/`rest_list_prs` comments, predates PR #125): replace the naive offset+limit re-fetch, which re-walks from the start on every page, with a cursor-based `gh api graphql` query. Removes the quadratic re-fetch cost for repos with very large open-PR counts; most repos stay well under the current 300-PR prefetch ceiling, so this is scalability hardening, not an urgent fix.
+- **Dock PR-count staleness indicator** — the app-dock "prs" badge (PR #125) refreshes only on repo-open and on the PR view's manual refresh, no periodic poll — a long-lived session can show a stale count if PRs open/close externally in the meantime. A lightweight visual "possibly stale" cue is preferred over polling, which would reopen the exact boot-perf risk (v2.8.5) this design was built to avoid.
 
 ---