cawdev-cli 1.0.10-beta → 1.0.11-beta

package/lib/background-shells.mjs

@@ -17,6 +17,15 @@
  * - `BashOutput` (or `TaskOutput`) reads one by `bash_id`/`shell_id`/`task_id`;
  *   the command is over only when a read says a status other than running;
  * - `KillShell`/`KillBash`/`TaskStop` ends one.
+ * And a delegation started in the background: `Agent` (or `Task`) with
+ * `run_in_background: true`, or whose result says "Async agent launched" —
+ * its id is the result's `agentId: <id>`. It is over when a `<task-notification>`
+ * naming that id arrives with a status other than running, when a
+ * `TaskOutput` read says so, or when `TaskStop` ends it. R6 on saasng is why:
+ * IMPLEMENT handed the whole card to two background agents, said "both agents
+ * are still working in the background" and ended its turn; the walk marched on
+ * and the run FINISHED with nothing built.
+ *
  * A command whose id cannot be read off its result stays unfinished: failing
  * loudly and re-running a stage costs a turn, calling unproven work proven
  * costs somebody's afternoon.
@@ -26,6 +35,7 @@
  */
 
 const READS = new Set(['BashOutput', 'TaskOutput']);
+const DELEGATES = new Set(['Agent', 'Task']);
 const KILLS = new Set(['KillShell', 'KillBash', 'TaskStop']);
 
 /** The text of a tool_result's content, whichever of its two shapes it came in. */
