@danypops/tickets 0.10.5 → 0.12.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danypops/tickets",
-  "version": "0.10.5",
+  "version": "0.12.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

@@ -34,6 +34,7 @@ const LIMITS = { defaultTimeoutMs: 10_000, maxTimeoutMs: 30_000, maxRequestBytes
 
 const stringProp: LooseObjectProperty = { type: "string" };
 const numberProp: LooseObjectProperty = { type: "number" };
+const booleanProp: LooseObjectProperty = { type: "boolean" };
 
 interface OperationSpec {
   readonly action: TicketOperation;
@@ -71,7 +72,8 @@ const OPERATIONS: readonly OperationSpec[] = [
   },
   {
     action: "issue.list",
-    description: "Lists issues from one backend, optionally filtered.",
+    description:
+      "Lists issues from one backend, optionally filtered. reportedByMe/assignedToMe/reviewRequestedOfMe/qaContactIsMe filter to the caller's own tickets using each backend's own identity (no username needed); set more than one to OR them together. reviewRequestedOfMe is GitHub/GitLab-only (PR/MR reviewer requests); qaContactIsMe is Jira-only (its discovered 'QA Contact' field) -- an unsupported flag on a given backend throws rather than being silently ignored.",
     effect: "read",
     properties: {
       backend: stringProp,
@@ -80,11 +82,25 @@ const OPERATIONS: readonly OperationSpec[] = [
       assignee: stringProp,
       labels: stringArrayProp,
       limit: numberProp,
+      reportedByMe: booleanProp,
+      assignedToMe: booleanProp,
+      reviewRequestedOfMe: booleanProp,
+      qaContactIsMe: booleanProp,
     },
     required: ["backend"],
-    mapInput: ({ backend, project, status, assignee, labels, limit }) => ({
+    mapInput: ({ backend, project, status, assignee, labels, limit, reportedByMe, assignedToMe, reviewRequestedOfMe, qaContactIsMe }) => ({
       backend,
-      filter: definedEntriesOnly({ project, status, assignee, labels, limit }),
+      filter: definedEntriesOnly({
+        project,
+        status,
+        assignee,
+        labels,
+        limit,
+        reportedByMe,
+        assignedToMe,
+        reviewRequestedOfMe,
+        qaContactIsMe,
+      }),
     }),
   },
   {
@@ -136,6 +152,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 +313,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 +344,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

@@ -47,6 +47,10 @@ program
   .option("--assignee <user>", "filter by assignee")
   .option("--label <label...>", "filter by label(s)")
   .option("--limit <n>", "max results", (v) => Number.parseInt(v, 10))
+  .option("--reported-by-me", "only issues reported/authored by you (Jira reporter / GitHub PR author / GitLab issue author)")
+  .option("--assigned-to-me", "only issues assigned to you")
+  .option("--review-requested-of-me", "only PRs/MRs where you're requested as a reviewer (GitHub/GitLab only)")
+  .option("--qa-contact-is-me", "only issues where you're the QA Contact (Jira only)")
   .action(async (opts) => {
     const filter: ListFilter = {
       project: opts.project,
@@ -54,6 +58,10 @@ program
       assignee: opts.assignee,
       labels: opts.label,
       limit: opts.limit,
+      reportedByMe: opts.reportedByMe,
+      assignedToMe: opts.assignedToMe,
+      reviewRequestedOfMe: opts.reviewRequestedOfMe,
+      qaContactIsMe: opts.qaContactIsMe,
     };
     await withClient((client) => client.call("issue.list", { backend: opts.backend, filter }));
   });
@@ -124,6 +132,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;
@@ -133,19 +165,34 @@ export class GitHubRepository {
   }
 
   async list(filter: ListFilter): Promise<Issue[]> {
+    if (filter.qaContactIsMe) throw new Error('github: "qaContactIsMe" is a Jira-only concept, not supported on the github backend');
     const limit = filter.limit && filter.limit > 0 ? filter.limit : 50;
-    const raw = await this.call((signal) =>
-      this.client.rest.issues.listForRepo({
-        owner: this.owner,
-        repo: this.repoName(),
-        per_page: limit,
-        state: filter.status ? mapStatusToGitHub(filter.status) : "all",
-        assignee: filter.assignee,
-        labels: filter.labels?.length ? filter.labels.join(",") : undefined,
-        request: { signal },
-      }),
-    );
-    return (raw as GhIssue[]).filter((i) => !i.pull_request).map(toDomain);
+    const meQualifiers = buildMeQualifiers(filter);
+    if (meQualifiers.length === 0) {
+      const raw = await this.call((signal) =>
+        this.client.rest.issues.listForRepo({
+          owner: this.owner,
+          repo: this.repoName(),
+          per_page: limit,
+          state: filter.status ? mapStatusToGitHub(filter.status) : "all",
+          assignee: filter.assignee,
+          labels: filter.labels?.length ? filter.labels.join(",") : undefined,
+          request: { signal },
+        }),
+      );
+      return (raw as GhIssue[]).map((i) => toDomain(i));
+    }
+    // Any "me" flag routes through the Search API instead of listForRepo: it's the only GitHub
+    // surface with a review-requested filter at all (confirmed against GitHub's own REST docs --
+    // listForRepo has no such parameter), and it happens to support author/assignee "me" qualifiers
+    // too, so one call covers every combination of the three flags. Response items are Issue-shaped
+    // (same pull_request: {merged_at} stub as listForRepo's own entries -- confirmed against
+    // @octokit/openapi-types' issue-search-result-item schema), so toDomain() applies unchanged.
+    const q = buildMeSearchQuery(this.owner, this.repoName(), filter, meQualifiers);
+    const result = (await this.call((signal) =>
+      this.client.rest.search.issuesAndPullRequests({ q, per_page: limit, request: { signal } }),
+    )) as { items: GhIssue[] };
+    return result.items.map((i) => toDomain(i));
   }
 
   async get(key: string): Promise<Issue> {
@@ -153,8 +200,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 +264,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 +272,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) =>
@@ -271,6 +377,24 @@ function mapStatusToGitHub(status: Status): "open" | "closed" {
   return status === "done" || status === "canceled" ? "closed" : "open";
 }
 
+/** ListFilter.{reportedByMe,assignedToMe,reviewRequestedOfMe} -> GitHub Search API qualifiers -- see ListFilter's own doc comment. */
+function buildMeQualifiers(filter: ListFilter): string[] {
+  const qualifiers: string[] = [];
+  if (filter.reportedByMe) qualifiers.push("author:@me");
+  if (filter.assignedToMe) qualifiers.push("assignee:@me");
+  if (filter.reviewRequestedOfMe) qualifiers.push("user-review-requested:@me");
+  return qualifiers;
+}
+
+/** Composes a full Search API `q` string: repo scope + status/labels (AND, matching list()'s own semantics) + the "me" qualifiers (OR'd together). */
+function buildMeSearchQuery(owner: string, repo: string, filter: ListFilter, meQualifiers: readonly string[]): string {
+  const parts = [`repo:${owner}/${repo}`];
+  if (filter.status) parts.push(`is:${mapStatusToGitHub(filter.status)}`);
+  for (const label of filter.labels ?? []) parts.push(`label:"${label.replace(/"/g, '\\"')}"`);
+  parts.push(meQualifiers.length === 1 ? meQualifiers[0]! : `(${meQualifiers.join(" OR ")})`);
+  return parts.join(" ");
+}
+
 function mapStatusFromGitHub(state: string): Status {
   return state.toLowerCase() === "closed" ? "done" : "todo";
 }
@@ -290,7 +414,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 +476,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;
 
@@ -113,25 +166,71 @@ export class GitLabRepository {
   }
 
   async list(filter: ListFilter): Promise<Issue[]> {
+    if (filter.qaContactIsMe) throw new Error('gitlab: "qaContactIsMe" is a Jira-only concept, not supported on the gitlab backend');
+    if (filter.reviewRequestedOfMe) {
+      throw new Error(
+        'gitlab: "reviewRequestedOfMe" is a merge-request-only concept (scope=reviews_for_me) that list()\'s Issues-only scope can\'t express -- see get()\'s "!<iid>" convention for merge requests',
+      );
+    }
     const limit = filter.limit && filter.limit > 0 ? filter.limit : 50;
-    const raw = await this.call<GlIssue[]>(() =>
-      this.client.Issues.all({
-        projectId: this.projectId,
-        perPage: limit,
-        state: filter.status ? mapStatusToGitLab(filter.status) : undefined,
-        assigneeUsername: filter.assignee ? [filter.assignee] : undefined,
-        labels: filter.labels?.length ? filter.labels.join(",") : undefined,
-      }),
+    const scopes = meScopes(filter);
+    if (scopes.length <= 1) {
+      const raw = await this.call<GlIssue[]>(() =>
+        this.client.Issues.all({
+          projectId: this.projectId,
+          perPage: limit,
+          state: filter.status ? mapStatusToGitLab(filter.status) : undefined,
+          assigneeUsername: filter.assignee ? [filter.assignee] : undefined,
+          labels: filter.labels?.length ? filter.labels.join(",") : undefined,
+          ...(scopes[0] ? { scope: scopes[0] } : {}),
+        }),
+      );
+      return raw.map(toDomain);
+    }
+    // Both reportedByMe and assignedToMe: GitLab's own `scope` param takes exactly one value per
+    // call (no server-side OR across scopes), so the OR-of-roles group ListFilter's own doc comment
+    // describes is executed here as two calls, deduped client-side by ref -- the one place in this
+    // adapter an OR of "me" flags genuinely costs more than one request (Jira/GitHub both express
+    // it in a single native query).
+    const results = await Promise.all(
+      scopes.map((scope) =>
+        this.call<GlIssue[]>(() =>
+          this.client.Issues.all({
+            projectId: this.projectId,
+            perPage: limit,
+            state: filter.status ? mapStatusToGitLab(filter.status) : undefined,
+            labels: filter.labels?.length ? filter.labels.join(",") : undefined,
+            scope,
+          }),
+        ),
+      ),
     );
-    return raw.map(toDomain);
+    const seen = new Set<string>();
+    const merged: Issue[] = [];
+    for (const raw of results.flat()) {
+      const issue = toDomain(raw);
+      if (seen.has(issue.ref)) continue;
+      seen.add(issue.ref);
+      merged.push(issue);
+    }
+    return merged.slice(0, limit);
   }
 
   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 +284,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,10 +360,63 @@ 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";
 }
 
+/** ListFilter.{reportedByMe,assignedToMe} -> GitLab Issues API `scope` values -- see ListFilter's own doc comment. */
+function meScopes(filter: ListFilter): ("created_by_me" | "assigned_to_me")[] {
+  const scopes: ("created_by_me" | "assigned_to_me")[] = [];
+  if (filter.reportedByMe) scopes.push("created_by_me");
+  if (filter.assignedToMe) scopes.push("assigned_to_me");
+  return scopes;
+}
+
 function mapStatusEventToGitLab(status: Status): "close" | "reopen" {
   return status === "done" || status === "canceled" ? "close" : "reopen";
 }
@@ -270,6 +455,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 {
@@ -122,6 +178,30 @@ export interface ListFilter {
   assignee?: string;
   query?: string;
   limit?: number;
+  /**
+   * "Mine" filtering -- deliberately a small set of named, orthogonal boolean flags rather than
+   * either a hardcoded single `mine` concept or a generic cross-backend query language (see the
+   * research Doc "Tickets 'mine' filtering: grounded API research" for why both alternatives were
+   * rejected). Every backend maps each flag to its own native "current user" mechanism (Jira's JQL
+   * currentUser(), GitHub's Search API @me qualifiers, GitLab's scope=*_me) -- never a resolved
+   * literal username. Setting more than one of these ORs them together ("assignee OR reporter"),
+   * AND'd with every other ListFilter field exactly like today's plain fields. A backend that has
+   * no native equivalent for a given flag throws rather than silently ignoring it (e.g.
+   * reviewRequestedOfMe on Jira, qaContactIsMe on GitHub/GitLab) -- a silently-dropped role would
+   * make an incomplete result look complete.
+   */
+  /** Jira: `reporter = currentUser()`. GitHub: `author:@me` (Search API). GitLab: `scope=created_by_me` (Issues API). */
+  reportedByMe?: boolean;
+  /** Jira: `assignee = currentUser()`. GitHub: `assignee:@me` (Search API). GitLab: `scope=assigned_to_me` (Issues API). */
+  assignedToMe?: boolean;
+  /**
+   * GitHub: `user-review-requested:@me` (Search API, PRs only). GitLab: `scope=reviews_for_me` --
+   * a merge-request-only concept list()'s Issues-only scope can't express, so GitLab throws. Jira
+   * has no reviewer concept on plain issues, so Jira throws too.
+   */
+  reviewRequestedOfMe?: boolean;
+  /** Jira only, via the discovered "QA Contact" custom field (auto-discovers if never run). GitHub/GitLab throw -- no equivalent concept. */
+  qaContactIsMe?: boolean;
 }
 
 /** "backend:key" ref parsing, split on the first colon only (keys may contain colons). */

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/jira/jira.ts

@@ -204,6 +204,11 @@ export class JiraRepository {
    * the background), not just the single legacy `project` config field.
    */
   async list(filter: ListFilter): Promise<Issue[]> {
+    if (filter.reviewRequestedOfMe) {
+      throw new Error(
+        'jira: "reviewRequestedOfMe" has no meaning on Jira issues (no reviewer concept) -- omit this filter for the jira backend',
+      );
+    }
     const projects = filter.project ? [filter.project] : this.defaultProjects();
     const clauses: string[] = [];
     const scope = projectClause(projects);
@@ -211,9 +216,30 @@ export class JiraRepository {
     if (filter.status) clauses.push(`status = ${jqlQuote(mapStatusToJira(filter.status))}`);
     if (filter.assignee) clauses.push(`assignee = ${jqlQuote(filter.assignee)}`);
     for (const label of filter.labels ?? []) clauses.push(`labels = ${jqlQuote(label)}`);
+    const meClauses = await this.buildMeClauses(filter);
+    if (meClauses.length > 0) clauses.push(meClauses.length === 1 ? meClauses[0]! : `(${meClauses.join(" OR ")})`);
     return this.searchJql(buildJql(clauses, "AND"), filter.limit ?? 50);
   }
 
+  /**
+   * Builds the OR'd group of "me" role clauses for list()'s ListFilter.{reportedByMe,assignedToMe,
+   * qaContactIsMe} flags -- see ListFilter's own doc comment for why this is a small set of named
+   * flags rather than a hardcoded single "mine" concept or a generic query language. "QA Contact"
+   * resolves through the same discoverFields()-backed manifest applyCustomFields() already uses
+   * (auto-discovering on first use), so an instance without that field throws a clear "unknown
+   * custom field" error rather than silently omitting the clause.
+   */
+  private async buildMeClauses(filter: ListFilter): Promise<string[]> {
+    const clauses: string[] = [];
+    if (filter.assignedToMe) clauses.push("assignee = currentUser()");
+    if (filter.reportedByMe) clauses.push("reporter = currentUser()");
+    if (filter.qaContactIsMe) {
+      await this.resolveCustomField("QA Contact");
+      clauses.push('"QA Contact" = currentUser()');
+    }
+    return clauses;
+  }
+
   async get(key: string): Promise<Issue> {
     const [raw, remoteLinks] = await Promise.all([
       this.call<JiraIssue>(() => this.client.issues.getIssue({ issueIdOrKey: key }), key),

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) => {