@osdlc/repo-cleaner 0.13.0 → 0.14.2

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # @osdlc/repo-cleaner
 
+## 0.14.2
+
+### Patch Changes
+
+- 5cba918: `apply` says `skipped`, not `dropped`, for rows it leaves alone, matching the `skip` label on each row: `skipped 12, not deleted: 8 needs-review (name with --row), 4 not-authorized (--allow abandon-unmerged)`. The counts name how to include each kind. The closing prune step reads `prune   worktree records`, with the repository on the progress board, instead of a bare `prune`. The JSON receipt and summary keep their `dropped` field.
+
+## 0.14.1
+
+### Patch Changes
+
+- Updated dependencies [a3ef86d]
+  - @osdlc/cli-tool@0.15.0
+
+## 0.14.0
+
+### Minor Changes
+
+- cde983c: Pull request evidence now comes from a provider, and GitLab is one (prototype). `--provider auto|github|gitlab|none` on every sweeping command picks it; `auto`, the default, reads the remote's host, so a `gitlab` host asks `glab` for merge requests and any other host asks `gh` as before. `--no-gh` is `--provider none`. A plan records the choice for `apply`'s re-check. **Breaking (library):** `RepoInfo.provider` says which provider was asked and what its probe found, and replaces `hasGh` and `ghAuthenticated`. The `noGh` sweep and plan option is now `noProvider`. `fetchPrs` takes a provider (`githubProvider(gh)` for the old `Gh` form), and its third argument is an exact branch, not a prefix. The plan file keeps its `no_gh` field. Not yet done: Gitea, Forgejo, Bitbucket, a host-to-provider config, GitLab squash metadata, and GitLab installed under a sub-path. Without `--remotes` no provider is asked.
+
 ## 0.13.0
 
 ### Minor Changes

package/README.md

@@ -34,7 +34,7 @@ own bar, empty while it waits, half full while it runs and full with a `✓`
   ██████████ ✓ delete  local_branch  feat/a
   █████░░░░░ › delete  local_branch  feat/b
   ░░░░░░░░░░   delete  remote_branch  origin/feat/b
-  ░░░░░░░░░░   prune
+  ░░░░░░░░░░   prune   worktree records in /Users/me/work/api
   ████████░░░░░░░░░░░░░░░░░░░░░░ 1/4
 ```
 
@@ -74,7 +74,7 @@ Three signals settle most items. The first two are enough alone; the third needs
 
 | Signal | Source |
 | --- | --- |
-| A `MERGED` pull request from this repository, into the default branch, whose head commit is the branch tip | `gh pr list`, one listing per repository |
+| A `MERGED` pull request from this repository, into the default branch, whose head commit is the branch tip | `gh pr list` (or `glab` for GitLab), one listing per repository |
 | The branch tip is reachable from the default branch | `git merge-base --is-ancestor` |
 | The branch's changes are on the default branch under other commit ids (rebase merge, cherry-pick, squash merge) | `git cherry` plus `git merge-tree`, see [Patch equivalence](#patch-equivalence) |
 
@@ -226,8 +226,9 @@ table cannot be read the worktree is held back as `process-probe-failed`. A
 host or test supplies its own probe.
 Nothing is ever killed.
 
-Without `gh`, or without authentication, classification proceeds on git
-evidence alone and the report says so.
+Without the provider's CLI (`gh`, or `glab` for GitLab), or without
+authentication, classification proceeds on git evidence alone and the report
+says so. See [Providers (prototype)](#providers-prototype).
 
 Every branch delete names the full sha the sweep judged. `update-ref -d` and
 the pinned `--force-with-lease` push both refuse when the branch has moved
@@ -350,7 +351,8 @@ Every command that sweeps takes these:
 | `--branch <name\|HEAD>` | One branch of this repository: its worktree and local branch, and its remote branch with `--remotes`. Refuses the default branch |
 | `--remote <name>` | Remote to measure against (default `origin`) |
 | `--remote-url <url>` | Sweep this remote's branches with no checkout of your own (see [A remote with no checkout](#a-remote-with-no-checkout)); repeatable |
-| `--no-gh` | With `--remotes`: classify on git evidence alone. Without `--remotes`, `gh` is never called |
+| `--provider <name>` | With `--remotes`: where pull requests come from: `auto` (default, by the remote's host), `github`, `gitlab` or `none` |
+| `--no-gh` | With `--remotes`: classify on git evidence alone; the same as `--provider none`. Without `--remotes`, no provider is asked |
 | `--no-fetch` | With `--remotes`: skip the fetch; the header then says `not fetched`. Without `--remotes`, nothing is fetched |
 
 `status` also takes:
@@ -393,13 +395,13 @@ asks `Delete N items? [y/N]`:
 /Users/me/work/api
   delete  local_branch   fix/login-redirect
           git update-ref -d refs/heads/fix/login-redirect 3f9c2e1d…
-  prune
+  prune   worktree records
           git -C /Users/me/work/api worktree prune
   skip    worktree       /Users/me/work/api/wt/spike
           needs-review: clean but no clear disposability signal; name it with --row to apply it
 
 would delete: 1 local branch
-dropped 1: 1 needs-review
+skipped 1, not deleted: 1 needs-review (name with --row)
 Delete 2 items? [y/N]
 ```
 
@@ -432,7 +434,7 @@ Every run ends with what it did:
 
 ```text
 deleted: 1 worktree, 3 local branches, 2 remote branches, 1 stale worktree pruned
-dropped 2: 1 needs-review, 1 duplicate
+skipped 2, not deleted: 1 needs-review (name with --row), 1 duplicate
 status: complete
 ```
 
@@ -463,7 +465,7 @@ that swept, or read its plan from stdin, writes a receipt only when
 ```ts
 import { sweepRepo, sweepRepos } from '@osdlc/repo-cleaner'
 
-const sweep = sweepRepo('/Users/me/work/api', { noGh: true })
+const sweep = sweepRepo('/Users/me/work/api', { noProvider: true })
 for (const item of sweep.items) {
   console.log(item.classification, item.id, item.reason)
 }
@@ -497,10 +499,49 @@ or `needs-investigation`.
 An issue tracker's linkage, applied this way, is a host's own layer over the
 sweep and `applyPlan`.
 
+## Providers (prototype)
+
+Pull request evidence comes from a provider. Classification reads the same
+fields whichever one answered: number, state, head branch, head commit, target
+branch.
+
+| Provider | CLI | Listing |
+| --- | --- | --- |
+| `github` | `gh` | `gh pr list --state all`, up to 300 |
+| `gitlab` | `glab` | `glab api projects/<path>/merge_requests?state=all`, 100 a page, up to 300 |
+
+`--provider auto` (the default) reads the remote's host: a host with `gitlab`
+in its name is GitLab, any other is GitHub, which is what the tool did before
+providers existed. Name one with `--provider github|gitlab` for a host the
+name does not give away, or `--provider none` to skip pull requests. A plan
+records the choice, so `apply` re-checks with the same provider.
+
+GitLab maps onto the same evidence: `opened` and `locked` are `OPEN`, `merged`
+is `MERGED`, `closed` is `CLOSED`, `sha` is the head commit and `target_branch`
+the base. A merge request from a fork (source project is not the target
+project) is dropped, as a cross-repository PR is on GitHub. The project path is
+read off the remote URL with its groups (`group/sub/name`), and `glab` is asked
+for that host with `--hostname`.
+
+Not done yet:
+
+- Gitea, Forgejo and Bitbucket.
+- Mapping a self-hosted host to a provider in config; today it is the host
+  name or `--provider`.
+- Auth edge cases: tokens without API scope, `glab` signed in to a different
+  host than the remote, rate limits. Each reads as "no PR found".
+- Squash metadata. GitLab reports `squash_commit_sha`; it is not used, so a
+  squashed MR proves landing only by its head commit, as on GitHub.
+- GitLab under a sub-path (`https://host/gitlab/group/proj`). The URL does not
+  say where the install ends and the project begins, so the whole path is read
+  as the project, `glab` is asked for a project that does not exist, and the
+  listing fails. That reads as "no PR found": rows stay at `review`, nothing is
+  deleted on its account.
+
 ## Runtime dependencies
 