@@ -44,15 +54,19 @@ function shellIdOf(input) {
 
 export class BackgroundShells {
   constructor() {
-    /** tool_use id of each background `Bash` → { command, shellId, done }. */
+    /** tool_use id of each background `Bash` or `Agent` → { command, shellId, done }. */
     this.started = new Map();
+    /** tool_use id of each `Agent` call not yet known to be in the background → its label and input. */
+    this.delegations = new Map();
     /** tool_use id of each read → the shell id it read. */
     this.reads = new Map();
   }
 
   /** One stream-json event. Anything that is not about a shell is ignored. */
   observe(event) {
-    const parts = event?.message?.content;
+    const content = event?.message?.content;
+    if (event?.type === 'user') this.notified(textOf(content));
+    const parts = content;
     if (!Array.isArray(parts)) return;
     if (event.type === 'assistant') {
       for (const part of parts) {
@@ -63,6 +77,9 @@ export class BackgroundShells {
             shellId: null,
             done: false,
           });
+        } else if (DELEGATES.has(part.name)) {
+          const label = `Agent: ${String(part.input?.description ?? part.input?.subagent_type ?? 'a delegation').trim()}`;
+          this.delegations.set(part.id, { label, background: part.input?.run_in_background === true });
         } else if (READS.has(part.name)) {
           const id = shellIdOf(part.input);
           if (id) this.reads.set(part.id, id);
@@ -76,6 +93,17 @@ export class BackgroundShells {
       for (const part of parts) {
         if (part?.type !== 'tool_result') continue;
         const text = textOf(part.content);
+        const delegation = this.delegations.get(part.tool_use_id);
+        if (delegation) {
+          this.delegations.delete(part.tool_use_id);
+          // A foreground delegation's result IS its end; only one that came
+          // back as "launched" is still out there.
+          if (delegation.background || /async agent launched/i.test(text)) {
+            const id = /\bagentId:?\s*([A-Za-z0-9_-]+)/i.exec(text);
+            this.started.set(part.tool_use_id, { command: delegation.label, shellId: id ? id[1] : null, done: false });
+          }
+          continue;
+        }
         const launched = this.started.get(part.tool_use_id);
         if (launched && !launched.shellId) {
           const id = /\bID:?\s*([A-Za-z0-9_-]+)/.exec(text);
@@ -94,6 +122,20 @@ export class BackgroundShells {
     }
   }
 
+  /**
+   * The CLI tells a session that a background task ended with a
+   * `<task-notification>` in a user turn — `<task-id>` and `<status>`. Any
+   * status but running is over: a failed or killed agent is not one to wait for.
+   */
+  notified(text) {
+    if (!text || !text.includes('<task-notification>')) return;
+    for (const block of text.split('<task-notification>').slice(1)) {
+      const id = /<task-id>\s*([^<\s]+)\s*<\/task-id>/.exec(block);
+      const status = /<status>\s*([^<\s]+)\s*<\/status>/.exec(block);
+      if (id && status && status[1].toLowerCase() !== 'running') this.finish(id[1]);
+    }
+  }
+
   finish(shellId) {
     if (!shellId) return;
     for (const each of this.started.values()) {
@@ -101,7 +143,7 @@ export class BackgroundShells {
     }
   }
 
-  /** The commands started in the background whose end this session never saw. */
+  /** The commands and delegations started in the background whose end this session never saw. */
   unfinished() {
     return [...this.started.values()].filter((each) => !each.done).map((each) => each.command);
   }

package/lib/roadmap-format.mjs

@@ -253,6 +253,12 @@ export function parseRoadmap(text) {
         entry.targetVersion = target[1].trim();
         continue;
       }
+      // R378. The versions an issue was found in, comma separated.
+      const affects = /^Affects:\s*(.+)$/.exec(line.trim());
+      if (affects) {
+        entry.affectedVersions = affects[1].split(',').map((v) => v.trim()).filter(Boolean);
+        continue;
+      }
       const estimate = /^Estimate:\s*(.+)$/.exec(line.trim());
       if (estimate) {
         const n = Number(estimate[1].trim());
@@ -534,6 +540,10 @@ function renderEntry(entry) {
   if (entry.targetVersion && !entry.version) {
     lines.push(`Target: ${entry.targetVersion}`);
   }
+  // R378. Where an issue was found; history, so it stays once the issue ships.
+  if (entry.affectedVersions?.length) {
+    lines.push(`Affects: ${entry.affectedVersions.join(', ')}`);
+  }
 
   // Each status writes only what it currently claims. A MERGED entry keeps its
   // branch in the database as history, but the file must not print it: the

package/mcp/README.md

@@ -85,7 +85,8 @@ without opening pull requests has none to give it.
 when you name no status is the project's rule, per door, and the default for a
 card or issue an agent files is the backlog: waiting until a person or a sprint
 brings it in, in no sprint and on no board column. Its origin names your
-session and the card your run was on. Name a status (`CONSIDERING`, `NEW`) when
+session and the card your run was on. A plan session's card lands where the console's
+do (R380). Name a status (`CONSIDERING`, `NEW`) when
 you mean the pipeline. Giving a backlog card a sprint moves it to the first
 status of its kind; moving a card to `BACKLOG` takes it out of its sprint.
 
@@ -171,7 +172,7 @@ what you are allowed to do.
 | `roadmap_list` | Entries, optionally by status. `brief` omits bodies — use it to survey. |
 | `roadmap_get` | One entry in full: its body, **the plan agreed for it**, and the discussion on it. |
 | `roadmap_create` | Create an entry; the platform allocates its permanent number. |
-| `roadmap_update` | Title, body, section, related ids, the cards it starts coding after (`after` — R181), when it is due and how big it is (`due` — R351: an ISO date, `""` clears; `estimate`: a positive number, `0` clears), the version it is meant for (`targetVersion` — R358, `""` clears; since R362 it must be one the project defined under Project settings → Versions, and any other name is refused), and who it is assigned to (`assignee` — R331: a username, `""` clears; `roadmap_list`/`issue_list` take `assignee` too, and `me` means the token's owner). |
+| `roadmap_update` | Title, body, section, related ids, the cards it starts coding after (`after` — R181), when it is due and how big it is (`due` — R351: an ISO date, `""` clears; `estimate`: a positive number, `0` clears), the version it is meant for (`targetVersion` — R358, `""` clears; since R362 it must be one the project defined under Project settings → Versions, and any other name is refused), the versions an issue was found in (`affectedVersions` — R378, issues only: names the project defined or shipped in, `[]` clears), and who it is assigned to (`assignee` — R331: a username, `""` clears; `roadmap_list`/`issue_list` take `assignee` too, and `me` means the token's owner). |
 | `roadmap_comment` | Say something *beside* an entry rather than inside it. |
 | `done_when_tick` | Tick (or untick) one numbered item of the card's Done-when checklist as built, with one line of evidence (R368). `task_current` lists the items. Defaults to the run's own card and refuses another; the reviewer's column is a person's and no token can set it. |
 | `roadmap_set_status` | Move an entry, carrying whatever the status requires. |

package/mcp/server.mjs

@@ -685,7 +685,8 @@ const TOOLS = [
       'project decides where a card you file starts — the BACKLOG by default for a card an ' +
       'agent files, waiting until a person or a sprint brings it in — unless you say ' +
       'otherwise; a status that requires something must be given it. A card in the BACKLOG ' +
-      'holds no sprint: giving it one moves it to CONSIDERING.',
+      'holds no sprint: giving it one moves it to CONSIDERING. A plan session\'s card lands ' +
+      'where the console\'s do (R380).',
     inputSchema: {
       type: 'object',
       properties: {
@@ -866,6 +867,12 @@ const TOOLS = [
           description:
             'How much it matters; it does not reorder the board. Leave out for MEDIUM.',
         },
+        affectedVersions: {
+          type: 'array',
+          items: { type: 'string' },
+          description:
+            'Versions the project defined or shipped in where this issue was found — R378. Any other name is refused.',
+        },
       },
       required: ['title', 'severity'],
     },
@@ -873,7 +880,7 @@ const TOOLS = [
       const slug = await resolveProject(config, args.project);
       const issue = await api(config, `/api/projects/${slug}/issues`, {
         method: 'POST',
-        body: pick(args, ['title', 'body', 'severity', 'status', 'related', 'tags', 'assignee', 'priority']),
+        body: pick(args, ['title', 'body', 'severity', 'status', 'related', 'tags', 'assignee', 'priority', 'affectedVersions']),
       });
       return `Filed ${refOf(issue)} in ${slug}.\n\n${formatEntry(issue, {})}`;
     },
@@ -993,6 +1000,13 @@ const TOOLS = [
             'The card this one sits under (an epic), e.g. "R300". "" takes the card out of its ' +
             'parent; leave out to leave it alone. Same rules as roadmap_create.',
         },
+        affectedVersions: {
+          type: 'array',
+          items: { type: 'string' },
+          description:
+            'Issues only (R378): the versions the project defined or shipped in where it was found. ' +
+            'Leave out to leave them alone; [] clears them. A roadmap card refuses a non-empty list.',
+        },
       },
       required: ['number'],
     },
@@ -1003,7 +1017,7 @@ const TOOLS = [
         // pick keeps a present 0, which is how a card leaves its sprint.
         body: pick(args, [
           'title', 'body', 'section', 'related', 'after', 'sprint', 'tags', 'assignee', 'priority',
-          'due', 'estimate', 'targetVersion', 'parent',
+          'due', 'estimate', 'targetVersion', 'parent', 'affectedVersions',
         ]),
       });
       return `Updated ${refOf(entry)}.\n\n${formatEntry(entry, {})}`;
@@ -2341,6 +2355,8 @@ function formatEntry(entry, { brief, comments, plan }) {
   if (entry.estimate) lines.push(`  estimate: ${entry.estimate}`);
   // R358. Printed until the card ships; `version` says where it did.
   if (entry.targetVersion && !entry.version) lines.push(`  target: ${entry.targetVersion}`);
+  // R378. History, not plan: still printed once the issue has shipped.
+  if (entry.affectedVersions?.length) lines.push(`  affects: ${entry.affectedVersions.join(', ')}`);
   // R257. Always printed when the card has one, so a reader's shape does not
   // depend on which tool printed the card; a closed sprint says so.
   if (entry.sprint) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cawdev-cli",
-  "version": "1.0.10-beta",
+  "version": "1.0.11-beta",
   "description": "cawdev's terminal client and runner daemon — zero dependencies, on purpose",
   "type": "module",
   "bin": {

package/runner/README.md

@@ -469,7 +469,7 @@ this machine serves — unless the command names it with `@project`, or
 advanced mode is narrowed to ONE project (`/projects`), which is a choice
 already made rather than a guess. Never guessed from the focused window, nor
 from a machine serving just one, since a session on the wrong project is a
-card planned or a branch cut in the wrong repository. `/new dev` alone and `d` list the planned cards of every project,
+card planned or a branch cut in the wrong repository. `/new dev` alone and `d` list the planned cards and the confirmed issues of every project,
 each with its own, so they ask nothing more. A usage window over this machine's threshold is refused in a
 sentence; `--anyway` starts it regardless, the same decision the console's
 panel asks for. All four commands need you signed in (`/login`), and they work
@@ -575,7 +575,12 @@ serves as a small board — Considering, Planned and In development side by
 side, one line per card, `●` on a card with a session running now; Merged,
 Shipped and Declined — work that is over, and only grows — are counts beside
 the project's name (`1 merged · 2 shipped`), as the console's board folds its
-own last columns. As tall as the fullest column, never more than a
+own last columns. The Backlog is a count there too, first (`3 backlog`): since
+R371 it is where a new issue lands, and it would be the first column to go. **Issues are on it too** (R85's other board, read from
+`/issues` beside `/roadmap`): a NEW issue sits in Considering and a CONFIRMED
+one in Planned — their counterparts — first in the column and most severe first,
+so a `+N more` never hides a critical defect, with the ref (`i12`) in the colour
+of its severity. As tall as the fullest column, never more than a
 third of the screen, and gone before the windows are on a short terminal.
 When the room runs out it is SAID: a column ends in `+N more`, empty columns
 go first when the width does, then whole columns (Considering, then Planned —

package/runner/attach.mjs

@@ -61,7 +61,7 @@ import { clip, keyList, padVisible, painter, stripAnsi, visibleWidth, wrap } fro
 import { restartNeededFor } from '../lib/runner-config.mjs';
 import {
   BOARD_COLUMNS, MIN_ZONE_HEIGHT, PROMPT_ROWS, SplitScreen, readerFrame, tabsLine, visibleSessions, actionsFor, composeFrame,
-  carriesOnHere, builtNothing, cardLines, cardTitleFor, commandWords, wordsText, subtitleFor, agentModelFor, wordWrap, isAutoCheckout, isPullRequest, parseNew, roadmapStrip, sessionTag, splitLayout, titleFor, toneFor,
+  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';
@@ -3413,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
@@ -3435,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) {
@@ -3447,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 };
@@ -3482,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}`;
     });
@@ -3498,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;

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;
+}