@promptctl/cc-candybar 1.5.0 → 1.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@promptctl/cc-candybar",
-  "version": "1.5.0",
+  "version": "1.6.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.6.0",
+    "@promptctl/cc-candybar-darwin-x64": "1.6.0",
+    "@promptctl/cc-candybar-linux-x64": "1.6.0",
+    "@promptctl/cc-candybar-linux-arm64": "1.6.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
@@ -542,6 +557,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

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/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 {
@@ -472,6 +482,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 }),
   };
 }
 
@@ -809,6 +825,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 +867,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",

package/src/segments/git.ts

@@ -16,6 +16,17 @@ export interface AheadBehind {
   behind: number;
 }
 
+// [LAW:types-are-the-program] The branch's open PR/MR as the forge reports it.
+// `number` and `url` are the click target; `state` is the forge's status string
+// (GitHub "OPEN", GitLab "opened") — carried so a consumer can color/label it,
+// though resolvePullRequest only ever returns a PR whose state is open (a
+// merged/closed PR for the branch is the domain's `absent`, not a value).
+export interface PullRequest {
+  number: number;
+  state: string;
+  url: string;
+}
+
 // [LAW:types-are-the-program] Every on-demand field is an Outcome, so "this
 // value is unknown because the fetch failed" is representable distinct from
 // a real 0/""/basename — the states the old catch-and-substitute blocks
@@ -37,6 +48,13 @@ export interface GitInfo {
   upstream?: Outcome<string>;
   repoName?: Outcome<string>;
   isWorktree?: boolean;
+  // [LAW:no-silent-failure] The forge lookup's three outcomes are all kept
+  // distinct here: `ok` is an open PR, `absent` is "this branch has none / no
+  // forge / no forge CLI", `failed` is "the forge was asked but couldn't
+  // answer" (auth, network, API error). The render boundary surfaces `failed`
+  // as a VISIBLE marker — collapsing it to `absent` would make a transient
+  // outage look like the PR vanished. Undefined = `showPullRequest` was off.
+  pullRequest?: Outcome<PullRequest>;
 }
 
 // [LAW:one-source-of-truth] The one shape of getGitInfo's `show*` toggles. Each
@@ -53,6 +71,11 @@ export interface GitInfoOptions {
   showStashCount?: boolean;
   showUpstream?: boolean;
   showRepoName?: boolean;
+  // Opts into the forge (gh/glab) PR/MR lookup — a network call, so it is the
+  // one option whose fetch the daemon caches on a longer, independent TTL than
+  // the rest of GitInfo (see src/daemon/cache/git.ts). Never resolved by the
+  // inner GitService's computeGitInfo; the cache layer owns the lookup+cache.
+  showPullRequest?: boolean;
 }
 
 // [LAW:dataflow-not-control-flow] One classifier for every git invocation.
@@ -89,6 +112,134 @@ function nonEmpty(o: Outcome<string>): Outcome<string> {
   return v ? ok(v) : ABSENT;
 }
 
