@danypops/tickets 0.10.5 → 0.11.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danypops/tickets",
-  "version": "0.10.5",
+  "version": "0.11.0",
   "description": "Unified CLI, daemon, and TypeScript library for issue tracking across GitHub, GitLab, and Jira.",
   "type": "module",
   "license": "MIT",

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

@@ -136,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).",
@@ -275,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)" },
@@ -305,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

package/src/github/github.ts

@@ -22,7 +22,18 @@
 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";
 
@@ -56,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;
@@ -65,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;
@@ -145,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> {
@@ -153,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> {
@@ -199,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.
@@ -207,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) =>
@@ -290,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),
@@ -305,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,18 @@ 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";
 
@@ -60,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;
 
@@ -127,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;
@@ -185,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
@@ -228,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";
 }
@@ -270,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/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

@@ -142,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

@@ -13,6 +13,8 @@ import {
   hasComments,
   hasConfigurationReadiness,
   hasFieldDiscovery,
+  hasPullRequestChangesRequest,
+  hasPullRequestReview,
   hasRawQuery,
   hasStatusDiscovery,
   hasSyncScopeExpansion,
@@ -30,6 +32,10 @@ export interface BackendCapabilities {
   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 {
@@ -79,6 +85,8 @@ export class TicketService {
       supportsTemplateDiscovery: hasTemplateDiscovery(repo),
       supportsBoardQuickFilterDiscovery: hasBoardQuickFilterDiscovery(repo),
       supportsBoardFilterDiscovery: hasBoardFilterDiscovery(repo),
+      supportsPullRequestReview: hasPullRequestReview(repo),
+      supportsPullRequestChangesRequest: hasPullRequestChangesRequest(repo),
     }));
   }
 
@@ -203,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/rpc/ops.ts

@@ -21,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"
@@ -55,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 };
@@ -93,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 };
@@ -128,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) => {