cawdev-cli 1.0.9-beta → 1.0.11-beta

package/runner/attach.mjs

@@ -60,8 +60,8 @@ import {
 import { clip, keyList, padVisible, painter, stripAnsi, visibleWidth, wrap } from '../lib/ansi.mjs';
 import { restartNeededFor } from '../lib/runner-config.mjs';
 import {
-  BOARD_COLUMNS, MIN_ZONE_HEIGHT, PROMPT_ROWS, SplitScreen, tabsLine, visibleSessions, actionsFor, composeFrame,
-  carriesOnHere, builtNothing, cardLines, cardTitleFor, commandWords, wordsText, subtitleFor, agentModelFor, wordWrap, isAutoCheckout, isPullRequest, parseNew, roadmapStrip, sessionTag, splitLayout, titleFor, toneFor,
+  BOARD_COLUMNS, MIN_ZONE_HEIGHT, PROMPT_ROWS, SplitScreen, readerFrame, tabsLine, visibleSessions, actionsFor, composeFrame,
+  carriesOnHere, builtNothing, cardLines, columnOf, cardTitleFor, commandWords, wordsText, subtitleFor, agentModelFor, wordWrap, isAutoCheckout, isPullRequest, parseNew, roadmapStrip, sessionTag, splitLayout, titleFor, toneFor,
   windowLines,
 } from './split.mjs';
 import { KNOWN_AGENTS, agentOfCommand } from '../lib/agents.mjs';
@@ -298,8 +298,14 @@ export function permissionBanner(pending, width, ink = painter(3), machine = {})
     .find((lines) => lines.length <= 2)
     ?? rows(without(short));
 
+  // A stage gate's summary is the whole PLAN, many lines long: one row here,
+  // and how much more there is — `/view` reads it whole. Clipped as one
+  // string, its newlines went through and filled the prompt.
+  const [first = '', ...more] = String(approval.summary ?? '').split('\n');
+  const rest = more.filter((line) => line.trim()).length;
+  const tail = rest ? ` (+${rest} lines)` : '';
   return [
-    `${ink.bold(ink.warn(' permission '))} ${clip(approval.summary, Math.max(8, width - 13))}`,
+    `${ink.bold(ink.warn(' permission '))} ${clip(first, Math.max(8, width - 13 - tail.length))}${ink.muted(tail)}`,
     ink.muted(` ${approval.toolName} · waiting since ${approval.askedAt?.slice(11, 19) ?? ''}`),
     ...keys,
   ];
@@ -832,8 +838,8 @@ const COMMANDS = [
   ['/continue', 'pick a failed or stopped session back up on this machine — the console\'s Carry on'],
   ['/projects', 'which projects advanced mode shows — tick one or several'],
   ['/refresh', "read the cards and their statuses from cawdev again — advanced mode's roadmap"],
-  ['/open', "open the session's pull request in your browser — or, on a finished plan, its card and plan on cawdev"],
-  ['/view', "a card here in the terminal: /view R29, /view <words of its title> (@project), /view card for the session's; /view alone opens the session on cawdev"],
+  ['/open', "open the session's pull request in your browser — on a finished plan, its card and plan; on one waiting for you, its page on cawdev"],
+  ['/view', "a card here in the terminal: /view R29, /view <words of its title> (@project), /view card for the session's; /view alone reads what a session waits on in full, or opens it on cawdev"],
   ['/drop', 'delete the checkout a finished session was made on demand for'],
   ['/close', "close an ended session's window"],
   ['/reload', 'quit and start again on the code on disk — the runner too, when nothing is running'],
@@ -1625,6 +1631,9 @@ export class Attached {
     }
     this.interrupting = false;
 
+    if (this.reader && this.mode === 'keys') {
+      return this.onReaderKey(key);
+    }
     if (this.mode === 'typing') {
       return this.onTyping(key);
     }
@@ -1755,7 +1764,8 @@ export class Attached {
 
   /** Everything open, closed. Returns whether there was anything. */
   closeEverything() {
-    const open = this.mode !== 'keys';
+    const open = this.mode !== 'keys' || Boolean(this.reader);
+    this.reader = null;
     this.mode = 'keys';
     this.select = null;
     this.input = null;
@@ -2082,6 +2092,16 @@ export class Attached {
       this.select = null;
       return this.note('');
     }
+    // A question's or a permission's list holds only the start of what is
+    // asked; `/` leaves it for a command — `/view` reads it whole, `/open`
+    // answers it on cawdev — and `a` (or `y`/`n`) brings the choice back.
+    if (key === '/' && (select.kind === 'question' || select.kind === 'permission')) {
+      this.mode = 'keys';
+      this.select = null;
+      this.answering = null;
+      this.deciding = null;
+      return this.type('command', 'cawdev ▸', '/');
+    }
 
     const outcome = select.key(key);
     if (!outcome) {
@@ -2287,8 +2307,9 @@ export class Attached {
     }
     return this.openPicker(new Select({
       kind: 'question',
-      title: clip(`${this.tagOf(this.current())} asks: ${asking.question.question}`,
+      title: clip(`${this.tagOf(this.current())} asks: ${String(asking.question.question).split('\n')[0]}`,
         Math.max(20, this.screen.width - 2)),
+      hint: '/view reads it all',
       rows: [
         ...options.map((option) => ({ id: option, label: option })),
         // Always last, and always there.
@@ -2316,7 +2337,10 @@ export class Attached {
       kind: 'permission',
       // The call, on the title, as well as printed in full above: the picker
       // may still be on screen when the transcript under it has moved on.
-      title: `${this.tagOf(this.current())} wants ${approval.toolName} · ${approval.summary}`,
+      // The first line only: a stage gate's summary is the whole plan, and
+      // `/view` is where it is read.
+      title: `${this.tagOf(this.current())} wants ${approval.toolName} · ${String(approval.summary ?? '').split('\n')[0]}`,
+      hint: '/view reads it all',
       rows: [
         { id: 'y', label: 'Allow once', hint: 'this call and no more' },
         // R78: the middle grant NAMES what it covers, and it says so in the
@@ -2831,7 +2855,8 @@ export class Attached {
       case 'open':
         return void this.openInBrowser();
       case 'view':
-        return rest.length ? void this.viewCard(rest) : this.viewOnCawdev();
+        if (rest.length) return void this.viewCard(rest);
+        return this.waitingOn(this.commandTarget()) ? this.openReader() : this.viewOnCawdev();
       case 'drop':
         return void this.dropCheckout();
       case 'close':
@@ -3250,6 +3275,9 @@ export class Attached {
   splitFrame() {
     const { width, height } = this.split.screen;
     const ink = this.ink;
+    if (this.reader) {
+      return composeFrame(width, height, [{ rect: { top: 0, left: 0, width, height }, lines: this.readerScreen(width, height) }]);
+    }
     const windows = this.windows();
     const inner = Math.max(8, width - 2);
 
@@ -3269,6 +3297,11 @@ export class Attached {
         + ' · / commands · tab next window');
     // A question or a request on screen says which window it came from.
     const from = banner.length ? [ink.bold(ink.warn(` from ${this.tagOf(current)}`))] : [];
+    // Under the banner and right above the line, so a long one never pushes
+    // it out of the window: the way to read all of it, and the other door.
+    // Also while its list is open, which hides the banner.
+    const whole = banner.length || this.waitingOn(this.commandTarget())
+      ? [ink.muted(' /view reads it all · /open answers it on cawdev')] : [];
     // The commands matching what is typed, above the line as in the footer —
     // advanced mode drew none, so enter took a highlighted command nobody saw.
     const matches = this.mode === 'typing' && this.input?.showing !== false ? this.matching() : { rows: [], at: 0 };
@@ -3278,7 +3311,7 @@ export class Attached {
     const completing = completionLines(
       matches.rows.slice(first, first + SPLIT_COMPLETIONS), matches.at - first, inner, ink,
     );
-    const fixed = [...from, ...banner, ...overlay, ...completing, input];
+    const fixed = [...from, ...banner, ...whole, ...overlay, ...completing, input];
     const promptRows = Math.max(PROMPT_ROWS, fixed.length + 5);
     // The roadmap across the top: as tall as its fullest column needs, never
     // more than a third of the screen, and never so tall that no window fits
@@ -3380,9 +3413,10 @@ export class Attached {
   }
 
   /**
-   * Every card of every project this machine serves, whatever its status —
-   * the strip draws them all, and `d` offers the PLANNED ones. One request
-   * per project, the board's own (`brief`, so no bodies). Needs a person's
+   * Every card AND ISSUE of every project this machine serves, whatever its
+   * status — the strip draws them all, and `d` offers the PLANNED cards and
+   * the CONFIRMED issues. Two requests per project, the two boards' own
+   * (`brief`, so no bodies). Needs a person's
    * session, like everything read off the roadmap here.
    *
    * A project that cannot be read keeps ITS last cards and no other's: this
@@ -3402,6 +3436,15 @@ export class Attached {
         for (const card of Array.isArray(cards) ? cards : []) {
           all.push({ ref: card.ref, title: card.title, slug, status: card.status, live: Boolean(card.activeRun) });
         }
+        // The issues are another list on the platform (R85), and were never
+        // read here: the strip drew a project's ideas and not one of its bugs.
+        const issues = await this.session.request(`/api/projects/${slug}/issues?brief=true`);
+        for (const issue of Array.isArray(issues) ? issues : []) {
+          all.push({
+            ref: issue.ref, title: issue.title, slug, status: issue.status,
+            live: Boolean(issue.activeRun), severity: issue.severity ?? 'MINOR',
+          });
+        }
         read.push(slug);
         this.gone.delete(slug);
       } catch (failure) {
@@ -3414,7 +3457,8 @@ export class Attached {
       }
     }
     this.cards = all;
-    this.planned = all.filter((card) => card.status === 'PLANNED');
+    // Ready to be developed: a planned card, or a confirmed issue.
+    this.planned = all.filter((card) => columnOf(card.status) === 'PLANNED');
     this.dirty = true;
     if (!hold) this.sayGone();
     return { signedIn: true, read, failed };
@@ -3449,7 +3493,7 @@ export class Attached {
     const counts = read.filter((slug) => shown.has(slug)).map((slug) => {
       const mine = this.cards.filter((card) => card.slug === slug);
       const tally = BOARD_COLUMNS
-        .map(([status, label]) => `${mine.filter((card) => card.status === status).length} ${label.toLowerCase()}`)
+        .map(([status, label]) => `${mine.filter((card) => columnOf(card.status) === status).length} ${label.toLowerCase()}`)
         .join(' · ');
       return `${slug}: ${tally}`;
     });
@@ -3465,8 +3509,8 @@ export class Attached {
   }
 
   /**
-   * `d`, or `/new dev` with nothing after it: the planned cards as a list, and
-   * the one picked is developed — `/new dev R3 @slug`, on this machine.
+   * `d`, or `/new dev` with nothing after it: the planned cards — and the
+   * confirmed issues — as a list, and the one picked is developed — `/new dev R3 @slug`, on this machine.
    */
   async pickPlanned(slug = null) {
     if (!this.requireSignIn('start a session')) return;
@@ -3499,17 +3543,20 @@ export class Attached {
     if (shown.length === 1 && !words.some((word) => word.startsWith('@'))) {
       words = [...words, `@${shown[0]}`];
     }
-    const bare = words.filter((word) => word && !word.startsWith('@') && word !== '--anyway');
+    const bare = words.filter((word) => word && !word.startsWith('@') && word !== '--anyway' && word !== '--again');
     if (bare.length === 1 && ['dev', 'code'].includes(bare[0].toLowerCase())) {
       const named = words.find((word) => word.startsWith('@'));
       await this.pickPlanned(named ? named.slice(1) : null);
       return;
     }
     const anyway = words.includes('--anyway');
+    // R369: the answer to "a session already finished here" — `--anyway`'s
+    // shape, for a different question.
+    const again = words.includes('--again');
     // `--codex`, `--claude`, `--agy`: this session's agent, over `/agent`'s.
     const flagged = words.find((word) => AGENT_FLAGS.has(word));
     let agent = flagged ? flagged.slice(2) : this.agent;
-    const parsed = parseNew(words.filter((word) => word !== '--anyway' && !AGENT_FLAGS.has(word)), {
+    const parsed = parseNew(words.filter((word) => word !== '--anyway' && word !== '--again' && !AGENT_FLAGS.has(word)), {
       // In advanced mode, among the projects it shows.
       projects: this.shownProjects(),
     });
@@ -3557,7 +3604,7 @@ export class Attached {
           // R150: the session writes the card first, then plans it.
           : ['runs/plan', { prompt: parsed.text }, 'a plan — it writes its card first']
         : ['runs', { entryNumber: parsed.ref }, `the development of ${parsed.ref}`];
-    const started = await this.startSession(parsed.slug, path, withAgent(body, agent), withWho(what, agent), anyway);
+    const started = await this.startSession(parsed.slug, path, withAgent(body, agent), withWho(what, agent), anyway, again);
     if (started && plan) {
       this.closeWindowOf(plan);
       this.focusOnArrival = plan.projectSlug;
@@ -3819,9 +3866,10 @@ export class Attached {
    * One POST that starts a session, aimed at THIS machine so its window opens
    * here. A usage window over the machine's threshold is refused by the
    * platform in a sentence; `--anyway` is the same decision the console's
-   * panel asks for.
+   * panel asks for. A card whose last session of that kind finished asks too
+   * (R369), and `--again` answers it.
    */
-  async startSession(slug, path, body, what, anyway) {
+  async startSession(slug, path, body, what, anyway, again = false) {
     try {
       await this.session.request(`/api/projects/${slug}/${path}`, {
         method: 'POST',
@@ -3829,15 +3877,20 @@ export class Attached {
           ...body,
           ...(this.runner?.id ? { targetRunnerId: this.runner.id } : {}),
           ...(anyway ? { acknowledgeUsage: true } : {}),
+          ...(again ? { again: true } : {}),
         },
       });
       this.say(this.ink.success(`  started ${what} on ${slug} — its window opens when this machine takes it`));
       this.note('');
       return true;
     } catch (failure) {
-      this.note(/usage|window/i.test(failure.message)
-        ? `${failure.message} — add --anyway to start it regardless`
-        : failure.message);
+      // R369's sentence is checked first: it is the one that names a session,
+      // and the usage test is loose enough to match words in other sentences.
+      this.note(/session that finished/.test(failure.message)
+        ? `${failure.message} — add --again to start it regardless`
+        : /usage|window/i.test(failure.message)
+          ? `${failure.message} — add --anyway to start it regardless`
+          : failure.message);
       return false;
     }
   }
@@ -3948,6 +4001,16 @@ export class Attached {
     if (!meta) {
       return this.note('/open needs a session — focus one');
     }
+    if (this.waitingOn(meta)) {
+      // Stopped on a question or a permission: the run page on cawdev, where
+      // the question panel and the decision are, whole.
+      const url = this.consoleUrl(meta.projectSlug ?? meta.view?.projectSlug, `runs/${meta.id}`);
+      if (!url) {
+        return this.note('cannot tell where this session is on cawdev');
+      }
+      this.openLink(url);
+      return this.note(`opened ${url}`);
+    }
     if (this.finishedPlan(meta)) {
       const ref = meta.view.entryRef;
       const board = /^i/i.test(ref) ? 'issues' : 'roadmap';
@@ -3989,6 +4052,129 @@ export class Attached {
     opener(url);
   }
 
+  /** What a session is stopped on — a question or a permission request — or null. */
+  waitingOn(meta) {
+    const run = meta ? this.runs.find((each) => each.id === meta.id) : null;
+    if (!run) return null;
+    const pending = this.pendingOn(run);
+    if (pending) return { kind: 'permission', pending };
+    const asking = this.askingOn(run);
+    return asking ? { kind: 'question', asking } : null;
+  }
+
+  /**
+   * `/view` on a session waiting for you: what it is waiting on, in FULL. In
+   * advanced mode the reader — the session's output and the request under
+   * it, over the whole screen, scrolled with the arrows (the wheel arrives as
+   * arrows there), PgUp/PgDn, g/G; esc closes it, and any other key closes it
+   * and does what it does (`a` answers, `y`/`n` decide). In the scrollback
+   * the request is printed whole, where the terminal scrolls it.
+   */
+  openReader() {
+    const meta = this.commandTarget();
+    if (!this.split) {
+      this.say('');
+      for (const line of this.requestLines(this.waitingOn(meta), this.screen.width)) this.say(line);
+      this.say('');
+      return this.note('');
+    }
+    this.reader = { runId: meta.id, top: null, room: 1, max: 0 };
+    this.dirty = true;
+    return this.note('');
+  }
+
+  /** The request a session waits on, every word of it. */
+  requestLines(waiting, width) {
+    const ink = this.ink;
+    if (!waiting) {
+      return [ink.muted('  no longer waiting — answered, decided, or gone')];
+    }
+    const room = Math.max(20, width - 4);
+    if (waiting.kind === 'question') {
+      const { question, yours, waitingOn } = waiting.asking;
+      return [
+        ink.bold(ink.accent(' question ')),
+        ...String(question.question ?? '').split('\n').flatMap((part) => wordWrap(part, room)).map((line) => `  ${line}`),
+        ...(question.options?.length
+          ? ['', ...question.options.map((option, i) => `  ${ink.success(String(i + 1))} ${option}`)]
+          : []),
+        '',
+        yours
+          ? `  ${ink.success('a')} ${ink.muted('answers it here · /open answers it on cawdev')}`
+          : ink.muted(`  waiting on ${waitingOn ?? 'somebody else'} — theirs to answer`),
+      ];
+    }
+    const approval = waiting.pending.approval ?? waiting.pending;
+    return [
+      `${ink.bold(ink.warn(' permission '))} ${ink.muted(`${approval.toolName ?? ''} · waiting since ${approval.askedAt?.slice(11, 19) ?? ''}`)}`,
+      ...String(approval.summary ?? '').split('\n').flatMap((part) => wordWrap(part, room)).map((line) => `  ${line}`),
+      ...(approval.toolInput && approval.toolInput !== approval.summary
+        ? ['', ink.muted('  input'), ...String(approval.toolInput).split('\n').map((line) => `  ${ink.text(line)}`)]
+        : []),
+      '',
+      ...permissionBanner(waiting.pending, width, ink, this.runner ?? {}).slice(2),
+    ];
+  }
+
+  /** The reader, drawn over the whole screen — see `readerFrame` in split.mjs. */
+  readerScreen(width, height) {
+    const ink = this.ink;
+    const meta = this.windows().find((each) => each.id === this.reader.runId)
+      ?? this.sessions.get(this.reader.runId) ?? { id: this.reader.runId };
+    const output = (this.lines.get(this.reader.runId) ?? []).map((line) => this.render(line));
+    const waiting = this.waitingOn(meta);
+    const request = this.requestLines(waiting, width - 2);
+    const n = this.windowNumberOf(meta.id);
+    const keys = waiting?.kind === 'permission'
+      ? 'y once · s session · n refuse'
+      : waiting?.asking?.yours ? 'a answer' : '';
+    const drawn = readerFrame(width, height, {
+      title: `${n ? `${n} ` : ''}${titleFor(meta, waiting ? `waiting for ${waiting.kind === 'question' ? 'an answer' : 'permission'}` : null)}`,
+      lines: [...output, ink.muted('─'.repeat(Math.min(40, width - 2))), ...request],
+      requestAt: output.length,
+      top: this.reader.top,
+      footer: keyList(['↑↓ scroll', 'PgUp/PgDn page', 'g/G top/end', 'esc close',
+        ...(keys ? [keys] : []), '/open on cawdev'], '', width - 2, ink),
+    }, ink);
+    Object.assign(this.reader, { top: drawn.top, max: drawn.max, room: drawn.room });
+    return drawn.lines;
+  }
+
+  /** Keys while the reader is open. */
+  onReaderKey(key) {
+    const reader = this.reader;
+    const move = (to) => {
+      reader.top = Math.min(Math.max(0, to), reader.max);
+      this.dirty = true;
+      return undefined;
+    };
+    const at = reader.top ?? 0;
+    switch (key) {
+      case `${ESC}[A`: case `${ESC}OA`: case 'k':
+        return move(at - 1);
+      case `${ESC}[B`: case `${ESC}OB`: case 'j':
+        return move(at + 1);
+      case `${ESC}[5~`: case 'b':
+        return move(at - reader.room);
+      case `${ESC}[6~`: case ' ':
+        return move(at + reader.room);
+      case `${ESC}[H`: case `${ESC}[1~`: case 'g':
+        return move(0);
+      case `${ESC}[F`: case `${ESC}[4~`: case 'G':
+        return move(reader.max);
+      case ESC: case 'q':
+        this.reader = null;
+        this.dirty = true;
+        return this.note('');
+      default:
+        // Anything else is what it always is — `a` answers, `y`/`n` decide,
+        // `/` a command — with the reader closed first.
+        this.reader = null;
+        this.dirty = true;
+        return this.onKey(key);
+    }
+  }
+
   /**
    * `/view` alone — the focused session's page on cawdev (its transcript,
    * stages, card and checkout). On the console this terminal signed in to:

package/runner/git-host.mjs

@@ -0,0 +1,263 @@
+// The git host's side of the runner — R379.
+//
+// The runner has only ever spoken to GitHub, through `gh`. A GitLab project
+// could be pushed to but not opened, found or merged against, and a run's link
+// to its pull request came back empty. This is the one place that knows there
+// are two: `adapterFor('github')` is the `gh` calls the daemon always made,
+// moved here without change; `adapterFor('gitlab')` is the same questions asked
+// of `glab`.
+//
+// No dependencies, and in `tools/runner/` rather than `tools/lib/` on purpose:
+// this half of the tree is open-licence and must not import the other.
+
+import { spawn } from 'node:child_process';
+
+// --- the repository --------------------------------------------------------------
+
+/**
+ * `{ host, path }` for an origin URL, or null when it is not one we can read.
+ * `git@h:a/b/c.git`, `https://h/a/b/c(.git)` and `ssh://git@h:2222/a/b.git` —
+ * `path` is the repository's path on the host without `.git`, subgroups kept.
+ */
+export function repoOf(originUrl) {
+  const url = (originUrl ?? '').trim();
+  if (!url) {
+    return null;
+  }
+  const scp = /^[\w.-]+@([\w.-]+):(?!\/\/)(.+?)(?:\.git)?\/?$/.exec(url);
+  if (scp) {
+    return { host: scp[1], path: scp[2].replace(/^\/+/, '') };
+  }
+  const full = /^[a-z][a-z0-9+.-]*:\/\/(?:[^@/]+@)?([\w.-]+)(?::\d+)?\/(.+?)(?:\.git)?\/?$/i.exec(url);
+  if (full) {
+    return { host: full[1], path: full[2] };
+  }
+  return null;
+}
+
+/**
+ * Which host's CLI to use: `'github'` or `'gitlab'`.
+ *
+ * A host the project DECLARED wins; otherwise a host name containing `gitlab` is
+ * GitLab; otherwise GitHub, which is what the runner has always assumed — so a
+ * project that never set anything behaves exactly as it did.
+ */
+export function hostFor({ declared = null, originUrl = null } = {}) {
+  const said = String(declared ?? '').trim().toUpperCase();
+  if (said === 'GITLAB') return 'gitlab';
+  if (said === 'GITHUB') return 'github';
+  const repo = repoOf(originUrl);
+  return repo && /gitlab/i.test(repo.host) ? 'gitlab' : 'github';
+}
+
+/**
+ * A link somebody can click to open a pull or merge request themselves. It
+ * always contains `/compare/` — the platform tells a real pull request from this
+ * by that, and nothing else.
+ */
+export function compareUrl(host, repo, base, branch) {
+  if (!repo) {
+    return null;
+  }
+  const name = encodeURIComponent(branch);
+  if (host === 'gitlab') {
+    return `https://${repo.host}/${repo.path}/-/compare/${encodeURIComponent(base || 'main')}...${name}`;
+  }
+  return `https://${repo.host}/${repo.path}/compare/${name}`;
+}
+
+/** The merge request URL a `glab mr create` printed, or null. */
+export function mrUrlIn(text) {
+  const found = String(text ?? '').match(/https?:\/\/\S+?\/-\/merge_requests\/\d+/g);
+  return found ? found[found.length - 1] : null;
+}
+
+/** The iid at the end of a merge request URL. */
+export function iidOf(url) {
+  return /\/merge_requests\/(\d+)/.exec(url ?? '')?.[1] ?? null;
+}
+
+const GITLAB_WAIT = new Set(['checking', 'unchecked', 'preparing', 'ci_still_running']);
+const GITLAB_BLOCKED = new Set([
+  'not_approved', 'blocked_status', 'ci_must_pass', 'discussions_not_resolved',
+  'draft_status', 'not_open', 'requested_changes',
+]);
+
+/**
+ * What `glab mr view --output json` says about whether a merge request can
+ * merge: `CONFLICT`, `UNKNOWN` (the host has not computed it — wait),
+ * `NOT_PERMITTED` or `KNOWN`.
+ */
+export function gitlabMergeability(view) {
+  if (!view || typeof view !== 'object') {
+    return 'KNOWN';
+  }
+  const status = String(view.detailed_merge_status ?? '').toLowerCase();
+  if (view.has_conflicts === true || status === 'conflict') return 'CONFLICT';
+  if (GITLAB_WAIT.has(status)) return 'UNKNOWN';
+  if (GITLAB_BLOCKED.has(status)) return 'NOT_PERMITTED';
+  return 'KNOWN';
+}
+
+// --- running a CLI ---------------------------------------------------------------
+
+/** Runs `bin` and hands back everything it said, including on failure. */
+export function runCli(bin, cwd, args) {
+  return new Promise((resolvePromise) => {
+    const child = spawn(bin, args, { cwd, stdio: ['ignore', 'pipe', 'pipe'] });
+    let out = '';
+    let err = '';
+    child.stdout.on('data', (chunk) => (out += chunk));
+    child.stderr.on('data', (chunk) => (err += chunk));
+    child.on('error', (failure) => resolvePromise({
+      code: -1,
+      out: '',
+      err: failure.code === 'ENOENT'
+        ? `${bin} is not installed on this machine, so it cannot talk to the git host.`
+        : failure.message,
+    }));
+    // `close`, not `exit`: stdout may still hold data when the process exits.
+    child.on('close', (code) => resolvePromise({ code, out: out.trim(), err: err.trim() }));
+  });
+}
+
+function parse(text) {
+  try {
+    return JSON.parse(text || '{}');
+  } catch {
+    return null;
+  }
+}
+
+// --- the adapters ----------------------------------------------------------------
+
+const github = {
+  name: 'github',
+  bin: 'gh',
+  noun: 'pull request',
+  installHint: 'brew install gh && gh auth login',
+
+  run: (cwd, args) => runCli('gh', cwd, args),
+
+  /** The URL of the pull request for a branch, or null. */
+  async find(cwd, branch) {
+    const asked = await runCli('gh', cwd, ['pr', 'view', branch, '--json', 'url', '--jq', '.url']);
+    return asked.code === 0 && asked.out ? asked.out : null;
+  },
+
+  create: (cwd, { branch, base, title, body }) => runCli('gh', cwd, [
+    'pr', 'create',
+    '--head', branch,
+    ...(base ? ['--base', base] : []),
+    '--title', title,
+    '--body', body,
+  ]),
+
+  /** The URL a successful create printed. */
+  urlOf: (created) => created.out.split('\n').pop().trim(),
+
+  /** `'UNKNOWN'` while the host has not computed it; anything else is "stop waiting". */
+  async mergeability(cwd, url) {
+    const asked = await runCli('gh', cwd, ['pr', 'view', url, '--json', 'mergeable,mergeStateStatus']);
+    if (asked.code !== 0) return 'KNOWN';
+    const view = parse(asked.out);
+    return view && view.mergeable === 'UNKNOWN' ? 'UNKNOWN' : 'KNOWN';
+  },
+
+  merge: (cwd, url, { mergeCommit }) => runCli('gh', cwd,
+    ['pr', 'merge', url, mergeCommit ? '--merge' : '--squash', '--delete-branch']),
+
+  /** Why a merge was refused, when the host can say: `CONFLICT`, `NOT_PERMITTED` or null. */
+  async refusal(cwd, url) {
+    const asked = await runCli('gh', cwd, ['pr', 'view', url, '--json', 'mergeable,mergeStateStatus']);
+    if (asked.code !== 0) return null;
+    const view = parse(asked.out);
+    if (!view) return null;
+    if (view.mergeable === 'CONFLICTING' || view.mergeStateStatus === 'DIRTY') return 'CONFLICT';
+    if (view.mergeStateStatus === 'BLOCKED') return 'NOT_PERMITTED';
+    return null;
+  },
+
+  /** The compare link fallback — only for github.com, as it always was. */
+  fallbackLink(repo, _base, branch) {
+    return repo && repo.host === 'github.com' ? compareUrl('github', repo, null, branch) : null;
+  },
+};
+
+// `glab mr merge` queues an auto-merge by default on versions that have the
+// flag; asked once per process whether this glab does.
+let glabHasAutoMerge = null;
+
+async function autoMergeFlag(cwd) {
+  if (glabHasAutoMerge === null) {
+    const help = await runCli('glab', cwd, ['mr', 'merge', '--help']);
+    const has = /--auto-merge/.test(`${help.out}\n${help.err}`);
+    // Only a real answer is remembered: glab not installed yet, or a failed first
+    // call, must not decide for the life of the daemon.
+    if (help.code !== 0) {
+      return has ? ['--auto-merge=false'] : [];
+    }
+    glabHasAutoMerge = has;
+  }
+  return glabHasAutoMerge ? ['--auto-merge=false'] : [];
+}
+
+const gitlab = {
+  name: 'gitlab',
+  bin: 'glab',
+  noun: 'merge request',
+  installHint: 'install glab and run `glab auth login --hostname <your GitLab host>`',
+
+  run: (cwd, args) => runCli('glab', cwd, args),
+
+  async find(cwd, branch) {
+    const asked = await runCli('glab', cwd, ['mr', 'list', '--source-branch', branch, '--output', 'json']);
+    if (asked.code !== 0) return null;
+    const rows = parse(asked.out);
+    const first = Array.isArray(rows) ? rows[0] : null;
+    return first?.web_url ?? null;
+  },
+
+  create: (cwd, { branch, base, title, body }) => runCli('glab', cwd, [
+    'mr', 'create',
+    '--source-branch', branch,
+    ...(base ? ['--target-branch', base] : []),
+    '--title', title,
+    '--description', body,
+    '--yes',
+  ]),
+
+  urlOf: (created) => mrUrlIn(`${created.out}\n${created.err}`),
+
+  async mergeability(cwd, url) {
+    const iid = iidOf(url);
+    if (!iid) return 'KNOWN';
+    const asked = await runCli('glab', cwd, ['mr', 'view', iid, '--output', 'json']);
+    if (asked.code !== 0) return 'KNOWN';
+    return gitlabMergeability(parse(asked.out)) === 'UNKNOWN' ? 'UNKNOWN' : 'KNOWN';
+  },
+
+  async merge(cwd, url, { mergeCommit }) {
+    const iid = iidOf(url) ?? url;
+    return runCli('glab', cwd, [
+      'mr', 'merge', iid, '--yes', '--remove-source-branch',
+      ...(mergeCommit ? [] : ['--squash']),
+      ...(await autoMergeFlag(cwd)),
+    ]);
+  },
+
+  async refusal(cwd, url) {
+    const iid = iidOf(url);
+    if (!iid) return null;
+    const asked = await runCli('glab', cwd, ['mr', 'view', iid, '--output', 'json']);
+    if (asked.code !== 0) return null;
+    const verdict = gitlabMergeability(parse(asked.out));
+    return verdict === 'CONFLICT' || verdict === 'NOT_PERMITTED' ? verdict : null;
+  },
+
+  fallbackLink: (repo, base, branch) => compareUrl('gitlab', repo, base, branch),
+};
+
+export function adapterFor(host) {
+  return host === 'gitlab' ? gitlab : github;
+}