@promptctl/cc-candybar 1.5.0 → 1.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@promptctl/cc-candybar",
-  "version": "1.5.0",
+  "version": "1.7.0",
   "description": "Statusline renderer for Claude Code — a JSON5-configurable DSL with daemon-cached data sources, byte-clean palette-aware composition, and OSC8 click verbs.",
   "type": "module",
   "main": "./dist/index.mjs",
@@ -91,10 +91,10 @@
     "mobx": "^6.15.0"
   },
   "optionalDependencies": {
-    "@promptctl/cc-candybar-darwin-arm64": "1.5.0",
-    "@promptctl/cc-candybar-darwin-x64": "1.5.0",
-    "@promptctl/cc-candybar-linux-x64": "1.5.0",
-    "@promptctl/cc-candybar-linux-arm64": "1.5.0"
+    "@promptctl/cc-candybar-darwin-arm64": "1.7.0",
+    "@promptctl/cc-candybar-darwin-x64": "1.7.0",
+    "@promptctl/cc-candybar-linux-x64": "1.7.0",
+    "@promptctl/cc-candybar-linux-arm64": "1.7.0"
   },
   "pnpm": {
     "supportedArchitectures": {

package/src/config/default-dsl-config.ts

@@ -280,6 +280,21 @@ export const DEFAULT_DSL_CONFIG = {
       default: 0,
     },
 
+    // Forge PR/MR — the daemon's git provider resolves the branch's open PR via
+    // gh/glab and projects it here. Declaring any of these turns on the network
+    // lookup. [LAW:no-silent-failure] prError is non-empty ONLY when the forge
+    // was asked but couldn't answer (auth/network) — distinct from "no PR"
+    // (every field empty). prNumber 0 (default) ⇒ no open PR.
+    "git.prNumber": {
+      kind: "input",
+      path: "git.prNumber",
+      type: "number",
+      default: 0,
+    },
+    "git.prState": { kind: "input", path: "git.prState", default: "" },
+    "git.prUrl": { kind: "input", path: "git.prUrl", default: "" },
+    "git.prError": { kind: "input", path: "git.prError", default: "" },
+
     // Prompt-cache expiry — epoch seconds, projected by the cache provider.
     // Same unit/shape as block/weekly resetsAt so the cacheTimer segment
     // composes `minutesUntilReset` identically. 0 (default) ⇒ no cache
@@ -410,6 +425,17 @@ export const DEFAULT_DSL_CONFIG = {
       type: "number",
       default: -1,
     },
+    // Recent burn-rate trend: a comma-delimited series of total-lane tok/s the
+    // daemon folds from its sample ring (render-payload.ts). A series cannot
+    // cross the scalar var-system seam, so it travels as a string the
+    // `sparkline` helper decodes. Default "" is the genuine "no history yet"
+    // form (the helper renders nothing); the segment gates on it being present.
+    "speed.history": {
+      kind: "input",
+      path: "speed.history",
+      type: "string",
+      default: "",
+    },
 
     // Context — daemon fetches via ContextProvider; contextLeftPercentage.
     "context.totalTokens": {
@@ -542,6 +568,24 @@ export const DEFAULT_DSL_CONFIG = {
       fg: "foreground",
       when: '{{ ne .git.branch "" }}',
     },
+    // Git PR/MR — the branch's open pull/merge request as a clickable link.
+    // OPT-IN: declared but NOT in the default root (it adds a network gh/glab
+    // call). Add "gitPr" to a container's children to enable it. The `{{ link
+    // url text }}` emits ONE OSC-8 region carrying the https PR url, so the
+    // CLICK is handled by the terminal/OS (opens the browser) — no daemon verb.
+    // [LAW:no-silent-failure] Three render states from the data: an open PR
+    // (prUrl set) renders the link; a lookup FAILURE (prError set, prUrl empty)
+    // renders a distinct ⚠ marker so an outage is not mistaken for "no PR";
+    // no PR (both empty) leaves the `when` gate false and the segment absent.
+    gitPr: {
+      template:
+        '{{ if ne .git.prUrl "" }}' +
+        '{{ link .git.prUrl (printf " ⇆ #%v " .git.prNumber) }}' +
+        "{{ else }} ⚠ PR {{ end }}",
+      bg: "surface-active",
+      fg: "foreground",
+      when: '{{ or (ne .git.prUrl "") (ne .git.prError "") }}',
+    },
     // Quick-action tray — copy the session id / cwd, open the project dir /
     // transcript in the editor. [LAW:locality-or-seam] The glyph is the
     // REPRESENTATION; the named action (below) is the BEHAVIOR; the action
@@ -623,6 +667,21 @@ export const DEFAULT_DSL_CONFIG = {
       fg: "foreground",
       when: "{{ gt .session.tokens 0 }}",
     },
+    // Burn-rate sparkline: the recent total-lane tok/s trend as a unicode
+    // mini-graph. Declared-but-opt-in (NOT in the default root, like speed /
+    // block / weekly): a user adds `tokenSparkline` to their layout. The
+    // `sparkline` helper decodes the daemon-owned series and draws it; `24`
+    // caps the glyph count to the cell, showing the live tail of the ring. The
+    // segment's fg colors the whole graph (no per-glyph color). Gated on the
+    // history being present so the cell never renders empty (the series needs
+    // two samples before its first bar). [LAW:effects-at-boundaries] — all the
+    // history lives in the daemon ring, the template only draws.
+    tokenSparkline: {
+      template: " ⚡ {{ sparkline .speed.history 24 }} ",
+      bg: "panel",
+      fg: "foreground",
+      when: '{{ ne .speed.history "" }}',
+    },
     // Prompt-cache warmth countdown. minutesUntilReset clamps a past expiry
     // to 0, so an expired cache renders "cold" (and reads red via the ≤8
     // arm) rather than a negative number. [LAW:dataflow-not-control-flow]

package/src/daemon/cache/git.ts

@@ -1,7 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
-import { GitService, type GitInfo } from "../../segments/git";
-import { ok, type Outcome } from "../../utils/outcome";
+import { GitService, type GitInfo, type PullRequest } from "../../segments/git";
+import { ABSENT, ok, type Outcome } from "../../utils/outcome";
 import { debug } from "../../utils/logger";
 import { WatcherRegistry, type WatcherHandle } from "./watchers";
 
@@ -44,6 +44,17 @@ const DEFAULT_TTL_MS = 30_000;
 const DEFAULT_MAX_ENTRIES = 64;
 const SANITY_INTERVAL_MS = 5 * 60_000;
 
+// [LAW:decomposition] The forge PR lookup is a network resource with a
+// different lifecycle than local git state: it changes ~twice in a PR's life
+// and the fs watchers on .git/HEAD|index say nothing about remote PR state. So
+// it gets its OWN cache + TTL — independent of the 30s GitInfo TTL — so the
+// per-render git fetch stays all-local and the gh/glab spawn happens at most
+// once per window (or on branch switch, via the branch in the key). A `failed`
+// lookup caches for a SHORTER window so a transient forge outage is retried
+// soon, not pinned to the bar for the full ok-TTL.
+const PR_TTL_OK_MS = 5 * 60_000;
+const PR_TTL_FAIL_MS = 45_000;
+
 // Options applied to subscribe()'s internal getInfo() call. var-system's six
 // GitField values (branch, sha, dirty, ahead, behind, stash) all project from
 // these flags — keep them in lockstep with the projection in
@@ -60,6 +71,11 @@ interface MtimeSnapshot {
   index: number;
 }
 
+interface PrCacheEntry {
+  pr: Outcome<PullRequest>;
+  computedAt: number;
+}
+
 interface GitCacheEntry {
   info: GitInfo;
   computedAt: number;
@@ -147,6 +163,16 @@ export class GitDataProvider extends GitService {
   // here; subsequent concurrent callers await the same promise and resolve in
   // lockstep.
   private readonly fetchInFlight = new Map<string, Promise<Outcome<GitInfo>>>();
+  // [LAW:one-source-of-truth] The forge PR cache, keyed by `repoRoot|branch`
+  // (a branch switch is a new key, so its PR is fetched fresh; the old branch's
+  // entry ages out). Separate from `entries` because it carries its own TTL.
+  private readonly prCache = new Map<string, PrCacheEntry>();
+  // [LAW:single-enforcer] Coalesce concurrent PR misses on the same key — same
+  // role as fetchInFlight for the GitInfo path, but for the network forge call.
+  private readonly prFetchInFlight = new Map<
+    string,
+    Promise<Outcome<PullRequest>>
+  >();
   // [LAW:single-enforcer] Coalesce overlapping refreshes for the same repo.
   // `refreshing` holds the repoRoots whose refresh loop is currently
   // executing; `refreshAgain` is the trailing-edge flag: if a new
@@ -292,6 +318,15 @@ export class GitDataProvider extends GitService {
     if (outcome.kind !== "ok") return outcome;
     const info = outcome.value;
 
+    // [LAW:decomposition] The inner GitService never resolves the PR — the
+    // cache layer owns that lookup so it can give it an independent TTL. On the
+    // 30s GitInfo refetch the prCache is almost always warm, so attaching the
+    // PR here is a memory read; the gh/glab spawn only fires when the prCache
+    // entry has aged past its (outcome-dependent) TTL or the branch changed.
+    if (options.showPullRequest) {
+      info.pullRequest = await this.getPullRequestCached(repoRoot, info.branch);
+    }
+
     // Drop any prior entry for this exact key before re-inserting (so we
     // release its watcher refcount cleanly).
     this.dropEntry(key);
@@ -315,6 +350,63 @@ export class GitDataProvider extends GitService {
     return outcome;
   }
 
+  // [LAW:single-enforcer] The one read path for a branch's PR. Reads the remote
+  // (cheap local git) so the cache key reflects every input the PR value
+  // depends on — `repoRoot|branch|remote` — and a re-pointed origin is a fresh
+  // key, not a stale hit ([LAW:one-source-of-truth]). TTL is outcome-dependent
+  // (a `failed` retries sooner). Concurrent misses coalesce through
+  // prFetchInFlight. The forge dispatch delegates to inner.resolvePullRequest —
+  // this layer is cache + lifecycle only, never forge knowledge.
+  private async getPullRequestCached(
+    repoRoot: string,
+    branch: string,
+  ): Promise<Outcome<PullRequest>> {
+    // [LAW:no-silent-failure] A `failed` remote read (git couldn't run) must
+    // surface; only `absent` (no remote configured) means "no forge PR".
+    const remote = await this.inner.getRemoteOriginUrl(repoRoot);
+    if (remote.kind === "failed") return remote;
+    if (remote.kind === "absent") return ABSENT;
+    const remoteUrl = remote.value;
+
+    const key = `${repoRoot}|${branch}|${remoteUrl}`;
+    const now = Date.now();
+
+    const existing = this.prCache.get(key);
+    if (existing) {
+      const ttl = existing.pr.kind === "failed" ? PR_TTL_FAIL_MS : PR_TTL_OK_MS;
+      if (now - existing.computedAt < ttl) {
+        // LRU touch so the active branch's PR survives eviction.
+        this.prCache.delete(key);
+        this.prCache.set(key, existing);
+        return existing.pr;
+      }
+    }
+
+    const pending = this.prFetchInFlight.get(key);
+    if (pending) return pending;
+
+    const promise = this.inner
+      .resolvePullRequest(repoRoot, remoteUrl)
+      .then((pr) => {
+        this.prCache.set(key, { pr, computedAt: Date.now() });
+        this.evictPrIfNeeded();
+        return pr;
+      })
+      .finally(() => {
+        this.prFetchInFlight.delete(key);
+      });
+    this.prFetchInFlight.set(key, promise);
+    return promise;
+  }
+
+  private evictPrIfNeeded(): void {
+    while (this.prCache.size > this.maxEntries) {
+      const oldest = this.prCache.keys().next().value;
+      if (oldest === undefined) break;
+      this.prCache.delete(oldest);
+    }
+  }
+
   // [LAW:effects-at-boundaries] The subscribe surface's edge: fold the typed
   // outcome into the GitInfo|null the var-system callback contract expects.
   // `failed` is logged HERE — the one log site for this consumption path
@@ -548,6 +640,10 @@ export class GitDataProvider extends GitService {
     this.refreshing.clear();
     this.refreshAgain.clear();
     this.fetchInFlight.clear();
+    // In-flight PR fetches resolve naturally; clearing the maps means the next
+    // caller starts fresh (the prCache is rebuilt cold like every other cache).
+    this.prCache.clear();
+    this.prFetchInFlight.clear();
     if (this.ownsWatchers) this.watchers.closeAll();
   }
 }

package/src/daemon/cache/session-usage-store.ts

@@ -61,14 +61,24 @@ export interface SpeedSample {
   readonly atMs: number;
 }
 
-// The prior observation (absent on the very first render of a session) and the
-// one just taken. The pure rate projection lives at the render-payload boundary;
-// this store only remembers and reports the pair.
+// The prior observation (absent on the very first render of a session), the one
+// just taken, and the recent ring (oldest→newest, INCLUDING `cur`). The pure
+// projections live at the render-payload boundary; this store only remembers and
+// reports. [LAW:one-source-of-truth] `prev === samples[samples.length - 2]` — the
+// tok/s baseline and the burn-rate history fold from the SAME owned ring, not two
+// parallel stores. tok/s reads the last pair; the sparkline reads every pair.
 export interface SpeedObservation {
   readonly prev?: SpeedSample;
   readonly cur: SpeedSample;
+  readonly samples: readonly SpeedSample[];
 }
 
+// How many recent samples the burn-rate ring retains per session. A render-cadence
+// trend, not an archive: enough to fill a wide sparkline cell, capped so an
+// idle-but-alive session can't grow it without bound. The window the sparkline
+// draws is a tail slice of this (the `width` arg), so this only sets the ceiling.
+const SPEED_RING_CAPACITY = 64;
+
 function speedSampleOf(
   breakdown: TokenBreakdown | null,
   atMs: number,
@@ -202,11 +212,13 @@ export class SessionUsageStore {
   // first seed completes every later read awaits an already-settled promise —
   // zero rescan. A rejected seed is dropped so the next read retries.
   private readonly seeded = new Map<string, Promise<void>>();
-  // [LAW:one-source-of-truth] The prior tok/s observation per session. tok/s is
-  // a derivative of the SAME token totals the records map already owns; the
-  // baseline (prev counts + time) lives HERE, not in a parallel counter. One
-  // call to observeSpeed advances it; the pure delta math is render-payload's.
-  private readonly speedSamples = new Map<string, SpeedSample>();
+  // [LAW:one-source-of-truth] The recent tok/s observations per session, a
+  // bounded ring (oldest→newest). tok/s is a derivative of the SAME token totals
+  // the records map already owns; the baseline (prior counts + time) is the ring's
+  // last element, not a parallel counter. The burn-rate sparkline folds over the
+  // whole ring; tok/s folds over its final pair. One call to observeSpeed appends;
+  // the pure delta math is render-payload's.
+  private readonly speedRings = new Map<string, SpeedSample[]>();
   // [LAW:no-ambient-temporal-coupling] Explicit owner of observe/commit ordering
   // for the speed sample. Concurrent renders observing the SAME transcript state
   // (key = `${sessionId}:${mtime}`) share ONE observation and commit the baseline
@@ -356,9 +368,33 @@ export class SessionUsageStore {
       const breakdown =
         record.kind === "ok" ? record.value.sessionInfo.tokenBreakdown : null;
       const cur = speedSampleOf(breakdown, nowMs);
-      const prev = this.speedSamples.get(sessionId);
-      this.speedSamples.set(sessionId, cur);
-      return ok({ ...(prev !== undefined && { prev }), cur });
+      const ring = this.speedRings.get(sessionId) ?? [];
+      // [LAW:no-ambient-temporal-coupling] Observation time (atMs, the render
+      // clock) owns ring order — NOT ingest-completion order. Two concurrent
+      // observes with different mtimes don't coalesce in speedFlight and each
+      // awaits ingest before this mutation, so a plain append would record
+      // samples in whichever-ingest-settled-first order and invert oldest→newest.
+      // prev is the latest sample strictly before this observation; the post-
+      // insert sort by atMs makes the ring's order independent of completion
+      // order. (get→insert→set is synchronous after the await, so each resumed
+      // continuation mutates atomically — no lost update.)
+      let prev: SpeedSample | undefined;
+      for (const s of ring) {
+        if (s.atMs < cur.atMs && (prev === undefined || s.atMs > prev.atMs)) {
+          prev = s;
+        }
+      }
+      ring.push(cur);
+      ring.sort((a, b) => a.atMs - b.atMs);
+      // Drop oldest (smallest atMs ⇒ ring[0]) beyond the cap — a tail window,
+      // not an archive.
+      if (ring.length > SPEED_RING_CAPACITY) ring.shift();
+      this.speedRings.set(sessionId, ring);
+      return ok({
+        ...(prev !== undefined && { prev }),
+        cur,
+        samples: [...ring],
+      });
     });
   }
 
@@ -494,7 +530,7 @@ export class SessionUsageStore {
     for (const [sid, record] of this.entries) {
       if (now - record.lastSeenAt > this.staleAgeMs) {
         this.entries.delete(sid);
-        this.speedSamples.delete(sid);
+        this.speedRings.delete(sid);
         dropped++;
       }
     }
@@ -510,7 +546,7 @@ export class SessionUsageStore {
       const oldest = this.entries.keys().next().value;
       if (oldest === undefined) break;
       this.entries.delete(oldest);
-      this.speedSamples.delete(oldest);
+      this.speedRings.delete(oldest);
       dlog("info", `usageStore evict ${oldest}`);
     }
   }
@@ -522,6 +558,6 @@ export class SessionUsageStore {
     }
     this.entries.clear();
     this.seeded.clear();
-    this.speedSamples.clear();
+    this.speedRings.clear();
   }
 }

package/src/daemon/render-payload.ts

@@ -98,6 +98,16 @@ export interface GitPayload {
   readonly status?: string;
   readonly operation?: string;
   readonly timeSinceCommit?: number;
+  // Forge PR/MR. [LAW:no-silent-failure] Unlike every other git field (where
+  // `failed` collapses to a missing key), the PR's failure is surfaced as
+  // `prError` so the segment can render a VISIBLY DISTINCT marker — a forge
+  // outage must not look like "no PR". The three render-distinguishable states:
+  // open PR (prNumber/prState/prUrl present), lookup failed (prError present),
+  // no PR (all absent → segment when-gated off).
+  readonly prNumber?: number;
+  readonly prState?: string;
+  readonly prUrl?: string;
+  readonly prError?: string;
 }
 
 export interface SessionPayload {
@@ -130,6 +140,14 @@ export interface SpeedPayload {
   readonly input?: number;
   readonly output?: number;
   readonly total?: number;
+  // [LAW:one-type-per-behavior] The recent burn-rate trend: a delimited series
+  // of total-lane tok/s over the store's sample ring, for the `sparkline` helper.
+  // It rides the speed lane because it folds from the SAME observation the three
+  // instantaneous rates do, but it is INDEPENDENTLY optional — a session that
+  // burst then went idle has no current rate yet still has a history to draw. It
+  // travels as a string because a series cannot cross the scalar var-system seam;
+  // the helper decodes it. Absent (no measurable in-window pair) → missing → "".
+  readonly history?: string;
 }
 
 export interface BlockPayload {
@@ -320,6 +338,42 @@ function projectSpeed(obs: SpeedObservation): SpeedPayload | undefined {
   };
 }
 
+// [LAW:effects-at-boundaries] Pure fold of the observation's sample ring into the
+// burn-rate history string. Each adjacent pair becomes one total-lane tok/s; an
+// un-projectable pair (no new tokens, or a gap outside the sample window) is a
+// real ZERO-throughput interval, not absence — the series is a string of numbers,
+// and 0 is the honest value for "burned nothing here" ([LAW:no-silent-failure] —
+// the gap is reported, not dropped to misalign the graph). Fewer than two samples
+// ⇒ no pair ⇒ undefined (the whole field drops to the "" default).
+function projectSpeedHistory(obs: SpeedObservation): string | undefined {
+  const { samples } = obs;
+  const rates: number[] = [];
+  for (let i = 1; i < samples.length; i++) {
+    const prev = samples[i - 1]!;
+    const cur = samples[i]!;
+    // [LAW:no-silent-failure] Only an in-window interval is a measurable reading.
+    // An out-of-window pair — samples too close to time a rate reliably, or a
+    // stale gap spanning idle time — is UNMEASURABLE, not zero burn, so it is
+    // SKIPPED rather than fabricated as a 0 bar that would read as real activity.
+    // projectTokensPerSecond stays the single formula+window authority (same
+    // module constants); this classifier disambiguates its undefined: out-of-
+    // window ⇒ skip, in-window ⇒ undefined means a non-positive token delta, a
+    // genuine zero-burn reading that stays 0.
+    const deltaMs = cur.atMs - prev.atMs;
+    if (deltaMs < MIN_SPEED_SAMPLE_MS || deltaMs > MAX_SPEED_SAMPLE_MS)
+      continue;
+    const rate = projectTokensPerSecond(
+      prev.total,
+      prev.atMs,
+      cur.total,
+      cur.atMs,
+    );
+    rates.push(rate ?? 0);
+  }
+  if (rates.length === 0) return undefined;
+  return rates.join(",");
+}
+
 // ─── Builder ─────────────────────────────────────────────────────────────────
 
 // ─── Config-driven provider gating ───────────────────────────────────────────
@@ -472,6 +526,12 @@ function gitOptionsFromClosure(needed: ReadonlySet<string>): GitInfoOptions {
     ...(has("git.repoName") && { showRepoName: true }),
     ...(has("git.operation") && { showOperation: true }),
     ...(has("git.timeSinceCommit") && { showTimeSinceCommit: true }),
+    // Any PR field laid out turns on the (network) forge lookup. Keep these in
+    // lockstep with the projected `git.pr*` fields below.
+    ...((has("git.prNumber") ||
+      has("git.prState") ||
+      has("git.prUrl") ||
+      has("git.prError")) && { showPullRequest: true }),
   };
 }
 
@@ -641,8 +701,22 @@ export async function buildRenderPayload(
   // that data here at the edge. Absent observation (lane skipped/failed) or no
   // projectable lane → no `speed` key → every lane reads its -1 default.
   const speedObs = take(speed);
-  const speedPayload =
+  // [LAW:dataflow-not-control-flow] The instantaneous rates and the burn-rate
+  // history fold independently from one observation — either can be present
+  // without the other (a fresh burst has rates but a one-sample history; an
+  // idle-after-burst session has a history but no current rate). Merge whatever
+  // each yields; the whole `speed` key drops only when both are absent.
+  const speedRates =
     speedObs !== undefined ? projectSpeed(speedObs) : undefined;
+  const speedHistory =
+    speedObs !== undefined ? projectSpeedHistory(speedObs) : undefined;
+  const speedPayload =
+    speedRates !== undefined || speedHistory !== undefined
+      ? {
+          ...speedRates,
+          ...(speedHistory !== undefined && { history: speedHistory }),
+        }
+      : undefined;
 
   // [LAW:one-source-of-truth] The theme variable surfaces the session's
   // resolved theme so the toolbar/tray DSL templates can encode it into
@@ -809,6 +883,28 @@ function projectGitInfo(outcome: Outcome<GitInfo>): {
   const upstream = field("upstream", info.upstream);
   const repoName = field("repoName", info.repoName);
 
+  // [LAW:no-silent-failure] The PR deliberately breaks the `field` pattern: a
+  // `failed` lookup is NOT dropped to a missing key (which the template can't
+  // tell apart from "no PR"). It is BOTH logged AND surfaced as `prError` so
+  // the segment renders a distinct marker. `absent` is still a missing key (no
+  // PR / no forge → segment off). The reason is the gate value the template
+  // tests; the same reason is logged for the operator.
+  const pr = info.pullRequest;
+  const prFields: {
+    prNumber?: number;
+    prState?: string;
+    prUrl?: string;
+    prError?: string;
+  } = {};
+  if (pr?.kind === "ok") {
+    prFields.prNumber = pr.value.number;
+    prFields.prState = pr.value.state;
+    prFields.prUrl = pr.value.url;
+  } else if (pr?.kind === "failed") {
+    failures.push(`git.pr: ${pr.reason}`);
+    prFields.prError = pr.reason;
+  }
+
   return {
     git: {
       branch: info.branch,
@@ -829,6 +925,7 @@ function projectGitInfo(outcome: Outcome<GitInfo>): {
       ...(stash !== undefined && { stash }),
       ...(upstream !== undefined && { upstream }),
       ...(repoName !== undefined && { repoName }),
+      ...prFields,
     },
     failures,
   };

package/src/proc/launch.ts

@@ -31,6 +31,10 @@ import type { LaunchStatsHandle } from "./stats-handle";
 // pattern. [LAW:no-mode-explosion]: no per-site escape hatch.
 export const LAUNCH_CATEGORIES = [
   "git",
+  // Forge CLIs (gh / glab) for the PR/MR lookup. A network-bound spawn,
+  // separate from "git" so daemon-stats attributes it independently and a
+  // future rate limit can target it without throttling local git.
+  "forge",
   "user-shell",
   "tmux",
   "click.pbcopy",