-`git` on `PATH`, and `gh` when PR state should count. Authentication is `gh`'s
-own — this package reads no token.
+`git` on `PATH`, and `gh` (or `glab` for GitLab) when PR state should count.
+Authentication is the CLI's own — this package reads no token.
 
 ## Running from a checkout
 

package/dist/apply.d.ts

@@ -26,9 +26,10 @@ export interface Grant {
     row: RowRef | null;
 }
 export interface ApplyOptions extends HostHooks {
-    /** Injected runners. Defaults spawn the real `git` and `gh`. */
+    /** Injected runners. Defaults spawn the real `git`, `gh` and `glab`. */
     git?: CommandRunner | undefined;
     gh?: CommandRunner | undefined;
+    glab?: CommandRunner | undefined;
     /**
      * Answers lock-owner and working-directory questions, for the re-sweep and
      * for the checks just before an unlock and a remove. Defaults to `ps` and

package/dist/apply.js

@@ -95,13 +95,15 @@ function resweep(repo, scope, opts) {
     }
     const sweep = sweepRepo(repo.root, {
         remote: repo.remote,
-        noGh: repo.no_gh,
+        noProvider: repo.no_gh,
+        provider: repo.provider,
         branch: repo.branch ?? undefined,
         fetch: opts.fetch ?? repo.fetch,
         scope,
         cwd: opts.callerCwd,
         git: opts.git,
         gh: opts.gh,
+        glab: opts.glab,
         probe: opts.probe,
         onProgress: opts.onSweepProgress,
     });

package/dist/branches.d.ts

@@ -25,6 +25,8 @@ export declare function recordPr(facts: Record<string, unknown>, pr: PRInfo | un
     landed: boolean;
     gap: PrEvidenceGap | null;
 };
+/** Why a branch has no PR, naming where the sweep looked. */
+export declare function noPrSentence(repo: RepoInfo): string;
 /** One sentence on why a merged PR did not count, for `investigationParts`. */
 export declare function gapSentence(pr: PRInfo, gap: PrEvidenceGap, repo: RepoInfo): string;
 /**

package/dist/branches.js

@@ -53,6 +53,13 @@ export function recordPr(facts, pr, tip, repo) {
     out['evidence'] = verdict === true ? 'exact-head' : verdict;
     return verdict === true ? { landed: true, gap: null } : { landed: false, gap: verdict };
 }
+/** Why a branch has no PR, naming where the sweep looked. */
+export function noPrSentence(repo) {
+    const provider = repo.provider;
+    if (provider === null)
+        return 'No PR lookup (no provider).';
+    return `No ${provider.noun} found via \`${provider.listing}\`.`;
+}
 /** One sentence on why a merged PR did not count, for `investigationParts`. */
 export function gapSentence(pr, gap, repo) {
     return gap === 'other-base'
@@ -233,9 +240,7 @@ export function classifyLocalBranch(opts) {
         : `Branch \`${name}\` is not an ancestor of \`${compareRef}\`.`;
     const parts = [lead];
     parts.push(upstream ? `Tracks \`${upstream}\` (${track || 'in sync'}).` : 'Has no upstream.');
-    parts.push(pr
-        ? `Associated PR #${pr.number} is ${pr.state} (${pr.url}).`
-        : 'No PR found via `gh pr list`.');
+    parts.push(pr ? `Associated PR #${pr.number} is ${pr.state} (${pr.url}).` : noPrSentence(repo));
     if (pr && gap)
         parts.push(gapSentence(pr, gap, repo));
     const unmatched = patch === null ? null : unmatchedSentence(patch, repo);

package/dist/cli.js

@@ -32,6 +32,7 @@ import { VENDOR_DIRS } from "./devlink.js";
 import { ensureMirror, mirrorProblem } from "./remote-mirror.js";
 import { ApplyArgumentError, applyPlan, parseGrant, parseRowRef } from "./apply.js";
 import { PLAN_VERSION, fileStamp, parsePlan, planRepo, readPlan, writePlan, } from "./plan.js";
+import { PROVIDER_CHOICES } from "./providers/index.js";
 import { RECEIPT_VERSION } from "./receipt.js";
 import { PLAIN, proposedCommands, renderCountsJson, renderCountsText, renderJson, renderPreview, renderPreviewDrops, renderReceipt, renderStepFailure, renderSummary, renderText, rowsActedOn, summarizeReceipt, TERMINAL_STYLE, } from "./render.js";
 import { NO_STATUS_LINE, describeStep, describeSweep, statusLine, } from "./status-line.js";
@@ -77,7 +78,13 @@ const SWEEP_FLAGS = {
     gh: {
         kind: 'boolean',
         negatable: true,
-        help: 'with --remotes: classify on git evidence alone (without --remotes gh is never called)',
+        help: 'with --remotes: classify on git evidence alone, the same as --provider none (without --remotes no provider is asked)',
+    },
+    provider: {
+        kind: 'enum',
+        choices: PROVIDER_CHOICES,
+        valueName: 'name',
+        help: 'with --remotes: where pull requests come from: auto (by remote host), github (gh), gitlab (glab), none',
     },
     fetch: {
         kind: 'boolean',
@@ -200,7 +207,7 @@ const applyCli = () => defineCli({
         output: OUTPUT,
     },
     epilogue: `risks: abandon-unmerged, discard-changes, confirm-open-pr
-A row that carries a risk you did not --allow is dropped, never deleted.`,
+A row that carries a risk you did not --allow is skipped, never deleted.`,
 });
 const terminalConfirm = (question) => (canPrompt() ? askYesNo(question) : null);
 const PAUSE = new Int32Array(new SharedArrayBuffer(4));
@@ -293,6 +300,10 @@ function sweep(name, v, paths, ctx, status) {
         if (conflict !== null)
             return { kind: 'exit', code: usageError(ctx, name, conflict) };
     }
+    if (!v.gh && v.provider !== undefined && v.provider !== 'none') {
+        const message = `--no-gh asks no provider; drop it or --provider ${v.provider}`;
+        return { kind: 'exit', code: usageError(ctx, name, message) };
+    }
     let branch;
     try {
         branch = v.branch === undefined ? undefined : resolveBranch(v.branch, new Git(ctx.cwd));
@@ -306,8 +317,9 @@ function sweep(name, v, paths, ctx, status) {
         baseDir: ctx.cwd,
         cwd: ctx.cwd,
         // Local by default means offline: the fetch and gh go with remote branches.
-        noGh: !(online && v.gh),
+        noProvider: !(online && v.gh) || v.provider === 'none',
         fetch: online && v.fetch,
+        provider: v.provider,
         branch,
         // Mid-walk, while the wait is happening — the summary comes too late to
         // explain why the tool appeared to hang.
@@ -344,7 +356,7 @@ function sweep(name, v, paths, ctx, status) {
         return { kind: 'exit', code: failure(ctx, new Error(refused)) };
     if (result.repos.length === 0)
         return { kind: 'nothing', result };
-    return { kind: 'ok', result, branch, values: v, scope, noGh: options.noGh === true };
+    return { kind: 'ok', result, branch, values: v, scope, noProvider: options.noProvider === true };
 }
 /**
  * Name each repository the sweep could not read, on stderr. True when there
@@ -360,7 +372,8 @@ function reportUnreadable(ctx, name, result) {
 function planOf(swept, now) {
     const opts = {
         remote: swept.values.remote ?? null,
-        noGh: swept.noGh,
+        noProvider: swept.noProvider,
+        provider: swept.values.provider,
         branch: swept.branch ?? null,
     };
     return {

package/dist/discover.d.ts

@@ -1,10 +1,12 @@
 /**
  * What the sweep must know about a repository before it can classify anything:
  * where its main checkout is, what its default branch is called, which remote
- * to measure against, and whether `gh` can be asked about pull requests.
+ * to measure against, and which provider can be asked about pull requests.
  */
 import { type Git } from '@osdlc/typed-git';
+import type { CommandRunner } from '@osdlc/command-seam';
 import type { Gh } from '@osdlc/typed-gh';
+import { type PrProvider, type ProviderChoice, type ProviderName } from './providers/index.ts';
 import type { RepoInfo } from './types.ts';
 /**
  * Thrown when a path names no repository, or names one whose default branch
@@ -26,7 +28,14 @@ export declare class DiscoveryFailed extends Error {
  */
 export declare function discoverRepo(hint: string, opts: {
     remote?: string | null;
-    allowGh?: boolean;
+    /** False is `provider: 'none'`, whatever `provider` says. */
+    allowProvider?: boolean;
+    /** Which provider to ask for pull requests. Defaults to `auto`, by the remote's host. */
+    provider?: ProviderChoice | undefined;
     git: Git;
     gh: Gh;
+    /** The `glab` runner for the GitLab provider. Defaults to the real binary. */
+    glab?: CommandRunner | undefined;
+    /** The providers to choose from. Defaults to {@link providers} over `gh` and `glab`. */
+    providers?: Record<ProviderName, PrProvider> | undefined;
 }): RepoInfo;

package/dist/discover.js

@@ -1,9 +1,10 @@
 /**
  * What the sweep must know about a repository before it can classify anything:
  * where its main checkout is, what its default branch is called, which remote
- * to measure against, and whether `gh` can be asked about pull requests.
+ * to measure against, and which provider can be asked about pull requests.
  */
 import { parseRemoteRepo } from '@osdlc/typed-git';
+import { forgeTarget, probeProvider, providers, } from "./providers/index.js";
 /**
  * Thrown when a path names no repository, or names one whose default branch
  * cannot be determined. A single-repository caller lets it propagate; a
@@ -28,7 +29,7 @@ export class DiscoveryFailed extends Error {
 export function discoverRepo(hint, opts) {
     const { git, gh } = opts;
     const remoteHint = opts.remote ?? null;
-    const allowGh = opts.allowGh ?? true;
+    const allowProvider = opts.allowProvider ?? true;
     // `topLevel()` answers null for exit 128 only — "this is not a repository",
     // which is the answer to the question. Any other git failure throws.
     const top = git.at(hint).topLevel();
@@ -70,14 +71,24 @@ export function discoverRepo(hint, opts) {
         throw new DiscoveryFailed(`could not determine the default branch of ${root}`);
     // A short name for the report's header, so a fan-out over long paths stays
     // readable. It also keys duplicate checkouts.
-    const slug = remote === null ? null : remoteSlugOf(git.at(root).try.remoteGetUrl(remote));
+    const url = remote === null ? null : git.at(root).try.remoteGetUrl(remote);
+    const slug = url === null ? null : remoteSlugOf(url);
+    const remoteUrl = url?.ok === true && typeof url.value === 'string' ? url.value : null;
     const currentBranch = git.at(root).headRef() ?? '';
-    // The two halves separately, not `ready()`: the report says "gh not
-    // available" and "gh not authenticated" differently, because they send a
-    // person somewhere different.
-    const hasGh = allowGh && gh.at(root).installed();
-    const ghAuthenticated = hasGh && gh.at(root).authenticated();
-    return { root, slug, mainBranch, remote, currentBranch, hasGh, ghAuthenticated, fetched: false };
+    // Installed and signed in are probed separately: "not installed" and "not
+    // authenticated" send a person somewhere different.
+    const choice = allowProvider ? (opts.provider ?? 'auto') : 'none';
+    const target = forgeTarget(remoteUrl);
+    const provider = probeProvider(choice, root, target, opts.providers ?? providers({ gh, glab: opts.glab }));
+    return {
+        root,
+        slug,
+        mainBranch,
+        remote,
+        currentBranch,
+        provider,
+        fetched: false,
+    };
 }
 /**
  * `owner/name` for a github.com remote, `host/owner/name` for any other, or

package/dist/index.d.ts

@@ -24,6 +24,7 @@ export { PLAN_VERSION, PlanReadError, planRepo, parsePlan, readPlan, writePlan,
 export { RECEIPT_VERSION, ReceiptSchema, type Dropped, type Receipt, type RowRef, type Step, } from './receipt.ts';
 export { defaultProcessProbe, isIdleShell, parseLockOwner, parseLsofCwd, type DefaultProbeOptions, type LockOwner, type ProcessHolder, type ProcessProbe, } from './processes.ts';
 export { fetchPrs } from './prs.ts';
+export { PROVIDER_CHOICES, PROVIDER_NAMES, chooseProvider, forgeTarget, githubProvider, gitlabProvider, probeProvider, providers, type ForgeTarget, type PrProvider, type ProviderChoice, type ProviderName, type ProviderStatus, } from './providers/index.ts';
 export { expandTilde, isCheckoutRoot, resolveEntries, type Resolution, type ResolveOptions, } from './resolve.ts';
 export { sweepRepo, sweepRepos, type SweepOptions, type SweepReposOptions } from './sweep.ts';
 export { proposedCommands, renderJson, renderApplySummary, renderReceipt, summarizeReceipt, type ApplySummary, renderRepo, renderScan, renderSummary, renderText, requiresNote, } from './render.ts';

package/dist/index.js

@@ -23,6 +23,7 @@ export { PLAN_VERSION, PlanReadError, planRepo, parsePlan, readPlan, writePlan,
 export { RECEIPT_VERSION, ReceiptSchema, } from "./receipt.js";
 export { defaultProcessProbe, isIdleShell, parseLockOwner, parseLsofCwd, } from "./processes.js";
 export { fetchPrs } from "./prs.js";
+export { PROVIDER_CHOICES, PROVIDER_NAMES, chooseProvider, forgeTarget, githubProvider, gitlabProvider, probeProvider, providers, } from "./providers/index.js";
 export { expandTilde, isCheckoutRoot, resolveEntries, } from "./resolve.js";
 export { sweepRepo, sweepRepos } from "./sweep.js";
 export { proposedCommands, renderJson, renderApplySummary, renderReceipt, summarizeReceipt, renderRepo, renderScan, renderSummary, renderText, requiresNote, } from "./render.js";

package/dist/plan.d.ts

@@ -4,6 +4,7 @@
  * whose fingerprint no longer matches.
  */
 import { z } from 'zod';
+import { type ProviderChoice } from './providers/types.ts';
 import { type SweepItem } from './types.ts';
 export declare const PLAN_VERSION = 1;
 /** The categories a plan can hold, in the order apply runs them. */
@@ -28,6 +29,12 @@ export declare const PlanRepoSchema: z.ZodObject<{
     root: z.ZodString;
     remote: z.ZodNullable<z.ZodString>;
     no_gh: z.ZodBoolean;
+    provider: z.ZodOptional<z.ZodEnum<{
+        github: "github";
+        gitlab: "gitlab";
+        auto: "auto";
+        none: "none";
+    }>>;
     branch: z.ZodDefault<z.ZodNullable<z.ZodString>>;
     fetch: z.ZodDefault<z.ZodBoolean>;
     rows: z.ZodArray<z.ZodObject<{
@@ -53,6 +60,12 @@ export declare const PlanSchema: z.ZodObject<{
         root: z.ZodString;
         remote: z.ZodNullable<z.ZodString>;
         no_gh: z.ZodBoolean;
+        provider: z.ZodOptional<z.ZodEnum<{
+            github: "github";
+            gitlab: "gitlab";
+            auto: "auto";
+            none: "none";
+        }>>;
         branch: z.ZodDefault<z.ZodNullable<z.ZodString>>;
         fetch: z.ZodDefault<z.ZodBoolean>;
         rows: z.ZodArray<z.ZodObject<{
@@ -89,9 +102,10 @@ export declare function sameFingerprint(a: Record<string, unknown>, b: Record<st
 /** One repository's plan entry: its deletable rows. */
 export declare function planRepo(root: string, opts: {
     remote: string | null;
-    noGh: boolean;
+    noProvider: boolean;
     branch?: string | null;
     fetch?: boolean;
+    provider?: ProviderChoice | undefined;
 }, items: readonly PlannableRow[]): PlanRepo;
 /** A UTC timestamp safe in a file name, e.g. `2026-10-04T12-30-05-123Z`. */
 export declare function fileStamp(d: Date): string;

package/dist/plan.js

@@ -5,6 +5,7 @@
  */
 import { readFileSync } from 'node:fs';
 import { z } from 'zod';
+import { PROVIDER_CHOICES } from "./providers/types.js";
 import { AUTHORIZATIONS } from "./types.js";
 import { writeJsonAtomic } from "./write-json.js";
 export const PLAN_VERSION = 1;
@@ -20,7 +21,14 @@ export const PlanRepoSchema = z.object({
     root: z.string(),
     /** The `remote` the sweep ran with; the re-sweep uses the same. */
     remote: z.string().nullable(),
+    /**
+     * True when the sweep asked no provider for pull requests. The name is the
+     * plan format's, from when GitHub was the only provider; renaming it would
+     * break every plan already written.
+     */
     no_gh: z.boolean(),
+    /** The provider choice the sweep ran with; absent is `auto`. `no_gh` wins over it. */
+    provider: z.enum(PROVIDER_CHOICES).optional(),
     /** The `branch` the sweep was narrowed to; the re-sweep uses the same. */
     branch: z.string().nullable().default(null),
     /**
@@ -87,7 +95,8 @@ export function planRepo(root, opts, items) {
     return {
         root,
         remote: opts.remote,
-        no_gh: opts.noGh,
+        no_gh: opts.noProvider,
+        ...(opts.provider === undefined || opts.provider === 'auto' ? {} : { provider: opts.provider }),
         branch: opts.branch ?? null,
         fetch: opts.fetch ?? false,
         rows,

package/dist/providers/github.d.ts

@@ -0,0 +1,10 @@
+/** Pull requests from GitHub, through `gh`. */
+import type { Gh } from '@osdlc/typed-gh';
+import type { PrProvider } from './types.ts';
+/** The most PRs one listing reads. */
+export declare const PR_LIMIT = 300;
+/**
+ * A provider over `gh pr list`. `gh` picks the repository from the checkout's
+ * remotes, so `target` is not consulted.
+ */
+export declare function githubProvider(gh: Gh): PrProvider;

package/dist/providers/github.js

@@ -0,0 +1,56 @@
+/** Pull requests from GitHub, through `gh`. */
+/** The fields classification consults. Asking for more costs latency. */
+const FIELDS = [
+    'number',
+    'state',
+    'mergedAt',
+    'headRefName',
+    'headRefOid',
+    'baseRefName',
+    'isCrossRepository',
+    'title',
+    'url',
+];
+/** The most PRs one listing reads. */
+export const PR_LIMIT = 300;
+/**
+ * A provider over `gh pr list`. `gh` picks the repository from the checkout's
+ * remotes, so `target` is not consulted.
+ */
+export function githubProvider(gh) {
+    return {
+        name: 'github',
+        words: { tool: 'gh', noun: 'PR', listing: 'gh pr list' },
+        probe(root) {
+            const available = gh.at(root).installed();
+            return { available, authenticated: available && gh.at(root).authenticated() };
+        },
+        listPrs(root, _target, branch) {
+            const rows = gh.at(root).prList({
+                state: 'all',
+                limit: PR_LIMIT,
+                fields: FIELDS,
+                head: branch,
+            });
+            if (rows === null)
+                return null;
+            const prs = [];
+            for (const row of rows.rows) {
+                // A fork's head branch is not this repository's branch, whatever its name.
+                if (!row.headRefName || row.isCrossRepository)
+                    continue;
+                prs.push({
+                    number: row.number,
+                    state: row.state,
+                    mergedAt: row.mergedAt,
+                    headRef: row.headRefName,
+                    headOid: row.headRefOid,
+                    baseRef: row.baseRefName,
+                    title: row.title,
+                    url: row.url,
+                });
+            }
+            return prs;
+        },
+    };
+}

package/dist/providers/gitlab.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Merge requests from GitLab, through `glab api`.
+ *
+ * The REST listing, not `glab mr list`: it carries the source and target
+ * project ids, which is how a fork's merge request is told apart, and it takes
+ * an explicit host and project, so a checkout with several remotes is read
+ * against the one the sweep measures.
+ */
+import { type CommandRunner } from '@osdlc/command-seam';
+import type { PRInfo } from '../types.ts';
+import type { PrProvider } from './types.ts';
+/** The fields of a merge request this reads. */
+interface MergeRequest {
+    iid: number;
+    state: string;
+    source_branch: string;
+    target_branch: string;
+    sha?: string | null;
+    merged_at?: string | null;
+    web_url?: string;
+    title?: string;
+    source_project_id: number;
+    target_project_id: number;
+}
+/** One merge request as a {@link PRInfo}, or null for a fork's or an unknown state's. */
+export declare function mergeRequestToPr(mr: MergeRequest): PRInfo | null;
+/**
+ * A provider over `glab`. It needs `target.project`: without one there is
+ * nothing to ask, and the listing answers null.
+ */
+export declare function gitlabProvider(glab: CommandRunner): PrProvider;
+export {};

package/dist/providers/gitlab.js

@@ -0,0 +1,117 @@
+/**
+ * Merge requests from GitLab, through `glab api`.
+ *
+ * The REST listing, not `glab mr list`: it carries the source and target
+ * project ids, which is how a fork's merge request is told apart, and it takes
+ * an explicit host and project, so a checkout with several remotes is read
+ * against the one the sweep measures.
+ */
+import { parseJsonResult, runFailed, } from '@osdlc/command-seam';
+import { PR_LIMIT } from "./github.js";
+const PER_PAGE = 100;
+/** GitLab's states, as the GitHub names classification reads. A locked MR is an open one mid-update. */
+const STATE = {
+    opened: 'OPEN',
+    locked: 'OPEN',
+    merged: 'MERGED',
+    closed: 'CLOSED',
+};
+/** Absent, or of the given type (null counting where `nullable`). */
+function optional(value, type, nullable = false) {
+    return value === undefined || (nullable && value === null) || typeof value === type;
+}
+function isMergeRequest(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const mr = value;
+    return (optional(mr['sha'], 'string', true) &&
+        optional(mr['merged_at'], 'string', true) &&
+        optional(mr['web_url'], 'string') &&
+        optional(mr['title'], 'string') &&
+        typeof mr['iid'] === 'number' &&
+        typeof mr['state'] === 'string' &&
+        typeof mr['source_branch'] === 'string' &&
+        typeof mr['target_branch'] === 'string' &&
+        typeof mr['source_project_id'] === 'number' &&
+        typeof mr['target_project_id'] === 'number');
+}
+/** One merge request as a {@link PRInfo}, or null for a fork's or an unknown state's. */
+export function mergeRequestToPr(mr) {
+    // A fork's source branch is not this repository's branch, whatever its name.
+    if (mr.source_project_id !== mr.target_project_id)
+        return null;
+    const state = STATE[mr.state];
+    if (state === undefined || mr.source_branch === '')
+        return null;
+    return {
+        number: mr.iid,
+        state,
+        mergedAt: mr.merged_at ?? null,
+        headRef: mr.source_branch,
+        headOid: typeof mr.sha === 'string' && mr.sha !== '' ? mr.sha : null,
+        baseRef: mr.target_branch,
+        title: mr.title ?? '',
+        url: mr.web_url ?? '',
+    };
+}
+/** Exited 0 with all its output captured. */
+function succeeded(result) {
+    return !runFailed(result);
+}
+/**
+ * A provider over `glab`. It needs `target.project`: without one there is
+ * nothing to ask, and the listing answers null.
+ */
+export function gitlabProvider(glab) {
+    const run = (root, argv) => glab.run(argv, { cwd: root });
+    const hostArgs = (host) => (host === null ? [] : ['--hostname', host]);
+    return {
+        name: 'gitlab',
+        words: { tool: 'glab', noun: 'merge request', listing: 'glab api' },
+        probe(root, target) {
+            const available = succeeded(run(root, ['--version']));
+            const authenticated = available && succeeded(run(root, ['auth', 'status', ...hostArgs(target.host)]));
+            return { available, authenticated };
+        },
+        listPrs(root, target, branch) {
+            if (target.project === null)
+                return null;
+            const project = encodeURIComponent(target.project);
+            const prs = [];
+            for (let page = 1; (page - 1) * PER_PAGE < PR_LIMIT; page++) {
+                const query = new URLSearchParams({
+                    state: 'all',
+                    per_page: String(PER_PAGE),
+                    page: String(page),
+                    order_by: 'updated_at',
+                    sort: 'desc',
+                });
+                if (branch !== undefined)
+                    query.set('source_branch', branch);
+                const result = run(root, [
+                    'api',
+                    ...hostArgs(target.host),
+                    `projects/${project}/merge_requests?${query.toString()}`,
+                ]);
+                // A failed, cut-short or unreadable page fails the listing: a missing
+                // open MR would read as no MR.
+                if (!succeeded(result))
+                    return null;
+                const listed = parseJsonResult(result);
+                if (!listed.ok || !Array.isArray(listed.value))
+                    return null;
+                const rows = listed.value;
+                for (const row of rows) {
+                    if (!isMergeRequest(row))
+                        continue;
+                    const pr = mergeRequestToPr(row);
+                    if (pr !== null)
+                        prs.push(pr);
+                }
+                if (rows.length < PER_PAGE)
+                    break;
+            }
+            return prs;
+        },
+    };
+}

package/dist/providers/index.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Choosing a provider for a repository, from the caller's choice and the
+ * remote's host.
+ */
+import { type CommandRunner } from '@osdlc/command-seam';
+import type { Gh } from '@osdlc/typed-gh';
+import type { ForgeTarget, PrProvider, ProviderChoice, ProviderName, ProviderStatus } from './types.ts';
+export { githubProvider } from './github.ts';
+export { gitlabProvider } from './gitlab.ts';
+export * from './types.ts';
+/** Every known provider, over the given clients. `glab` defaults to the real binary. */
+export declare function providers(clients: {
+    gh: Gh;
+    glab?: CommandRunner | undefined;
+}): Record<ProviderName, PrProvider>;
+/**
+ * The host and full project path a remote URL names, groups kept
+ * (`gitlab.com:group/sub/name.git` is project `group/sub/name`). A local path
+ * or a `file:` URL names no forge.
+ */
+export declare function forgeTarget(url: string | null): ForgeTarget;
+/**
+ * The provider `choice` names for `target`. `auto` reads the host: one with
+ * `gitlab` in its name is GitLab, any other is GitHub, which is what the sweep
+ * did before providers existed (`gh` answers nothing for a host it does not
+ * know). `none` is no provider.
+ */
+export declare function chooseProvider(choice: ProviderChoice, target: ForgeTarget): ProviderName | null;
+/** The chosen provider for a repository, probed; null for none. */
+export declare function probeProvider(choice: ProviderChoice, root: string, target: ForgeTarget, all: Record<ProviderName, PrProvider>): ProviderStatus | null;

package/dist/providers/index.js

@@ -0,0 +1,63 @@
+/**
+ * Choosing a provider for a repository, from the caller's choice and the
+ * remote's host.
+ */
+import { resolveRunner } from '@osdlc/command-seam';
+import { githubProvider } from "./github.js";
+import { gitlabProvider } from "./gitlab.js";
+export { githubProvider } from "./github.js";
+export { gitlabProvider } from "./gitlab.js";
+export * from "./types.js";
+/** Every known provider, over the given clients. `glab` defaults to the real binary. */
+export function providers(clients) {
+    return {
+        github: githubProvider(clients.gh),
+        gitlab: gitlabProvider(resolveRunner('glab', clients.glab)),
+    };
+}
+const NO_TARGET = { host: null, project: null };
+/**
+ * The host and full project path a remote URL names, groups kept
+ * (`gitlab.com:group/sub/name.git` is project `group/sub/name`). A local path
+ * or a `file:` URL names no forge.
+ */
+export function forgeTarget(url) {
+    if (url === null)
+        return NO_TARGET;
+    const trimmed = url.trim();
+    if (/^file:/i.test(trimmed))
+        return NO_TARGET;
+    // scp form, user optional (`host:path` is valid git). A one-letter host is a
+    // Windows drive (`C:/repo`), which git reads as a local path.
+    const scp = /^(?:[\w.-]+@)?([^:/\\]{2,}):(?!\/\/)(.+)$/.exec(trimmed);
+    const uri = /^[a-z][a-z0-9+.-]*:\/\/(?:[^@/]+@)?([^/:]+)(?::\d+)?\/(.+)$/i.exec(trimmed);
+    const match = uri ?? scp;
+    if (match === null)
+        return NO_TARGET;
+    const path = match[2].replace(/^\/+|\/+$/g, '').replace(/\.git$/, '');
+    const parts = path.split('/').filter((p) => p !== '');
+    if (parts.length < 2)
+        return { host: match[1].toLowerCase(), project: null };
+    return { host: match[1].toLowerCase(), project: parts.join('/') };
+}
+/**
+ * The provider `choice` names for `target`. `auto` reads the host: one with
+ * `gitlab` in its name is GitLab, any other is GitHub, which is what the sweep
+ * did before providers existed (`gh` answers nothing for a host it does not
+ * know). `none` is no provider.
+ */
+export function chooseProvider(choice, target) {
+    if (choice === 'none')
+        return null;
+    if (choice !== 'auto')
+        return choice;
+    return target.host !== null && target.host.includes('gitlab') ? 'gitlab' : 'github';
+}
+/** The chosen provider for a repository, probed; null for none. */
+export function probeProvider(choice, root, target, all) {
+    const name = chooseProvider(choice, target);
+    if (name === null)
+        return null;
+    const provider = all[name];
+    return { name, ...provider.words, ...target, ...provider.probe(root, target) };
+}

package/dist/providers/types.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Where pull request evidence comes from. A provider answers two questions
+ * for a repository: can its CLI be asked at all, and which pull (or merge)
+ * requests exist. Classification reads {@link PRInfo} and never knows which
+ * provider answered.
+ */
+import type { PRInfo } from '../types.ts';
+/** The providers this build knows. */
+export declare const PROVIDER_NAMES: readonly ["github", "gitlab"];
+export type ProviderName = (typeof PROVIDER_NAMES)[number];
+/** What a caller may ask for: one provider, none, or the one the remote's host suggests. */
+export declare const PROVIDER_CHOICES: readonly ["auto", "github", "gitlab", "none"];
+export type ProviderChoice = (typeof PROVIDER_CHOICES)[number];
+/** The forge a remote points at, read off its URL. */
+export interface ForgeTarget {
+    /** The host, lower-cased, without a port; null when the remote names none. */
+    host: string | null;
+    /** The full project path, groups included (`group/sub/name`); null when there is none. */
+    project: string | null;
+}
+/** How a report names a provider's requests and the lookup that lists them. */
+export interface ProviderWords {
+    /** The CLI the provider runs: `gh`, `glab`. */
+    tool: string;
+    /** What the forge calls one request: `PR`, `merge request`. */
+    noun: string;
+    /** The command that lists them, as a report quotes it: `gh pr list`. */
+    listing: string;
+}
+/** The provider chosen for a repository, and what its probe found. */
+export interface ProviderStatus extends ForgeTarget, ProviderWords {
+    name: ProviderName;
+    /** The CLI is installed. */
+    available: boolean;
+    /** The CLI has credentials for `host`. */
+    authenticated: boolean;
+}
+/** One source of pull request evidence. */
+export interface PrProvider {
+    readonly name: ProviderName;
+    readonly words: ProviderWords;
+    /** Whether the CLI is installed and signed in for `target`'s host. */
+    probe(root: string, target: ForgeTarget): {
+        available: boolean;
+        authenticated: boolean;
+    };
+    /**
+     * The repository's pull requests, fork PRs already dropped, in any order;
+     * null when the listing failed. A failure is not "no PRs": the caller
+     * classifies on git evidence alone.
+     *
+     * @param branch Narrow the listing to this exact head branch. The caller
+     *   checks the head again, so a provider that cannot narrow may list all.
+     */
+    listPrs(root: string, target: ForgeTarget, branch?: string): PRInfo[] | null;
+}

package/dist/providers/types.js

@@ -0,0 +1,10 @@
+/**
+ * Where pull request evidence comes from. A provider answers two questions
+ * for a repository: can its CLI be asked at all, and which pull (or merge)
+ * requests exist. Classification reads {@link PRInfo} and never knows which
+ * provider answered.
+ */
+/** The providers this build knows. */
+export const PROVIDER_NAMES = ['github', 'gitlab'];
+/** What a caller may ask for: one provider, none, or the one the remote's host suggests. */
+export const PROVIDER_CHOICES = ['auto', ...PROVIDER_NAMES, 'none'];

package/dist/prs.d.ts

@@ -1,26 +1,30 @@
 /**
  * The pull requests of a repository, indexed by head branch.
  *
- * One `gh pr list` per repository, not one query per branch: a repository with
+ * One listing per repository, not one query per branch: a repository with
  * sixty branches would otherwise pay sixty round trips to answer a question
- * one listing covers.
+ * one listing covers. Which forge answers is the provider's business; see
+ * `providers/`.
  */
-import type { Gh } from '@osdlc/typed-gh';
+import type { PrProvider } from './providers/index.ts';
 import type { PRInfo, RepoInfo } from './types.ts';
 /**
  * Every same-repository pull request, keyed by head branch. Fork PRs are
- * dropped: a fork branch that shares a name proves nothing about ours.
+ * dropped by the provider: a fork branch that shares a name proves nothing
+ * about ours.
  *
  * A branch can carry several PRs over its life. The one that decides a
  * verdict is the most live: an open PR means keep whatever else happened, and
  * a merged one means the work landed. Ties go to the higher number, so two
  * runs over unchanged state agree.
  *
- * An empty map is the honest answer when `gh` is missing, unauthenticated or
- * failing. Classification degrades to git evidence and the report says so.
+ * An empty map is the honest answer when the provider's CLI is missing,
+ * unauthenticated or failing, or when there is no provider. Classification
+ * degrades to git evidence and the report says so.
  *
- * @param headPrefix Ask `gh` only for PRs whose head starts with this; the map is
- *   still keyed by exact head. typed-gh's `head` is exact, so the prefix goes
- *   through gh's `head:` search, which matches by prefix, and is checked again here.
+ * @param provider The provider to ask. It is asked only when it is the one
+ *   `repo.provider` names and that probe found it signed in.
+ * @param branch Ask only for PRs whose head is exactly this branch; rows
+ *   for any other head are dropped here too.
  */
-export declare function fetchPrs(repo: RepoInfo, gh: Gh, headPrefix?: string): Map<string, PRInfo>;
+export declare function fetchPrs(repo: RepoInfo, provider: PrProvider, branch?: string): Map<string, PRInfo>;

package/dist/prs.js

@@ -1,72 +1,48 @@
 /**
  * The pull requests of a repository, indexed by head branch.
  *
- * One `gh pr list` per repository, not one query per branch: a repository with
+ * One listing per repository, not one query per branch: a repository with
  * sixty branches would otherwise pay sixty round trips to answer a question
- * one listing covers.
+ * one listing covers. Which forge answers is the provider's business; see
+ * `providers/`.
  */
-/** The fields classification consults. Asking for more costs latency. */
-const FIELDS = [
-    'number',
-    'state',
-    'mergedAt',
-    'headRefName',
-    'headRefOid',
-    'baseRefName',
-    'isCrossRepository',
-    'title',
-    'url',
-];
-const LIMIT = 300;
 /** Open outranks merged outranks closed, and a newer PR outranks an older. */
 function priority(state) {
     return { OPEN: 3, MERGED: 2, CLOSED: 1 }[state] ?? 0;
 }
 /**
  * Every same-repository pull request, keyed by head branch. Fork PRs are
- * dropped: a fork branch that shares a name proves nothing about ours.
+ * dropped by the provider: a fork branch that shares a name proves nothing
+ * about ours.
  *
  * A branch can carry several PRs over its life. The one that decides a
  * verdict is the most live: an open PR means keep whatever else happened, and
  * a merged one means the work landed. Ties go to the higher number, so two
  * runs over unchanged state agree.
  *
- * An empty map is the honest answer when `gh` is missing, unauthenticated or
- * failing. Classification degrades to git evidence and the report says so.
+ * An empty map is the honest answer when the provider's CLI is missing,
+ * unauthenticated or failing, or when there is no provider. Classification
+ * degrades to git evidence and the report says so.
  *
- * @param headPrefix Ask `gh` only for PRs whose head starts with this; the map is
- *   still keyed by exact head. typed-gh's `head` is exact, so the prefix goes
- *   through gh's `head:` search, which matches by prefix, and is checked again here.
+ * @param provider The provider to ask. It is asked only when it is the one
+ *   `repo.provider` names and that probe found it signed in.
+ * @param branch Ask only for PRs whose head is exactly this branch; rows
+ *   for any other head are dropped here too.
  */
-export function fetchPrs(repo, gh, headPrefix) {
+export function fetchPrs(repo, provider, branch) {
     const byHead = new Map();
-    if (!(repo.hasGh && repo.ghAuthenticated))
+    const status = repo.provider;
+    if (status === null || status.name !== provider.name || !status.authenticated)
         return byHead;
-    const rows = gh.at(repo.root).prList({
-        state: 'all',
-        limit: LIMIT,
-        fields: FIELDS,
-        search: headPrefix === undefined ? undefined : `head:${headPrefix}`,
-    });
+    const rows = provider.listPrs(repo.root, status, branch);
     if (rows === null)
         return byHead;
-    for (const row of rows.rows) {
-        const head = row.headRefName;
-        // A fork's head branch is not this repository's branch, whatever its name.
-        if (!head || row.isCrossRepository)
+    for (const info of rows) {
+        const head = info.headRef;
+        if (!head)
             continue;
-        if (headPrefix !== undefined && !head.startsWith(headPrefix))
+        if (branch !== undefined && head !== branch)
             continue;
-        const info = {
-            number: row.number,
-            state: row.state,
-            mergedAt: row.mergedAt,
-            headRef: head,
-            headOid: row.headRefOid,
-            baseRef: row.baseRefName,
-            title: row.title,
-            url: row.url,
-        };
         const existing = byHead.get(head);
         if (existing === undefined) {
             byHead.set(head, info);

package/dist/render.d.ts

@@ -94,7 +94,7 @@ export interface ApplySummary {
 export declare function summarizeReceipt(receipt: Receipt): ApplySummary;
 /** Rows a receipt deletes or prunes, which is what a person is asked to approve. */
 export declare function rowsActedOn(summary: ApplySummary): number;
-/** The closing lines of an apply run: what it deleted, dropped and could not finish. */
+/** The closing lines of an apply run: what it deleted, skipped and could not finish. */
 export declare function renderApplySummary(receipt: Receipt): string[];
 /** The word a preview shows for a step: what it does to the row. */
 export declare const STEP_VERB: Record<Step['action'], string>;

package/dist/render.js

@@ -352,7 +352,27 @@ export function rowsActedOn(summary) {
     return d.worktree + d.local_branch + d.remote_branch + summary.pruned;
 }
 const plural = (n, one, many) => `${n} ${n === 1 ? one : many}`;
-/** The closing lines of an apply run: what it deleted, dropped and could not finish. */
+/**
+ * How to include a skipped row next time, for the reasons a person can act
+ * on. A `not-authorized` detail is `needs <risk>, <risk>` (see `recheck`).
+ */
+function dropHints(receipt) {
+    const risks = new Set();
+    for (const d of receipt.dropped) {
+        if (d.reason !== 'not-authorized')
+            continue;
+        for (const risk of d.detail.replace(/^needs /, '').split(', '))
+            if (risk)
+                risks.add(risk);
+    }
+    return {
+        'needs-review': 'name with --row',
+        ...(risks.size > 0
+            ? { 'not-authorized': [...risks].map((r) => `--allow ${r}`).join(', ') }
+            : {}),
+    };
+}
+/** The closing lines of an apply run: what it deleted, skipped and could not finish. */
 export function renderApplySummary(receipt) {
     const s = summarizeReceipt(receipt);
     const dry = receipt.status === 'dry-run';
@@ -372,7 +392,12 @@ export function renderApplySummary(receipt) {
     const dropped = Object.entries(s.dropped);
     if (dropped.length > 0) {
         const total = dropped.reduce((n, [, c]) => n + c, 0);
-        lines.push(`dropped ${total}: ${dropped.map(([reason, c]) => `${c} ${reason}`).join(', ')}`);
+        const hints = dropHints(receipt);
+        const counts = dropped.map(([reason, c]) => {
+            const hint = hints[reason];
+            return hint === undefined ? `${c} ${reason}` : `${c} ${reason} (${hint})`;
+        });
+        lines.push(`skipped ${total}, not deleted: ${counts.join(', ')}`);
     }
     if (s.failed > 0) {
         lines.push(`stopped at a failed step; ${plural(s.notRun, 'row', 'rows')} not run`);
@@ -421,7 +446,9 @@ export function renderPreview(receipt, style = PLAIN) {
         for (const s of receipt.steps.filter((s) => s.repo === repo)) {
             const verb = STEP_VERB[s.action];
             const color = actionStyle(style, verb === 'unlock' ? 'review' : verb);
-            lines.push(s.row === null ? `  ${color(verb)}` : `  ${color(pad(verb, 6))}  ${row(s.row)}`);
+            lines.push(s.row === null
+                ? `  ${color(pad(verb, 6))}  worktree records`
+                : `  ${color(pad(verb, 6))}  ${row(s.row)}`);
             lines.push(`          ${style.muted(stripControls(s.command))}`);
         }
         for (const d of receipt.dropped.filter((d) => d.repo === repo)) {
@@ -456,7 +483,7 @@ export function renderReceipt(receipt, receiptPath, style = PLAIN, opts = {}) {
     // A run shown live has printed its dropped rows and steps already.
     for (const d of opts.steps === false ? [] : receipt.dropped) {
         const shown = stripControls(`${d.category}:${d.id} — ${d.reason} (${d.detail})`);
-        lines.push(`${style.review('dropped  ')}${shown}`);
+        lines.push(`${style.review('skipped  ')}${shown}`);
     }
     for (const s of opts.steps === false ? [] : receipt.steps) {
         const what = s.row === null ? s.command : `${s.row.category}:${s.row.id} — ${s.command}`;

package/dist/status-line.js

@@ -31,7 +31,10 @@ export function describeSweep(p, home = homedir()) {
     const count = p.done === undefined || p.total === undefined
         ? ''
         : ` ${progressBar(p.done, p.total)} ${p.done + 1}/${p.total}`;
-    return `${where}${STEP_TEXT[p.step]}${count} · ${tilde(p.repo, home)}`;
+    const text = p.step === 'prs' && p.tool !== undefined
+        ? `listing pull requests (${p.tool})`
+        : STEP_TEXT[p.step];
+    return `${where}${text}${count} · ${tilde(p.repo, home)}`;
 }
 /** An apply step as one line, e.g. `deleting ██████░░░░ 3/7: delete-remote origin/feat/x`. */
 export function describeStep(index, total, step) {

package/dist/step-board.js

@@ -13,8 +13,9 @@ const BAR = 10;
 const TOTAL_BAR = 30;
 function label(step) {
     const verb = STEP_VERB[step.action];
+    // The closing prune belongs to no row: it clears the repository's stale worktree records.
     if (step.row === null)
-        return verb;
+        return stripControls(`${verb.padEnd(6)}  worktree records in ${step.repo}`);
     return stripControls(`${verb.padEnd(6)}  ${step.row.category}  ${step.row.id}`);
 }
 /**

package/dist/sweep.d.ts

@@ -7,14 +7,20 @@
  */
 import type { CommandRunner } from '@osdlc/command-seam';
 import { type ProcessProbe } from './processes.ts';
+import { type ProviderChoice } from './providers/index.ts';
 import { type RepoSweep, type Scope, type SweepProgress, type SweepResult } from './types.ts';
 export interface SweepOptions {
     /** Which categories to gather. Defaults to all of them. */
     scope?: Iterable<Scope | string>;
     /** Remote to measure against. Defaults to `origin`, then the first one. */
     remote?: string | null;
-    /** Skip `gh` entirely and classify on git evidence alone. */
-    noGh?: boolean;
+    /** Ask no provider and classify on git evidence alone. Same as `provider: 'none'`, and wins over it. */
+    noProvider?: boolean;
+    /**
+     * Which provider to ask for pull requests: `github` (`gh`), `gitlab`
+     * (`glab`), `none`, or `auto`, which reads the remote's host. Defaults to `auto`.
+     */
+    provider?: ProviderChoice | undefined;
     /**
      * Run `git fetch --prune <remote>` before classifying, so ancestry is read
      * against fresh remote-tracking refs. A failed fetch makes the repository
@@ -34,9 +40,10 @@ export interface SweepOptions {
      * when that worktree is blocked or cannot be removed.
      */
     branch?: string | undefined;
-    /** Injected runners. Defaults spawn the real `git` and `gh`. */
+    /** Injected runners. Defaults spawn the real `git`, `gh` and `glab`. */
     git?: CommandRunner | undefined;
     gh?: CommandRunner | undefined;
+    glab?: CommandRunner | undefined;
     /**
      * Answers whether a worktree lock's owner is alive and which processes work
      * inside a worktree. Defaults to {@link defaultProcessProbe}, one per

package/dist/sweep.js

@@ -11,6 +11,7 @@ import { gatherLocalBranches, gatherRemoteBranches } from "./branches.js";
 import { DiscoveryFailed, discoverRepo } from "./discover.js";
 import { defaultProcessProbe } from "./processes.js";
 import { fetchPrs } from "./prs.js";
+import { providers } from "./providers/index.js";
 import { resolveEntries } from "./resolve.js";
 import { ALL_SCOPES, findDuplicateCheckouts, } from "./types.js";
 import { gatherWorktrees } from "./worktrees.js";
@@ -33,13 +34,15 @@ function clients(path, opts) {
 export function sweepRepo(path, opts = {}) {
     const scope = scopeSet(opts.scope);
     const { git, gh } = clients(path, opts);
+    const known = providers({ gh, glab: opts.glab });
     const only = opts.branch;
     const at = opts.position ?? { index: 1, of: 1 };
-    const report = (step, done, total) => opts.onProgress?.({
+    const report = (step, done, total, tool) => opts.onProgress?.({
         repo: path,
         ...at,
         step,
         ...(done === undefined || total === undefined ? {} : { done, total }),
+        ...(tool === undefined ? {} : { tool }),
     });
     const ticker = (step) => (done, total) => report(step, done, total);
     report('discover');
@@ -47,9 +50,11 @@ export function sweepRepo(path, opts = {}) {
     try {
         repo = discoverRepo(path, {
             remote: opts.remote ?? null,
-            allowGh: opts.noGh !== true,
+            allowProvider: opts.noProvider !== true,
+            provider: opts.provider,
             git,
             gh,
+            providers: known,
         });
     }
     catch (err) {
@@ -77,9 +82,10 @@ export function sweepRepo(path, opts = {}) {
         repo = { ...repo, fetched: true };
     }
     try {
-        if (repo.hasGh && repo.ghAuthenticated)
-            report('prs');
-        const prs = fetchPrs(repo, gh, only);
+        const status = repo.provider ?? null;
+        if (status?.authenticated === true)
+            report('prs', undefined, undefined, status.tool);
+        const prs = status === null ? new Map() : fetchPrs(repo, known[status.name], only);
         const items = [];
         // Worktrees are gathered whenever local branches are, even if they are not
         // reported: a branch checked out in one must not be judged on its own.

package/dist/types.d.ts

@@ -5,6 +5,7 @@
  * by `category` rather than reading a different type, and a host that adds its
  * own knowledge (an issue tracker's linkage, say) rewrites rows in place.
  */
+import type { ProviderStatus } from './providers/types.ts';
 /** What the sweep concluded about an item. */
 export type Classification = 'safe-to-delete' | 'safe-to-keep' | 'needs-investigation';
 /** The kinds of thing a sweep inventories. */
@@ -21,6 +22,8 @@ export interface SweepProgress {
     step: 'discover' | 'fetch' | 'prs' | 'worktrees' | 'local-branches' | 'remote-branches';
     done?: number;
     total?: number;
+    /** The CLI asked during the `prs` step: `gh`, `glab`. */
+    tool?: string;
 }
 /** Which categories to gather. */
 export declare const ALL_SCOPES: readonly ["local-branches", "worktrees", "remote-branches"];
@@ -47,8 +50,12 @@ export interface RepoInfo {
     mainBranch: string;
     remote: string | null;
     currentBranch: string;
-    hasGh: boolean;
-    ghAuthenticated: boolean;
+    /**
+     * The provider asked for pull requests and what its probe found: whether
+     * its CLI is installed and signed in. Null when none was asked
+     * (`--provider none`, `--no-gh`, or a sweep without `--remotes`).
+     */
+    provider: ProviderStatus | null;
     /** True when the sweep fetched the remote before classifying. */
     fetched: boolean;
 }

package/dist/version.generated.d.ts

@@ -1,2 +1,2 @@
 /** This package's version, from its package.json when it was built. */
-export declare const VERSION = "0.13.0";
+export declare const VERSION = "0.14.2";

package/dist/version.generated.js

@@ -1,3 +1,3 @@
 // Generated by cli-tool-stamp-version from package.json. Do not edit.
 /** This package's version, from its package.json when it was built. */
-export const VERSION = '0.13.0';
+export const VERSION = '0.14.2';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@osdlc/repo-cleaner",
-  "version": "0.13.0",
+  "version": "0.14.2",
   "description": "What has been merged into the default branch, and what can go away. Inventories local branches, worktrees and remote branches across one repository or many, classifying each with the evidence behind the verdict and the command that would act on it. Plans and applies approved deletes, compare-and-swap.",
   "license": "MIT OR Apache-2.0",
   "author": "sksizer",
@@ -49,12 +49,12 @@
   },
   "dependencies": {
     "zod": "^4.6.6",
-    "@osdlc/cli-tool": "^0.14.0",
-    "@osdlc/command-seam": "^0.14.0",
+    "@osdlc/cli-tool": "^0.15.0",
     "@osdlc/path-guard": "^0.3.1",
+    "@osdlc/command-seam": "^0.14.0",
     "@osdlc/typed-gh": "^0.14.1",
-    "@osdlc/ux": "^0.1.1",
-    "@osdlc/typed-git": "^0.12.0"
+    "@osdlc/typed-git": "^0.12.0",
+    "@osdlc/ux": "^0.1.1"
   },
   "devDependencies": {
     "@types/node": "^26.1.0",