@danypops/tickets 0.10.4 → 0.11.0

package/README.md

@@ -45,6 +45,8 @@ bun run src/cli/index.ts daemon start
 bun run src/cli/index.ts daemon stop      # asks it to shut down gracefully
 bun run src/cli/index.ts daemon restart
 
+# Reports capabilities plus local read/write readiness and missing setting names.
+# It never probes provider connectivity and never returns credential values.
 bun run src/cli/index.ts backends
 bun run src/cli/index.ts list -b github --status todo
 # get includes fixVersions, issueLinks, externalLinks (Jira "Web Links", e.g.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danypops/tickets",
-  "version": "0.10.4",
+  "version": "0.11.0",
   "description": "Unified CLI, daemon, and TypeScript library for issue tracking across GitHub, GitLab, and Jira.",
   "type": "module",
   "license": "MIT",
@@ -24,9 +24,9 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@danypops/vehicle-core": "^0.12.5",
-    "@danypops/vehicle-server": "^0.18.2",
-    "@danypops/vehicle-client": "^0.7.0",
+    "@danypops/vehicle-core": "^0.13.0",
+    "@danypops/vehicle-server": "^0.18.4",
+    "@danypops/vehicle-client": "^0.7.1",
     "@danypops/enigma-client": "^0.6.1",
     "@gitbeaker/rest": "^43.8.0",
     "commander": "^12.1.0",

package/src/agent-tools/tickets-vehicle.ts