+// [LAW:one-type-per-behavior] `gh` and `glab` are two instances of one act:
+// "ask a forge CLI for the branch's PR, fold the typed launch result into an
+// Outcome<PullRequest>." The accept/reject shape table is identical across
+// both — only the no-PR stderr signature and the JSON field names differ — so
+// the classification lives here once and each forge supplies its own
+// (noPrPattern, parse) as data.
+//
+// [LAW:no-silent-failure] The full shape table, enumerated so no input leaks:
+//   ok + parse ok (open PR)         → ok            (the value)
+//   ok + parse ok (not open)        → absent        (branch's PR is done)
+//   ok + parse fails                → failed        (forge answered garbage)
+//   non-zero + no-PR stderr         → absent        (genuine "none for branch")
+//   spawn-error ENOENT (no CLI)     → absent        (no forge integration)
+//   spawn-error other (EACCES, …)   → failed        (CLI present but unlaunchable)
+//   non-zero (auth/net/not-a-repo)  → failed        (forge couldn't answer)
+//   timeout / signal / rate-limited → failed        (forge couldn't answer)
+export type ForgeName = "github" | "gitlab";
+
+// [LAW:types-are-the-program] Extract the host from a git remote, handling the
+// two shapes git uses: scp-like `[user@]host:path` and URL `scheme://[user@]
+// host[:port]/path`. The URL form is checked first — its `host` in a scp regex
+// would mis-capture the scheme (`https` before `://`). Returns null for an
+// unrecognized shape (local path, unknown syntax).
+function remoteHost(remoteUrl: string): string | null {
+  const url = remoteUrl.trim();
+  const proto = url.match(/^[a-z][a-z0-9+.-]*:\/\/(?:[^@/]+@)?([^/:]+)/i);
+  if (proto) return proto[1]!.toLowerCase();
+  const scp = url.match(/^(?:[^@/]+@)?([^/:]+):/);
+  if (scp) return scp[1]!.toLowerCase();
+  return null;
+}
+
+// [LAW:types-are-the-program] Branch on the HOST, not a substring of the whole
+// URL — a non-GitLab remote whose path merely contains "gitlab" (a repo named
+// `gitlab`) must not dispatch to glab. Self-hosted GitLab is detected by a
+// `gitlab.`-prefixed host label (gitlab.example.com); a GitLab on an arbitrary
+// hostname is undetectable here and falls through to null (absent), same as
+// GitHub Enterprise on a custom domain.
+export function detectForge(remoteUrl: string): ForgeName | null {
+  const host = remoteHost(remoteUrl);
+  if (!host) return null;
+  if (host === "github.com" || host.endsWith(".github.com")) return "github";
+  if (/(^|\.)gitlab\./.test(host)) return "gitlab";
+  return null;
+}
+
+export function classifyForgePr(
+  label: string,
+  result: LaunchResult,
+  noPrPattern: RegExp,
+  parse: (stdout: string) => Outcome<PullRequest>,
+): Outcome<PullRequest> {
+  if (result.ok) return parse(result.stdout);
+  // ENOENT (no forge CLI on PATH) is a static configuration absence, not a
+  // transient lookup failure — it never showed a PR, so showing nothing costs
+  // nothing. [LAW:no-silent-failure] Every OTHER spawn failure (EACCES,
+  // resource limits) means the CLI is present but could not launch — a real
+  // failure that must stay visible, so it falls through to the `failed` path.
+  if (result.reason === "spawn-error" && /ENOENT/i.test(result.error ?? ""))
+    return ABSENT;
+  if (result.reason === "non-zero" && noPrPattern.test(result.stderr))
+    return ABSENT;
+  const detail = [
+    result.reason,
+    result.exitCode != null ? `exit ${result.exitCode}` : null,
+    result.error ?? firstLine(result.stderr),
+  ]
+    .filter(Boolean)
+    .join(", ");
+  return failed(`${label}: ${detail}`);
+}
+
+function isRecord(v: unknown): v is Record<string, unknown> {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+
+// `gh pr view --json number,state,url` → one JSON object. Only an OPEN PR is a
+// value; a MERGED/CLOSED PR for the branch is the domain's `absent`.
+export function parseGithubPr(stdout: string): Outcome<PullRequest> {
+  let json: unknown;
+  try {
+    json = JSON.parse(stdout);
+  } catch (e) {
+    return failed(
+      `gh pr view: unparseable JSON (${e instanceof Error ? e.message : String(e)})`,
+    );
+  }
+  if (!isRecord(json)) return failed("gh pr view: JSON is not an object");
+  const { number, state, url } = json;
+  if (
+    typeof number !== "number" ||
+    typeof state !== "string" ||
+    typeof url !== "string"
+  ) {
+    return failed("gh pr view: missing number/state/url");
+  }
+  if (state.toUpperCase() !== "OPEN") return ABSENT;
+  return ok({ number, state, url });
+}
+
+// `glab mr view --output json` → one JSON object (iid / state / web_url). State
+// "opened" is the open MR; anything else is `absent`. NOTE: verified against
+// glab's documented JSON shape, not runtime-exercised here (glab not installed
+// on the dev machine) — the github path is the runtime-verified one.
+export function parseGitlabMr(stdout: string): Outcome<PullRequest> {
+  let json: unknown;
+  try {
+    json = JSON.parse(stdout);
+  } catch (e) {
+    return failed(
+      `glab mr view: unparseable JSON (${e instanceof Error ? e.message : String(e)})`,
+    );
+  }
+  if (!isRecord(json)) return failed("glab mr view: JSON is not an object");
+  const iid = json.iid;
+  const state = json.state;
+  const url = json.web_url;
+  if (
+    typeof iid !== "number" ||
+    typeof state !== "string" ||
+    typeof url !== "string"
+  ) {
+    return failed("glab mr view: missing iid/state/web_url");
+  }
+  if (state.toLowerCase() !== "opened") return ABSENT;
+  return ok({ number: iid, state, url });
+}
+
 export class GitService {
   private isGitRepo(workingDir: string): boolean {
     try {
@@ -407,6 +558,83 @@ export class GitService {
     return ok(match?.[1] || path.basename(workingDir));
   }
 
+  // [LAW:locality-or-seam] Public so the daemon's GitDataProvider can read the
+  // remote to fold into its PR cache key (the PR value depends on the remote;
+  // a re-pointed origin must be a new key). Raw origin URL (unparsed) — the
+  // forge detector reads the host from it. `config --get` exits 1 when unset →
+  // `absent` (no remote, hence no forge PR concept), distinct from a failure.
+  async getRemoteOriginUrl(workingDir: string): Promise<Outcome<string>> {
+    return nonEmpty(
+      classify(
+        "git config remote.origin.url",
+        await this.execGitAsync(["config", "--get", "remote.origin.url"], {
+          cwd: workingDir,
+          timeout: 2000,
+        }),
+        "absent",
+      ),
+    );
+  }
+
+  // [LAW:single-enforcer] One boundary for forge-CLI spawns. Mirrors
+  // execGitAsync but carries the "forge" launch category and a longer timeout
+  // (this is a network call, not a local git read). Returns the typed
+  // LaunchResult so classifyForgePr maps every termination cause to an Outcome.
+  private async execForgeAsync(
+    bin: string,
+    args: readonly string[],
+    options: { cwd: string; timeout: number },
+  ): Promise<LaunchResult> {
+    return launch({
+      bin,
+      args: [...args],
+      cwd: options.cwd,
+      env: { ...process.env },
+      timeoutMs: options.timeout,
+      category: "forge",
+    });
+  }
+
+  // [LAW:effects-at-boundaries] Resolve the branch's open PR/MR via the forge
+  // CLI. Pure dispatch over a remote the CALLER has already read: pick the
+  // forge by host, run its CLI, fold the launch result into an Outcome. The
+  // remote is a parameter (not read here) so the cache layer can fold it into
+  // its key in the same read — no caching here; the daemon's GitDataProvider
+  // owns the PR cache + TTL (a network resource wants a longer, independent
+  // lifecycle than local git state). `absent` when the host is no recognized
+  // forge; the CLI dispatch then classifies the rest.
+  async resolvePullRequest(
+    workingDir: string,
+    remoteUrl: string,
+  ): Promise<Outcome<PullRequest>> {
+    const forge = detectForge(remoteUrl);
+    if (forge === "github") {
+      return classifyForgePr(
+        "gh pr view",
+        await this.execForgeAsync(
+          "gh",
+          ["pr", "view", "--json", "number,state,url"],
+          { cwd: workingDir, timeout: 5000 },
+        ),
+        /no (open )?pull requests? found/i,
+        parseGithubPr,
+      );
+    }
+    if (forge === "gitlab") {
+      return classifyForgePr(
+        "glab mr view",
+        await this.execForgeAsync("glab", ["mr", "view", "--output", "json"], {
+          cwd: workingDir,
+          timeout: 5000,
+        }),
+        /no (open )?merge requests? (found|available)/i,
+        parseGitlabMr,
+      );
+    }
+    // Recognized neither host → no forge integration for this remote.
+    return ABSENT;
+  }
+
   private isWorktree(workingDir: string): boolean {
     try {
       const gitDir = path.join(workingDir, ".git");