@@ -63,7 +63,8 @@ function definedEntriesOnly(input: Record<string, unknown>): Record<string, unkn
 const OPERATIONS: readonly OperationSpec[] = [
   {
     action: "backends.list",
-    description: "Lists every configured backend name (github, gitlab, jira, ...).",
+    description:
+      "Lists configured backends with capabilities and local credential-safe read/write readiness. Connectivity is not probed and is always reported as not_checked.",
     effect: "read",
     properties: {},
     required: [],
@@ -135,6 +136,28 @@ const OPERATIONS: readonly OperationSpec[] = [
     properties: { ref: stringProp, body: stringProp },
     required: ["ref", "body"],
   },
+  {
+    action: "issue.approve",
+    description: "Approves a pull request / merge request on a live backend (GitHub, GitLab) -- a real, externally visible write.",
+    effect: "external-write",
+    properties: { ref: stringProp, body: stringProp },
+    required: ["ref"],
+  },
+  {
+    action: "issue.request_changes",
+    description:
+      "Requests changes on a pull request on a live backend -- a real, externally visible write. GitHub only: GitLab has no REST endpoint for this.",
+    effect: "external-write",
+    properties: { ref: stringProp, body: stringProp },
+    required: ["ref", "body"],
+  },
+  {
+    action: "issue.merge",
+    description: "Merges a pull request / merge request on a live backend (GitHub, GitLab) -- a real, externally visible write.",
+    effect: "external-write",
+    properties: { ref: stringProp, method: stringProp },
+    required: ["ref"],
+  },
   {
     action: "ledger.search",
     description: "Searches the local pooled-issue ledger (no live backend call).",
@@ -274,13 +297,14 @@ const OPERATIONS: readonly OperationSpec[] = [
 ];
 
 /**
- * The five discover.* operations only ever succeed against a backend whose
- * repository implements the matching optional capability (Jira today,
- * structurally -- never a hardcoded backend name). An operation none of the
- * currently configured backends could possibly satisfy is marked
- * unavailable so it never appears in the LLM's callable tool list in the
- * first place, instead of being offered and then failing with
- * NotSupportedError on the first real call.
+ * The five discover.* operations, plus the three pull-request-review operations below,
+ * only ever succeed against a backend whose repository implements the matching optional
+ * capability (structurally -- never a hardcoded backend name: discover.* is Jira-only
+ * today, issue.approve/issue.merge need PullRequestReviewable (GitHub, GitLab both),
+ * issue.request_changes needs PullRequestChangesRequestable (GitHub only)). An operation
+ * none of the currently configured backends could possibly satisfy is marked unavailable
+ * so it never appears in the LLM's callable tool list in the first place, instead of being
+ * offered and then failing with NotSupportedError on the first real call.
  */
 const DISCOVER_AVAILABILITY: readonly { action: TicketOperation; capability: keyof BackendCapabilities; reason: string }[] = [
   { action: "discover.fields", capability: "supportsFieldDiscovery", reason: "no configured backend supports field discovery (Jira only)" },
@@ -304,14 +328,31 @@ const DISCOVER_AVAILABILITY: readonly { action: TicketOperation; capability: key
     capability: "supportsBoardFilterDiscovery",
     reason: "no configured backend supports board filter discovery (Jira only)",
   },
+  {
+    action: "issue.approve",
+    capability: "supportsPullRequestReview",
+    reason: "no configured backend supports pull request review (GitHub, GitLab)",
+  },
+  {
+    action: "issue.merge",
+    capability: "supportsPullRequestReview",
+    reason: "no configured backend supports pull request review (GitHub, GitLab)",
+  },
+  {
+    action: "issue.request_changes",
+    capability: "supportsPullRequestChangesRequest",
+    reason: "no configured backend supports requesting changes on a pull request (GitHub only)",
+  },
 ];
 
 /**
- * Re-syncs the five discover.* operations' availability against the
- * service's current backend set -- called once right after the registry is
- * built, and again after every live backend refresh (config.ts's
- * createBackendRefreshTask), so a Jira credential added or removed at
- * runtime flips these tools' visibility without a daemon restart.
+ * Re-syncs every capability-gated operation's availability (the five discover.* operations
+ * plus issue.approve/issue.request_changes/issue.merge) against the service's current
+ * backend set -- called once right after the registry is built, and again after every live
+ * backend refresh (config.ts's createBackendRefreshTask), so a Jira credential added or a
+ * GitHub/GitLab backend added or removed at runtime flips these tools' visibility without a
+ * daemon restart. Name kept from before pull-request support existed -- still exported and
+ * called by that name from bootstrap.ts and existing tests.
  */
 export function syncDiscoverAvailability(registry: VehicleRegistry, service: TicketService): void {
   const capabilities = service.backendCapabilities();

package/src/cli/index.ts

@@ -124,6 +124,32 @@ program
     await withClient((client) => client.call("issue.children", { ref }));
   });
 
+program
+  .command("approve <ref>")
+  .description("approve a pull request / merge request (GitHub, GitLab)")
+  .option("--body <text>", "optional review comment (GitHub only -- GitLab's approve endpoint has no comment body)")
+  .action(async (ref: string, opts) => {
+    await withClient((client) => client.call("issue.approve", { ref, body: opts.body }));
+  });
+
+program
+  .command("request-changes <ref> <body>")
+  .description("request changes on a pull request -- GitHub only, GitLab has no such REST endpoint")
+  .action(async (ref: string, body: string) => {
+    await withClient((client) => client.call("issue.request_changes", { ref, body }));
+  });
+
+program
+  .command("merge <ref>")
+  .description("merge a pull request / merge request (GitHub, GitLab)")
+  .option(
+    "--method <method>",
+    "merge | squash | rebase (GitLab: only squash is distinct from a plain merge; rebase falls back to a plain merge)",
+  )
+  .action(async (ref: string, opts) => {
+    await withClient((client) => client.call("issue.merge", { ref, method: opts.method }));
+  });
+
 const comment = program.command("comment").description("comment operations");
 
 comment
@@ -160,7 +186,7 @@ ledger
 
 program
   .command("backends")
-  .description("list configured backend names")
+  .description("list configured backends, capabilities, and local read/write readiness (no connectivity probe)")
   .action(async () => {
     await withClient((client) => client.call("backends.list", {}));
   });

package/src/github/github.ts

@@ -22,7 +22,20 @@
 import { RequestError } from "@octokit/request-error";
 import { Octokit } from "octokit";
 import { ApiError, AuthRequiredError, BackendConfigurationError, BackendConnectionError, IssueNotFoundError } from "../issue/errors.js";
-import type { Comment, CreateInput, Issue, ListFilter, parsePriority, Status, UpdateInput } from "../issue/issue.js";
+import type {
+  Comment,
+  CreateInput,
+  Issue,
+  ListFilter,
+  MergeableState,
+  PullRequestDetails,
+  PullRequestReviewer,
+  parsePriority,
+  Status,
+  UpdateInput,
+} from "../issue/issue.js";
+import type { BackendConfigurationReadiness } from "../issue/repository.js";
+import { classifyBackendTransportFailure } from "../issue/transport-error.js";
 
 const DEFAULT_TIMEOUT_MS = 30_000;
 
@@ -54,7 +67,10 @@ interface GhIssue {
   labels: (GhLabel | string)[];
   created_at: string;
   updated_at: string;
-  pull_request?: unknown;
+  /** The Issues API's own PR stub -- confirmed against @octokit/openapi-types' "issue" schema: only these fields, never base/head/mergeable/diffStat/requestedReviewers. See github.ts's get()/pullRequestDetailsFromIssue for why those need a dedicated pulls.get() call instead. */
+  pull_request?: { merged_at: string | null };
+  /** A real top-level field on the Issues API's own "issue" schema (not nested under pull_request) -- free at list()/get() time. */
+  draft?: boolean;
 }
 interface GhComment {
   id: number;
@@ -63,6 +79,24 @@ interface GhComment {
   updated_at: string;
   user: GhUser | null;
 }
+/** The dedicated Pulls API's full shape (GET /pulls/{pull_number}) -- only reachable via a second call from get(), never from the Issues API list()/get() calls above. */
+interface GhPullRequestFull {
+  base: { ref: string; sha: string };
+  head: { ref: string; sha: string };
+  draft?: boolean;
+  merged: boolean;
+  merged_at: string | null;
+  mergeable: boolean | null;
+  mergeable_state: string;
+  additions: number;
+  deletions: number;
+  changed_files: number;
+  requested_reviewers?: GhUser[] | null;
+}
+interface GhReview {
+  user: GhUser | null;
+  state: string;
+}
 
 export class GitHubRepository {
   readonly name: string;
@@ -104,6 +138,32 @@ export class GitHubRepository {
     if (this.readOnly) throw new AuthRequiredError("github", "GITHUB_TOKEN");
   }
 
+  configurationReadiness(): BackendConfigurationReadiness {
+    const repositoryMissing = this.repo ? [] : ["GITHUB_REPO"];
+    const writeMissing = [...repositoryMissing, ...(this.readOnly ? ["GITHUB_TOKEN"] : [])];
+    return {
+      backendType: "github",
+      connectivity: "not_checked",
+      read: this.repo
+        ? { state: "ready", missingConfiguration: [] }
+        : {
+            state: "partial",
+            missingConfiguration: repositoryMissing,
+            recovery:
+              "Set GITHUB_REPO (or the backend's repo setting) for repository list/get/comment operations; organization search remains available.",
+          },
+      write:
+        writeMissing.length === 0
+          ? { state: "ready", missingConfiguration: [] }
+          : {
+              state: "blocked",
+              missingConfiguration: writeMissing,
+              recovery:
+                "Configure the repository scope and GITHUB_TOKEN (or equivalent backend settings) before using live write operations.",
+            },
+    };
+  }
+
   async list(filter: ListFilter): Promise<Issue[]> {
     const limit = filter.limit && filter.limit > 0 ? filter.limit : 50;
     const raw = await this.call((signal) =>
@@ -117,7 +177,7 @@ export class GitHubRepository {
         request: { signal },
       }),
     );
-    return (raw as GhIssue[]).filter((i) => !i.pull_request).map(toDomain);
+    return (raw as GhIssue[]).map((i) => toDomain(i));
   }
 
   async get(key: string): Promise<Issue> {
@@ -125,8 +185,26 @@ export class GitHubRepository {
     const raw = (await this.call((signal) =>
       this.client.rest.issues.get({ owner: this.owner, repo: this.repoName(), issue_number, request: { signal } }),
     )) as GhIssue;
-    if (raw.pull_request) throw new Error(`github: #${issue_number} is a pull request, not an issue`);
-    return toDomain(raw);
+    if (!raw.pull_request) return toDomain(raw);
+    // A PR's full shape (base/head/mergeable/diffStat/requestedReviewers) is not on the Issues
+    // API's own "issue" schema at all -- only reachable via the dedicated Pulls API, and only
+    // fetched here (the single-item path), never from list()/search(), per this project's own
+    // N+1-avoidance discipline. See the research Doc's correction for why this differs from
+    // list()'s zero-extra-call population below.
+    const [pull, reviews] = await Promise.all([this.fetchPullRequest(issue_number), this.fetchReviews(issue_number)]);
+    return toDomain(raw, pullRequestDetailsFromFull(pull, reviews));
+  }
+
+  private async fetchPullRequest(pull_number: number): Promise<GhPullRequestFull> {
+    return (await this.call((signal) =>
+      this.client.rest.pulls.get({ owner: this.owner, repo: this.repoName(), pull_number, request: { signal } }),
+    )) as GhPullRequestFull;
+  }
+
+  private async fetchReviews(pull_number: number): Promise<GhReview[]> {
+    return (await this.call((signal) =>
+      this.client.rest.pulls.listReviews({ owner: this.owner, repo: this.repoName(), pull_number, request: { signal } }),
+    )) as GhReview[];
   }
 
   async create(input: CreateInput): Promise<Issue> {
@@ -171,7 +249,7 @@ export class GitHubRepository {
     const result = (await this.call((signal) =>
       this.client.rest.search.issuesAndPullRequests({ q: `${scope} ${query}`, per_page: limit, request: { signal } }),
     )) as { items: GhIssue[] };
-    return result.items.filter((i) => !i.pull_request).map(toDomain);
+    return result.items.map((i) => toDomain(i));
   }
 
   // GitHub has no native sub-issue relationship exposed via REST v3.
@@ -179,6 +257,47 @@ export class GitHubRepository {
     return [];
   }
 
+  async approvePullRequest(key: string, body?: string): Promise<Issue> {
+    this.requireAuth();
+    const pull_number = parseIssueNumber(key);
+    await this.call((signal) =>
+      this.client.rest.pulls.createReview({
+        owner: this.owner,
+        repo: this.repoName(),
+        pull_number,
+        event: "APPROVE",
+        body,
+        request: { signal },
+      }),
+    );
+    return this.get(key);
+  }
+
+  async requestPullRequestChanges(key: string, body: string): Promise<Issue> {
+    this.requireAuth();
+    const pull_number = parseIssueNumber(key);
+    await this.call((signal) =>
+      this.client.rest.pulls.createReview({
+        owner: this.owner,
+        repo: this.repoName(),
+        pull_number,
+        event: "REQUEST_CHANGES",
+        body,
+        request: { signal },
+      }),
+    );
+    return this.get(key);
+  }
+
+  async mergePullRequest(key: string, method?: "merge" | "squash" | "rebase"): Promise<Issue> {
+    this.requireAuth();
+    const pull_number = parseIssueNumber(key);
+    await this.call((signal) =>
+      this.client.rest.pulls.merge({ owner: this.owner, repo: this.repoName(), pull_number, merge_method: method, request: { signal } }),
+    );
+    return this.get(key);
+  }
+
   async listComments(key: string): Promise<Comment[]> {
     const issue_number = parseIssueNumber(key);
     const raw = (await this.call((signal) =>
@@ -216,12 +335,13 @@ export class GitHubRepository {
       return res.data;
     } catch (err) {
       if (err instanceof BackendConfigurationError) throw err;
-      if (err instanceof RequestError) {
+      const transportKind = classifyBackendTransportFailure(err);
+      if (transportKind) throw new BackendConnectionError("github", transportKind, err);
+      if (err instanceof RequestError && err.response) {
         if (err.status === 404) throw new IssueNotFoundError("github", err.request.url);
         throw new ApiError("github", err.request.method, err.request.url, err.status, redact(err.message));
       }
-      if (err instanceof DOMException && err.name === "AbortError") throw new BackendConnectionError("github", "timeout", err);
-      throw new BackendConnectionError("github", "unreachable", err);
+      throw err;
     } finally {
       clearTimeout(timer);
     }
@@ -261,7 +381,54 @@ function priorityFromLabels(labels: (GhLabel | string)[]): ReturnType<typeof par
   return "none";
 }
 
-function toDomain(gh: GhIssue): Issue {
+/** Normalizes GitHub's loose mergeable_state string (not a closed enum in its own OpenAPI schema) into this project's own MergeableState. */
+function mapMergeableState(gh: GhPullRequestFull): MergeableState {
+  if (gh.mergeable === null) return "checking";
+  if (!gh.mergeable) return "conflicting";
+  return gh.mergeable_state.toLowerCase() === "unknown" ? "unknown" : "mergeable";
+}
+
+function mapReviewState(state: string): PullRequestReviewer["state"] {
+  switch (state.toUpperCase()) {
+    case "APPROVED":
+      return "approved";
+    case "CHANGES_REQUESTED":
+      return "changes_requested";
+    case "COMMENTED":
+      return "commented";
+    case "PENDING":
+      return "pending";
+    default:
+      return "unreviewed";
+  }
+}
+
+/** get()-only enrichment -- see the research Doc's correction for why this needs a dedicated pulls.get() call, unreachable from list()/search(). */
+function pullRequestDetailsFromFull(pull: GhPullRequestFull, reviews: GhReview[]): PullRequestDetails {
+  return {
+    baseBranch: pull.base.ref,
+    headBranch: pull.head.ref,
+    baseSha: pull.base.sha,
+    headSha: pull.head.sha,
+    draft: pull.draft,
+    merged: pull.merged,
+    mergedAt: pull.merged_at ?? undefined,
+    requestedReviewers: pull.requested_reviewers?.length ? pull.requested_reviewers.map((r) => r.login) : undefined,
+    mergeableState: mapMergeableState(pull),
+    diffStat: { filesChanged: pull.changed_files, additions: pull.additions, deletions: pull.deletions },
+    reviewers: reviews.length
+      ? reviews.filter((r) => r.user).map((r) => ({ username: r.user!.login, state: mapReviewState(r.state) }))
+      : undefined,
+  };
+}
+
+/** list()/search()-cheap population -- only what the Issues API's own "issue" schema actually carries for a PR item (see the research Doc's correction): draft and merged/mergedAt, nothing requiring the dedicated Pulls API. */
+function pullRequestDetailsFromIssue(gh: GhIssue): PullRequestDetails | undefined {
+  if (!gh.pull_request) return undefined;
+  return { draft: gh.draft, merged: gh.pull_request.merged_at !== null, mergedAt: gh.pull_request.merged_at ?? undefined };
+}
+
+function toDomain(gh: GhIssue, pullRequest?: PullRequestDetails): Issue {
   return {
     ref: `github:#${gh.number}`,
     id: String(gh.number),
@@ -276,6 +443,7 @@ function toDomain(gh: GhIssue): Issue {
     url: gh.html_url,
     createdAt: gh.created_at,
     updatedAt: gh.updated_at,
+    pullRequest: pullRequest ?? pullRequestDetailsFromIssue(gh),
   };
 }
 

package/src/gitlab/gitlab.ts

@@ -15,7 +15,20 @@ import { isIP } from "node:net";
 import { GitbeakerRequestError, type RequesterType, type ResourceOptions } from "@gitbeaker/requester-utils";
 import { Gitlab } from "@gitbeaker/rest";
 import { ApiError, AuthRequiredError, BackendConnectionError, InvalidUrlError, IssueNotFoundError } from "../issue/errors.js";
-import type { Comment, CreateInput, Issue, ListFilter, parsePriority, Status, UpdateInput } from "../issue/issue.js";
+import type {
+  Comment,
+  CreateInput,
+  Issue,
+  ListFilter,
+  MergeableState,
+  PullRequestDetails,
+  PullRequestReviewer,
+  parsePriority,
+  Status,
+  UpdateInput,
+} from "../issue/issue.js";
+import type { BackendConfigurationReadiness } from "../issue/repository.js";
+import { classifyBackendTransportFailure } from "../issue/transport-error.js";
 
 export interface GitLabOptions {
   projectId: string;
@@ -58,6 +71,48 @@ interface GlNote {
   author: GlUser | null;
 }
 
+/**
+ * GitLab's MergeRequests resource is a dedicated endpoint entirely separate from Issues --
+ * issues and merge requests have their own independent `iid` sequences within a project (a
+ * project can have both a `#5` issue and a `!5` merge request, unrelated to each other), unlike
+ * GitHub where a PR *is* an Issue with a `pull_request` stub. list()/search() below stay
+ * Issues-only, unchanged: mixing two independently-numbered collections into one list() call
+ * would be surprising, not the GitHub-shaped "free extra items" case this adapter otherwise
+ * mirrors. Merge requests surface instead via GitLab's own `!<iid>` reference convention
+ * (mirrored by the UI itself) as a key prefix get()/approvePullRequest()/mergePullRequest()
+ * all recognize -- see parseMrIid().
+ */
+interface GlMergeRequest {
+  iid: number;
+  title: string;
+  description: string | null;
+  state: string;
+  web_url: string;
+  author: GlUser | null;
+  assignee: GlUser | null;
+  labels: string[];
+  created_at: string;
+  updated_at: string;
+  source_branch: string;
+  target_branch: string;
+  sha: string;
+  draft: boolean;
+  merged_at: string | null;
+  merge_status: string;
+  /** list()-cheap per the research Doc -- the usernames only; per-reviewer *state* always needs the dedicated showReviewers() call below. */
+  reviewers: GlUser[] | null;
+}
+/** get()-only shape (ExpandedMergeRequestSchema) -- ordinary list()/show() responses don't carry changes_count/diff_refs. */
+interface GlMergeRequestExpanded extends GlMergeRequest {
+  /** A string, not a number -- GitLab caps and reports e.g. "1000+" past its own diff-size limit rather than an exact count. */
+  changes_count: string;
+  diff_refs: { base_sha: string; head_sha: string };
+}
+interface GlMergeRequestReviewerEntry {
+  user: GlUser;
+  state: string;
+}
+
 const DEFAULT_URL = "https://gitlab.com";
 const DEFAULT_TIMEOUT_MS = 30_000;
 
@@ -89,6 +144,27 @@ export class GitLabRepository {
     if (this.readOnly) throw new AuthRequiredError("gitlab", "GITLAB_TOKEN");
   }
 
+  configurationReadiness(): BackendConfigurationReadiness {
+    return {
+      backendType: "gitlab",
+      connectivity: "not_checked",
+      read: this.readOnly
+        ? {
+            state: "partial",
+            missingConfiguration: ["GITLAB_TOKEN"],
+            recovery: "Configure GITLAB_TOKEN for private-project reads; unauthenticated reads remain limited to public projects.",
+          }
+        : { state: "ready", missingConfiguration: [] },
+      write: this.readOnly
+        ? {
+            state: "blocked",
+            missingConfiguration: ["GITLAB_TOKEN"],
+            recovery: "Configure GITLAB_TOKEN (or delegated OAuth) before using live write operations.",
+          }
+        : { state: "ready", missingConfiguration: [] },
+    };
+  }
+
   async list(filter: ListFilter): Promise<Issue[]> {
     const limit = filter.limit && filter.limit > 0 ? filter.limit : 50;
     const raw = await this.call<GlIssue[]>(() =>
@@ -104,11 +180,20 @@ export class GitLabRepository {
   }
 
   async get(key: string): Promise<Issue> {
+    if (isMergeRequestKey(key)) return this.getMergeRequest(parseMrIid(key));
     const iid = parseIid(key);
     const raw = await this.call<GlIssue>(() => this.client.Issues.show(iid, { projectId: this.projectId }));
     return toDomain(raw);
   }
 
+  private async getMergeRequest(iid: number): Promise<Issue> {
+    const [raw, reviewers] = await Promise.all([
+      this.call<GlMergeRequestExpanded>(() => this.client.MergeRequests.show(this.projectId, iid)),
+      this.call<GlMergeRequestReviewerEntry[]>(() => this.client.MergeRequests.showReviewers(this.projectId, iid)),
+    ]);
+    return mrToDomain(raw, reviewers);
+  }
+
   async create(input: CreateInput): Promise<Issue> {
     this.requireAuth();
     const assigneeIds = input.assignee ? [await this.resolveUserId(input.assignee)] : undefined;
@@ -162,6 +247,39 @@ export class GitLabRepository {
     return noteToDomain(raw);
   }
 
+  /**
+   * GitLab's approve endpoint (unlike GitHub's createReview) returns only an approval-state
+   * summary, not the full MR -- so this re-fetches the same way get() does, `body` is accepted
+   * for interface parity with GitHub but ignored: GitLab's approve endpoint has no comment-body
+   * parameter at all (confirmed against @gitbeaker/core's ApproveMergeRequestOptions -- just
+   * sha/approvalPassword).
+   */
+  async approvePullRequest(key: string): Promise<Issue> {
+    this.requireAuth();
+    const iid = parseMrIid(key);
+    await this.call(() => this.client.MergeRequestApprovals.approve(this.projectId, iid));
+    return this.getMergeRequest(iid);
+  }
+
+  /**
+   * GitLab's merge endpoint returns the full expanded MR directly (per the research Doc) --
+   * no extra show() call needed for the MR object itself, unlike approve() above. Reviewer
+   * state is still a separate call every time on both backends (see PullRequestReviewer's own
+   * doc comment), so that part isn't free. GitLab's accept endpoint only has a boolean `squash`
+   * option, not a 3-way merge/squash/rebase choice like GitHub's -- "rebase" has no GitLab merge
+   * equivalent (GitLab's own rebase is a distinct pre-merge branch operation), so it falls back
+   * to a plain merge rather than rejecting the call.
+   */
+  async mergePullRequest(key: string, method?: "merge" | "squash" | "rebase"): Promise<Issue> {
+    this.requireAuth();
+    const iid = parseMrIid(key);
+    const [raw, reviewers] = await Promise.all([
+      this.call<GlMergeRequestExpanded>(() => this.client.MergeRequests.merge(this.projectId, iid, { squash: method === "squash" })),
+      this.call<GlMergeRequestReviewerEntry[]>(() => this.client.MergeRequests.showReviewers(this.projectId, iid)),
+    ]);
+    return mrToDomain(raw, reviewers);
+  }
+
   /**
    * GitLab's assignee write contract takes a numeric user ID, not a username
    * (`assignee_ids: number[]`, confirmed against @gitbeaker/rest's generated
@@ -185,11 +303,14 @@ export class GitLabRepository {
       if (err instanceof GitbeakerRequestError) {
         const status = err.cause?.response?.status;
         const url = err.cause?.request?.url ?? "";
-        if (status === undefined) throw new BackendConnectionError("gitlab", "unreachable", err);
-        if (status === 404) throw new IssueNotFoundError("gitlab", url);
-        throw new ApiError("gitlab", err.cause?.request?.method ?? "?", url, status, redact(err.message));
+        if (status !== undefined) {
+          if (status === 404) throw new IssueNotFoundError("gitlab", url);
+          throw new ApiError("gitlab", err.cause?.request?.method ?? "?", url, status, redact(err.message));
+        }
       }
-      throw new BackendConnectionError("gitlab", "unreachable", err);
+      const transportKind = classifyBackendTransportFailure(err);
+      if (transportKind) throw new BackendConnectionError("gitlab", transportKind, err);
+      throw err;
     }
   }
 }
@@ -202,6 +323,51 @@ function parseIid(key: string): number {
   return Number(key.replace(/^#/, ""));
 }
 
+/** GitLab's own merge-request reference convention, mirrored by its UI: "!5", vs. an issue's "#5". */
+function isMergeRequestKey(key: string): boolean {
+  return key.trim().startsWith("!");
+}
+
+function parseMrIid(key: string): number {
+  return Number(key.replace(/^!/, "").replace(/^#/, ""));
+}
+
+/** Primarily merge_status, not detailed_merge_status -- see MergeableState's own doc comment for the cross-backend normalization this feeds. */
+function mapMergeableState(mergeStatus: string): MergeableState {
+  switch (mergeStatus) {
+    case "can_be_merged":
+      return "mergeable";
+    case "cannot_be_merged":
+    case "cannot_be_merged_recheck":
+      return "conflicting";
+    case "checking":
+      return "checking";
+    default:
+      return "unknown"; // "unchecked"
+  }
+}
+
+/** GitLab's own showReviewers() state enum, mapped onto this project's cross-backend PullRequestReviewer.state. "reviewed" (a completed, non-approve/non-reject review) is the closest fit to "commented"; "review_started" (in progress) maps to "pending". */
+function mapReviewerState(state: string): PullRequestReviewer["state"] {
+  switch (state) {
+    case "approved":
+      return "approved";
+    case "requested_changes":
+      return "changes_requested";
+    case "reviewed":
+      return "commented";
+    case "review_started":
+      return "pending";
+    default:
+      return "unreviewed";
+  }
+}
+
+/** "5" -> 5; GitLab reports "1000+" past its own diff-size limit -- parsed as a floor, not an exact count (see GlMergeRequestExpanded's own doc comment). */
+function parseChangesCount(changesCount: string): number {
+  return Number.parseInt(changesCount, 10) || 0;
+}
+
 function mapStatusToGitLab(status: Status): "opened" | "closed" {
   return status === "done" || status === "canceled" ? "closed" : "opened";
 }
@@ -244,6 +410,43 @@ function toDomain(gl: GlIssue): Issue {
   };
 }
 
+function mrPullRequestDetails(mr: GlMergeRequest | GlMergeRequestExpanded, reviewers: GlMergeRequestReviewerEntry[]): PullRequestDetails {
+  const expanded = "changes_count" in mr ? mr : undefined;
+  return {
+    baseBranch: mr.target_branch,
+    headBranch: mr.source_branch,
+    headSha: mr.sha,
+    baseSha: expanded?.diff_refs.base_sha,
+    draft: mr.draft,
+    merged: mr.state === "merged",
+    mergedAt: mr.merged_at ?? undefined,
+    requestedReviewers: mr.reviewers?.length ? mr.reviewers.map((r) => r.username) : undefined,
+    mergeableState: mapMergeableState(mr.merge_status),
+    diffStat: expanded ? { filesChanged: parseChangesCount(expanded.changes_count) } : undefined,
+    reviewers: reviewers.length ? reviewers.map((r) => ({ username: r.user.username, state: mapReviewerState(r.state) })) : undefined,
+  };
+}
+
+function mrToDomain(mr: GlMergeRequestExpanded, reviewers: GlMergeRequestReviewerEntry[]): Issue {
+  return {
+    ref: `gitlab:!${mr.iid}`,
+    id: String(mr.iid),
+    key: `!${mr.iid}`,
+    title: mr.title,
+    description: mr.description ?? undefined,
+    status: mapStatusFromGitLab(mr.state === "merged" ? "closed" : mr.state),
+    rawStatus: mr.state,
+    priority: priorityFromLabels(mr.labels ?? []),
+    labels: mr.labels?.length ? mr.labels : undefined,
+    assignee: mr.assignee?.username,
+    reporter: mr.author?.username,
+    url: mr.web_url,
+    createdAt: mr.created_at,
+    updatedAt: mr.updated_at,
+    pullRequest: mrPullRequestDetails(mr, reviewers),
+  };
+}
+
 function noteToDomain(n: GlNote): Comment {
   return {
     id: String(n.id),

package/src/index.ts

@@ -28,7 +28,7 @@ export { type GitLabOptions, GitLabRepository } from "./gitlab/gitlab.js";
 export * from "./issue/errors.js";
 export * from "./issue/issue.js";
 export * from "./issue/repository.js";
-export { NotSupportedError, TicketService, UnknownBackendError } from "./issue/service.js";
+export { type BackendCapabilities, NotSupportedError, TicketService, UnknownBackendError } from "./issue/service.js";
 export { type JiraOptions, JiraRepository } from "./jira/jira.js";
 export type { TicketOperation, TicketOpInputs, TicketOpOutputs } from "./rpc/ops.js";
 export type { FocusStatus, TicketFocusState } from "./sqlite/focus.js";

package/src/issue/issue.ts

@@ -57,6 +57,60 @@ export interface ExternalLink {
   type?: string;
 }
 
+/**
+ * Normalized across backends even though availability differs: GitHub only reports this on
+ * get() (list/search omit it entirely); GitLab reports merge_status/detailed_merge_status on
+ * both list and get, but is still normalized to get()-only here so callers get one predictable
+ * contract instead of a per-backend availability difference. See the research Doc "Tickets
+ * PR/MR support: grounded GitHub & GitLab API research and domain design" for the source API
+ * fields each state is derived from.
+ */
+export type MergeableState = "mergeable" | "conflicting" | "checking" | "unknown";
+
+/**
+ * get()-only on both backends. GitLab never totals additions/deletions in its merge request
+ * object (only a `changes_count` string like "5" or "1000+") -- getting real added/removed line
+ * counts would need a separate Diffs-API round trip this project's N+1-avoidance discipline
+ * says to skip, so additions/deletions stay undefined for GitLab.
+ */
+export interface PullRequestDiffStat {
+  filesChanged: number;
+  additions?: number;
+  deletions?: number;
+}
+
+/** Per-reviewer review state -- always a dedicated call on both backends (GitHub: listReviews(); GitLab: showReviewers()), never embedded in the list/get response itself. */
+export interface PullRequestReviewer {
+  username: string;
+  /** Only populated by get() -- both backends require the same dedicated call regardless of path. */
+  state?: "approved" | "changes_requested" | "commented" | "pending" | "unreviewed";
+}
+
+/**
+ * The extra fields a GitHub pull request / GitLab merge request carries beyond a plain Issue.
+ * A PR/MR is an issue superset via both platforms' own APIs, so this lives as an optional field
+ * on Issue (see below) rather than a parallel type hierarchy -- every existing Issue consumer
+ * keeps working unchanged for a plain issue, where this is simply undefined.
+ */
+export interface PullRequestDetails {
+  /** Undefined at list()/search() time for a backend whose issue-superset listing endpoint doesn't carry branch refs (GitHub) -- populated by get() there. Always present for a backend with a dedicated MR endpoint (GitLab). */
+  baseBranch?: string;
+  headBranch?: string;
+  baseSha?: string;
+  headSha?: string;
+  draft?: boolean;
+  merged?: boolean;
+  mergedAt?: string;
+  /** list()/search()-cheap on both backends -- populated with zero extra calls. */
+  requestedReviewers?: string[];
+  /** get()-only -- see MergeableState's own doc comment for why this is normalized across backends. */
+  mergeableState?: MergeableState;
+  /** get()-only on both backends. */
+  diffStat?: PullRequestDiffStat;
+  /** get()-only on both backends (a dedicated call every time, on either backend). */
+  reviewers?: PullRequestReviewer[];
+}
+
 /** The unified representation of a work item, regardless of which platform it lives on. */
 export interface Issue {
   /** "backend:key", e.g. "jira:PROJ-42" or "github:#7". */
@@ -87,6 +141,8 @@ export interface Issue {
   externalLinks?: ExternalLink[];
   /** Custom fields keyed by their backend display name (e.g. Jira's "Target Version"), resolved via that backend's field-discovery manifest. Empty until discovery has run at least once for the backend. */
   customFields?: Record<string, string>;
+  /** Present only for a GitHub pull request / GitLab merge request -- undefined for a plain issue. */
+  pullRequest?: PullRequestDetails;
 }
 
 export interface CreateInput {

package/src/issue/repository.ts

@@ -5,6 +5,31 @@
 import type { Comment, CreateInput, Issue, ListFilter, UpdateInput } from "./issue.js";
 import type { Template } from "./template.js";
 
+export type BackendReadinessState = "ready" | "partial" | "blocked" | "unknown";
+
+export interface BackendOperationReadiness {
+  readonly state: BackendReadinessState;
+  /** Names only; never configuration values. */
+  readonly missingConfiguration: readonly string[];
+  readonly recovery?: string;
+}
+
+/** Local configuration assessment. Connectivity is intentionally never inferred or probed here. */
+export interface BackendConfigurationReadiness {
+  readonly backendType: string;
+  readonly connectivity: "not_checked";
+  readonly read: BackendOperationReadiness;
+  readonly write: BackendOperationReadiness;
+}
+
+export interface ConfigurationInspectable {
+  configurationReadiness(): BackendConfigurationReadiness;
+}
+
+export function hasConfigurationReadiness(repo: IssueRepository): repo is IssueRepository & ConfigurationInspectable {
+  return typeof (repo as Partial<ConfigurationInspectable>).configurationReadiness === "function";
+}
+
 export interface IssueRepository {
   /** Backend identifier used in refs, e.g. "github", "gitlab", "jira". */
   readonly name: string;
@@ -117,3 +142,39 @@ export interface SyncScopeExpandable {
 export function hasSyncScopeExpansion(repo: IssueRepository): repo is IssueRepository & SyncScopeExpandable {
   return typeof (repo as Partial<SyncScopeExpandable>).buildSyncQuery === "function";
 }
+
+/**
+ * Optional capability -- approve/merge a pull request or merge request. Both GitHub and GitLab
+ * support both actions as real REST endpoints (see the research Doc "Tickets PR/MR support:
+ * grounded GitHub & GitLab API research and domain design"), so both adapters implement this.
+ * Each method returns the refreshed Issue -- neither platform's own review/merge endpoint
+ * response is the full PR/MR object, so implementations re-fetch after acting.
+ */
+export interface PullRequestReviewable {
+  approvePullRequest(key: string, body?: string): Promise<Issue>;
+  mergePullRequest(key: string, method?: "merge" | "squash" | "rebase"): Promise<Issue>;
+}
+
+export function hasPullRequestReview(repo: IssueRepository): repo is IssueRepository & PullRequestReviewable {
+  return (
+    typeof (repo as Partial<PullRequestReviewable>).approvePullRequest === "function" &&
+    typeof (repo as Partial<PullRequestReviewable>).mergePullRequest === "function"
+  );
+}
+
+/**
+ * Optional capability -- request changes on a pull request. GitHub-only: confirmed against
+ * GitLab's own REST API (both gitbeaker's generated types and GitLab's official docs) that
+ * "request changes" has no REST endpoint at all -- it is GraphQL-only on GitLab. Adding a
+ * second HTTP client to gitlab.ts just for this one action is out of proportion to what this
+ * capability needs, so GitLab's repository simply does not implement this interface;
+ * TicketService.requestChanges() throws NotSupportedError via hasPullRequestChangesRequest(),
+ * the same pattern every other GitLab-unsupported action already uses (e.g. hasRawQuery).
+ */
+export interface PullRequestChangesRequestable {
+  requestPullRequestChanges(key: string, body: string): Promise<Issue>;
+}
+
+export function hasPullRequestChangesRequest(repo: IssueRepository): repo is IssueRepository & PullRequestChangesRequestable {
+  return typeof (repo as Partial<PullRequestChangesRequestable>).requestPullRequestChanges === "function";
+}

package/src/issue/service.ts

@@ -7,10 +7,14 @@
 import type { Comment, CreateInput, Issue, ListFilter, UpdateInput } from "./issue.js";
 import { parseRef } from "./issue.js";
 import {
+  type BackendConfigurationReadiness,
   hasBoardFilterDiscovery,
   hasBoardQuickFilterDiscovery,
   hasComments,
+  hasConfigurationReadiness,
   hasFieldDiscovery,
+  hasPullRequestChangesRequest,
+  hasPullRequestReview,
   hasRawQuery,
   hasStatusDiscovery,
   hasSyncScopeExpansion,
@@ -21,12 +25,17 @@ import type { Template } from "./template.js";
 
 export interface BackendCapabilities {
   readonly name: string;
+  readonly readiness: BackendConfigurationReadiness;
   readonly supportsRawQuery: boolean;
   readonly supportsFieldDiscovery: boolean;
   readonly supportsStatusDiscovery: boolean;
   readonly supportsTemplateDiscovery: boolean;
   readonly supportsBoardQuickFilterDiscovery: boolean;
   readonly supportsBoardFilterDiscovery: boolean;
+  /** approvePullRequest/mergePullRequest -- GitHub and GitLab both support this today. */
+  readonly supportsPullRequestReview: boolean;
+  /** requestPullRequestChanges -- GitHub only; GitLab has no such REST endpoint. */
+  readonly supportsPullRequestChangesRequest: boolean;
 }
 
 export class UnknownBackendError extends Error {
@@ -54,12 +63,30 @@ export class TicketService {
   backendCapabilities(): BackendCapabilities[] {
     return Object.values(this.repos).map((repo) => ({
       name: repo.name,
+      readiness: hasConfigurationReadiness(repo)
+        ? repo.configurationReadiness()
+        : {
+            backendType: repo.name,
+            connectivity: "not_checked",
+            read: {
+              state: "unknown",
+              missingConfiguration: [],
+              recovery: "This adapter does not expose local configuration readiness.",
+            },
+            write: {
+              state: "unknown",
+              missingConfiguration: [],
+              recovery: "This adapter does not expose local configuration readiness.",
+            },
+          },
       supportsRawQuery: hasRawQuery(repo),
       supportsFieldDiscovery: hasFieldDiscovery(repo),
       supportsStatusDiscovery: hasStatusDiscovery(repo),
       supportsTemplateDiscovery: hasTemplateDiscovery(repo),
       supportsBoardQuickFilterDiscovery: hasBoardQuickFilterDiscovery(repo),
       supportsBoardFilterDiscovery: hasBoardFilterDiscovery(repo),
+      supportsPullRequestReview: hasPullRequestReview(repo),
+      supportsPullRequestChangesRequest: hasPullRequestChangesRequest(repo),
     }));
   }
 
@@ -184,4 +211,28 @@ export class TicketService {
     if (!hasBoardFilterDiscovery(repo)) throw new NotSupportedError(backend, "board filter discovery");
     return repo.discoverBoardFilterJql(boardId);
   }
+
+  /** Approves a pull request / merge request. Both GitHub and GitLab support this today. */
+  async approve(ref: string, body?: string): Promise<Issue> {
+    const { backend, key } = parseRef(ref);
+    const repo = this.repo(backend);
+    if (!hasPullRequestReview(repo)) throw new NotSupportedError(backend, "pull request review");
+    return repo.approvePullRequest(key, body);
+  }
+
+  /** Requests changes on a pull request. GitHub-only -- GitLab has no such REST endpoint (see PullRequestChangesRequestable's own doc comment), so this always throws NotSupportedError there. */
+  async requestChanges(ref: string, body: string): Promise<Issue> {
+    const { backend, key } = parseRef(ref);
+    const repo = this.repo(backend);
+    if (!hasPullRequestChangesRequest(repo)) throw new NotSupportedError(backend, "requesting changes on a pull request");
+    return repo.requestPullRequestChanges(key, body);
+  }
+
+  /** Merges a pull request / merge request. Both GitHub and GitLab support this today. */
+  async merge(ref: string, method?: "merge" | "squash" | "rebase"): Promise<Issue> {
+    const { backend, key } = parseRef(ref);
+    const repo = this.repo(backend);
+    if (!hasPullRequestReview(repo)) throw new NotSupportedError(backend, "pull request review");
+    return repo.mergePullRequest(key, method);
+  }
 }

package/src/issue/transport-error.ts

@@ -0,0 +1,68 @@
+/**
+ * Fail-closed transport classification shared by provider adapters.
+ *
+ * Only stable error names/codes emitted by the runtimes and HTTP clients we
+ * use are accepted. Messages are deliberately ignored: they are unstable,
+ * may contain credentials/URLs, and can make an arbitrary programming error
+ * look like a network outage.
+ */
+
+export type BackendTransportFailureKind = "unreachable" | "timeout";
+
+const TIMEOUT_CODES = new Set([
+  "ABORT_ERR",
+  "ECONNABORTED",
+  "ERR_CANCELED",
+  "ESOCKETTIMEDOUT",
+  "ETIMEDOUT",
+  "UND_ERR_BODY_TIMEOUT",
+  "UND_ERR_CONNECT_TIMEOUT",
+  "UND_ERR_HEADERS_TIMEOUT",
+]);
+
+const UNREACHABLE_CODES = new Set([
+  "CERT_HAS_EXPIRED",
+  "DEPTH_ZERO_SELF_SIGNED_CERT",
+  "EAI_AGAIN",
+  "ECONNREFUSED",
+  "ECONNRESET",
+  "EHOSTUNREACH",
+  "ENETUNREACH",
+  "ENOTFOUND",
+  "EPIPE",
+  "ERR_NETWORK",
+  "ERR_TLS_CERT_ALTNAME_INVALID",
+  "SELF_SIGNED_CERT_IN_CHAIN",
+  "UNABLE_TO_GET_ISSUER_CERT",
+  "UNABLE_TO_VERIFY_LEAF_SIGNATURE",
+  "UND_ERR_SOCKET",
+]);
+
+const TIMEOUT_NAMES = new Set(["AbortError", "GitbeakerTimeoutError", "TimeoutError"]);
+
+function record(value: unknown): Record<string, unknown> | undefined {
+  return typeof value === "object" && value !== null ? (value as Record<string, unknown>) : undefined;
+}
+
+/** Returns undefined for every unreviewed/unknown exception. */
+export function classifyBackendTransportFailure(error: unknown): BackendTransportFailureKind | undefined {
+  let current: unknown = error;
+  const seen = new Set<unknown>();
+
+  for (let depth = 0; depth < 6; depth++) {
+    const candidate = record(current);
+    if (!candidate || seen.has(current)) return undefined;
+    seen.add(current);
+
+    const name = typeof candidate.name === "string" ? candidate.name : undefined;
+    if (name && TIMEOUT_NAMES.has(name)) return "timeout";
+
+    const code = typeof candidate.code === "string" ? candidate.code.toUpperCase() : undefined;
+    if (code && TIMEOUT_CODES.has(code)) return "timeout";
+    if (code && UNREACHABLE_CODES.has(code)) return "unreachable";
+
+    current = candidate.cause;
+  }
+
+  return undefined;
+}

package/src/jira/jira.ts

@@ -18,8 +18,10 @@ import type { HttpException, Config as JiraClientConfig } from "jira.js";
 import { AgileClient, Version2Client } from "jira.js";
 import { ApiError, BackendConfigurationError, BackendConnectionError, IssueNotFoundError } from "../issue/errors.js";
 import type { Comment, CreateInput, Issue, IssueLink, ListFilter, parsePriority, Status, UpdateInput } from "../issue/issue.js";
+import type { BackendConfigurationReadiness } from "../issue/repository.js";
 import type { Template } from "../issue/template.js";
 import { buildTemplateBody, extractTemplateSections } from "../issue/template.js";
+import { classifyBackendTransportFailure } from "../issue/transport-error.js";
 import * as manifest from "./manifest.js";
 
 /**
@@ -180,6 +182,21 @@ export class JiraRepository {
     this.client = new Version2Client(this.clientConfig);
   }
 
+  configurationReadiness(): BackendConfigurationReadiness {
+    return {
+      backendType: "jira",
+      connectivity: "not_checked",
+      read: { state: "ready", missingConfiguration: [] },
+      write: this.project
+        ? { state: "ready", missingConfiguration: [] }
+        : {
+            state: "partial",
+            missingConfiguration: ["JIRA_PROJECT"],
+            recovery: "Set JIRA_PROJECT (or pass input.project) for issue creation; updates and comments remain available.",
+          },
+    };
+  }
+
   /**
    * An explicit filter.project always wins and narrows to exactly that one
    * project; with none given, defaults to every project this repository
@@ -219,12 +236,15 @@ export class JiraRepository {
       return (await fn()) as T;
     } catch (err) {
       const status = (err as Partial<HttpException>)?.status;
-      if (typeof status === "number") {
+      const responseStatus = (err as { response?: { status?: unknown } })?.response?.status;
+      if (typeof status === "number" && typeof responseStatus === "number") {
         if (status === 404) throw new IssueNotFoundError("jira", key ?? "?");
         const message = err instanceof Error ? err.message : String(err);
         throw new ApiError("jira", "?", key ?? "?", status, redact(message));
       }
-      throw new BackendConnectionError("jira", err instanceof DOMException && err.name === "AbortError" ? "timeout" : "unreachable", err);
+      const transportKind = classifyBackendTransportFailure(err);
+      if (transportKind) throw new BackendConnectionError("jira", transportKind, err);
+      throw err;
     }
   }
 

package/src/rpc/ops.ts

@@ -5,6 +5,7 @@
  * import from either side without pulling in bun:sqlite or Bun.serve.
  */
 import type { Comment, CreateInput, Issue, ListFilter, UpdateInput } from "../issue/issue.js";
+import type { BackendCapabilities } from "../issue/service.js";
 import type { Template } from "../issue/template.js";
 import type { TicketFocusState } from "../sqlite/focus.js";
 import type { SavedQuery } from "../sqlite/saved-queries.js";
@@ -20,6 +21,9 @@ export type TicketOperation =
   | "issue.children"
   | "issue.comments"
   | "issue.comment_add"
+  | "issue.approve"
+  | "issue.request_changes"
+  | "issue.merge"
   | "ledger.search"
   | "ledger.stats"
   | "focus.set"
@@ -54,6 +58,9 @@ export interface TicketOpInputs extends Record<TicketOperation, unknown> {
   "issue.children": { ref: string };
   "issue.comments": { ref: string };
   "issue.comment_add": { ref: string; body: string };
+  "issue.approve": { ref: string; body?: string };
+  "issue.request_changes": { ref: string; body: string };
+  "issue.merge": { ref: string; method?: "merge" | "squash" | "rebase" };
   "ledger.search": { query: string; limit?: number; backend?: string };
   "ledger.stats": Record<string, never>;
   "focus.set": { ref: string };
@@ -83,7 +90,7 @@ export interface TicketOpInputs extends Record<TicketOperation, unknown> {
 export type StagePushResult = { issue: Issue } | { comment: Comment };
 
 export interface TicketOpOutputs extends Record<TicketOperation, unknown> {
-  "backends.list": { backends: { name: string; supportsRawQuery: boolean }[] };
+  "backends.list": { backends: BackendCapabilities[] };
   "issue.list": { issues: Issue[] };
   "issue.get": { issue: Issue };
   "issue.create": { issue: Issue };
@@ -92,6 +99,9 @@ export interface TicketOpOutputs extends Record<TicketOperation, unknown> {
   "issue.children": { issues: Issue[] };
   "issue.comments": { comments: Comment[] };
   "issue.comment_add": { comment: Comment };
+  "issue.approve": { issue: Issue };
+  "issue.request_changes": { issue: Issue };
+  "issue.merge": { issue: Issue };
   "ledger.search": { issues: Issue[] };
   "ledger.stats": { backends: { backend: string; count: number }[] };
   "focus.set": { focus: TicketFocusState };
@@ -127,6 +137,9 @@ export const TICKET_OPERATIONS: TicketOperation[] = [
   "issue.children",
   "issue.comments",
   "issue.comment_add",
+  "issue.approve",
+  "issue.request_changes",
+  "issue.merge",
   "ledger.search",
   "ledger.stats",
   "focus.set",

package/src/rpc/server.ts

@@ -71,6 +71,9 @@ export const TICKET_OP_HANDLERS: { [Op in TicketOperation]: Handler<Op> } = {
   "issue.children": async (deps, input) => ({ issues: await deps.service.children(input.ref) }),
   "issue.comments": async (deps, input) => ({ comments: await deps.service.comments(input.ref) }),
   "issue.comment_add": async (deps, input) => ({ comment: await deps.service.addComment(input.ref, input.body) }),
+  "issue.approve": async (deps, input) => ({ issue: await deps.service.approve(input.ref, input.body) }),
+  "issue.request_changes": async (deps, input) => ({ issue: await deps.service.requestChanges(input.ref, input.body) }),
+  "issue.merge": async (deps, input) => ({ issue: await deps.service.merge(input.ref, input.method) }),
   "ledger.search": async (deps, input) => ({ issues: deps.ledger.search(input.query, input.limit, input.backend) }),
   "ledger.stats": async (deps) => ({ backends: deps.ledger.stats() }),
   "focus.set": async (deps, input) => {