paperclip-github-plugin 0.2.2 → 0.3.0

package/dist/worker.js

@@ -3,7 +3,10 @@ import { readFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { Octokit } from "@octokit/rest";
-import { definePlugin, runWorker } from "@paperclipai/plugin-sdk";
+import {
+  definePlugin,
+  runWorker
+} from "@paperclipai/plugin-sdk";
 
 // src/github-agent-tools.ts
 var repositoryProperty = {
@@ -515,6 +518,10 @@ var SYNC_STATE_SCOPE = {
   scopeKind: "instance",
   stateKey: "paperclip-github-plugin-last-sync"
 };
+var SYNC_CANCELLATION_SCOPE = {
+  scopeKind: "instance",
+  stateKey: "paperclip-github-plugin-sync-cancel-request"
+};
 var IMPORT_REGISTRY_SCOPE = {
   scopeKind: "instance",
   stateKey: "paperclip-github-plugin-import-registry"
@@ -525,9 +532,21 @@ var DEFAULT_IGNORED_GITHUB_ISSUE_USERNAMES = ["renovate"];
 var GITHUB_API_VERSION = "2026-03-10";
 var DEFAULT_PAPERCLIP_LABEL_COLOR = "#6366f1";
 var PAPERCLIP_LABEL_PAGE_SIZE = 100;
+var PROJECT_PULL_REQUEST_SUMMARY_CONCURRENCY = 8;
+var PROJECT_PULL_REQUEST_PAGE_SIZE = 10;
+var PROJECT_PULL_REQUEST_METRICS_BATCH_SIZE = 100;
+var PROJECT_PULL_REQUEST_PAGE_CACHE_TTL_MS = 30 * 6e4;
+var PROJECT_PULL_REQUEST_SUMMARY_CACHE_TTL_MS = 60 * 6e4;
+var PROJECT_PULL_REQUEST_DETAIL_CACHE_TTL_MS = 30 * 6e4;
+var PROJECT_PULL_REQUEST_ISSUE_LOOKUP_CACHE_TTL_MS = 60 * 6e4;
+var PROJECT_PULL_REQUEST_GITHUB_INSIGHT_CACHE_TTL_MS = 60 * 6e4;
+var PROJECT_PULL_REQUEST_BRANCH_COMPARE_CACHE_TTL_MS = 30 * 6e4;
+var GITHUB_TOKEN_PERMISSION_AUDIT_CACHE_TTL_MS = 5 * 6e4;
 var MANUAL_SYNC_RESPONSE_GRACE_PERIOD_MS = 500;
 var RUNNING_SYNC_MESSAGE = "GitHub sync is running in the background. This page will update when it finishes.";
+var CANCELLING_SYNC_MESSAGE = "Cancellation requested. GitHub sync will stop after the current step finishes.";
 var SYNC_PROGRESS_PERSIST_INTERVAL_MS = 250;
+var MAX_SYNC_FAILURE_LOG_ENTRIES = 25;
 var GITHUB_SECONDARY_RATE_LIMIT_FALLBACK_MS = 6e4;
 var MISSING_GITHUB_TOKEN_SYNC_MESSAGE = "Configure a GitHub token before running sync.";
 var MISSING_GITHUB_TOKEN_SYNC_ACTION = 'Open settings and save a GitHub token secret, or create ~/.paperclip/plugins/github-sync/config.json with a "githubToken" value, and then run sync again.';
@@ -536,6 +555,7 @@ var MISSING_MAPPING_SYNC_ACTION = "Open settings, add a repository mapping, let
 var MISSING_BOARD_ACCESS_SYNC_MESSAGE = "Connect Paperclip board access before running sync on this authenticated deployment.";
 var MISSING_BOARD_ACCESS_SYNC_ACTION = "Open plugin settings for each mapped company that sync will touch, connect Paperclip board access, approve the flow, and then run sync again.";
 var ISSUE_LINK_ENTITY_TYPE = "paperclip-github-plugin.issue-link";
+var PULL_REQUEST_LINK_ENTITY_TYPE = "paperclip-github-plugin.pull-request-link";
 var COMMENT_ANNOTATION_ENTITY_TYPE = "paperclip-github-plugin.comment-annotation";
 var EXTERNAL_CONFIG_FILE_PATH_SEGMENTS = [".paperclip", "plugins", "github-sync", "config.json"];
 var AI_AUTHORED_COMMENT_FOOTER_PREFIX = "Created by a Paperclip AI agent using ";
@@ -546,6 +566,26 @@ var activeSyncPromise = null;
 var activeRunningSyncState = null;
 var activePaperclipApiAuthTokensByCompanyId = null;
 var activeExternalConfigWarningKey = null;
+var activeProjectPullRequestPageCache = /* @__PURE__ */ new Map();
+var activeProjectPullRequestCountCache = /* @__PURE__ */ new Map();
+var activeProjectPullRequestCountPromiseCache = /* @__PURE__ */ new Map();
+var activeProjectPullRequestMetricsCache = /* @__PURE__ */ new Map();
+var activeProjectPullRequestMetricsPromiseCache = /* @__PURE__ */ new Map();
+var activeProjectPullRequestSummaryCache = /* @__PURE__ */ new Map();
+var activeProjectPullRequestSummaryPromiseCache = /* @__PURE__ */ new Map();
+var activeProjectPullRequestSummaryRecordCache = /* @__PURE__ */ new Map();
+var activeProjectPullRequestDetailCache = /* @__PURE__ */ new Map();
+var activeProjectPullRequestIssueLookupCache = /* @__PURE__ */ new Map();
+var activeGitHubPullRequestStatusSnapshotCache = /* @__PURE__ */ new Map();
+var activeGitHubPullRequestStatusSnapshotPromiseCache = /* @__PURE__ */ new Map();
+var activeGitHubPullRequestReviewSummaryCache = /* @__PURE__ */ new Map();
+var activeGitHubPullRequestReviewSummaryPromiseCache = /* @__PURE__ */ new Map();
+var activeGitHubPullRequestReviewThreadSummaryCache = /* @__PURE__ */ new Map();
+var activeGitHubPullRequestReviewThreadSummaryPromiseCache = /* @__PURE__ */ new Map();
+var activeGitHubPullRequestBehindCountCache = /* @__PURE__ */ new Map();
+var activeGitHubPullRequestBehindCountPromiseCache = /* @__PURE__ */ new Map();
+var activeGitHubRepositoryTokenCapabilityAuditCache = /* @__PURE__ */ new Map();
+var activeGitHubRepositoryTokenCapabilityAuditPromiseCache = /* @__PURE__ */ new Map();
 var PaperclipLabelSyncError = class extends Error {
   name = "PaperclipLabelSyncError";
   status;
@@ -577,6 +617,14 @@ var PaperclipLabelSyncError = class extends Error {
     this.labelNames = labelNames;
   }
 };
+var SyncCancellationError = class extends Error {
+  name = "SyncCancellationError";
+  requestedAt;
+  constructor(requestedAt) {
+    super(CANCELLING_SYNC_MESSAGE);
+    this.requestedAt = requestedAt;
+  }
+};
 var SUCCESSFUL_CHECK_RUN_CONCLUSIONS = /* @__PURE__ */ new Set(["SUCCESS", "NEUTRAL", "SKIPPED"]);
 var FAILED_CHECK_RUN_CONCLUSIONS = /* @__PURE__ */ new Set([
   "ACTION_REQUIRED",
@@ -620,23 +668,6 @@ var GITHUB_ISSUE_STATUS_SNAPSHOT_QUERY = `
     }
   }
 `;
-var GITHUB_PULL_REQUEST_REVIEW_THREADS_QUERY = `
-  query GitHubPullRequestReviewThreads($owner: String!, $repo: String!, $pullRequestNumber: Int!, $after: String) {
-    repository(owner: $owner, name: $repo) {
-      pullRequest(number: $pullRequestNumber) {
-        reviewThreads(first: 100, after: $after) {
-          pageInfo {
-            hasNextPage
-            endCursor
-          }
-          nodes {
-            isResolved
-          }
-        }
-      }
-    }
-  }
-`;
 var GITHUB_PULL_REQUEST_CI_CONTEXTS_QUERY = `
   query GitHubPullRequestCiContexts($owner: String!, $repo: String!, $pullRequestNumber: Int!, $after: String) {
     repository(owner: $owner, name: $repo) {
@@ -736,6 +767,235 @@ var GITHUB_REPOSITORY_OPEN_PULL_REQUEST_STATUSES_QUERY = `
     }
   }
 `;
+var GITHUB_PROJECT_PULL_REQUEST_BASE_FIELDS = `
+          id
+          number
+          title
+          url
+          state
+          mergeable
+          mergeStateStatus
+          createdAt
+          updatedAt
+          baseRefName
+          headRefName
+          headRepositoryOwner {
+            login
+          }
+          changedFiles
+          commits {
+            totalCount
+          }
+          author {
+            login
+            url
+            avatarUrl
+          }
+          labels(first: 20) {
+            nodes {
+              name
+              color
+            }
+          }
+          comments {
+            totalCount
+          }
+          closingIssuesReferences(first: 10) {
+            nodes {
+              number
+              url
+            }
+          }
+`;
+var GITHUB_PROJECT_PULL_REQUEST_INSIGHT_FIELDS = `
+          reviews(first: 100) {
+            pageInfo {
+              hasNextPage
+              endCursor
+            }
+            nodes {
+              state
+              author {
+                login
+              }
+            }
+          }
+          reviewThreads(first: 100) {
+            totalCount
+            pageInfo {
+              hasNextPage
+              endCursor
+            }
+            nodes {
+              isResolved
+              comments(first: 1) {
+                nodes {
+                  author {
+                    login
+                  }
+                }
+              }
+            }
+          }
+          statusCheckRollup {
+            contexts(first: 100) {
+              pageInfo {
+                hasNextPage
+                endCursor
+              }
+              nodes {
+                __typename
+                ... on CheckRun {
+                  status
+                  conclusion
+                }
+                ... on StatusContext {
+                  state
+                }
+              }
+            }
+          }
+`;
+var GITHUB_PROJECT_PULL_REQUEST_SUMMARY_FIELDS = `${GITHUB_PROJECT_PULL_REQUEST_BASE_FIELDS}${GITHUB_PROJECT_PULL_REQUEST_INSIGHT_FIELDS}`;
+var GITHUB_PROJECT_PULL_REQUEST_METRICS_FIELDS = `
+          number
+          mergeable
+          reviews(first: 100) {
+            pageInfo {
+              hasNextPage
+              endCursor
+            }
+            nodes {
+              state
+              author {
+                login
+              }
+            }
+          }
+          reviewThreads(first: 100) {
+            pageInfo {
+              hasNextPage
+              endCursor
+            }
+            nodes {
+              isResolved
+              comments(first: 1) {
+                nodes {
+                  author {
+                    login
+                  }
+                }
+              }
+            }
+          }
+          statusCheckRollup {
+            contexts(first: 100) {
+              pageInfo {
+                hasNextPage
+                endCursor
+              }
+              nodes {
+                __typename
+                ... on CheckRun {
+                  status
+                  conclusion
+                }
+                ... on StatusContext {
+                  state
+                }
+              }
+            }
+          }
+`;
+var GITHUB_PROJECT_PULL_REQUESTS_QUERY = `
+  query GitHubProjectPullRequests($owner: String!, $repo: String!, $after: String, $first: Int!) {
+    repository(owner: $owner, name: $repo) {
+      nameWithOwner
+      url
+      defaultBranchRef {
+        name
+      }
+      pullRequests(first: $first, after: $after, states: [OPEN], orderBy: { field: UPDATED_AT, direction: DESC }) {
+        totalCount
+        pageInfo {
+          hasNextPage
+          endCursor
+        }
+        nodes {
+${GITHUB_PROJECT_PULL_REQUEST_SUMMARY_FIELDS}
+        }
+      }
+    }
+  }
+`;
+var GITHUB_PROJECT_PULL_REQUEST_METRICS_QUERY = `
+  query GitHubProjectPullRequestMetrics($owner: String!, $repo: String!, $after: String, $first: Int!) {
+    repository(owner: $owner, name: $repo) {
+      defaultBranchRef {
+        name
+      }
+      pullRequests(first: $first, after: $after, states: [OPEN], orderBy: { field: UPDATED_AT, direction: DESC }) {
+        totalCount
+        pageInfo {
+          hasNextPage
+          endCursor
+        }
+        nodes {
+${GITHUB_PROJECT_PULL_REQUEST_METRICS_FIELDS}
+        }
+      }
+    }
+  }
+`;
+function buildGitHubProjectPullRequestByNumberAlias(pullRequestNumber) {
+  return `pr_${Math.max(1, Math.floor(pullRequestNumber))}`;
+}
+function buildGitHubProjectPullRequestsByNumberQuery(pullRequestNumbers) {
+  const normalizedNumbers = [
+    ...new Set(
+      pullRequestNumbers.map((value) => Math.floor(value)).filter((value) => Number.isFinite(value) && value > 0)
+    )
+  ];
+  if (normalizedNumbers.length === 0) {
+    throw new Error("At least one pull request number is required.");
+  }
+  const selections = normalizedNumbers.map(
+    (pullRequestNumber) => `
+      ${buildGitHubProjectPullRequestByNumberAlias(pullRequestNumber)}: pullRequest(number: ${pullRequestNumber}) {
+${GITHUB_PROJECT_PULL_REQUEST_BASE_FIELDS}
+      }`
+  ).join("\n");
+  return `
+    query GitHubProjectPullRequestsByNumber($owner: String!, $repo: String!) {
+      repository(owner: $owner, name: $repo) {
+${selections}
+      }
+    }
+  `;
+}
+var GITHUB_PROJECT_OPEN_PULL_REQUEST_COUNT_QUERY = `
+  query GitHubProjectOpenPullRequestCount($owner: String!, $repo: String!) {
+    repository(owner: $owner, name: $repo) {
+      pullRequests(first: 1, states: [OPEN]) {
+        totalCount
+      }
+    }
+  }
+`;
+var GITHUB_PULL_REQUEST_CLOSING_ISSUES_QUERY = `
+  query GitHubPullRequestClosingIssues($owner: String!, $repo: String!, $pullRequestNumber: Int!) {
+    repository(owner: $owner, name: $repo) {
+      pullRequest(number: $pullRequestNumber) {
+        closingIssuesReferences(first: 10) {
+          nodes {
+            number
+            url
+          }
+        }
+      }
+    }
+  }
+`;
 var GITHUB_PULL_REQUEST_REVIEW_THREADS_DETAILED_QUERY = `
   query GitHubPullRequestReviewThreadsDetailed($owner: String!, $repo: String!, $pullRequestNumber: Int!, $after: String) {
     repository(owner: $owner, name: $repo) {
@@ -846,6 +1106,30 @@ var GITHUB_MARK_PULL_REQUEST_READY_FOR_REVIEW_MUTATION = `
     }
   }
 `;
+var GITHUB_REQUEST_PULL_REQUEST_COPILOT_REVIEW_MUTATION = `
+  mutation GitHubRequestPullRequestCopilotReview($pullRequestId: ID!, $botLogins: [String!]!) {
+    requestReviews(input: {
+      pullRequestId: $pullRequestId
+      botLogins: $botLogins
+    }) {
+      pullRequest {
+        id
+        number
+        url
+      }
+      requestedReviewers(first: 10) {
+        edges {
+          node {
+            __typename
+            ... on Bot {
+              login
+            }
+          }
+        }
+      }
+    }
+  }
+`;
 var DEFAULT_SETTINGS = {
   mappings: [],
   syncState: {
@@ -884,6 +1168,20 @@ function createIdleSyncState() {
     status: "idle"
   };
 }
+function createCancelledSyncState(params) {
+  const { message, trigger, syncedIssuesCount, createdIssuesCount, skippedIssuesCount, erroredIssuesCount, progress } = params;
+  return {
+    status: "cancelled",
+    message,
+    checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    syncedIssuesCount,
+    createdIssuesCount,
+    skippedIssuesCount,
+    erroredIssuesCount,
+    lastRunTrigger: trigger,
+    ...progress ? { progress: normalizeSyncProgress(progress) } : {}
+  };
+}
 function formatGitHubIssueCountLabel(count) {
   const normalizedCount = Math.max(0, Math.floor(count));
   return `${normalizedCount} GitHub ${normalizedCount === 1 ? "issue" : "issues"}`;
@@ -931,6 +1229,118 @@ function getErrorResponseDataMessage(error) {
   const message = data.message;
   return typeof message === "string" && message.trim() ? message.trim() : void 0;
 }
+function getErrorResponseDataErrors(error) {
+  if (!error || typeof error !== "object" || !("response" in error)) {
+    return [];
+  }
+  const response = error.response;
+  if (!response || typeof response !== "object" || !("data" in response)) {
+    return [];
+  }
+  const data = response.data;
+  if (!data || typeof data !== "object" || !("errors" in data)) {
+    return [];
+  }
+  const errors = data.errors;
+  return Array.isArray(errors) ? errors : [];
+}
+function getGitHubValidationErrorSummary(error) {
+  const entries = getErrorResponseDataErrors(error);
+  if (entries.length === 0) {
+    return void 0;
+  }
+  const summaries = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    if (typeof entry === "string" && entry.trim()) {
+      summaries.add(entry.trim());
+      continue;
+    }
+    if (!entry || typeof entry !== "object") {
+      continue;
+    }
+    const explicitMessage = "message" in entry && typeof entry.message === "string" ? entry.message.trim() : "";
+    if (explicitMessage) {
+      summaries.add(explicitMessage);
+      continue;
+    }
+    const resource = "resource" in entry && typeof entry.resource === "string" ? entry.resource.trim() : "";
+    const field = "field" in entry && typeof entry.field === "string" ? entry.field.trim() : "";
+    const code = "code" in entry && typeof entry.code === "string" ? entry.code.trim().replace(/_/g, " ") : "";
+    const parts = [
+      resource ? resource.replace(/([a-z])([A-Z])/g, "$1 $2") : "",
+      field ? `field "${field}"` : "",
+      code
+    ].filter(Boolean);
+    if (parts.length > 0) {
+      summaries.add(parts.join(" "));
+    }
+  }
+  return summaries.size > 0 ? [...summaries].join("; ") : void 0;
+}
+function formatGitHubPermissionsHeader(value) {
+  if (!value?.trim()) {
+    return void 0;
+  }
+  const parts = value.replace(/;/g, ",").split(",").map((entry) => entry.trim()).filter(Boolean).map((entry) => {
+    const [name, level] = entry.split("=").map((part) => part.trim());
+    if (!name) {
+      return "";
+    }
+    const normalizedName = name.replace(/_/g, " ");
+    return level ? `${normalizedName}: ${level}` : normalizedName;
+  }).filter(Boolean);
+  return parts.length > 0 ? parts.join(", ") : void 0;
+}
+function getAcceptedGitHubPermissionsSummary(error) {
+  const headers = getErrorResponseHeaders(error);
+  return formatGitHubPermissionsHeader(headers["x-accepted-github-permissions"]) ?? formatGitHubPermissionsHeader(headers["x-accepted-oauth-scopes"]);
+}
+function buildGitHubPullRequestWriteActionError(params) {
+  const rateLimitPause = getGitHubRateLimitPauseDetails(params.error);
+  if (rateLimitPause) {
+    const resourceLabel = formatGitHubRateLimitResource(rateLimitPause.resource) ?? "GitHub API";
+    return new Error(`${resourceLabel} rate limit reached. Wait until ${formatUtcTimestamp(rateLimitPause.resetAt)} before retrying.`);
+  }
+  const actionLabel = params.action === "comment" ? "comment" : params.action === "review" ? "review" : "branch update";
+  const rawMessage = getErrorMessage(params.error).trim();
+  const responseMessage = getErrorResponseDataMessage(params.error);
+  const validationSummary = getGitHubValidationErrorSummary(params.error);
+  const permissionsSummary = getAcceptedGitHubPermissionsSummary(params.error);
+  const status = getErrorStatus(params.error);
+  const combinedMessage = [rawMessage, responseMessage].filter((value) => Boolean(value?.trim())).join(" ").toLowerCase();
+  if (params.action === "review" && params.reviewType === "REQUEST_CHANGES" && !params.body?.trim() && status === 422) {
+    return new Error("Add a review summary before requesting changes. GitHub requires a comment for this action.");
+  }
+  if ((status === 403 || status === 404) && (combinedMessage.includes("resource not accessible") || combinedMessage.includes("not accessible by"))) {
+    const requiredAccess = params.action === "comment" ? "Issues: write" : "Pull requests: write";
+    const permissionSuffix = permissionsSummary ? ` GitHub reported required permissions: ${permissionsSummary}.` : "";
+    return new Error(
+      `GitHub rejected this ${actionLabel} because the configured token cannot write to ${params.repositoryLabel}. Reconnect a token with ${requiredAccess} access and repository visibility for this repo, then retry.${permissionSuffix}`
+    );
+  }
+  if (params.action === "update_branch" && status === 422) {
+    if (combinedMessage.includes("expected head sha") || validationSummary?.toLowerCase().includes("expected_head_sha")) {
+      return new Error("This pull request changed while the branch update was being requested. Refresh the queue and try again.");
+    }
+    if (combinedMessage.includes("merge conflict") || combinedMessage.includes("conflict")) {
+      return new Error("This pull request needs conflict resolution before it can be updated with the base branch.");
+    }
+  }
+  if (responseMessage === "Validation Failed" && validationSummary) {
+    return new Error(`GitHub rejected this ${actionLabel}: ${validationSummary}.`);
+  }
+  if (responseMessage && responseMessage !== rawMessage) {
+    const validationSuffix = validationSummary ? ` ${validationSummary}.` : "";
+    return new Error(`GitHub rejected this ${actionLabel}: ${responseMessage}.${validationSuffix}`);
+  }
+  if (validationSummary) {
+    return new Error(`GitHub rejected this ${actionLabel}: ${validationSummary}.`);
+  }
+  if (rawMessage) {
+    return new Error(rawMessage);
+  }
+  return new Error(`GitHub rejected this ${actionLabel}.`);
+}
 function parsePositiveInteger(value) {
   if (!value?.trim()) {
     return void 0;
@@ -952,6 +1362,58 @@ function parseRetryAfterTimestamp(value, now = Date.now()) {
   const timestamp = Date.parse(value);
   return Number.isFinite(timestamp) ? timestamp : void 0;
 }
+function buildGitHubRepositoryTokenCapabilityAuditCacheKey(repository, samplePullRequestNumber) {
+  return `${repository.url.toLowerCase()}::${typeof samplePullRequestNumber === "number" ? samplePullRequestNumber : "none"}`;
+}
+function clearGitHubRepositoryTokenCapabilityAudits() {
+  activeGitHubRepositoryTokenCapabilityAuditCache.clear();
+  activeGitHubRepositoryTokenCapabilityAuditPromiseCache.clear();
+}
+function getGitHubCapabilityMissingPermissionLabel(capability) {
+  switch (capability) {
+    case "comment":
+      return "Issues: write or Pull requests: write";
+    case "review":
+    case "close":
+    case "update_branch":
+      return "Pull requests: write";
+    case "merge":
+      return "Contents: write";
+    case "rerun_ci":
+      return "Checks: write";
+  }
+}
+function classifyGitHubCapabilityProbeError(error, options = {}) {
+  const status = getErrorStatus(error);
+  if (status && options.grantedStatuses?.includes(status)) {
+    return "granted";
+  }
+  if (status === 404 && options.allowNotFoundAsGranted) {
+    return "granted";
+  }
+  if (status === 401 || status === 403 || status === 404) {
+    return "missing";
+  }
+  return "unknown";
+}
+function buildGitHubRepositoryTokenCapabilityAudit(params) {
+  const warnings = [...new Set((params.warnings ?? []).map((warning) => warning.trim()).filter(Boolean))];
+  return {
+    repositoryUrl: params.repository.url,
+    repositoryLabel: formatRepositoryLabel(params.repository),
+    checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    status: params.missingPermissions.length > 0 ? "missing_permissions" : warnings.length > 0 ? "unverifiable" : "verified",
+    ...typeof params.samplePullRequestNumber === "number" ? { samplePullRequestNumber: params.samplePullRequestNumber } : {},
+    canComment: params.canComment,
+    canReview: params.canReview,
+    canClose: params.canClose,
+    canUpdateBranch: params.canUpdateBranch,
+    canMerge: params.canMerge,
+    canRerunCi: params.canRerunCi,
+    missingPermissions: [...new Set(params.missingPermissions)].sort((left, right) => left.localeCompare(right)),
+    warnings
+  };
+}
 function normalizeSecretRef(value) {
   return typeof value === "string" && value.trim() ? value.trim() : void 0;
 }
@@ -997,7 +1459,10 @@ function getGitHubRateLimitPauseDetails(error, now = Date.now()) {
   const retryAfterTimestamp = parseRetryAfterTimestamp(headers["retry-after"], now);
   const responseMessage = getErrorResponseDataMessage(error);
   const rawMessage = [getErrorMessage(error), responseMessage].filter((value) => Boolean(value?.trim())).join(" ").toLowerCase();
-  const looksRateLimited = remaining === "0" || resetAtSeconds !== void 0 || retryAfterTimestamp !== void 0 || rawMessage.includes("rate limit");
+  const hasPrimaryLimitHeaders = remaining === "0" && resetAtSeconds !== void 0;
+  const hasRetryAfterLimitHint = retryAfterTimestamp !== void 0;
+  const hasRateLimitMessage = rawMessage.includes("rate limit");
+  const looksRateLimited = status === 429 || hasPrimaryLimitHeaders || hasRetryAfterLimitHint || hasRateLimitMessage;
   if (!looksRateLimited) {
     return null;
   }
@@ -1047,6 +1512,7 @@ function normalizeSyncConfigurationIssue(value) {
   switch (value) {
     case "missing_token":
     case "missing_mapping":
+    case "missing_board_access":
       return value;
     default:
       return void 0;
@@ -1120,19 +1586,43 @@ function normalizeSyncErrorDetails(value) {
     ...rateLimitResource ? { rateLimitResource } : {}
   };
 }
-function formatSyncFailurePhase(phase) {
-  switch (phase) {
-    case "configuration":
-      return "checking sync configuration";
-    case "loading_paperclip_labels":
-      return "loading Paperclip labels";
-    case "listing_github_issues":
-      return "listing GitHub issues";
-    case "building_import_plan":
-      return "building the GitHub import plan";
-    case "importing_issue":
-      return "importing a GitHub issue";
-    case "syncing_labels":
+function normalizeSyncFailureLogEntry(value) {
+  if (!value || typeof value !== "object") {
+    return void 0;
+  }
+  const record = value;
+  const details = normalizeSyncErrorDetails(record);
+  const message = typeof record.message === "string" && record.message.trim() ? record.message.trim() : void 0;
+  const occurredAt = typeof record.occurredAt === "string" && record.occurredAt.trim() ? record.occurredAt.trim() : void 0;
+  if (!message || !occurredAt) {
+    return void 0;
+  }
+  return {
+    message,
+    occurredAt,
+    ...details ?? {}
+  };
+}
+function normalizeSyncFailureLogEntries(value) {
+  if (!Array.isArray(value)) {
+    return void 0;
+  }
+  const entries = value.map((entry) => normalizeSyncFailureLogEntry(entry)).filter((entry) => entry !== void 0).slice(-MAX_SYNC_FAILURE_LOG_ENTRIES);
+  return entries.length > 0 ? entries : void 0;
+}
+function formatSyncFailurePhase(phase) {
+  switch (phase) {
+    case "configuration":
+      return "checking sync configuration";
+    case "loading_paperclip_labels":
+      return "loading Paperclip labels";
+    case "listing_github_issues":
+      return "listing GitHub issues";
+    case "building_import_plan":
+      return "building the GitHub import plan";
+    case "importing_issue":
+      return "importing a GitHub issue";
+    case "syncing_labels":
       return "syncing issue labels";
     case "syncing_description":
       return "syncing issue descriptions";
@@ -1274,8 +1764,49 @@ function buildSyncErrorDetails(error, context) {
     ...rateLimitPause?.resource ? { rateLimitResource: rateLimitPause.resource } : {}
   };
 }
+function createSyncFailureLogEntry(params) {
+  const message = params.message.trim();
+  const occurredAt = typeof params.occurredAt === "string" && params.occurredAt.trim() ? params.occurredAt.trim() : (/* @__PURE__ */ new Date()).toISOString();
+  const errorDetails = normalizeSyncErrorDetails(params.errorDetails);
+  if (!message) {
+    return void 0;
+  }
+  return {
+    message,
+    occurredAt,
+    ...errorDetails ?? {}
+  };
+}
+function buildSyncFailureLogEntry(error, context, occurredAt) {
+  return createSyncFailureLogEntry({
+    message: buildSyncFailureMessage(error, context),
+    occurredAt,
+    errorDetails: buildSyncErrorDetails(error, context)
+  });
+}
+function buildRecentSyncFailureLogEntries(failures) {
+  const entries = failures.slice(-MAX_SYNC_FAILURE_LOG_ENTRIES).map((failure) => buildSyncFailureLogEntry(failure.error, failure.context, failure.occurredAt)).filter((entry) => entry !== void 0);
+  return entries.length > 0 ? entries : void 0;
+}
+function appendRecentSyncFailureLogEntry(entries, entry) {
+  if (!entry) {
+    return entries;
+  }
+  return [...entries ?? [], entry].slice(-MAX_SYNC_FAILURE_LOG_ENTRIES);
+}
 function createErrorSyncState(params) {
-  const { message, trigger, syncedIssuesCount, createdIssuesCount, skippedIssuesCount, erroredIssuesCount, progress, errorDetails } = params;
+  const {
+    message,
+    trigger,
+    syncedIssuesCount,
+    createdIssuesCount,
+    skippedIssuesCount,
+    erroredIssuesCount,
+    progress,
+    errorDetails,
+    recentFailures
+  } = params;
+  const normalizedRecentFailures = normalizeSyncFailureLogEntries(recentFailures);
   return {
     status: "error",
     message,
@@ -1286,20 +1817,27 @@ function createErrorSyncState(params) {
     erroredIssuesCount,
     lastRunTrigger: trigger,
     ...progress ? { progress: normalizeSyncProgress(progress) } : {},
-    ...errorDetails ? { errorDetails } : {}
+    ...errorDetails ? { errorDetails } : {},
+    ...normalizedRecentFailures ? { recentFailures: normalizedRecentFailures } : {}
   };
 }
 function createRunningSyncState(previous, trigger, options = {}) {
+  const previousRunningState = previous.status === "running" ? previous : void 0;
+  const nextMessage = options.message ?? previousRunningState?.message ?? RUNNING_SYNC_MESSAGE;
+  const nextCancelRequestedAt = options.cancelRequestedAt ?? previousRunningState?.cancelRequestedAt;
+  const normalizedRecentFailures = normalizeSyncFailureLogEntries(options.recentFailures);
   return {
     status: "running",
-    message: options.message ?? RUNNING_SYNC_MESSAGE,
+    message: nextMessage,
     checkedAt: previous.checkedAt,
     syncedIssuesCount: options.syncedIssuesCount ?? 0,
     createdIssuesCount: options.createdIssuesCount ?? 0,
     skippedIssuesCount: options.skippedIssuesCount ?? 0,
     erroredIssuesCount: options.erroredIssuesCount ?? 0,
     lastRunTrigger: trigger,
-    ...options.progress ? { progress: normalizeSyncProgress(options.progress) } : {}
+    ...nextCancelRequestedAt ? { cancelRequestedAt: nextCancelRequestedAt } : {},
+    ...options.progress ? { progress: normalizeSyncProgress(options.progress) } : {},
+    ...normalizedRecentFailures ? { recentFailures: normalizedRecentFailures } : {}
   };
 }
 function getSyncableMappings(mappings) {
@@ -1341,6 +1879,96 @@ function getSyncableMappingsForTarget(mappings, target) {
       return syncableMappings;
   }
 }
+function normalizeProjectNameForComparison(value) {
+  if (typeof value !== "string") {
+    return "";
+  }
+  return value.trim().replace(/\s+/g, " ").toLowerCase();
+}
+function hydrateResolvedProjectMapping(mapping, context) {
+  const resolvedProjectName = mapping.paperclipProjectName.trim() || context.projectName?.trim() || mapping.paperclipProjectName;
+  return {
+    ...mapping,
+    companyId: mapping.companyId ?? context.companyId,
+    paperclipProjectId: mapping.paperclipProjectId ?? context.projectId,
+    paperclipProjectName: resolvedProjectName
+  };
+}
+function getProjectRepositoryUrlFromProjectRecord(project) {
+  if (!project) {
+    return void 0;
+  }
+  const repositoryCandidates = [
+    project.codebase?.repoUrl,
+    project.primaryWorkspace?.repoUrl,
+    ...Array.isArray(project.workspaces) ? project.workspaces.map((workspace) => workspace?.repoUrl) : []
+  ];
+  for (const repositoryUrl of repositoryCandidates) {
+    if (typeof repositoryUrl !== "string" || !repositoryUrl.trim()) {
+      continue;
+    }
+    const normalizedRepositoryUrl = parseRepositoryReference(repositoryUrl)?.url ?? repositoryUrl.trim();
+    if (parseRepositoryReference(normalizedRepositoryUrl)) {
+      return normalizedRepositoryUrl;
+    }
+  }
+  return void 0;
+}
+async function resolveProjectScopedMappings(ctx, mappings, params) {
+  const companyId = normalizeCompanyId(params.companyId);
+  const projectId = typeof params.projectId === "string" && params.projectId.trim() ? params.projectId.trim() : void 0;
+  if (!companyId || !projectId) {
+    return [];
+  }
+  const candidateMappings = mappings.filter((mapping) => mapping.repositoryUrl.trim());
+  const exactMatches = candidateMappings.filter(
+    (mapping) => mapping.paperclipProjectId === projectId && (!mapping.companyId || mapping.companyId === companyId)
+  ).map((mapping) => hydrateResolvedProjectMapping(mapping, {
+    companyId,
+    projectId
+  }));
+  if (exactMatches.length > 0) {
+    return exactMatches;
+  }
+  const namedFallbackCandidates = candidateMappings.filter(
+    (mapping) => !mapping.paperclipProjectId && mapping.companyId === companyId && Boolean(normalizeProjectNameForComparison(mapping.paperclipProjectName))
+  );
+  let projectName = "";
+  let projectRepositoryUrl;
+  try {
+    const project = await ctx.projects.get(projectId, companyId);
+    projectName = typeof project?.name === "string" ? project.name.trim() : "";
+    projectRepositoryUrl = getProjectRepositoryUrlFromProjectRecord(project);
+  } catch (error) {
+    ctx.logger.warn("Unable to resolve Paperclip project metadata for GitHub project mapping fallback.", {
+      companyId,
+      projectId,
+      error: getErrorMessage(error)
+    });
+    return [];
+  }
+  const normalizedProjectName = normalizeProjectNameForComparison(projectName);
+  if (normalizedProjectName) {
+    const namedFallbackMatches = namedFallbackCandidates.filter((mapping) => normalizeProjectNameForComparison(mapping.paperclipProjectName) === normalizedProjectName).map((mapping) => hydrateResolvedProjectMapping(mapping, {
+      companyId,
+      projectId,
+      projectName
+    }));
+    if (namedFallbackMatches.length > 0) {
+      return namedFallbackMatches;
+    }
+  }
+  if (!projectRepositoryUrl) {
+    return [];
+  }
+  return [{
+    id: `project-repo:${companyId}:${projectId}`,
+    repositoryUrl: projectRepositoryUrl,
+    paperclipProjectName: projectName || "Project",
+    paperclipProjectId: projectId,
+    companyId
+  }];
+}
 function doesGitHubIssueMatchTarget(issue, target) {
   if (!target || target.kind !== "issue") {
     return true;
@@ -1523,7 +2151,7 @@ function extractGitHubLinksFromCommentBody(body) {
   return [...links.values()];
 }
 async function buildToolbarSyncState(ctx, input) {
-  const settings = normalizeSettings(await ctx.state.get(SETTINGS_SCOPE));
+  const settings = await getActiveOrCurrentSyncState(ctx);
   const config = await getResolvedConfig(ctx);
   const githubTokenConfigured = hasConfiguredGithubToken(settings, config);
   const companyId = typeof input.companyId === "string" && input.companyId.trim() ? input.companyId.trim() : void 0;
@@ -1771,6 +2399,93 @@ async function listAvailableAssignees(ctx, companyId) {
     return [];
   }
 }
+async function resolvePaperclipIssueDrawerAgents(ctx, companyId, agentIds) {
+  const normalizedAgentIds = [
+    ...new Set(
+      agentIds.filter((agentId) => typeof agentId === "string" && agentId.trim().length > 0).map((agentId) => agentId.trim())
+    )
+  ];
+  const agentsById = /* @__PURE__ */ new Map();
+  if (normalizedAgentIds.length === 0 || !ctx.agents || typeof ctx.agents.get !== "function") {
+    return agentsById;
+  }
+  await Promise.all(
+    normalizedAgentIds.map(async (agentId) => {
+      try {
+        const agent = await ctx.agents.get(agentId, companyId);
+        if (!agent) {
+          return;
+        }
+        agentsById.set(agent.id, {
+          id: agent.id,
+          name: agent.name,
+          ...agent.title?.trim() ? { title: agent.title.trim() } : {}
+        });
+      } catch (error) {
+        ctx.logger.warn("Unable to load Paperclip agent for pull request issue drawer.", {
+          companyId,
+          agentId,
+          error: getErrorMessage(error)
+        });
+      }
+    })
+  );
+  return agentsById;
+}
+async function buildProjectPullRequestPaperclipIssueData(ctx, input) {
+  const issueId = typeof input.issueId === "string" && input.issueId.trim() ? input.issueId.trim() : void 0;
+  const companyId = typeof input.companyId === "string" && input.companyId.trim() ? input.companyId.trim() : void 0;
+  if (!issueId || !companyId) {
+    return null;
+  }
+  const issue = await ctx.issues.get(issueId, companyId);
+  if (!issue) {
+    return null;
+  }
+  const comments = ctx.issues && typeof ctx.issues.listComments === "function" ? await ctx.issues.listComments(issue.id, companyId) : [];
+  const agentsById = await resolvePaperclipIssueDrawerAgents(ctx, companyId, [
+    issue.assigneeAgentId,
+    issue.createdByAgentId,
+    ...comments.map((comment) => comment.authorAgentId)
+  ]);
+  const assignee = issue.assigneeAgentId ? agentsById.get(issue.assigneeAgentId) ?? null : null;
+  const orderedComments = [...comments].sort(
+    (left, right) => coerceDate(left.createdAt).getTime() - coerceDate(right.createdAt).getTime()
+  );
+  return {
+    issueId: issue.id,
+    ...issue.identifier?.trim() ? { issueIdentifier: issue.identifier.trim() } : {},
+    title: issue.title,
+    description: issue.description ?? "",
+    status: issue.status,
+    priority: issue.priority,
+    projectName: issue.project?.name ?? void 0,
+    createdAt: coerceDate(issue.createdAt).toISOString(),
+    updatedAt: coerceDate(issue.updatedAt).toISOString(),
+    labels: Array.isArray(issue.labels) ? issue.labels.map((label) => ({
+      name: label.name,
+      color: label.color
+    })).filter((label) => label.name.trim().length > 0) : [],
+    assignee: assignee ? {
+      id: assignee.id,
+      name: assignee.name,
+      ...assignee.title ? { title: assignee.title } : {}
+    } : null,
+    commentCount: orderedComments.length,
+    comments: orderedComments.map((comment) => {
+      const author = comment.authorAgentId ? agentsById.get(comment.authorAgentId) : null;
+      return {
+        id: comment.id,
+        body: comment.body ?? "",
+        createdAt: coerceDate(comment.createdAt).toISOString(),
+        updatedAt: coerceDate(comment.updatedAt).toISOString(),
+        authorLabel: author?.name ?? (comment.authorUserId ? "Team member" : "Paperclip"),
+        authorKind: author ? "agent" : comment.authorUserId ? "user" : "system",
+        ...author?.title ? { authorTitle: author.title } : {}
+      };
+    })
+  };
+}
 function createSetupConfigurationErrorSyncState(issue, trigger) {
   switch (issue) {
     case "missing_token":
@@ -1785,7 +2500,16 @@ function createSetupConfigurationErrorSyncState(issue, trigger) {
           phase: "configuration",
           configurationIssue: "missing_token",
           suggestedAction: MISSING_GITHUB_TOKEN_SYNC_ACTION
-        }
+        },
+        recentFailures: [
+          {
+            message: MISSING_GITHUB_TOKEN_SYNC_MESSAGE,
+            occurredAt: (/* @__PURE__ */ new Date()).toISOString(),
+            phase: "configuration",
+            configurationIssue: "missing_token",
+            suggestedAction: MISSING_GITHUB_TOKEN_SYNC_ACTION
+          }
+        ]
       });
     case "missing_mapping":
       return createErrorSyncState({
@@ -1799,7 +2523,16 @@ function createSetupConfigurationErrorSyncState(issue, trigger) {
           phase: "configuration",
           configurationIssue: "missing_mapping",
           suggestedAction: MISSING_MAPPING_SYNC_ACTION
-        }
+        },
+        recentFailures: [
+          {
+            message: MISSING_MAPPING_SYNC_MESSAGE,
+            occurredAt: (/* @__PURE__ */ new Date()).toISOString(),
+            phase: "configuration",
+            configurationIssue: "missing_mapping",
+            suggestedAction: MISSING_MAPPING_SYNC_ACTION
+          }
+        ]
       });
     case "missing_board_access":
       return createErrorSyncState({
@@ -1813,7 +2546,16 @@ function createSetupConfigurationErrorSyncState(issue, trigger) {
           phase: "configuration",
           configurationIssue: "missing_board_access",
           suggestedAction: MISSING_BOARD_ACCESS_SYNC_ACTION
-        }
+        },
+        recentFailures: [
+          {
+            message: MISSING_BOARD_ACCESS_SYNC_MESSAGE,
+            occurredAt: (/* @__PURE__ */ new Date()).toISOString(),
+            phase: "configuration",
+            configurationIssue: "missing_board_access",
+            suggestedAction: MISSING_BOARD_ACCESS_SYNC_ACTION
+          }
+        ]
       });
   }
 }
@@ -1826,6 +2568,29 @@ async function saveSettingsSyncState(ctx, settings, syncState) {
   await ctx.state.set(SYNC_STATE_SCOPE, next.syncState);
   return next;
 }
+async function setSyncCancellationRequest(ctx, request) {
+  if (request) {
+    await ctx.state.set(SYNC_CANCELLATION_SCOPE, request);
+    return;
+  }
+  await ctx.state.delete(SYNC_CANCELLATION_SCOPE);
+}
+async function getSyncCancellationRequest(ctx) {
+  const activeRequestedAt = activeRunningSyncState?.syncState.cancelRequestedAt?.trim();
+  if (activeRunningSyncState?.syncState.status === "running" && activeRequestedAt) {
+    return {
+      requestedAt: activeRequestedAt
+    };
+  }
+  return normalizeSyncCancellationRequest(await ctx.state.get(SYNC_CANCELLATION_SCOPE));
+}
+function buildCancelledSyncMessage(target, progress) {
+  const completedIssueCount = typeof progress?.completedIssueCount === "number" ? Math.max(0, progress.completedIssueCount) : void 0;
+  const totalIssueCount = typeof progress?.totalIssueCount === "number" ? Math.max(0, progress.totalIssueCount) : void 0;
+  const scopeLabel = target ? `GitHub sync for ${target.displayLabel}` : "GitHub sync";
+  const completionSummary = completedIssueCount !== void 0 && totalIssueCount !== void 0 ? ` Completed ${Math.min(completedIssueCount, totalIssueCount)} of ${totalIssueCount} issues before stopping.` : "";
+  return `${scopeLabel} was cancelled before it finished.${completionSummary}`;
+}
 async function createUnexpectedSyncErrorResult(ctx, trigger, error) {
   const settings = normalizeSettings(await ctx.state.get(SETTINGS_SCOPE));
   const errorDetails = buildSyncErrorDetails(error, {
@@ -1844,7 +2609,14 @@ async function createUnexpectedSyncErrorResult(ctx, trigger, error) {
       createdIssuesCount: settings.syncState.createdIssuesCount ?? 0,
       skippedIssuesCount: settings.syncState.skippedIssuesCount ?? 0,
       erroredIssuesCount: 0,
-      errorDetails
+      errorDetails,
+      recentFailures: appendRecentSyncFailureLogEntry(
+        void 0,
+        createSyncFailureLogEntry({
+          message,
+          errorDetails
+        })
+      )
     })
   );
 }
@@ -1864,11 +2636,14 @@ async function waitForSyncResultWithinGracePeriod(promise, timeoutMs) {
   }
 }
 async function getActiveOrCurrentSyncState(ctx) {
+  if (activeRunningSyncState?.syncState.status === "running") {
+    return activeRunningSyncState;
+  }
   const current = normalizeSettings(await ctx.state.get(SETTINGS_SCOPE));
   if (current.syncState.status === "running") {
     return current;
   }
-  return activeRunningSyncState?.syncState.status === "running" ? activeRunningSyncState : current;
+  return current;
 }
 function updateSyncFailureContext(current, next) {
   if ("phase" in next) {
@@ -1892,7 +2667,8 @@ function recordRecoverableSyncFailure(ctx, failures, error, context) {
   const snapshot = cloneSyncFailureContext(context);
   failures.push({
     error,
-    context: snapshot
+    context: snapshot,
+    occurredAt: (/* @__PURE__ */ new Date()).toISOString()
   });
   ctx.logger.warn("GitHub sync skipped a failed item and continued.", {
     phase: snapshot.phase,
@@ -1998,6 +2774,13 @@ function normalizePaperclipBoardApiTokenRefs(value) {
   }
   return Object.fromEntries(entries);
 }
+function normalizeSyncCancellationRequest(value) {
+  if (!value || typeof value !== "object") {
+    return null;
+  }
+  const requestedAt = typeof value.requestedAt === "string" ? value.requestedAt.trim() : "";
+  return requestedAt ? { requestedAt } : null;
+}
 function normalizeSyncState(value) {
   if (!value || typeof value !== "object") {
     return DEFAULT_SETTINGS.syncState;
@@ -2007,8 +2790,9 @@ function normalizeSyncState(value) {
   const lastRunTrigger = record.lastRunTrigger;
   const progress = normalizeSyncProgress(record.progress);
   const errorDetails = normalizeSyncErrorDetails(record.errorDetails);
+  const recentFailures = normalizeSyncFailureLogEntries(record.recentFailures);
   return {
-    status: status === "running" || status === "success" || status === "error" ? status : "idle",
+    status: status === "running" || status === "success" || status === "error" || status === "cancelled" ? status : "idle",
     message: typeof record.message === "string" ? record.message : void 0,
     checkedAt: typeof record.checkedAt === "string" ? record.checkedAt : void 0,
     syncedIssuesCount: typeof record.syncedIssuesCount === "number" ? record.syncedIssuesCount : void 0,
@@ -2016,8 +2800,10 @@ function normalizeSyncState(value) {
     skippedIssuesCount: typeof record.skippedIssuesCount === "number" ? record.skippedIssuesCount : void 0,
     erroredIssuesCount: typeof record.erroredIssuesCount === "number" ? record.erroredIssuesCount : void 0,
     lastRunTrigger: lastRunTrigger === "manual" || lastRunTrigger === "schedule" || lastRunTrigger === "retry" ? lastRunTrigger : void 0,
+    cancelRequestedAt: typeof record.cancelRequestedAt === "string" ? record.cancelRequestedAt : void 0,
     ...progress ? { progress } : {},
-    ...errorDetails ? { errorDetails } : {}
+    ...errorDetails ? { errorDetails } : {},
+    ...recentFailures ? { recentFailures } : {}
   };
 }
 function normalizeMappings(value) {
@@ -2051,6 +2837,22 @@ function normalizeGitHubUsername(value) {
   const trimmed = value.trim().replace(/^@+/, "");
   return trimmed ? trimmed.toLowerCase() : void 0;
 }
+function buildGitHubUsernameAliases(value) {
+  const normalized = normalizeGitHubUsername(value);
+  if (!normalized) {
+    return [];
+  }
+  const aliases = /* @__PURE__ */ new Set([normalized]);
+  if (normalized.endsWith("[bot]")) {
+    const withoutBotSuffix = normalized.slice(0, -"[bot]".length);
+    if (withoutBotSuffix) {
+      aliases.add(withoutBotSuffix);
+    }
+  } else {
+    aliases.add(`${normalized}[bot]`);
+  }
+  return [...aliases];
+}
 function parseIgnoredIssueAuthorUsernames(value) {
   return value.split(/[\s,]+/g).map((entry) => normalizeGitHubUsername(entry)).filter((entry) => Boolean(entry));
 }
@@ -2370,6 +3172,286 @@ function getPageCursor(pageInfo) {
   }
   return pageInfo.endCursor;
 }
+async function mapWithConcurrency(items, concurrency, mapper) {
+  if (items.length === 0) {
+    return [];
+  }
+  const limit = Math.max(1, Math.floor(concurrency));
+  const results = new Array(items.length);
+  let nextIndex = 0;
+  async function worker() {
+    while (nextIndex < items.length) {
+      const currentIndex = nextIndex;
+      nextIndex += 1;
+      results[currentIndex] = await mapper(items[currentIndex], currentIndex);
+    }
+  }
+  await Promise.all(
+    Array.from(
+      { length: Math.min(limit, items.length) },
+      async () => worker()
+    )
+  );
+  return results;
+}
+function getFreshCacheValue(cache, key, now = Date.now()) {
+  const entry = cache.get(key);
+  if (!entry) {
+    return null;
+  }
+  if (entry.expiresAt <= now) {
+    cache.delete(key);
+    return null;
+  }
+  return entry.value;
+}
+function getFreshCacheEntry(cache, key, now = Date.now()) {
+  const entry = cache.get(key);
+  if (!entry) {
+    return null;
+  }
+  if (entry.expiresAt <= now) {
+    cache.delete(key);
+    return null;
+  }
+  return entry;
+}
+function setCacheValue(cache, key, value, ttlMs, now = Date.now()) {
+  cache.set(key, {
+    expiresAt: now + ttlMs,
+    value
+  });
+  return value;
+}
+function normalizeProjectPullRequestFilter(value) {
+  switch (value) {
+    case "mergeable":
+    case "reviewable":
+    case "failing":
+      return value;
+    default:
+      return "all";
+  }
+}
+function normalizeProjectPullRequestPageIndex(value) {
+  if (typeof value === "number" && Number.isFinite(value) && value >= 0) {
+    return Math.floor(value);
+  }
+  if (typeof value === "string" && value.trim()) {
+    const parsed = Number(value.trim());
+    if (Number.isFinite(parsed) && parsed >= 0) {
+      return Math.floor(parsed);
+    }
+  }
+  return 0;
+}
+function isCopilotActorLogin(value) {
+  const normalizedLogin = normalizeGitHubUsername(value);
+  return Boolean(normalizedLogin && normalizedLogin.includes("copilot"));
+}
+function getProjectPullRequestReviewThreadStarterLogin(node) {
+  return normalizeGitHubUsername(
+    node?.comments?.nodes?.find((comment) => comment?.author?.login)?.author?.login
+  );
+}
+function getDetailedPullRequestReviewThreadStarterLogin(thread) {
+  const rootComment = thread.comments.find((comment) => !comment.replyToId) ?? thread.comments[0];
+  return normalizeGitHubUsername(rootComment?.authorLogin);
+}
+function summarizeProjectPullRequestReviewThreadsFromConnection(connection) {
+  let unresolvedReviewThreads = 0;
+  let copilotUnresolvedReviewThreads = 0;
+  for (const thread of connection?.nodes ?? []) {
+    if (thread?.isResolved !== false) {
+      continue;
+    }
+    unresolvedReviewThreads += 1;
+    if (isCopilotActorLogin(getProjectPullRequestReviewThreadStarterLogin(thread))) {
+      copilotUnresolvedReviewThreads += 1;
+    }
+  }
+  return {
+    unresolvedReviewThreads,
+    copilotUnresolvedReviewThreads
+  };
+}
+function summarizeDetailedPullRequestReviewThreads(threads) {
+  let unresolvedReviewThreads = 0;
+  let copilotUnresolvedReviewThreads = 0;
+  for (const thread of threads) {
+    if (thread.isResolved) {
+      continue;
+    }
+    unresolvedReviewThreads += 1;
+    if (isCopilotActorLogin(getDetailedPullRequestReviewThreadStarterLogin(thread))) {
+      copilotUnresolvedReviewThreads += 1;
+    }
+  }
+  return {
+    unresolvedReviewThreads,
+    copilotUnresolvedReviewThreads
+  };
+}
+function normalizeProjectPullRequestClosingIssues(repository, nodes) {
+  const seen = /* @__PURE__ */ new Set();
+  const issues = [];
+  for (const node of nodes ?? []) {
+    const issueNumber = typeof node?.number === "number" && node.number > 0 ? Math.floor(node.number) : void 0;
+    const issueUrl = typeof node?.url === "string" && node.url.trim() ? normalizeGitHubIssueHtmlUrl(node.url) : issueNumber !== void 0 ? buildGitHubIssueUrlFromRepository(repository.url, issueNumber) : void 0;
+    if (issueNumber === void 0 || !issueUrl || seen.has(issueUrl)) {
+      continue;
+    }
+    seen.add(issueUrl);
+    issues.push({
+      number: issueNumber,
+      url: issueUrl
+    });
+  }
+  return issues;
+}
+function resolveProjectPullRequestReviewable(record) {
+  return record.githubMergeable === true && record.checksStatus === "passed" && typeof record.copilotUnresolvedReviewThreads === "number" && record.copilotUnresolvedReviewThreads === 0;
+}
+function resolveProjectPullRequestMergeable(record) {
+  return record.githubMergeable === true && record.checksStatus === "passed" && typeof record.reviewApprovals === "number" && record.reviewApprovals > 0 && typeof record.unresolvedReviewThreads === "number" && record.unresolvedReviewThreads === 0;
+}
+function resolveProjectPullRequestUpToDateStatus(record) {
+  const mergeStateStatus = typeof record.mergeStateStatus === "string" ? record.mergeStateStatus : null;
+  if (mergeStateStatus === "DIRTY" || record.mergeable === "CONFLICTING") {
+    return "conflicts";
+  }
+  if (typeof record.behindBy === "number" && Number.isFinite(record.behindBy) && record.behindBy > 0) {
+    return "can_update";
+  }
+  if (typeof record.behindBy === "number" && Number.isFinite(record.behindBy) && record.behindBy === 0) {
+    return "up_to_date";
+  }
+  if (mergeStateStatus === "BEHIND") {
+    return "can_update";
+  }
+  return "unknown";
+}
+function normalizeProjectPullRequestCopilotAction(value) {
+  switch (typeof value === "string" ? value.trim().toLowerCase() : "") {
+    case "fix_ci":
+      return "fix_ci";
+    case "rebase":
+      return "rebase";
+    case "address_review_feedback":
+      return "address_review_feedback";
+    case "review":
+      return "review";
+    default:
+      return null;
+  }
+}
+function getProjectPullRequestCopilotActionLabel(action) {
+  switch (action) {
+    case "fix_ci":
+      return "Fix CI";
+    case "rebase":
+      return "Rebase";
+    case "address_review_feedback":
+      return "Address review feedback";
+    case "review":
+      return "Review";
+  }
+}
+function getProjectPullRequestNumber(record) {
+  const number = record.number;
+  if (typeof number !== "number" || !Number.isFinite(number) || number <= 0) {
+    return null;
+  }
+  return Math.floor(number);
+}
+function getProjectPullRequestUpdatedAtTimestamp(record) {
+  const updatedAt = typeof record.updatedAt === "string" ? Date.parse(record.updatedAt) : Number.NaN;
+  return Number.isFinite(updatedAt) ? updatedAt : 0;
+}
+function sortProjectPullRequestRecordsByUpdatedAt(records) {
+  return [...records].sort((left, right) => {
+    const timestampDelta = getProjectPullRequestUpdatedAtTimestamp(right) - getProjectPullRequestUpdatedAtTimestamp(left);
+    if (timestampDelta !== 0) {
+      return timestampDelta;
+    }
+    return (getProjectPullRequestNumber(right) ?? 0) - (getProjectPullRequestNumber(left) ?? 0);
+  });
+}
+function getLinkedPaperclipIssueFromProjectPullRequestRecord(record) {
+  const paperclipIssueId = typeof record.paperclipIssueId === "string" && record.paperclipIssueId.trim() ? record.paperclipIssueId.trim() : void 0;
+  if (!paperclipIssueId) {
+    return void 0;
+  }
+  return {
+    paperclipIssueId,
+    ...typeof record.paperclipIssueKey === "string" && record.paperclipIssueKey.trim() ? { paperclipIssueKey: record.paperclipIssueKey.trim() } : {}
+  };
+}
+function buildProjectPullRequestMetrics(pullRequests, totalOpenPullRequests, defaultBranchName) {
+  const mergeablePullRequestNumbers = [];
+  const reviewablePullRequestNumbers = [];
+  const failingPullRequestNumbers = [];
+  for (const pullRequest of pullRequests) {
+    const number = getProjectPullRequestNumber(pullRequest);
+    if (number === null) {
+      continue;
+    }
+    if (pullRequest.mergeable === true) {
+      mergeablePullRequestNumbers.push(number);
+    }
+    if (pullRequest.reviewable === true) {
+      reviewablePullRequestNumbers.push(number);
+    }
+    if (pullRequest.checksStatus === "failed") {
+      failingPullRequestNumbers.push(number);
+    }
+  }
+  return {
+    totalOpenPullRequests,
+    ...defaultBranchName ? { defaultBranchName } : {},
+    mergeablePullRequests: mergeablePullRequestNumbers.length,
+    reviewablePullRequests: reviewablePullRequestNumbers.length,
+    failingPullRequests: failingPullRequestNumbers.length,
+    mergeablePullRequestNumbers,
+    reviewablePullRequestNumbers,
+    failingPullRequestNumbers
+  };
+}
+function getPublicProjectPullRequestMetrics(metrics) {
+  return {
+    totalOpenPullRequests: metrics.totalOpenPullRequests,
+    ...metrics.defaultBranchName ? { defaultBranchName: metrics.defaultBranchName } : {},
+    mergeablePullRequests: metrics.mergeablePullRequests,
+    reviewablePullRequests: metrics.reviewablePullRequests,
+    failingPullRequests: metrics.failingPullRequests
+  };
+}
+function sliceProjectPullRequestRecords(pullRequests, pageIndex, pageSize = PROJECT_PULL_REQUEST_PAGE_SIZE) {
+  const effectivePageSize = Math.max(1, Math.floor(pageSize));
+  const maxPageIndex = Math.max(0, Math.ceil(pullRequests.length / effectivePageSize) - 1);
+  const normalizedPageIndex = Math.min(Math.max(0, Math.floor(pageIndex)), maxPageIndex);
+  const start = normalizedPageIndex * effectivePageSize;
+  const end = start + effectivePageSize;
+  return {
+    pullRequests: pullRequests.slice(start, end),
+    pageIndex: normalizedPageIndex,
+    hasNextPage: end < pullRequests.length,
+    hasPreviousPage: normalizedPageIndex > 0
+  };
+}
+function sliceProjectPullRequestNumbers(pullRequestNumbers, pageIndex, pageSize = PROJECT_PULL_REQUEST_PAGE_SIZE) {
+  const effectivePageSize = Math.max(1, Math.floor(pageSize));
+  const maxPageIndex = Math.max(0, Math.ceil(pullRequestNumbers.length / effectivePageSize) - 1);
+  const normalizedPageIndex = Math.min(Math.max(0, Math.floor(pageIndex)), maxPageIndex);
+  const start = normalizedPageIndex * effectivePageSize;
+  const end = start + effectivePageSize;
+  return {
+    pullRequestNumbers: pullRequestNumbers.slice(start, end),
+    pageIndex: normalizedPageIndex,
+    hasNextPage: end < pullRequestNumbers.length,
+    hasPreviousPage: normalizedPageIndex > 0
+  };
+}
 function classifyGitHubPullRequestCiState(contexts) {
   if (contexts.length === 0) {
     return "unfinished";
@@ -2649,17 +3731,24 @@ function tryBuildGitHubPullRequestStatusSnapshotFromBatchNode(node) {
   if (typeof node.number !== "number") {
     return null;
   }
-  const reviewThreads = node.reviewThreads;
-  const ciContexts = node.statusCheckRollup?.contexts;
-  if (reviewThreads?.pageInfo?.hasNextPage || ciContexts?.pageInfo?.hasNextPage) {
+  const reviewThreadSummary = node.reviewThreads?.pageInfo?.hasNextPage ? null : summarizeProjectPullRequestReviewThreadsFromConnection(node.reviewThreads);
+  const ciState = tryBuildGitHubPullRequestCiStateFromBatchNode(node);
+  if (!reviewThreadSummary || !ciState) {
     return null;
   }
   return {
     number: node.number,
-    hasUnresolvedReviewThreads: (reviewThreads?.nodes ?? []).some((reviewThread) => reviewThread?.isResolved === false),
-    ciState: classifyGitHubPullRequestCiState(extractGitHubCiContextRecords(ciContexts?.nodes ?? []))
+    hasUnresolvedReviewThreads: reviewThreadSummary.unresolvedReviewThreads > 0,
+    ciState
   };
 }
+function tryBuildGitHubPullRequestCiStateFromBatchNode(node) {
+  const ciContexts = node.statusCheckRollup?.contexts;
+  if (ciContexts?.pageInfo?.hasNextPage) {
+    return null;
+  }
+  return classifyGitHubPullRequestCiState(extractGitHubCiContextRecords(ciContexts?.nodes ?? []));
+}
 async function warmGitHubPullRequestStatusCache(octokit, repository, targetPullRequestNumbers, pullRequestStatusCache) {
   if (targetPullRequestNumbers.size === 0) {
     return;
@@ -2689,6 +3778,7 @@ async function warmGitHubPullRequestStatusCache(octokit, repository, targetPullR
       const snapshot = tryBuildGitHubPullRequestStatusSnapshotFromBatchNode(node);
       if (snapshot) {
         pullRequestStatusCache.set(node.number, snapshot);
+        cacheGitHubPullRequestStatusSnapshot(repository, snapshot);
       }
     }
     if (remainingNumbers.size === 0) {
@@ -2697,29 +3787,8 @@ async function warmGitHubPullRequestStatusCache(octokit, repository, targetPullR
     after = getPageCursor(pullRequests?.pageInfo);
   } while (after);
 }
-async function hasGitHubPullRequestUnresolvedReviewThreads(octokit, repository, pullRequestNumber) {
-  let after;
-  do {
-    const response = await octokit.graphql(
-      GITHUB_PULL_REQUEST_REVIEW_THREADS_QUERY,
-      {
-        owner: repository.owner,
-        repo: repository.repo,
-        pullRequestNumber,
-        after
-      }
-    );
-    const reviewThreads = response.repository?.pullRequest?.reviewThreads;
-    const nodes = reviewThreads?.nodes ?? [];
-    if (nodes.some((node) => node?.isResolved === false)) {
-      return true;
-    }
-    after = getPageCursor(reviewThreads?.pageInfo);
-  } while (after);
-  return false;
-}
-async function getGitHubPullRequestCiState(octokit, repository, pullRequestNumber) {
-  const contexts = [];
+async function getGitHubPullRequestCiState(octokit, repository, pullRequestNumber) {
+  const contexts = [];
   let after;
   do {
     const response = await octokit.graphql(GITHUB_PULL_REQUEST_CI_CONTEXTS_QUERY, {
@@ -2753,22 +3822,53 @@ async function getGitHubPullRequestCiState(octokit, repository, pullRequestNumbe
   } while (after);
   return classifyGitHubPullRequestCiState(contexts);
 }
-async function getGitHubPullRequestStatusSnapshot(octokit, repository, pullRequestNumber, pullRequestStatusCache) {
+async function getGitHubPullRequestStatusSnapshot(octokit, repository, pullRequestNumber, pullRequestStatusCache, options) {
   const cached = pullRequestStatusCache.get(pullRequestNumber);
   if (cached) {
     return cached;
   }
-  const [hasUnresolvedReviewThreads, ciState] = await Promise.all([
-    hasGitHubPullRequestUnresolvedReviewThreads(octokit, repository, pullRequestNumber),
-    getGitHubPullRequestCiState(octokit, repository, pullRequestNumber)
-  ]);
-  const snapshot = {
-    number: pullRequestNumber,
-    hasUnresolvedReviewThreads,
-    ciState
-  };
-  pullRequestStatusCache.set(pullRequestNumber, snapshot);
-  return snapshot;
+  const cacheKey = buildRepositoryPullRequestRecordCacheKey(repository, pullRequestNumber, "status");
+  const cachedSnapshot = getFreshCacheValue(activeGitHubPullRequestStatusSnapshotCache, cacheKey);
+  if (cachedSnapshot) {
+    pullRequestStatusCache.set(pullRequestNumber, cachedSnapshot);
+    return cachedSnapshot;
+  }
+  if (options?.reviewThreadSummary && options.ciState) {
+    const snapshot = cacheGitHubPullRequestStatusSnapshot(repository, {
+      number: pullRequestNumber,
+      hasUnresolvedReviewThreads: options.reviewThreadSummary.unresolvedReviewThreads > 0,
+      ciState: options.ciState
+    });
+    pullRequestStatusCache.set(pullRequestNumber, snapshot);
+    return snapshot;
+  }
+  const inFlightSnapshot = activeGitHubPullRequestStatusSnapshotPromiseCache.get(cacheKey);
+  if (inFlightSnapshot) {
+    const snapshot = await inFlightSnapshot;
+    pullRequestStatusCache.set(pullRequestNumber, snapshot);
+    return snapshot;
+  }
+  const loadSnapshotPromise = (async () => {
+    const [reviewThreadSummary, ciState] = await Promise.all([
+      options?.reviewThreadSummary ?? getOrLoadCachedGitHubPullRequestReviewThreadSummary(octokit, repository, pullRequestNumber),
+      options?.ciState ?? getGitHubPullRequestCiState(octokit, repository, pullRequestNumber)
+    ]);
+    return cacheGitHubPullRequestStatusSnapshot(repository, {
+      number: pullRequestNumber,
+      hasUnresolvedReviewThreads: reviewThreadSummary.unresolvedReviewThreads > 0,
+      ciState
+    });
+  })();
+  activeGitHubPullRequestStatusSnapshotPromiseCache.set(cacheKey, loadSnapshotPromise);
+  try {
+    const snapshot = await loadSnapshotPromise;
+    pullRequestStatusCache.set(pullRequestNumber, snapshot);
+    return snapshot;
+  } finally {
+    if (activeGitHubPullRequestStatusSnapshotPromiseCache.get(cacheKey) === loadSnapshotPromise) {
+      activeGitHubPullRequestStatusSnapshotPromiseCache.delete(cacheKey);
+    }
+  }
 }
 async function getGitHubIssueStatusSnapshot(octokit, repository, issueNumber, githubIssue, linkedPullRequestsByIssueNumber, issueStatusSnapshotCache, pullRequestStatusCache) {
   if (issueStatusSnapshotCache.has(issueNumber)) {
@@ -3175,6 +4275,33 @@ function normalizeGitHubIssueLinkEntityData(value) {
     syncedAt
   };
 }
+function normalizeGitHubPullRequestLinkEntityData(value) {
+  if (!value || typeof value !== "object") {
+    return null;
+  }
+  const record = value;
+  const repositoryUrl = typeof record.repositoryUrl === "string" && record.repositoryUrl.trim() ? getNormalizedMappingRepositoryUrl({
+    repositoryUrl: record.repositoryUrl
+  }) : void 0;
+  const githubPullRequestNumber = typeof record.githubPullRequestNumber === "number" && record.githubPullRequestNumber > 0 ? Math.floor(record.githubPullRequestNumber) : void 0;
+  const githubPullRequestUrl = typeof record.githubPullRequestUrl === "string" && record.githubPullRequestUrl.trim() ? record.githubPullRequestUrl.trim() : void 0;
+  const githubPullRequestState = record.githubPullRequestState === "closed" ? "closed" : record.githubPullRequestState === "open" ? "open" : void 0;
+  const title = typeof record.title === "string" && record.title.trim() ? record.title.trim() : void 0;
+  const syncedAt = typeof record.syncedAt === "string" && record.syncedAt.trim() ? record.syncedAt.trim() : void 0;
+  if (!repositoryUrl || githubPullRequestNumber === void 0 || !githubPullRequestUrl || !githubPullRequestState || !syncedAt) {
+    return null;
+  }
+  return {
+    ...typeof record.companyId === "string" && record.companyId.trim() ? { companyId: record.companyId.trim() } : {},
+    ...typeof record.paperclipProjectId === "string" && record.paperclipProjectId.trim() ? { paperclipProjectId: record.paperclipProjectId.trim() } : {},
+    repositoryUrl,
+    githubPullRequestNumber,
+    githubPullRequestUrl,
+    githubPullRequestState,
+    ...title ? { title } : {},
+    syncedAt
+  };
+}
 function normalizeStoredStatusTransitionCommentAnnotation(value) {
   if (!value || typeof value !== "object") {
     return null;
@@ -3249,6 +4376,52 @@ async function listGitHubIssueLinkRecords(ctx, query = {}) {
   }
   return records;
 }
+async function listGitHubPullRequestLinkRecords(ctx, query = {}) {
+  const records = [];
+  const requestedIssueId = query.paperclipIssueId?.trim() || void 0;
+  const requestedExternalId = query.externalId?.trim() || void 0;
+  for (let offset = 0; ; ) {
+    const page = await ctx.entities.list({
+      entityType: PULL_REQUEST_LINK_ENTITY_TYPE,
+      scopeKind: "issue",
+      ...requestedIssueId ? { scopeId: requestedIssueId } : {},
+      ...requestedExternalId ? { externalId: requestedExternalId } : {},
+      limit: PAPERCLIP_LABEL_PAGE_SIZE,
+      offset
+    });
+    if (page.length === 0) {
+      break;
+    }
+    for (const entry of page) {
+      if (entry.scopeKind !== "issue" || !entry.scopeId) {
+        continue;
+      }
+      if (requestedIssueId && entry.scopeId !== requestedIssueId) {
+        continue;
+      }
+      if (requestedExternalId && entry.externalId !== requestedExternalId) {
+        continue;
+      }
+      const data = normalizeGitHubPullRequestLinkEntityData(entry.data);
+      if (!data) {
+        continue;
+      }
+      records.push({
+        paperclipIssueId: entry.scopeId,
+        ...typeof entry.createdAt === "string" ? { createdAt: entry.createdAt } : {},
+        ...typeof entry.updatedAt === "string" ? { updatedAt: entry.updatedAt } : {},
+        ...typeof entry.title === "string" && entry.title.trim() ? { title: entry.title.trim() } : {},
+        ...typeof entry.status === "string" && entry.status.trim() ? { status: entry.status.trim() } : {},
+        data
+      });
+    }
+    if (page.length < PAPERCLIP_LABEL_PAGE_SIZE || requestedIssueId && records.length > 0 || requestedExternalId && page.length < PAPERCLIP_LABEL_PAGE_SIZE) {
+      break;
+    }
+    offset += page.length;
+  }
+  return records;
+}
 async function findStoredStatusTransitionCommentAnnotation(ctx, params) {
   const issueId = params.issueId.trim();
   const commentId = params.commentId.trim();
@@ -3307,6 +4480,28 @@ async function upsertGitHubIssueLinkRecord(ctx, mapping, issueId, githubIssue, l
     }
   });
 }
+async function upsertGitHubPullRequestLinkRecord(ctx, params) {
+  await ctx.entities.upsert({
+    entityType: PULL_REQUEST_LINK_ENTITY_TYPE,
+    scopeKind: "issue",
+    scopeId: params.issueId,
+    externalId: params.pullRequestUrl,
+    title: `GitHub pull request #${params.pullRequestNumber}`,
+    status: params.pullRequestState,
+    data: {
+      companyId: params.companyId,
+      paperclipProjectId: params.projectId,
+      repositoryUrl: getNormalizedMappingRepositoryUrl({
+        repositoryUrl: params.repositoryUrl
+      }),
+      githubPullRequestNumber: params.pullRequestNumber,
+      githubPullRequestUrl: params.pullRequestUrl,
+      githubPullRequestState: params.pullRequestState,
+      title: params.pullRequestTitle,
+      syncedAt: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  });
+}
 async function upsertStatusTransitionCommentAnnotation(ctx, params) {
   const { issueId, commentId, annotation } = params;
   await ctx.entities.upsert({
@@ -4247,7 +5442,13 @@ async function listRepositoryIssuesForImport(allIssues) {
   return sortIssuesForImport(allIssues.filter((issue) => issue.state === "open"));
 }
 function shouldIgnoreGitHubIssue(issue, advancedSettings) {
-  return Boolean(issue.authorLogin && advancedSettings.ignoredIssueAuthorUsernames.includes(issue.authorLogin));
+  if (!issue.authorLogin || advancedSettings.ignoredIssueAuthorUsernames.length === 0) {
+    return false;
+  }
+  const issueAuthorAliases = new Set(buildGitHubUsernameAliases(issue.authorLogin));
+  return advancedSettings.ignoredIssueAuthorUsernames.some(
+    (ignoredUsername) => buildGitHubUsernameAliases(ignoredUsername).some((alias) => issueAuthorAliases.has(alias))
+  );
 }
 async function applyDefaultAssigneeToPaperclipIssue(ctx, params) {
   const { companyId, issueId, defaultAssigneeAgentId } = params;
@@ -4318,25 +5519,30 @@ async function createPaperclipIssue(ctx, mapping, advancedSettings, issue, avail
     createdIssueDescription = createdIssue.description;
     createPath = "sdk";
   }
+  const ensuredCreatedIssueId = createdIssueId;
+  if (!ensuredCreatedIssueId) {
+    throw new Error("GitHub sync could not resolve the created Paperclip issue id.");
+  }
+  const normalizedCreatedIssueDescription = createdIssueDescription ?? void 0;
   if (createPath !== "sdk") {
     await applyDefaultAssigneeToPaperclipIssue(ctx, {
       companyId: mapping.companyId,
-      issueId: createdIssueId,
+      issueId: ensuredCreatedIssueId,
       defaultAssigneeAgentId: advancedSettings.defaultAssigneeAgentId
     });
   }
-  if (normalizeIssueDescriptionValue(createdIssueDescription) !== description) {
+  if (normalizeIssueDescriptionValue(normalizedCreatedIssueDescription) !== description) {
     logIssueDescriptionDiagnostic(
       ctx,
       "warn",
       "GitHub sync detected a missing or mismatched Paperclip issue description immediately after issue creation.",
       {
         companyId: mapping.companyId,
-        issueId: createdIssueId,
+        issueId: ensuredCreatedIssueId,
         paperclipApiBaseUrl,
         githubIssue: issue,
         linkedPullRequestNumbers: [],
-        currentDescription: createdIssueDescription,
+        currentDescription: normalizedCreatedIssueDescription,
         nextDescription: description,
         reason: "create_response_mismatch",
         createPath
@@ -4346,8 +5552,8 @@ async function createPaperclipIssue(ctx, mapping, advancedSettings, issue, avail
       ctx,
       {
         companyId: mapping.companyId,
-        issueId: createdIssueId,
-        currentDescription: createdIssueDescription,
+        issueId: ensuredCreatedIssueId,
+        currentDescription: normalizedCreatedIssueDescription,
         githubIssue: issue,
         linkedPullRequestNumbers: [],
         paperclipApiBaseUrl,
@@ -4355,7 +5561,7 @@ async function createPaperclipIssue(ctx, mapping, advancedSettings, issue, avail
       }
     );
   }
-  await upsertGitHubIssueLinkRecord(ctx, mapping, createdIssueId, issue, []);
+  await upsertGitHubIssueLinkRecord(ctx, mapping, ensuredCreatedIssueId, issue, []);
   if (syncFailureContext) {
     updateSyncFailureContext(syncFailureContext, {
       phase: "syncing_labels",
@@ -4373,11 +5579,11 @@ async function createPaperclipIssue(ctx, mapping, advancedSettings, issue, avail
   await applyPaperclipLabelsToIssue(
     ctx,
     mapping.companyId,
-    createdIssueId,
+    ensuredCreatedIssueId,
     labelResolution.labels
   );
   return {
-    id: createdIssueId,
+    id: ensuredCreatedIssueId,
     unresolvedGitHubLabels: labelResolution.unresolvedGitHubLabels,
     ...labelResolution.failure ? { labelResolutionFailure: labelResolution.failure } : {}
   };
@@ -4449,7 +5655,7 @@ async function ensurePaperclipIssueImported(ctx, mapping, advancedSettings, issu
   }
   return createdIssue.id;
 }
-async function synchronizePaperclipIssueStatuses(ctx, octokit, repository, mapping, advancedSettings, allIssuesById, importedIssues, createdIssueIds, availableLabels, paperclipApiBaseUrl, linkedPullRequestsByIssueNumber, issueStatusSnapshotCache, pullRequestStatusCache, repositoryMaintainerCache, syncFailureContext, failures, onProgress) {
+async function synchronizePaperclipIssueStatuses(ctx, octokit, repository, mapping, advancedSettings, allIssuesById, importedIssues, createdIssueIds, availableLabels, paperclipApiBaseUrl, linkedPullRequestsByIssueNumber, issueStatusSnapshotCache, pullRequestStatusCache, repositoryMaintainerCache, syncFailureContext, failures, assertNotCancelled, onProgress) {
   if (!mapping.companyId || !ctx.issues || typeof ctx.issues.get !== "function" || typeof ctx.issues.update !== "function") {
     return {
       updatedStatusesCount: 0,
@@ -4463,6 +5669,9 @@ async function synchronizePaperclipIssueStatuses(ctx, octokit, repository, mappi
   let completedIssueCount = 0;
   const totalIssueCount = importedIssues.length;
   for (const importedIssue of importedIssues) {
+    if (assertNotCancelled) {
+      await assertNotCancelled();
+    }
     const githubIssue = allIssuesById.get(importedIssue.githubIssueId);
     try {
       if (!githubIssue) {
@@ -4824,6 +6033,230 @@ async function createGitHubToolOctokit(ctx) {
   }
   return new Octokit({ auth: token });
 }
+async function listGitHubRepositoryOpenPullRequestNumbers(octokit, repository) {
+  const response = await octokit.rest.pulls.list({
+    owner: repository.owner,
+    repo: repository.repo,
+    state: "open",
+    per_page: 1,
+    headers: {
+      "X-GitHub-Api-Version": GITHUB_API_VERSION
+    }
+  });
+  return (response.data ?? []).map((pullRequest) => typeof pullRequest.number === "number" && pullRequest.number > 0 ? Math.floor(pullRequest.number) : null).filter((number) => number !== null);
+}
+async function probeGitHubRepositoryTokenCapability(fn, options = {}) {
+  try {
+    await fn();
+    return "granted";
+  } catch (error) {
+    return classifyGitHubCapabilityProbeError(error, options);
+  }
+}
+async function loadGitHubRepositoryTokenCapabilityAudit(octokit, repository, options) {
+  try {
+    await octokit.rest.repos.get({
+      owner: repository.owner,
+      repo: repository.repo,
+      headers: {
+        "X-GitHub-Api-Version": GITHUB_API_VERSION
+      }
+    });
+  } catch (error) {
+    const status = getErrorStatus(error);
+    return buildGitHubRepositoryTokenCapabilityAudit({
+      repository,
+      canComment: false,
+      canReview: false,
+      canClose: false,
+      canUpdateBranch: false,
+      canMerge: false,
+      canRerunCi: false,
+      missingPermissions: status === 401 || status === 403 || status === 404 ? [
+        "Metadata: read",
+        "Issues: write or Pull requests: write",
+        "Pull requests: write",
+        "Contents: write",
+        "Checks: write"
+      ] : [],
+      warnings: [
+        status === 401 || status === 403 || status === 404 ? `GitHub Sync could not confirm repository access for ${formatRepositoryLabel(repository)} with the configured token.` : `GitHub Sync could not verify repository permissions for ${formatRepositoryLabel(repository)} because GitHub returned an unexpected error.`
+      ]
+    });
+  }
+  let samplePullRequestNumber = typeof options?.samplePullRequestNumber === "number" && options.samplePullRequestNumber > 0 ? Math.floor(options.samplePullRequestNumber) : void 0;
+  if (!samplePullRequestNumber) {
+    try {
+      samplePullRequestNumber = (await listGitHubRepositoryOpenPullRequestNumbers(octokit, repository))[0];
+    } catch {
+      return buildGitHubRepositoryTokenCapabilityAudit({
+        repository,
+        canComment: false,
+        canReview: false,
+        canClose: false,
+        canUpdateBranch: false,
+        canMerge: false,
+        canRerunCi: false,
+        missingPermissions: [],
+        warnings: [
+          `GitHub Sync could not verify write permissions for ${formatRepositoryLabel(repository)} because GitHub did not return a sample pull request.`
+        ]
+      });
+    }
+  }
+  if (!samplePullRequestNumber) {
+    return buildGitHubRepositoryTokenCapabilityAudit({
+      repository,
+      canComment: false,
+      canReview: false,
+      canClose: false,
+      canUpdateBranch: false,
+      canMerge: false,
+      canRerunCi: false,
+      missingPermissions: [],
+      warnings: [
+        `GitHub Sync could not verify write permissions for ${formatRepositoryLabel(repository)} because the repository has no open pull requests to probe safely.`
+      ]
+    });
+  }
+  const impossibleSha = "0000000000000000000000000000000000000000";
+  const [
+    commentProbe,
+    reviewProbe,
+    closeProbe,
+    updateBranchProbe,
+    mergeProbe,
+    rerunCiProbe
+  ] = await Promise.all([
+    probeGitHubRepositoryTokenCapability(
+      () => octokit.rest.issues.createComment({
+        owner: repository.owner,
+        repo: repository.repo,
+        issue_number: samplePullRequestNumber,
+        body: "",
+        headers: {
+          "X-GitHub-Api-Version": GITHUB_API_VERSION
+        }
+      }),
+      { grantedStatuses: [422] }
+    ),
+    probeGitHubRepositoryTokenCapability(
+      () => octokit.rest.pulls.createReview({
+        owner: repository.owner,
+        repo: repository.repo,
+        pull_number: samplePullRequestNumber,
+        event: "REQUEST_CHANGES",
+        headers: {
+          "X-GitHub-Api-Version": GITHUB_API_VERSION
+        }
+      }),
+      { grantedStatuses: [422] }
+    ),
+    probeGitHubRepositoryTokenCapability(
+      () => octokit.request("PATCH /repos/{owner}/{repo}/pulls/{pull_number}", {
+        owner: repository.owner,
+        repo: repository.repo,
+        pull_number: samplePullRequestNumber,
+        state: "__paperclip_invalid_state__",
+        headers: {
+          "X-GitHub-Api-Version": GITHUB_API_VERSION
+        }
+      }),
+      { grantedStatuses: [422] }
+    ),
+    probeGitHubRepositoryTokenCapability(
+      () => octokit.request("PUT /repos/{owner}/{repo}/pulls/{pull_number}/update-branch", {
+        owner: repository.owner,
+        repo: repository.repo,
+        pull_number: samplePullRequestNumber,
+        expected_head_sha: impossibleSha,
+        headers: {
+          "X-GitHub-Api-Version": GITHUB_API_VERSION
+        }
+      }),
+      { grantedStatuses: [409, 422] }
+    ),
+    probeGitHubRepositoryTokenCapability(
+      () => octokit.rest.pulls.merge({
+        owner: repository.owner,
+        repo: repository.repo,
+        pull_number: samplePullRequestNumber,
+        sha: impossibleSha,
+        headers: {
+          "X-GitHub-Api-Version": GITHUB_API_VERSION
+        }
+      }),
+      { grantedStatuses: [405, 409, 422] }
+    ),
+    probeGitHubRepositoryTokenCapability(
+      () => octokit.rest.checks.rerequestSuite({
+        owner: repository.owner,
+        repo: repository.repo,
+        check_suite_id: 0,
+        headers: {
+          "X-GitHub-Api-Version": GITHUB_API_VERSION
+        }
+      }),
+      { allowNotFoundAsGranted: true }
+    )
+  ]);
+  const missingPermissions = [
+    ...commentProbe === "missing" ? [getGitHubCapabilityMissingPermissionLabel("comment")] : [],
+    ...reviewProbe === "missing" ? [getGitHubCapabilityMissingPermissionLabel("review")] : [],
+    ...closeProbe === "missing" ? [getGitHubCapabilityMissingPermissionLabel("close")] : [],
+    ...updateBranchProbe === "missing" ? [getGitHubCapabilityMissingPermissionLabel("update_branch")] : [],
+    ...mergeProbe === "missing" ? [getGitHubCapabilityMissingPermissionLabel("merge")] : [],
+    ...rerunCiProbe === "missing" ? [getGitHubCapabilityMissingPermissionLabel("rerun_ci")] : []
+  ];
+  const warnings = [
+    ...commentProbe === "unknown" ? ["GitHub Sync could not verify comment permissions."] : [],
+    ...reviewProbe === "unknown" ? ["GitHub Sync could not verify review permissions."] : [],
+    ...closeProbe === "unknown" ? ["GitHub Sync could not verify close permissions."] : [],
+    ...updateBranchProbe === "unknown" ? ["GitHub Sync could not verify update-branch permissions."] : [],
+    ...mergeProbe === "unknown" ? ["GitHub Sync could not verify merge permissions."] : [],
+    ...rerunCiProbe === "unknown" ? ["GitHub Sync could not verify re-run CI permissions."] : []
+  ];
+  return buildGitHubRepositoryTokenCapabilityAudit({
+    repository,
+    samplePullRequestNumber,
+    canComment: commentProbe === "granted",
+    canReview: reviewProbe === "granted",
+    canClose: closeProbe === "granted",
+    canUpdateBranch: updateBranchProbe === "granted",
+    canMerge: mergeProbe === "granted",
+    canRerunCi: rerunCiProbe === "granted",
+    missingPermissions,
+    warnings
+  });
+}
+async function getOrLoadGitHubRepositoryTokenCapabilityAudit(octokit, repository, options) {
+  const cacheKey = buildGitHubRepositoryTokenCapabilityAuditCacheKey(repository, options?.samplePullRequestNumber);
+  const cachedAudit = getFreshCacheValue(activeGitHubRepositoryTokenCapabilityAuditCache, cacheKey);
+  if (cachedAudit) {
+    return cachedAudit;
+  }
+  const inFlightAudit = activeGitHubRepositoryTokenCapabilityAuditPromiseCache.get(cacheKey);
+  if (inFlightAudit) {
+    return inFlightAudit;
+  }
+  const loadAuditPromise = (async () => {
+    const audit = await loadGitHubRepositoryTokenCapabilityAudit(octokit, repository, options);
+    return setCacheValue(
+      activeGitHubRepositoryTokenCapabilityAuditCache,
+      cacheKey,
+      audit,
+      GITHUB_TOKEN_PERMISSION_AUDIT_CACHE_TTL_MS
+    );
+  })();
+  activeGitHubRepositoryTokenCapabilityAuditPromiseCache.set(cacheKey, loadAuditPromise);
+  try {
+    return await loadAuditPromise;
+  } finally {
+    if (activeGitHubRepositoryTokenCapabilityAuditPromiseCache.get(cacheKey) === loadAuditPromise) {
+      activeGitHubRepositoryTokenCapabilityAuditPromiseCache.delete(cacheKey);
+    }
+  }
+}
 async function resolveRepositoryFromRunContext(ctx, runCtx) {
   const settings = normalizeSettings(await ctx.state.get(SETTINGS_SCOPE));
   const mappings = getSyncableMappingsForTarget(settings.mappings, {
@@ -4846,136 +6279,2217 @@ async function resolveRepositoryFromRunContext(ctx, runCtx) {
   if (repositories.length === 0) {
     throw new Error("No GitHub repository is mapped to the current Paperclip project. Pass repository explicitly.");
   }
-  throw new Error("Multiple GitHub repositories are mapped to the current Paperclip project. Pass repository explicitly.");
+  throw new Error("Multiple GitHub repositories are mapped to the current Paperclip project. Pass repository explicitly.");
+}
+async function resolveGitHubToolRepository(ctx, runCtx, input) {
+  const explicitRepository = normalizeOptionalToolString(input.repository);
+  if (explicitRepository) {
+    return requireRepositoryReference(explicitRepository);
+  }
+  const paperclipIssueId = normalizeOptionalToolString(input.paperclipIssueId);
+  if (paperclipIssueId) {
+    const link = await resolvePaperclipIssueGitHubLink(ctx, paperclipIssueId, runCtx.companyId);
+    if (!link) {
+      throw new Error("This Paperclip issue is not linked to a GitHub issue yet. Pass repository explicitly.");
+    }
+    return requireRepositoryReference(link.repositoryUrl);
+  }
+  return resolveRepositoryFromRunContext(ctx, runCtx);
+}
+async function resolveGitHubIssueToolTarget(ctx, runCtx, input) {
+  const paperclipIssueId = normalizeOptionalToolString(input.paperclipIssueId);
+  if (paperclipIssueId) {
+    const link = await resolvePaperclipIssueGitHubLink(ctx, paperclipIssueId, runCtx.companyId);
+    if (!link) {
+      throw new Error("This Paperclip issue is not linked to a GitHub issue yet.");
+    }
+    const repository2 = assertExplicitRepositoryMatchesLinkedRepository(
+      input.repository,
+      link.repositoryUrl,
+      "The provided repository does not match the linked GitHub repository for this Paperclip issue."
+    );
+    const explicitIssueNumber = normalizeToolPositiveInteger(input.issueNumber);
+    if (explicitIssueNumber !== void 0 && explicitIssueNumber !== link.githubIssueNumber) {
+      throw new Error("The provided issue number does not match the linked GitHub issue for this Paperclip issue.");
+    }
+    return {
+      repository: repository2,
+      issueNumber: link.githubIssueNumber,
+      paperclipIssueId,
+      githubIssueId: link.githubIssueId,
+      githubIssueUrl: link.githubIssueUrl
+    };
+  }
+  const repository = await resolveGitHubToolRepository(ctx, runCtx, input);
+  const issueNumber = normalizeToolPositiveInteger(input.issueNumber);
+  if (issueNumber === void 0) {
+    throw new Error("issueNumber is required when paperclipIssueId is not provided.");
+  }
+  return {
+    repository,
+    issueNumber
+  };
+}
+async function resolveGitHubPullRequestToolTarget(ctx, runCtx, input) {
+  const paperclipIssueId = normalizeOptionalToolString(input.paperclipIssueId);
+  if (paperclipIssueId) {
+    const link = await resolvePaperclipIssueGitHubLink(ctx, paperclipIssueId, runCtx.companyId);
+    if (!link) {
+      throw new Error("This Paperclip issue is not linked to GitHub yet.");
+    }
+    const repository2 = assertExplicitRepositoryMatchesLinkedRepository(
+      input.repository,
+      link.repositoryUrl,
+      "repository must match the GitHub repository linked to the provided Paperclip issue."
+    );
+    const explicitPullRequestNumber = normalizeToolPositiveInteger(input.pullRequestNumber);
+    if (explicitPullRequestNumber !== void 0) {
+      return {
+        repository: repository2,
+        pullRequestNumber: explicitPullRequestNumber,
+        paperclipIssueId
+      };
+    }
+    if (link.linkedPullRequestNumbers.length === 1) {
+      return {
+        repository: repository2,
+        pullRequestNumber: link.linkedPullRequestNumbers[0],
+        paperclipIssueId
+      };
+    }
+    throw new Error("pullRequestNumber is required unless the linked Paperclip issue has exactly one linked pull request.");
+  }
+  const repository = await resolveGitHubToolRepository(ctx, runCtx, input);
+  const pullRequestNumber = normalizeToolPositiveInteger(input.pullRequestNumber);
+  if (pullRequestNumber === void 0) {
+    throw new Error("pullRequestNumber is required when paperclipIssueId is not provided.");
+  }
+  return {
+    repository,
+    pullRequestNumber
+  };
+}
+function formatAiAuthorshipFooter(llmModel) {
+  return `
+
+---
+${AI_AUTHORED_COMMENT_FOOTER_PREFIX}${llmModel.trim()}.`;
+}
+function appendAiAuthorshipFooter(body, llmModel) {
+  const trimmedBody = body.trim();
+  if (!trimmedBody) {
+    throw new Error("Comment body cannot be empty.");
+  }
+  const trimmedModel = llmModel.trim();
+  if (!trimmedModel) {
+    throw new Error("llmModel is required when posting a GitHub comment.");
+  }
+  return `${trimmedBody}${formatAiAuthorshipFooter(trimmedModel)}`;
+}
+async function listAllGitHubIssueComments(octokit, repository, issueNumber) {
+  const comments = [];
+  for await (const response of octokit.paginate.iterator(octokit.rest.issues.listComments, {
+    owner: repository.owner,
+    repo: repository.repo,
+    issue_number: issueNumber,
+    per_page: 100,
+    headers: {
+      "X-GitHub-Api-Version": GITHUB_API_VERSION
+    }
+  })) {
+    for (const comment of response.data) {
+      comments.push({
+        id: comment.id,
+        body: comment.body ?? "",
+        url: comment.html_url ?? void 0,
+        authorLogin: normalizeGitHubUserLogin(comment.user?.login),
+        authorUrl: comment.user?.html_url ?? void 0,
+        authorAvatarUrl: comment.user?.avatar_url ?? void 0,
+        createdAt: comment.created_at ?? void 0,
+        updatedAt: comment.updated_at ?? void 0
+      });
+    }
+  }
+  return comments;
+}
+async function listPaperclipIssuesForProject(ctx, companyId, projectId) {
+  const issues = [];
+  for (let offset = 0; ; ) {
+    const page = await ctx.issues.list({
+      companyId,
+      projectId,
+      limit: PAPERCLIP_LABEL_PAGE_SIZE,
+      offset
+    });
+    if (page.length === 0) {
+      break;
+    }
+    issues.push(...page);
+    if (page.length < PAPERCLIP_LABEL_PAGE_SIZE) {
+      break;
+    }
+    offset += page.length;
+  }
+  return issues;
+}
+function buildProjectPullRequestPerson(input) {
+  const normalizedLogin = normalizeGitHubUsername(input.login) ?? "unknown";
+  const displayName = typeof input.name === "string" && input.name.trim() ? input.name.trim() : normalizedLogin;
+  const profileUrl = typeof input.url === "string" && input.url.trim() ? input.url.trim() : `https://github.com/${normalizedLogin}`;
+  const avatarUrl = typeof input.avatarUrl === "string" && input.avatarUrl.trim() ? input.avatarUrl.trim() : void 0;
+  return {
+    name: displayName,
+    handle: `@${normalizedLogin}`,
+    profileUrl,
+    ...avatarUrl ? { avatarUrl } : {}
+  };
+}
+function normalizeProjectPullRequestLabels(nodes) {
+  if (!Array.isArray(nodes)) {
+    return [];
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const labels = [];
+  for (const entry of nodes) {
+    const name = typeof entry?.name === "string" ? entry.name.trim() : "";
+    if (!name) {
+      continue;
+    }
+    const key = normalizeLabelName(name);
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    labels.push({
+      name,
+      ...normalizeHexColor(entry?.color) ? { color: normalizeHexColor(entry?.color) } : {}
+    });
+  }
+  return labels;
+}
+function summarizeGitHubPullRequestReviewsFromEntries(entries) {
+  const latestStateByReviewer = /* @__PURE__ */ new Map();
+  let anonymousApprovals = 0;
+  let anonymousChangesRequested = 0;
+  for (const entry of entries) {
+    const state = typeof entry.state === "string" ? entry.state.trim().toUpperCase() : "";
+    const authorLogin = normalizeGitHubUsername(entry.authorLogin);
+    if (state === "APPROVED") {
+      if (authorLogin) {
+        latestStateByReviewer.set(authorLogin, "APPROVED");
+      } else {
+        anonymousApprovals += 1;
+      }
+      continue;
+    }
+    if (state === "CHANGES_REQUESTED") {
+      if (authorLogin) {
+        latestStateByReviewer.set(authorLogin, "CHANGES_REQUESTED");
+      } else {
+        anonymousChangesRequested += 1;
+      }
+      continue;
+    }
+    if (state === "DISMISSED" && authorLogin) {
+      latestStateByReviewer.delete(authorLogin);
+    }
+  }
+  let approvals = anonymousApprovals;
+  let changesRequested = anonymousChangesRequested;
+  for (const state of latestStateByReviewer.values()) {
+    if (state === "APPROVED") {
+      approvals += 1;
+    } else if (state === "CHANGES_REQUESTED") {
+      changesRequested += 1;
+    }
+  }
+  return {
+    approvals,
+    changesRequested
+  };
+}
+function summarizeGitHubPullRequestReviewNodes(nodes) {
+  const entries = (nodes ?? []).map((node) => ({
+    state: node?.state ?? void 0,
+    authorLogin: node?.author?.login ?? void 0
+  }));
+  return summarizeGitHubPullRequestReviewsFromEntries(entries);
+}
+async function listGitHubPullRequestReviewSummary(octokit, repository, pullRequestNumber) {
+  const entries = [];
+  for await (const response of octokit.paginate.iterator(octokit.rest.pulls.listReviews, {
+    owner: repository.owner,
+    repo: repository.repo,
+    pull_number: pullRequestNumber,
+    per_page: 100,
+    headers: {
+      "X-GitHub-Api-Version": GITHUB_API_VERSION
+    }
+  })) {
+    for (const review of response.data) {
+      entries.push({
+        state: review.state ?? void 0,
+        authorLogin: review.user?.login ?? void 0
+      });
+    }
+  }
+  return summarizeGitHubPullRequestReviewsFromEntries(entries);
+}
+function buildProjectPullRequestScopeCacheKey(params) {
+  return `${params.companyId}:${params.projectId}:${getNormalizedMappingRepositoryUrl({
+    repositoryUrl: params.repositoryUrl
+  })}`;
+}
+function buildRepositoryPullRequestCacheScopeKey(repository) {
+  return `${repository.owner.toLowerCase()}/${repository.repo.toLowerCase()}`;
+}
+function buildRepositoryPullRequestCollectionCacheKey(repository, suffix) {
+  return `${buildRepositoryPullRequestCacheScopeKey(repository)}:${suffix}`;
+}
+function buildRepositoryPullRequestRecordCacheKey(repository, pullRequestNumber, suffix) {
+  return `${buildRepositoryPullRequestCollectionCacheKey(repository, "pull-request")}:${Math.max(1, Math.floor(pullRequestNumber))}:${suffix}`;
+}
+function buildRepositoryPullRequestCompareCacheKey(repository, baseBranch, headBranch, headRepositoryOwner) {
+  const normalizedBaseBranch = baseBranch.trim();
+  const normalizedHeadBranch = headBranch.trim();
+  const normalizedHeadRepositoryOwner = typeof headRepositoryOwner === "string" && headRepositoryOwner.trim() ? headRepositoryOwner.trim() : repository.owner;
+  const compareHeadRef = normalizedHeadRepositoryOwner.toLowerCase() === repository.owner.toLowerCase() ? normalizedHeadBranch : `${normalizedHeadRepositoryOwner}:${normalizedHeadBranch}`;
+  return `${buildRepositoryPullRequestCollectionCacheKey(repository, "compare")}:${encodeURIComponent(`${normalizedBaseBranch}...${compareHeadRef}`)}`;
+}
+function buildProjectPullRequestPageCacheKey(scope, filter, pageIndex, cursor) {
+  return `${buildProjectPullRequestScopeCacheKey({
+    companyId: scope.companyId,
+    projectId: scope.projectId,
+    repositoryUrl: scope.repository.url
+  })}:page:${filter}:${pageIndex}:${cursor ?? ""}`;
+}
+function buildProjectPullRequestDetailCacheKey(scope, pullRequestNumber) {
+  return `${buildProjectPullRequestScopeCacheKey({
+    companyId: scope.companyId,
+    projectId: scope.projectId,
+    repositoryUrl: scope.repository.url
+  })}:detail:${pullRequestNumber}`;
+}
+function buildProjectPullRequestSummaryRecordCacheKey(scope, pullRequestNumber) {
+  return `${buildProjectPullRequestScopeCacheKey({
+    companyId: scope.companyId,
+    projectId: scope.projectId,
+    repositoryUrl: scope.repository.url
+  })}:summary-record:${Math.max(1, Math.floor(pullRequestNumber))}`;
+}
+function invalidateProjectPullRequestCaches(scope) {
+  const cacheKeyPrefix = `${buildProjectPullRequestScopeCacheKey({
+    companyId: scope.companyId,
+    projectId: scope.projectId,
+    repositoryUrl: scope.repository.url
+  })}:`;
+  const repositoryCacheKeyPrefix = `${buildRepositoryPullRequestCacheScopeKey(scope.repository)}:`;
+  for (const cache of [
+    activeProjectPullRequestPageCache,
+    activeProjectPullRequestSummaryCache,
+    activeProjectPullRequestSummaryRecordCache,
+    activeProjectPullRequestDetailCache,
+    activeProjectPullRequestIssueLookupCache
+  ]) {
+    for (const key of cache.keys()) {
+      if (key.startsWith(cacheKeyPrefix)) {
+        cache.delete(key);
+      }
+    }
+  }
+  for (const cache of [
+    activeProjectPullRequestCountCache,
+    activeProjectPullRequestMetricsCache,
+    activeGitHubPullRequestBehindCountCache,
+    activeGitHubPullRequestStatusSnapshotCache,
+    activeGitHubPullRequestReviewSummaryCache,
+    activeGitHubPullRequestReviewThreadSummaryCache
+  ]) {
+    for (const key of cache.keys()) {
+      if (key.startsWith(repositoryCacheKeyPrefix)) {
+        cache.delete(key);
+      }
+    }
+  }
+  for (const key of activeProjectPullRequestSummaryPromiseCache.keys()) {
+    if (key.startsWith(cacheKeyPrefix)) {
+      activeProjectPullRequestSummaryPromiseCache.delete(key);
+    }
+  }
+  for (const promiseCache of [
+    activeProjectPullRequestCountPromiseCache,
+    activeProjectPullRequestMetricsPromiseCache,
+    activeGitHubPullRequestBehindCountPromiseCache,
+    activeGitHubPullRequestStatusSnapshotPromiseCache,
+    activeGitHubPullRequestReviewSummaryPromiseCache,
+    activeGitHubPullRequestReviewThreadSummaryPromiseCache
+  ]) {
+    for (const key of promiseCache.keys()) {
+      if (key.startsWith(repositoryCacheKeyPrefix)) {
+        promiseCache.delete(key);
+      }
+    }
+  }
+}
+async function getGitHubPullRequestBehindCount(octokit, repository, options) {
+  const baseBranch = typeof options.baseBranch === "string" ? options.baseBranch.trim() : "";
+  const headBranch = typeof options.headBranch === "string" ? options.headBranch.trim() : "";
+  if (!baseBranch || !headBranch) {
+    return null;
+  }
+  const headRepositoryOwner = typeof options.headRepositoryOwner === "string" && options.headRepositoryOwner.trim() ? options.headRepositoryOwner.trim() : repository.owner;
+  const compareHeadRef = headRepositoryOwner.toLowerCase() === repository.owner.toLowerCase() ? headBranch : `${headRepositoryOwner}:${headBranch}`;
+  const cacheKey = buildRepositoryPullRequestCompareCacheKey(repository, baseBranch, headBranch, headRepositoryOwner);
+  const cachedBehindCountEntry = getFreshCacheEntry(activeGitHubPullRequestBehindCountCache, cacheKey);
+  if (cachedBehindCountEntry) {
+    return cachedBehindCountEntry.value;
+  }
+  const inFlightBehindCount = activeGitHubPullRequestBehindCountPromiseCache.get(cacheKey);
+  if (inFlightBehindCount) {
+    return inFlightBehindCount;
+  }
+  const loadBehindCountPromise = (async () => {
+    try {
+      const response = await octokit.request("GET /repos/{owner}/{repo}/compare/{basehead}", {
+        owner: repository.owner,
+        repo: repository.repo,
+        basehead: `${baseBranch}...${compareHeadRef}`
+      });
+      const behindBy = response.data?.behind_by;
+      return setCacheValue(
+        activeGitHubPullRequestBehindCountCache,
+        cacheKey,
+        typeof behindBy === "number" && behindBy >= 0 ? Math.floor(behindBy) : null,
+        PROJECT_PULL_REQUEST_BRANCH_COMPARE_CACHE_TTL_MS
+      );
+    } catch {
+      return setCacheValue(
+        activeGitHubPullRequestBehindCountCache,
+        cacheKey,
+        null,
+        PROJECT_PULL_REQUEST_BRANCH_COMPARE_CACHE_TTL_MS
+      );
+    }
+  })();
+  activeGitHubPullRequestBehindCountPromiseCache.set(cacheKey, loadBehindCountPromise);
+  try {
+    return await loadBehindCountPromise;
+  } finally {
+    if (activeGitHubPullRequestBehindCountPromiseCache.get(cacheKey) === loadBehindCountPromise) {
+      activeGitHubPullRequestBehindCountPromiseCache.delete(cacheKey);
+    }
+  }
+}
+function cacheGitHubPullRequestReviewSummary(repository, pullRequestNumber, summary) {
+  return setCacheValue(
+    activeGitHubPullRequestReviewSummaryCache,
+    buildRepositoryPullRequestRecordCacheKey(repository, pullRequestNumber, "review-summary"),
+    summary,
+    PROJECT_PULL_REQUEST_GITHUB_INSIGHT_CACHE_TTL_MS
+  );
+}
+function cacheGitHubPullRequestReviewThreadSummary(repository, pullRequestNumber, summary) {
+  return setCacheValue(
+    activeGitHubPullRequestReviewThreadSummaryCache,
+    buildRepositoryPullRequestRecordCacheKey(repository, pullRequestNumber, "review-threads"),
+    summary,
+    PROJECT_PULL_REQUEST_GITHUB_INSIGHT_CACHE_TTL_MS
+  );
+}
+function cacheGitHubPullRequestStatusSnapshot(repository, snapshot) {
+  return setCacheValue(
+    activeGitHubPullRequestStatusSnapshotCache,
+    buildRepositoryPullRequestRecordCacheKey(repository, snapshot.number, "status"),
+    snapshot,
+    PROJECT_PULL_REQUEST_GITHUB_INSIGHT_CACHE_TTL_MS
+  );
+}
+async function getOrLoadCachedGitHubPullRequestReviewSummary(octokit, repository, pullRequestNumber, inlineSummary) {
+  const cacheKey = buildRepositoryPullRequestRecordCacheKey(repository, pullRequestNumber, "review-summary");
+  const cachedSummary = getFreshCacheValue(activeGitHubPullRequestReviewSummaryCache, cacheKey);
+  if (cachedSummary) {
+    return cachedSummary;
+  }
+  if (inlineSummary) {
+    return cacheGitHubPullRequestReviewSummary(repository, pullRequestNumber, inlineSummary);
+  }
+  const inFlightSummary = activeGitHubPullRequestReviewSummaryPromiseCache.get(cacheKey);
+  if (inFlightSummary) {
+    return inFlightSummary;
+  }
+  const loadSummaryPromise = (async () => cacheGitHubPullRequestReviewSummary(
+    repository,
+    pullRequestNumber,
+    await listGitHubPullRequestReviewSummary(octokit, repository, pullRequestNumber)
+  ))();
+  activeGitHubPullRequestReviewSummaryPromiseCache.set(cacheKey, loadSummaryPromise);
+  try {
+    return await loadSummaryPromise;
+  } finally {
+    if (activeGitHubPullRequestReviewSummaryPromiseCache.get(cacheKey) === loadSummaryPromise) {
+      activeGitHubPullRequestReviewSummaryPromiseCache.delete(cacheKey);
+    }
+  }
+}
+async function getOrLoadCachedGitHubPullRequestReviewThreadSummary(octokit, repository, pullRequestNumber, inlineSummary) {
+  const cacheKey = buildRepositoryPullRequestRecordCacheKey(repository, pullRequestNumber, "review-threads");
+  const cachedSummary = getFreshCacheValue(activeGitHubPullRequestReviewThreadSummaryCache, cacheKey);
+  if (cachedSummary) {
+    return cachedSummary;
+  }
+  if (inlineSummary) {
+    return cacheGitHubPullRequestReviewThreadSummary(repository, pullRequestNumber, inlineSummary);
+  }
+  const inFlightSummary = activeGitHubPullRequestReviewThreadSummaryPromiseCache.get(cacheKey);
+  if (inFlightSummary) {
+    return inFlightSummary;
+  }
+  const loadSummaryPromise = (async () => cacheGitHubPullRequestReviewThreadSummary(
+    repository,
+    pullRequestNumber,
+    summarizeDetailedPullRequestReviewThreads(
+      await listDetailedPullRequestReviewThreads(octokit, repository, pullRequestNumber)
+    )
+  ))();
+  activeGitHubPullRequestReviewThreadSummaryPromiseCache.set(cacheKey, loadSummaryPromise);
+  try {
+    return await loadSummaryPromise;
+  } finally {
+    if (activeGitHubPullRequestReviewThreadSummaryPromiseCache.get(cacheKey) === loadSummaryPromise) {
+      activeGitHubPullRequestReviewThreadSummaryPromiseCache.delete(cacheKey);
+    }
+  }
+}
+function getProjectPullRequestNumbersForFilter(metrics, filter) {
+  switch (filter) {
+    case "mergeable":
+      return metrics.mergeablePullRequestNumbers;
+    case "reviewable":
+      return metrics.reviewablePullRequestNumbers;
+    case "failing":
+      return metrics.failingPullRequestNumbers;
+  }
+}
+function cacheProjectPullRequestSummaryRecords(scope, pullRequests, ttlMs = PROJECT_PULL_REQUEST_SUMMARY_CACHE_TTL_MS) {
+  const now = Date.now();
+  for (const pullRequest of pullRequests) {
+    const pullRequestNumber = getProjectPullRequestNumber(pullRequest);
+    if (pullRequestNumber === null) {
+      continue;
+    }
+    setCacheValue(
+      activeProjectPullRequestSummaryRecordCache,
+      buildProjectPullRequestSummaryRecordCacheKey(scope, pullRequestNumber),
+      pullRequest,
+      ttlMs,
+      now
+    );
+  }
+}
+function selectImportedPaperclipIssueReference(current, next) {
+  if (!current) {
+    return next;
+  }
+  return compareImportedPaperclipIssueCreatedAt(
+    {
+      id: next.paperclipIssueId,
+      createdAt: next.createdAt
+    },
+    {
+      id: current.paperclipIssueId,
+      createdAt: current.createdAt
+    }
+  ) < 0 ? next : current;
+}
+async function buildProjectPullRequestIssueLookup(ctx, scope) {
+  const cacheKey = `${buildProjectPullRequestScopeCacheKey({
+    companyId: scope.companyId,
+    projectId: scope.projectId,
+    repositoryUrl: scope.repository.url
+  })}:issue-lookup`;
+  const cachedLookup = getFreshCacheValue(activeProjectPullRequestIssueLookupCache, cacheKey);
+  if (cachedLookup) {
+    return cachedLookup;
+  }
+  const [projectIssues, issueLinks, pullRequestLinks] = await Promise.all([
+    listPaperclipIssuesForProject(ctx, scope.companyId, scope.projectId),
+    listGitHubIssueLinkRecords(ctx),
+    listGitHubPullRequestLinkRecords(ctx)
+  ]);
+  const issuesById = new Map(projectIssues.map((issue) => [issue.id, issue]));
+  const normalizedRepositoryUrl = scope.repository.url;
+  const linkedIssuesByGitHubIssueUrl = /* @__PURE__ */ new Map();
+  for (const record of issueLinks) {
+    if (record.data.repositoryUrl !== normalizedRepositoryUrl) {
+      continue;
+    }
+    if (record.data.companyId && record.data.companyId !== scope.companyId) {
+      continue;
+    }
+    if (record.data.paperclipProjectId && record.data.paperclipProjectId !== scope.projectId) {
+      continue;
+    }
+    const linkedIssue = issuesById.get(record.paperclipIssueId);
+    linkedIssuesByGitHubIssueUrl.set(
+      record.data.githubIssueUrl,
+      selectImportedPaperclipIssueReference(
+        linkedIssuesByGitHubIssueUrl.get(record.data.githubIssueUrl),
+        {
+          paperclipIssueId: record.paperclipIssueId,
+          ...linkedIssue?.identifier ? { paperclipIssueKey: linkedIssue.identifier } : {},
+          createdAt: record.createdAt
+        }
+      )
+    );
+  }
+  for (const issue of projectIssues) {
+    const githubIssueUrl = extractImportedGitHubIssueUrlFromDescription(issue.description);
+    if (!githubIssueUrl) {
+      continue;
+    }
+    linkedIssuesByGitHubIssueUrl.set(
+      githubIssueUrl,
+      selectImportedPaperclipIssueReference(
+        linkedIssuesByGitHubIssueUrl.get(githubIssueUrl),
+        {
+          paperclipIssueId: issue.id,
+          ...issue.identifier ? { paperclipIssueKey: issue.identifier } : {},
+          createdAt: issue.createdAt
+        }
+      )
+    );
+  }
+  const fallbackIssuesByPullRequestNumber = /* @__PURE__ */ new Map();
+  const sortedLinks = [...pullRequestLinks].sort((left, right) => {
+    const rightTimestamp = Date.parse(right.updatedAt ?? right.createdAt ?? "");
+    const leftTimestamp = Date.parse(left.updatedAt ?? left.createdAt ?? "");
+    const safeRightTimestamp = Number.isFinite(rightTimestamp) ? rightTimestamp : 0;
+    const safeLeftTimestamp = Number.isFinite(leftTimestamp) ? leftTimestamp : 0;
+    return safeRightTimestamp - safeLeftTimestamp;
+  });
+  for (const record of sortedLinks) {
+    if (record.data.repositoryUrl !== normalizedRepositoryUrl) {
+      continue;
+    }
+    if (record.data.companyId && record.data.companyId !== scope.companyId) {
+      continue;
+    }
+    if (record.data.paperclipProjectId && record.data.paperclipProjectId !== scope.projectId) {
+      continue;
+    }
+    if (fallbackIssuesByPullRequestNumber.has(record.data.githubPullRequestNumber)) {
+      continue;
+    }
+    const linkedIssue = issuesById.get(record.paperclipIssueId);
+    fallbackIssuesByPullRequestNumber.set(record.data.githubPullRequestNumber, {
+      paperclipIssueId: record.paperclipIssueId,
+      ...linkedIssue?.identifier ? { paperclipIssueKey: linkedIssue.identifier } : {}
+    });
+  }
+  return setCacheValue(
+    activeProjectPullRequestIssueLookupCache,
+    cacheKey,
+    {
+      linkedIssuesByGitHubIssueUrl: new Map(
+        [...linkedIssuesByGitHubIssueUrl.entries()].map(([githubIssueUrl, value]) => [
+          githubIssueUrl,
+          {
+            paperclipIssueId: value.paperclipIssueId,
+            ...value.paperclipIssueKey ? { paperclipIssueKey: value.paperclipIssueKey } : {}
+          }
+        ])
+      ),
+      fallbackIssuesByPullRequestNumber
+    },
+    PROJECT_PULL_REQUEST_ISSUE_LOOKUP_CACHE_TTL_MS
+  );
+}
+function resolveLinkedPaperclipIssueForPullRequest(pullRequestNumber, closingIssues, issueLookup) {
+  for (const closingIssue of closingIssues) {
+    const linkedIssue = issueLookup.linkedIssuesByGitHubIssueUrl.get(closingIssue.url);
+    if (linkedIssue) {
+      return linkedIssue;
+    }
+  }
+  return issueLookup.fallbackIssuesByPullRequestNumber.get(pullRequestNumber);
+}
+function getProjectPullRequestStatus(state) {
+  switch (state) {
+    case "MERGED":
+      return "merged";
+    case "CLOSED":
+      return "closed";
+    default:
+      return "open";
+  }
+}
+async function buildProjectPullRequestSummaryRecord(octokit, repository, node, issueLookup, pullRequestStatusCache) {
+  if (!node || typeof node.number !== "number" || !node.url || !node.title?.trim()) {
+    return null;
+  }
+  const inlineReviewThreadSummary = node.reviewThreads?.pageInfo?.hasNextPage ? null : summarizeProjectPullRequestReviewThreadsFromConnection(node.reviewThreads);
+  const inlineReviewSummary = node.reviews?.pageInfo?.hasNextPage ? null : summarizeGitHubPullRequestReviewNodes(node.reviews?.nodes);
+  const inlineCiState = tryBuildGitHubPullRequestCiStateFromBatchNode({
+    statusCheckRollup: node.statusCheckRollup
+  });
+  const [reviewThreadSummary, reviewSummary, statusSnapshot, behindBy] = await Promise.all([
+    getOrLoadCachedGitHubPullRequestReviewThreadSummary(
+      octokit,
+      repository,
+      node.number,
+      inlineReviewThreadSummary
+    ),
+    getOrLoadCachedGitHubPullRequestReviewSummary(
+      octokit,
+      repository,
+      node.number,
+      inlineReviewSummary
+    ),
+    getGitHubPullRequestStatusSnapshot(octokit, repository, node.number, pullRequestStatusCache, {
+      reviewThreadSummary: inlineReviewThreadSummary,
+      ciState: inlineCiState
+    }),
+    getGitHubPullRequestBehindCount(octokit, repository, {
+      baseBranch: node.baseRefName,
+      headBranch: node.headRefName,
+      headRepositoryOwner: node.headRepositoryOwner?.login
+    })
+  ]);
+  const closingIssues = normalizeProjectPullRequestClosingIssues(repository, node.closingIssuesReferences?.nodes);
+  const linkedIssue = resolveLinkedPaperclipIssueForPullRequest(node.number, closingIssues, issueLookup);
+  const author = buildProjectPullRequestPerson({
+    login: node.author?.login,
+    url: node.author?.url,
+    avatarUrl: node.author?.avatarUrl
+  });
+  const checksStatus = statusSnapshot.ciState === "green" ? "passed" : statusSnapshot.ciState === "red" ? "failed" : "pending";
+  const githubMergeable = node.mergeable === "MERGEABLE";
+  const reviewable = resolveProjectPullRequestReviewable({
+    checksStatus,
+    copilotUnresolvedReviewThreads: reviewThreadSummary.copilotUnresolvedReviewThreads,
+    githubMergeable
+  });
+  const mergeable = resolveProjectPullRequestMergeable({
+    checksStatus,
+    reviewApprovals: reviewSummary.approvals,
+    unresolvedReviewThreads: reviewThreadSummary.unresolvedReviewThreads,
+    githubMergeable
+  });
+  const upToDateStatus = resolveProjectPullRequestUpToDateStatus({
+    mergeStateStatus: node.mergeStateStatus,
+    mergeable: node.mergeable,
+    behindBy
+  });
+  return {
+    id: node.id ?? `github-pull-request-${repository.owner}-${repository.repo}-${node.number}`,
+    number: node.number,
+    title: node.title.trim(),
+    labels: normalizeProjectPullRequestLabels(node.labels?.nodes),
+    author,
+    assignees: [],
+    checksStatus,
+    upToDateStatus,
+    githubMergeable,
+    reviewable,
+    reviewApprovals: reviewSummary.approvals,
+    reviewChangesRequested: reviewSummary.changesRequested,
+    reviewCommentCount: 0,
+    unresolvedReviewThreads: reviewThreadSummary.unresolvedReviewThreads,
+    copilotUnresolvedReviewThreads: reviewThreadSummary.copilotUnresolvedReviewThreads,
+    commentsCount: typeof node.comments?.totalCount === "number" && node.comments.totalCount >= 0 ? Math.floor(node.comments.totalCount) : 0,
+    createdAt: node.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    updatedAt: node.updatedAt ?? node.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    ...linkedIssue?.paperclipIssueId ? { paperclipIssueId: linkedIssue.paperclipIssueId } : {},
+    ...linkedIssue?.paperclipIssueKey ? { paperclipIssueKey: linkedIssue.paperclipIssueKey } : {},
+    mergeable,
+    status: getProjectPullRequestStatus(node.state),
+    githubUrl: node.url,
+    checksUrl: `${node.url}/checks`,
+    reviewsUrl: `${node.url}/files`,
+    reviewThreadsUrl: `${node.url}/files`,
+    commentsUrl: node.url,
+    baseBranch: node.baseRefName ?? "",
+    headBranch: node.headRefName ?? "",
+    commits: typeof node.commits?.totalCount === "number" && node.commits.totalCount >= 0 ? Math.floor(node.commits.totalCount) : 0,
+    changedFiles: typeof node.changedFiles === "number" && node.changedFiles >= 0 ? Math.floor(node.changedFiles) : 0
+  };
+}
+async function listProjectPullRequestSummaryRecords(ctx, octokit, scope, options) {
+  const issueLookup = await buildProjectPullRequestIssueLookup(ctx, scope);
+  const pullRequestStatusCache = /* @__PURE__ */ new Map();
+  const pullRequests = [];
+  const first = Math.max(1, Math.floor(options?.first ?? PROJECT_PULL_REQUEST_PAGE_SIZE));
+  let after = typeof options?.after === "string" && options.after.trim() ? options.after.trim() : void 0;
+  let totalOpenPullRequests = 0;
+  let defaultBranchName;
+  let hasNextPage = false;
+  let nextCursor;
+  do {
+    const response = await octokit.graphql(
+      GITHUB_PROJECT_PULL_REQUESTS_QUERY,
+      {
+        owner: scope.repository.owner,
+        repo: scope.repository.repo,
+        first,
+        after
+      }
+    );
+    const connection = response.repository?.pullRequests;
+    if (typeof connection?.totalCount === "number" && connection.totalCount >= 0) {
+      totalOpenPullRequests = Math.floor(connection.totalCount);
+    }
+    defaultBranchName ??= normalizeOptionalString2(response.repository?.defaultBranchRef?.name);
+    const pageNodes = (connection?.nodes ?? []).filter((node) => node !== null);
+    const pageRecords = await mapWithConcurrency(
+      pageNodes,
+      PROJECT_PULL_REQUEST_SUMMARY_CONCURRENCY,
+      async (node) => buildProjectPullRequestSummaryRecord(
+        octokit,
+        scope.repository,
+        node,
+        issueLookup,
+        pullRequestStatusCache
+      )
+    );
+    pullRequests.push(...pageRecords.filter((record) => Boolean(record)));
+    nextCursor = getPageCursor(connection?.pageInfo);
+    hasNextPage = Boolean(connection?.pageInfo?.hasNextPage && nextCursor);
+    if (!options?.collectAll) {
+      break;
+    }
+    after = nextCursor;
+  } while (after);
+  return {
+    pullRequests: sortProjectPullRequestRecordsByUpdatedAt(pullRequests),
+    totalOpenPullRequests,
+    ...defaultBranchName ? { defaultBranchName } : {},
+    hasNextPage,
+    ...nextCursor ? { nextCursor } : {}
+  };
+}
+async function buildProjectPullRequestMetricCounts(octokit, repository, node, pullRequestStatusCache) {
+  if (!node || typeof node.number !== "number") {
+    return {
+      pullRequestNumber: null,
+      mergeablePullRequests: 0,
+      reviewablePullRequests: 0,
+      failingPullRequests: 0
+    };
+  }
+  const inlineReviewThreadSummary = node.reviewThreads?.pageInfo?.hasNextPage ? null : summarizeProjectPullRequestReviewThreadsFromConnection(node.reviewThreads);
+  const inlineReviewSummary = node.reviews?.pageInfo?.hasNextPage ? null : summarizeGitHubPullRequestReviewNodes(node.reviews?.nodes);
+  const inlineCiState = tryBuildGitHubPullRequestCiStateFromBatchNode({
+    statusCheckRollup: node.statusCheckRollup
+  });
+  const [reviewThreadSummary, reviewSummary, statusSnapshot] = await Promise.all([
+    getOrLoadCachedGitHubPullRequestReviewThreadSummary(
+      octokit,
+      repository,
+      node.number,
+      inlineReviewThreadSummary
+    ),
+    getOrLoadCachedGitHubPullRequestReviewSummary(
+      octokit,
+      repository,
+      node.number,
+      inlineReviewSummary
+    ),
+    getGitHubPullRequestStatusSnapshot(octokit, repository, node.number, pullRequestStatusCache, {
+      reviewThreadSummary: inlineReviewThreadSummary,
+      ciState: inlineCiState
+    })
+  ]);
+  const checksStatus = statusSnapshot.ciState === "green" ? "passed" : statusSnapshot.ciState === "red" ? "failed" : "pending";
+  const githubMergeable = node.mergeable === "MERGEABLE";
+  const reviewable = resolveProjectPullRequestReviewable({
+    checksStatus,
+    copilotUnresolvedReviewThreads: reviewThreadSummary.copilotUnresolvedReviewThreads,
+    githubMergeable
+  });
+  const mergeable = resolveProjectPullRequestMergeable({
+    checksStatus,
+    reviewApprovals: reviewSummary.approvals,
+    unresolvedReviewThreads: reviewThreadSummary.unresolvedReviewThreads,
+    githubMergeable
+  });
+  return {
+    pullRequestNumber: Math.floor(node.number),
+    mergeablePullRequests: mergeable ? 1 : 0,
+    reviewablePullRequests: reviewable ? 1 : 0,
+    failingPullRequests: checksStatus === "failed" ? 1 : 0
+  };
+}
+async function listProjectPullRequestCount(octokit, scope) {
+  const response = await octokit.graphql(
+    GITHUB_PROJECT_OPEN_PULL_REQUEST_COUNT_QUERY,
+    {
+      owner: scope.repository.owner,
+      repo: scope.repository.repo
+    }
+  );
+  const totalCount = response.repository?.pullRequests?.totalCount;
+  return typeof totalCount === "number" && totalCount >= 0 ? Math.floor(totalCount) : 0;
+}
+async function listProjectPullRequestMetrics(octokit, scope) {
+  const pullRequestStatusCache = /* @__PURE__ */ new Map();
+  let totalOpenPullRequests = 0;
+  let defaultBranchName;
+  let mergeablePullRequests = 0;
+  let reviewablePullRequests = 0;
+  let failingPullRequests = 0;
+  const mergeablePullRequestNumbers = [];
+  const reviewablePullRequestNumbers = [];
+  const failingPullRequestNumbers = [];
+  let after;
+  do {
+    const response = await octokit.graphql(
+      GITHUB_PROJECT_PULL_REQUEST_METRICS_QUERY,
+      {
+        owner: scope.repository.owner,
+        repo: scope.repository.repo,
+        first: PROJECT_PULL_REQUEST_METRICS_BATCH_SIZE,
+        after
+      }
+    );
+    const connection = response.repository?.pullRequests;
+    if (typeof connection?.totalCount === "number" && connection.totalCount >= 0) {
+      totalOpenPullRequests = Math.floor(connection.totalCount);
+    }
+    defaultBranchName ??= normalizeOptionalString2(response.repository?.defaultBranchRef?.name);
+    const pageNodes = (connection?.nodes ?? []).filter((node) => node !== null);
+    const pageMetrics = await mapWithConcurrency(
+      pageNodes,
+      PROJECT_PULL_REQUEST_SUMMARY_CONCURRENCY,
+      async (node) => buildProjectPullRequestMetricCounts(octokit, scope.repository, node, pullRequestStatusCache)
+    );
+    for (const pageMetric of pageMetrics) {
+      mergeablePullRequests += pageMetric.mergeablePullRequests;
+      reviewablePullRequests += pageMetric.reviewablePullRequests;
+      failingPullRequests += pageMetric.failingPullRequests;
+      if (pageMetric.pullRequestNumber !== null && pageMetric.mergeablePullRequests > 0) {
+        mergeablePullRequestNumbers.push(pageMetric.pullRequestNumber);
+      }
+      if (pageMetric.pullRequestNumber !== null && pageMetric.reviewablePullRequests > 0) {
+        reviewablePullRequestNumbers.push(pageMetric.pullRequestNumber);
+      }
+      if (pageMetric.pullRequestNumber !== null && pageMetric.failingPullRequests > 0) {
+        failingPullRequestNumbers.push(pageMetric.pullRequestNumber);
+      }
+    }
+    after = getPageCursor(connection?.pageInfo);
+  } while (after);
+  return {
+    totalOpenPullRequests,
+    ...defaultBranchName ? { defaultBranchName } : {},
+    mergeablePullRequests,
+    reviewablePullRequests,
+    failingPullRequests,
+    mergeablePullRequestNumbers,
+    reviewablePullRequestNumbers,
+    failingPullRequestNumbers
+  };
+}
+function buildProjectPullRequestMetricsCacheKey(scope) {
+  return buildRepositoryPullRequestCollectionCacheKey(scope.repository, "metrics");
+}
+function buildProjectPullRequestSummaryCacheKey(scope) {
+  return `${buildProjectPullRequestScopeCacheKey({
+    companyId: scope.companyId,
+    projectId: scope.projectId,
+    repositoryUrl: scope.repository.url
+  })}:summary`;
+}
+function buildProjectPullRequestCountCacheKey(scope) {
+  return buildRepositoryPullRequestCollectionCacheKey(scope.repository, "count");
+}
+function getCachedProjectPullRequestSummarySeed(scope) {
+  const cachedPage = getFreshCacheValue(
+    activeProjectPullRequestPageCache,
+    buildProjectPullRequestPageCacheKey(scope, "all", 0)
+  );
+  if (!cachedPage || cachedPage.status !== "ready") {
+    return null;
+  }
+  const totalOpenPullRequests = typeof cachedPage.totalOpenPullRequests === "number" && cachedPage.totalOpenPullRequests >= 0 ? Math.floor(cachedPage.totalOpenPullRequests) : null;
+  const pullRequests = Array.isArray(cachedPage.pullRequests) ? cachedPage.pullRequests.filter(
+    (record) => Boolean(record) && typeof record === "object" && !Array.isArray(record)
+  ) : null;
+  if (totalOpenPullRequests === null || !pullRequests) {
+    return null;
+  }
+  const hasNextPage = cachedPage.hasNextPage === true;
+  const nextCursor = typeof cachedPage.nextCursor === "string" && cachedPage.nextCursor.trim() ? cachedPage.nextCursor.trim() : void 0;
+  if (hasNextPage && !nextCursor) {
+    return null;
+  }
+  const defaultBranchName = normalizeOptionalString2(cachedPage.defaultBranchName);
+  return {
+    totalOpenPullRequests,
+    ...defaultBranchName ? { defaultBranchName } : {},
+    pullRequests: sortProjectPullRequestRecordsByUpdatedAt(pullRequests),
+    hasNextPage,
+    ...nextCursor ? { nextCursor } : {}
+  };
+}
+function cacheProjectPullRequestSummary(scope, summary) {
+  const pullRequests = sortProjectPullRequestRecordsByUpdatedAt(summary.pullRequests);
+  const metrics = buildProjectPullRequestMetrics(
+    pullRequests,
+    summary.totalOpenPullRequests,
+    summary.defaultBranchName
+  );
+  cacheProjectPullRequestSummaryRecords(scope, pullRequests);
+  cacheProjectPullRequestMetricsEntry(scope, metrics);
+  return setCacheValue(
+    activeProjectPullRequestSummaryCache,
+    buildProjectPullRequestSummaryCacheKey(scope),
+    {
+      totalOpenPullRequests: summary.totalOpenPullRequests,
+      ...summary.defaultBranchName ? { defaultBranchName: summary.defaultBranchName } : {},
+      pullRequests,
+      metrics
+    },
+    PROJECT_PULL_REQUEST_SUMMARY_CACHE_TTL_MS
+  );
+}
+function cacheProjectPullRequestCount(scope, totalOpenPullRequests, ttlMs = PROJECT_PULL_REQUEST_SUMMARY_CACHE_TTL_MS) {
+  return setCacheValue(
+    activeProjectPullRequestCountCache,
+    buildProjectPullRequestCountCacheKey(scope),
+    Math.max(0, Math.floor(totalOpenPullRequests)),
+    ttlMs
+  );
+}
+function cacheProjectPullRequestMetricsEntry(scope, metrics, ttlMs = PROJECT_PULL_REQUEST_SUMMARY_CACHE_TTL_MS) {
+  cacheProjectPullRequestCount(scope, metrics.totalOpenPullRequests, ttlMs);
+  return setCacheValue(
+    activeProjectPullRequestMetricsCache,
+    buildProjectPullRequestMetricsCacheKey(scope),
+    metrics,
+    ttlMs
+  );
+}
+async function getOrLoadCachedProjectPullRequestMetricsEntry(ctx, scope, octokit) {
+  const summaryCacheKey = buildProjectPullRequestSummaryCacheKey(scope);
+  const cachedSummary = getFreshCacheValue(activeProjectPullRequestSummaryCache, summaryCacheKey);
+  if (cachedSummary) {
+    return cachedSummary.metrics;
+  }
+  const metricsCacheKey = buildProjectPullRequestMetricsCacheKey(scope);
+  const cachedMetrics = getFreshCacheValue(activeProjectPullRequestMetricsCache, metricsCacheKey);
+  if (cachedMetrics) {
+    return cachedMetrics;
+  }
+  const inFlightMetrics = activeProjectPullRequestMetricsPromiseCache.get(metricsCacheKey);
+  if (inFlightMetrics) {
+    return inFlightMetrics;
+  }
+  const loadMetricsPromise = (async () => {
+    const resolvedOctokit = octokit ?? await createGitHubToolOctokit(ctx);
+    const metrics = await listProjectPullRequestMetrics(resolvedOctokit, scope);
+    return cacheProjectPullRequestMetricsEntry(scope, metrics);
+  })();
+  activeProjectPullRequestMetricsPromiseCache.set(metricsCacheKey, loadMetricsPromise);
+  try {
+    return await loadMetricsPromise;
+  } finally {
+    if (activeProjectPullRequestMetricsPromiseCache.get(metricsCacheKey) === loadMetricsPromise) {
+      activeProjectPullRequestMetricsPromiseCache.delete(metricsCacheKey);
+    }
+  }
+}
+async function getOrLoadCachedProjectPullRequestCount(ctx, scope, octokit) {
+  const summaryCacheKey = buildProjectPullRequestSummaryCacheKey(scope);
+  const cachedSummary = getFreshCacheValue(activeProjectPullRequestSummaryCache, summaryCacheKey);
+  if (cachedSummary) {
+    return cachedSummary.totalOpenPullRequests;
+  }
+  const metricsCacheKey = buildProjectPullRequestMetricsCacheKey(scope);
+  const cachedMetrics = getFreshCacheValue(activeProjectPullRequestMetricsCache, metricsCacheKey);
+  if (cachedMetrics) {
+    return cachedMetrics.totalOpenPullRequests;
+  }
+  const countCacheKey = buildProjectPullRequestCountCacheKey(scope);
+  const cachedCount = getFreshCacheValue(activeProjectPullRequestCountCache, countCacheKey);
+  if (cachedCount !== null) {
+    return cachedCount;
+  }
+  const cachedSummarySeed = getCachedProjectPullRequestSummarySeed(scope);
+  if (cachedSummarySeed) {
+    return cacheProjectPullRequestCount(scope, cachedSummarySeed.totalOpenPullRequests);
+  }
+  const inFlightCount = activeProjectPullRequestCountPromiseCache.get(countCacheKey);
+  if (inFlightCount) {
+    return inFlightCount;
+  }
+  const loadCountPromise = (async () => {
+    const resolvedOctokit = octokit ?? await createGitHubToolOctokit(ctx);
+    const totalOpenPullRequests = await listProjectPullRequestCount(resolvedOctokit, scope);
+    return setCacheValue(
+      activeProjectPullRequestCountCache,
+      countCacheKey,
+      totalOpenPullRequests,
+      PROJECT_PULL_REQUEST_SUMMARY_CACHE_TTL_MS
+    );
+  })();
+  activeProjectPullRequestCountPromiseCache.set(countCacheKey, loadCountPromise);
+  try {
+    return await loadCountPromise;
+  } finally {
+    if (activeProjectPullRequestCountPromiseCache.get(countCacheKey) === loadCountPromise) {
+      activeProjectPullRequestCountPromiseCache.delete(countCacheKey);
+    }
+  }
+}
+async function getOrLoadCachedProjectPullRequestMetrics(ctx, scope, octokit) {
+  return getPublicProjectPullRequestMetrics(
+    await getOrLoadCachedProjectPullRequestMetricsEntry(ctx, scope, octokit)
+  );
+}
+async function listProjectPullRequestSummaryRecordsByNumbers(ctx, octokit, scope, pullRequestNumbers) {
+  const normalizedPullRequestNumbers = [
+    ...new Set(
+      pullRequestNumbers.map((value) => Math.floor(value)).filter((value) => Number.isFinite(value) && value > 0)
+    )
+  ];
+  if (normalizedPullRequestNumbers.length === 0) {
+    return [];
+  }
+  const query = buildGitHubProjectPullRequestsByNumberQuery(normalizedPullRequestNumbers);
+  const response = await octokit.graphql(
+    query,
+    {
+      owner: scope.repository.owner,
+      repo: scope.repository.repo
+    }
+  );
+  const repository = response.repository && typeof response.repository === "object" ? response.repository : {};
+  const issueLookup = await buildProjectPullRequestIssueLookup(ctx, scope);
+  const pullRequestStatusCache = /* @__PURE__ */ new Map();
+  const recordsByNumber = /* @__PURE__ */ new Map();
+  const builtRecords = await mapWithConcurrency(
+    normalizedPullRequestNumbers,
+    PROJECT_PULL_REQUEST_SUMMARY_CONCURRENCY,
+    async (pullRequestNumber) => {
+      const node = repository[buildGitHubProjectPullRequestByNumberAlias(pullRequestNumber)];
+      if (!node) {
+        return null;
+      }
+      const record = await buildProjectPullRequestSummaryRecord(
+        octokit,
+        scope.repository,
+        node,
+        issueLookup,
+        pullRequestStatusCache
+      );
+      if (!record) {
+        return null;
+      }
+      return {
+        pullRequestNumber,
+        record
+      };
+    }
+  );
+  for (const builtRecord of builtRecords) {
+    if (!builtRecord) {
+      continue;
+    }
+    recordsByNumber.set(builtRecord.pullRequestNumber, builtRecord.record);
+  }
+  return normalizedPullRequestNumbers.map((pullRequestNumber) => recordsByNumber.get(pullRequestNumber)).filter((record) => Boolean(record));
+}
+async function getOrLoadProjectPullRequestSummaryRecordsForNumbers(ctx, scope, pullRequestNumbers, octokit) {
+  const normalizedPullRequestNumbers = [
+    ...new Set(
+      pullRequestNumbers.map((value) => Math.floor(value)).filter((value) => Number.isFinite(value) && value > 0)
+    )
+  ];
+  if (normalizedPullRequestNumbers.length === 0) {
+    return [];
+  }
+  const cachedSummary = getFreshCacheValue(
+    activeProjectPullRequestSummaryCache,
+    buildProjectPullRequestSummaryCacheKey(scope)
+  );
+  const summaryRecordsByNumber = cachedSummary ? new Map(
+    cachedSummary.pullRequests.map((pullRequest) => {
+      const pullRequestNumber = getProjectPullRequestNumber(pullRequest);
+      return pullRequestNumber === null ? null : [pullRequestNumber, pullRequest];
+    }).filter((entry) => Boolean(entry))
+  ) : null;
+  const recordsByNumber = /* @__PURE__ */ new Map();
+  for (const pullRequestNumber of normalizedPullRequestNumbers) {
+    const cachedSummaryRecord = summaryRecordsByNumber?.get(pullRequestNumber);
+    if (cachedSummaryRecord) {
+      recordsByNumber.set(pullRequestNumber, cachedSummaryRecord);
+      continue;
+    }
+    const cachedRecord = getFreshCacheValue(
+      activeProjectPullRequestSummaryRecordCache,
+      buildProjectPullRequestSummaryRecordCacheKey(scope, pullRequestNumber)
+    );
+    if (cachedRecord) {
+      recordsByNumber.set(pullRequestNumber, cachedRecord);
+    }
+  }
+  const missingPullRequestNumbers = normalizedPullRequestNumbers.filter((pullRequestNumber) => !recordsByNumber.has(pullRequestNumber));
+  if (missingPullRequestNumbers.length > 0) {
+    const resolvedOctokit = octokit ?? await createGitHubToolOctokit(ctx);
+    const loadedRecords = await listProjectPullRequestSummaryRecordsByNumbers(
+      ctx,
+      resolvedOctokit,
+      scope,
+      missingPullRequestNumbers
+    );
+    cacheProjectPullRequestSummaryRecords(scope, loadedRecords);
+    for (const loadedRecord of loadedRecords) {
+      const pullRequestNumber = getProjectPullRequestNumber(loadedRecord);
+      if (pullRequestNumber === null) {
+        continue;
+      }
+      recordsByNumber.set(pullRequestNumber, loadedRecord);
+    }
+  }
+  return normalizedPullRequestNumbers.map((pullRequestNumber) => recordsByNumber.get(pullRequestNumber)).filter((record) => Boolean(record));
+}
+function buildPaperclipIssueDescriptionFromPullRequest(params) {
+  const importLine = `Imported from GitHub pull request [#${params.pullRequestNumber}](${params.pullRequestUrl}) in ${formatRepositoryLabel(params.repository)}.`;
+  const body = typeof params.body === "string" ? params.body.trim() : "";
+  return body ? `${importLine}
+
+${body}` : importLine;
+}
+async function requireProjectPullRequestScope(ctx, input, resolvedProjectMappings) {
+  const companyId = normalizeCompanyId(input.companyId);
+  const projectId = typeof input.projectId === "string" && input.projectId.trim() ? input.projectId.trim() : void 0;
+  if (!companyId || !projectId) {
+    throw new Error("A company id and project id are required to load project pull requests.");
+  }
+  const mappings = resolvedProjectMappings ?? await resolveProjectScopedMappings(
+    ctx,
+    normalizeSettings(await ctx.state.get(SETTINGS_SCOPE)).mappings,
+    {
+      companyId,
+      projectId
+    }
+  );
+  if (mappings.length === 0) {
+    throw new Error("No saved GitHub repository mapping matches this Paperclip project.");
+  }
+  const requestedRepositoryUrl = typeof input.repositoryUrl === "string" && input.repositoryUrl.trim() ? getNormalizedMappingRepositoryUrl({
+    repositoryUrl: input.repositoryUrl
+  }) : void 0;
+  const sortedMappings = [...mappings].sort(
+    (left, right) => getNormalizedMappingRepositoryUrl(left).localeCompare(getNormalizedMappingRepositoryUrl(right))
+  );
+  const mapping = requestedRepositoryUrl ? sortedMappings.find((entry) => getNormalizedMappingRepositoryUrl(entry) === requestedRepositoryUrl) : sortedMappings[0];
+  if (!mapping) {
+    throw new Error("This Paperclip project is not mapped to the requested GitHub repository.");
+  }
+  return {
+    companyId,
+    projectId,
+    projectLabel: mapping.paperclipProjectName.trim() || "Project",
+    mapping,
+    repository: requireRepositoryReference(mapping.repositoryUrl),
+    mappingCount: sortedMappings.length
+  };
+}
+async function buildProjectPullRequestsPageData(ctx, input) {
+  const filter = normalizeProjectPullRequestFilter(input.filter);
+  const pageIndex = normalizeProjectPullRequestPageIndex(input.pageIndex);
+  const cursor = typeof input.cursor === "string" && input.cursor.trim() ? input.cursor.trim() : void 0;
+  const companyId = normalizeCompanyId(input.companyId);
+  const projectId = typeof input.projectId === "string" && input.projectId.trim() ? input.projectId.trim() : null;
+  if (!companyId || !projectId) {
+    return {
+      status: "missing_project",
+      projectId,
+      projectLabel: "Project",
+      repositoryLabel: "",
+      repositoryUrl: "",
+      repositoryDescription: "",
+      filter,
+      pageIndex: 0,
+      pageSize: PROJECT_PULL_REQUEST_PAGE_SIZE,
+      hasNextPage: false,
+      hasPreviousPage: false,
+      totalFilteredPullRequests: 0,
+      pullRequests: [],
+      message: "Open this page from a mapped Paperclip project."
+    };
+  }
+  const settings = normalizeSettings(await ctx.state.get(SETTINGS_SCOPE));
+  const projectMappings = await resolveProjectScopedMappings(ctx, settings.mappings, {
+    companyId,
+    projectId
+  });
+  if (projectMappings.length === 0) {
+    return {
+      status: "unmapped",
+      projectId,
+      projectLabel: "Project",
+      repositoryLabel: "",
+      repositoryUrl: "",
+      repositoryDescription: "",
+      filter,
+      pageIndex: 0,
+      pageSize: PROJECT_PULL_REQUEST_PAGE_SIZE,
+      hasNextPage: false,
+      hasPreviousPage: false,
+      totalFilteredPullRequests: 0,
+      pullRequests: [],
+      message: "No GitHub repository is mapped to this project yet."
+    };
+  }
+  const scope = await requireProjectPullRequestScope(ctx, input, projectMappings);
+  const config = await getResolvedConfig(ctx);
+  if (!hasConfiguredGithubToken(settings, config)) {
+    return {
+      status: "missing_token",
+      projectId,
+      projectLabel: scope.projectLabel,
+      repositoryLabel: formatRepositoryLabel(scope.repository),
+      repositoryUrl: scope.repository.url,
+      repositoryDescription: "",
+      filter,
+      pageIndex: 0,
+      pageSize: PROJECT_PULL_REQUEST_PAGE_SIZE,
+      hasNextPage: false,
+      hasPreviousPage: false,
+      totalFilteredPullRequests: 0,
+      pullRequests: [],
+      message: "Configure a GitHub token before opening pull requests."
+    };
+  }
+  try {
+    const octokit = await createGitHubToolOctokit(ctx);
+    const pageCacheKey = buildProjectPullRequestPageCacheKey(scope, filter, pageIndex, cursor);
+    const cachedPage = getFreshCacheValue(activeProjectPullRequestPageCache, pageCacheKey);
+    if (cachedPage) {
+      return cachedPage;
+    }
+    if (filter !== "all") {
+      const metrics = await getOrLoadCachedProjectPullRequestMetricsEntry(ctx, scope, octokit);
+      const filteredPullRequestNumbers = getProjectPullRequestNumbersForFilter(metrics, filter);
+      const page = sliceProjectPullRequestNumbers(filteredPullRequestNumbers, pageIndex, PROJECT_PULL_REQUEST_PAGE_SIZE);
+      const pullRequests = sortProjectPullRequestRecordsByUpdatedAt(
+        await getOrLoadProjectPullRequestSummaryRecordsForNumbers(
+          ctx,
+          scope,
+          page.pullRequestNumbers,
+          octokit
+        )
+      );
+      const tokenPermissionAudit2 = await getOrLoadGitHubRepositoryTokenCapabilityAudit(octokit, scope.repository, {
+        samplePullRequestNumber: pullRequests[0] ? getProjectPullRequestNumber(pullRequests[0]) ?? void 0 : void 0
+      });
+      cacheProjectPullRequestCount(scope, metrics.totalOpenPullRequests);
+      return setCacheValue(
+        activeProjectPullRequestPageCache,
+        pageCacheKey,
+        {
+          status: "ready",
+          projectId,
+          projectLabel: scope.projectLabel,
+          repositoryLabel: formatRepositoryLabel(scope.repository),
+          repositoryUrl: scope.repository.url,
+          repositoryDescription: "",
+          ...metrics.defaultBranchName ? { defaultBranchName: metrics.defaultBranchName } : {},
+          filter,
+          pageIndex: page.pageIndex,
+          pageSize: PROJECT_PULL_REQUEST_PAGE_SIZE,
+          hasNextPage: page.hasNextPage,
+          hasPreviousPage: page.hasPreviousPage,
+          totalFilteredPullRequests: filteredPullRequestNumbers.length,
+          totalOpenPullRequests: metrics.totalOpenPullRequests,
+          pullRequests,
+          tokenPermissionAudit: tokenPermissionAudit2
+        },
+        PROJECT_PULL_REQUEST_PAGE_CACHE_TTL_MS
+      );
+    }
+    const cachedFullSummary = getFreshCacheValue(
+      activeProjectPullRequestSummaryCache,
+      buildProjectPullRequestSummaryCacheKey(scope)
+    );
+    if (cachedFullSummary) {
+      cacheProjectPullRequestCount(scope, cachedFullSummary.totalOpenPullRequests);
+      const page = sliceProjectPullRequestRecords(
+        cachedFullSummary.pullRequests,
+        pageIndex,
+        PROJECT_PULL_REQUEST_PAGE_SIZE
+      );
+      const tokenPermissionAudit2 = await getOrLoadGitHubRepositoryTokenCapabilityAudit(octokit, scope.repository, {
+        samplePullRequestNumber: page.pullRequests[0] ? getProjectPullRequestNumber(page.pullRequests[0]) ?? void 0 : void 0
+      });
+      return setCacheValue(
+        activeProjectPullRequestPageCache,
+        pageCacheKey,
+        {
+          status: "ready",
+          projectId,
+          projectLabel: scope.projectLabel,
+          repositoryLabel: formatRepositoryLabel(scope.repository),
+          repositoryUrl: scope.repository.url,
+          repositoryDescription: "",
+          ...cachedFullSummary.defaultBranchName ? { defaultBranchName: cachedFullSummary.defaultBranchName } : {},
+          filter,
+          pageIndex: page.pageIndex,
+          pageSize: PROJECT_PULL_REQUEST_PAGE_SIZE,
+          hasNextPage: page.hasNextPage,
+          hasPreviousPage: page.hasPreviousPage,
+          totalFilteredPullRequests: cachedFullSummary.totalOpenPullRequests,
+          totalOpenPullRequests: cachedFullSummary.totalOpenPullRequests,
+          pullRequests: page.pullRequests,
+          tokenPermissionAudit: tokenPermissionAudit2
+        },
+        PROJECT_PULL_REQUEST_PAGE_CACHE_TTL_MS
+      );
+    }
+    const summary = await listProjectPullRequestSummaryRecords(ctx, octokit, scope, {
+      after: cursor,
+      first: PROJECT_PULL_REQUEST_PAGE_SIZE
+    });
+    cacheProjectPullRequestCount(scope, summary.totalOpenPullRequests);
+    cacheProjectPullRequestSummaryRecords(scope, summary.pullRequests, PROJECT_PULL_REQUEST_PAGE_CACHE_TTL_MS);
+    if (pageIndex === 0 && !summary.hasNextPage) {
+      cacheProjectPullRequestSummary(scope, {
+        totalOpenPullRequests: summary.totalOpenPullRequests,
+        ...summary.defaultBranchName ? { defaultBranchName: summary.defaultBranchName } : {},
+        pullRequests: summary.pullRequests
+      });
+    }
+    const tokenPermissionAudit = await getOrLoadGitHubRepositoryTokenCapabilityAudit(octokit, scope.repository, {
+      samplePullRequestNumber: summary.pullRequests[0] ? getProjectPullRequestNumber(summary.pullRequests[0]) ?? void 0 : void 0
+    });
+    return setCacheValue(
+      activeProjectPullRequestPageCache,
+      pageCacheKey,
+      {
+        status: "ready",
+        projectId,
+        projectLabel: scope.projectLabel,
+        repositoryLabel: formatRepositoryLabel(scope.repository),
+        repositoryUrl: scope.repository.url,
+        repositoryDescription: "",
+        ...summary.defaultBranchName ? { defaultBranchName: summary.defaultBranchName } : {},
+        filter,
+        pageIndex,
+        pageSize: PROJECT_PULL_REQUEST_PAGE_SIZE,
+        hasNextPage: summary.hasNextPage,
+        hasPreviousPage: pageIndex > 0,
+        totalFilteredPullRequests: summary.totalOpenPullRequests,
+        totalOpenPullRequests: summary.totalOpenPullRequests,
+        ...summary.nextCursor ? { nextCursor: summary.nextCursor } : {},
+        pullRequests: summary.pullRequests,
+        tokenPermissionAudit
+      },
+      PROJECT_PULL_REQUEST_PAGE_CACHE_TTL_MS
+    );
+  } catch (error) {
+    return {
+      status: "error",
+      projectId,
+      projectLabel: scope.projectLabel,
+      repositoryLabel: formatRepositoryLabel(scope.repository),
+      repositoryUrl: scope.repository.url,
+      repositoryDescription: "",
+      filter,
+      pageIndex,
+      pageSize: PROJECT_PULL_REQUEST_PAGE_SIZE,
+      hasNextPage: false,
+      hasPreviousPage: pageIndex > 0,
+      totalFilteredPullRequests: 0,
+      pullRequests: [],
+      message: getErrorMessage(error)
+    };
+  }
+}
+async function buildProjectPullRequestMetricsData(ctx, input) {
+  const companyId = normalizeCompanyId(input.companyId);
+  const projectId = typeof input.projectId === "string" && input.projectId.trim() ? input.projectId.trim() : null;
+  if (!companyId || !projectId) {
+    return {
+      status: "missing_project",
+      projectId,
+      totalOpenPullRequests: 0,
+      mergeablePullRequests: 0,
+      reviewablePullRequests: 0,
+      failingPullRequests: 0
+    };
+  }
+  const settings = normalizeSettings(await ctx.state.get(SETTINGS_SCOPE));
+  const projectMappings = await resolveProjectScopedMappings(ctx, settings.mappings, {
+    companyId,
+    projectId
+  });
+  if (projectMappings.length === 0) {
+    return {
+      status: "unmapped",
+      projectId,
+      totalOpenPullRequests: 0,
+      mergeablePullRequests: 0,
+      reviewablePullRequests: 0,
+      failingPullRequests: 0
+    };
+  }
+  const config = await getResolvedConfig(ctx);
+  if (!hasConfiguredGithubToken(settings, config)) {
+    return {
+      status: "missing_token",
+      projectId,
+      totalOpenPullRequests: 0,
+      mergeablePullRequests: 0,
+      reviewablePullRequests: 0,
+      failingPullRequests: 0
+    };
+  }
+  try {
+    const scope = await requireProjectPullRequestScope(ctx, input, projectMappings);
+    const metrics = await getOrLoadCachedProjectPullRequestMetrics(ctx, scope);
+    return {
+      status: "ready",
+      projectId,
+      ...metrics
+    };
+  } catch (error) {
+    return {
+      status: "error",
+      projectId,
+      message: getErrorMessage(error)
+    };
+  }
+}
+async function buildProjectPullRequestCountData(ctx, input) {
+  const companyId = normalizeCompanyId(input.companyId);
+  const projectId = typeof input.projectId === "string" && input.projectId.trim() ? input.projectId.trim() : null;
+  if (!companyId || !projectId) {
+    return {
+      status: "missing_project",
+      projectId,
+      totalOpenPullRequests: 0
+    };
+  }
+  const settings = normalizeSettings(await ctx.state.get(SETTINGS_SCOPE));
+  const projectMappings = await resolveProjectScopedMappings(ctx, settings.mappings, {
+    companyId,
+    projectId
+  });
+  if (projectMappings.length === 0) {
+    return {
+      status: "unmapped",
+      projectId,
+      totalOpenPullRequests: 0
+    };
+  }
+  const config = await getResolvedConfig(ctx);
+  if (!hasConfiguredGithubToken(settings, config)) {
+    return {
+      status: "missing_token",
+      projectId,
+      totalOpenPullRequests: 0
+    };
+  }
+  try {
+    const scope = await requireProjectPullRequestScope(ctx, input, projectMappings);
+    const totalOpenPullRequests = await getOrLoadCachedProjectPullRequestCount(ctx, scope);
+    return {
+      status: "ready",
+      projectId,
+      totalOpenPullRequests
+    };
+  } catch (error) {
+    return {
+      status: "error",
+      projectId,
+      totalOpenPullRequests: 0,
+      message: getErrorMessage(error)
+    };
+  }
+}
+async function buildSettingsTokenPermissionAuditData(ctx, input) {
+  const requestedCompanyId = normalizeCompanyId(input.companyId);
+  if (!requestedCompanyId) {
+    return {
+      status: "ready",
+      allRequiredPermissionsGranted: true,
+      repositories: [],
+      missingPermissions: [],
+      warnings: ["Open a company to audit token permissions for its mapped repositories."]
+    };
+  }
+  const settings = normalizeSettings(await ctx.state.get(SETTINGS_SCOPE));
+  const config = await getResolvedConfig(ctx);
+  if (!hasConfiguredGithubToken(settings, config)) {
+    return {
+      status: "missing_token",
+      allRequiredPermissionsGranted: false,
+      repositories: [],
+      missingPermissions: [],
+      warnings: [],
+      message: "Save a GitHub token before auditing repository permissions."
+    };
+  }
+  const scopedMappings = getSyncableMappings(filterMappingsByCompany(settings.mappings, requestedCompanyId));
+  if (scopedMappings.length === 0) {
+    return {
+      status: "ready",
+      allRequiredPermissionsGranted: true,
+      repositories: [],
+      missingPermissions: [],
+      warnings: ["Add at least one mapped repository in this company to audit token permissions."]
+    };
+  }
+  try {
+    const octokit = await createGitHubToolOctokit(ctx);
+    const repositories = await Promise.all(
+      [
+        ...new Map(
+          scopedMappings.map((mapping) => {
+            const repository = parseRepositoryReference(mapping.repositoryUrl);
+            return repository ? [repository.url, repository] : null;
+          }).filter((entry) => entry !== null)
+        ).values()
+      ].map((repository) => getOrLoadGitHubRepositoryTokenCapabilityAudit(octokit, repository))
+    );
+    const missingPermissions = [
+      ...new Set(repositories.flatMap((repository) => repository.missingPermissions))
+    ].sort((left, right) => left.localeCompare(right));
+    const warnings = repositories.flatMap((repository) => repository.warnings);
+    return {
+      status: "ready",
+      allRequiredPermissionsGranted: repositories.length > 0 && repositories.every((repository) => repository.status === "verified"),
+      repositories,
+      missingPermissions,
+      warnings
+    };
+  } catch (error) {
+    return {
+      status: "error",
+      allRequiredPermissionsGranted: false,
+      repositories: [],
+      missingPermissions: [],
+      warnings: [],
+      message: getErrorMessage(error)
+    };
+  }
+}
+async function listProjectPullRequestClosingIssues(octokit, repository, pullRequestNumber) {
+  const response = await octokit.graphql(
+    GITHUB_PULL_REQUEST_CLOSING_ISSUES_QUERY,
+    {
+      owner: repository.owner,
+      repo: repository.repo,
+      pullRequestNumber
+    }
+  );
+  return normalizeProjectPullRequestClosingIssues(
+    repository,
+    response.repository?.pullRequest?.closingIssuesReferences?.nodes
+  );
+}
+function getPullRequestApiState(value) {
+  if (value.merged === true) {
+    return "merged";
+  }
+  return value.state === "closed" ? "closed" : "open";
+}
+async function buildProjectPullRequestDetailData(ctx, input) {
+  const pullRequestNumber = normalizeToolPositiveInteger(input.pullRequestNumber);
+  if (!pullRequestNumber) {
+    return null;
+  }
+  const scope = await requireProjectPullRequestScope(ctx, input);
+  const detailCacheKey = buildProjectPullRequestDetailCacheKey(scope, pullRequestNumber);
+  const cachedDetail = getFreshCacheValue(activeProjectPullRequestDetailCache, detailCacheKey);
+  if (cachedDetail !== null) {
+    return cachedDetail;
+  }
+  const cachedSummaryRecord = getFreshCacheValue(
+    activeProjectPullRequestSummaryRecordCache,
+    buildProjectPullRequestSummaryRecordCacheKey(scope, pullRequestNumber)
+  );
+  const cachedLinkedIssue = cachedSummaryRecord ? getLinkedPaperclipIssueFromProjectPullRequestRecord(cachedSummaryRecord) : void 0;
+  const octokit = await createGitHubToolOctokit(ctx);
+  const response = await octokit.rest.pulls.get({
+    owner: scope.repository.owner,
+    repo: scope.repository.repo,
+    pull_number: pullRequestNumber,
+    headers: {
+      "X-GitHub-Api-Version": GITHUB_API_VERSION
+    }
+  });
+  const pullRequest = response.data;
+  const reviewSummaryPromise = getOrLoadCachedGitHubPullRequestReviewSummary(octokit, scope.repository, pullRequestNumber);
+  const reviewThreadSummaryPromise = getOrLoadCachedGitHubPullRequestReviewThreadSummary(octokit, scope.repository, pullRequestNumber);
+  const statusSnapshotPromise = reviewThreadSummaryPromise.then(
+    (reviewThreadSummary2) => getGitHubPullRequestStatusSnapshot(octokit, scope.repository, pullRequestNumber, /* @__PURE__ */ new Map(), {
+      reviewThreadSummary: reviewThreadSummary2
+    })
+  );
+  const [reviewSummary, reviewThreadSummary, comments, linkedIssue, statusSnapshot] = await Promise.all([
+    reviewSummaryPromise,
+    reviewThreadSummaryPromise,
+    listAllGitHubIssueComments(octokit, scope.repository, pullRequestNumber),
+    cachedLinkedIssue ? Promise.resolve(cachedLinkedIssue) : (async () => {
+      const issueLookup = await buildProjectPullRequestIssueLookup(ctx, scope);
+      return resolveLinkedPaperclipIssueForPullRequest(
+        pullRequestNumber,
+        await listProjectPullRequestClosingIssues(octokit, scope.repository, pullRequestNumber),
+        issueLookup
+      );
+    })(),
+    statusSnapshotPromise
+  ]);
+  const author = buildProjectPullRequestPerson({
+    login: pullRequest.user?.login,
+    url: pullRequest.user?.html_url,
+    avatarUrl: pullRequest.user?.avatar_url
+  });
+  const timeline = [];
+  const trimmedBody = pullRequest.body?.trim() ?? "";
+  if (trimmedBody) {
+    timeline.push({
+      id: `github-pull-request-${pullRequestNumber}-description`,
+      kind: "description",
+      author,
+      createdAt: pullRequest.created_at ?? (/* @__PURE__ */ new Date()).toISOString(),
+      body: trimmedBody
+    });
+  }
+  for (const comment of comments) {
+    timeline.push({
+      id: `github-pull-request-${pullRequestNumber}-comment-${comment.id}`,
+      kind: "comment",
+      author: buildProjectPullRequestPerson({
+        login: comment.authorLogin,
+        url: comment.authorUrl,
+        avatarUrl: comment.authorAvatarUrl
+      }),
+      createdAt: comment.createdAt ?? comment.updatedAt ?? pullRequest.updated_at ?? (/* @__PURE__ */ new Date()).toISOString(),
+      body: comment.body
+    });
+  }
+  timeline.sort(
+    (left, right) => Date.parse(String(left.createdAt ?? "")) - Date.parse(String(right.createdAt ?? ""))
+  );
+  const checksStatus = statusSnapshot.ciState === "green" ? "passed" : statusSnapshot.ciState === "red" ? "failed" : "pending";
+  const githubMergeable = pullRequest.mergeable === true;
+  const reviewable = resolveProjectPullRequestReviewable({
+    checksStatus,
+    copilotUnresolvedReviewThreads: reviewThreadSummary.copilotUnresolvedReviewThreads,
+    githubMergeable
+  });
+  const mergeable = resolveProjectPullRequestMergeable({
+    checksStatus,
+    reviewApprovals: reviewSummary.approvals,
+    unresolvedReviewThreads: reviewThreadSummary.unresolvedReviewThreads,
+    githubMergeable
+  });
+  return setCacheValue(
+    activeProjectPullRequestDetailCache,
+    detailCacheKey,
+    {
+      id: `github-pull-request-${scope.repository.owner}-${scope.repository.repo}-${pullRequestNumber}`,
+      number: pullRequest.number,
+      title: pullRequest.title,
+      labels: normalizeGitHubIssueLabels(pullRequest.labels),
+      author,
+      assignees: (pullRequest.assignees ?? []).map((assignee) => buildProjectPullRequestPerson({
+        login: assignee?.login,
+        url: assignee?.html_url,
+        avatarUrl: assignee?.avatar_url
+      })),
+      checksStatus,
+      githubMergeable,
+      reviewable,
+      reviewApprovals: reviewSummary.approvals,
+      reviewChangesRequested: reviewSummary.changesRequested,
+      reviewCommentCount: typeof pullRequest.review_comments === "number" && pullRequest.review_comments >= 0 ? Math.floor(pullRequest.review_comments) : 0,
+      unresolvedReviewThreads: reviewThreadSummary.unresolvedReviewThreads,
+      copilotUnresolvedReviewThreads: reviewThreadSummary.copilotUnresolvedReviewThreads,
+      commentsCount: typeof pullRequest.comments === "number" && pullRequest.comments >= 0 ? Math.floor(pullRequest.comments) : comments.length,
+      createdAt: pullRequest.created_at ?? (/* @__PURE__ */ new Date()).toISOString(),
+      updatedAt: pullRequest.updated_at ?? pullRequest.created_at ?? (/* @__PURE__ */ new Date()).toISOString(),
+      ...linkedIssue?.paperclipIssueId ? { paperclipIssueId: linkedIssue.paperclipIssueId } : {},
+      ...linkedIssue?.paperclipIssueKey ? { paperclipIssueKey: linkedIssue.paperclipIssueKey } : {},
+      mergeable,
+      status: getPullRequestApiState({
+        state: pullRequest.state,
+        merged: pullRequest.merged
+      }),
+      githubUrl: pullRequest.html_url,
+      checksUrl: `${pullRequest.html_url}/checks`,
+      reviewsUrl: `${pullRequest.html_url}/files`,
+      reviewThreadsUrl: `${pullRequest.html_url}/files`,
+      commentsUrl: pullRequest.html_url,
+      baseBranch: pullRequest.base.ref,
+      headBranch: pullRequest.head.ref,
+      commits: typeof pullRequest.commits === "number" && pullRequest.commits >= 0 ? pullRequest.commits : 0,
+      changedFiles: typeof pullRequest.changed_files === "number" && pullRequest.changed_files >= 0 ? pullRequest.changed_files : 0,
+      timeline
+    },
+    PROJECT_PULL_REQUEST_DETAIL_CACHE_TTL_MS
+  );
+}
+async function createProjectPullRequestPaperclipIssue(ctx, input) {
+  const pullRequestNumber = normalizeToolPositiveInteger(input.pullRequestNumber);
+  if (!pullRequestNumber) {
+    throw new Error("pullRequestNumber is required.");
+  }
+  if (!ctx.issues || typeof ctx.issues.create !== "function") {
+    throw new Error("This Paperclip runtime does not expose plugin issue creation yet.");
+  }
+  const scope = await requireProjectPullRequestScope(ctx, input);
+  const octokit = await createGitHubToolOctokit(ctx);
+  const pullRequestResponse = await octokit.rest.pulls.get({
+    owner: scope.repository.owner,
+    repo: scope.repository.repo,
+    pull_number: pullRequestNumber,
+    headers: {
+      "X-GitHub-Api-Version": GITHUB_API_VERSION
+    }
+  });
+  const pullRequest = pullRequestResponse.data;
+  const pullRequestUrl = pullRequest.html_url;
+  const existingLinks = await listGitHubPullRequestLinkRecords(ctx, {
+    externalId: pullRequestUrl
+  });
+  const existingLink = existingLinks.find(
+    (record) => record.data.githubPullRequestNumber === pullRequestNumber && record.data.repositoryUrl === scope.repository.url && (!record.data.companyId || record.data.companyId === scope.companyId) && (!record.data.paperclipProjectId || record.data.paperclipProjectId === scope.projectId)
+  );
+  const existingIssue = existingLink ? await ctx.issues.get(existingLink.paperclipIssueId, scope.companyId) : null;
+  if (existingLink && existingIssue) {
+    return {
+      paperclipIssueId: existingIssue.id,
+      ...existingIssue.identifier ? { paperclipIssueKey: existingIssue.identifier } : {},
+      alreadyLinked: true
+    };
+  }
+  const requestedTitle = typeof input.title === "string" && input.title.trim() ? input.title.trim() : pullRequest.title.trim();
+  const createdIssue = await ctx.issues.create({
+    companyId: scope.companyId,
+    projectId: scope.projectId,
+    title: requestedTitle,
+    description: buildPaperclipIssueDescriptionFromPullRequest({
+      repository: scope.repository,
+      pullRequestNumber,
+      pullRequestUrl,
+      body: pullRequest.body
+    })
+  });
+  const resolvedIssue = await ctx.issues.get(createdIssue.id, scope.companyId) ?? createdIssue;
+  await upsertGitHubPullRequestLinkRecord(ctx, {
+    companyId: scope.companyId,
+    projectId: scope.projectId,
+    issueId: resolvedIssue.id,
+    repositoryUrl: scope.repository.url,
+    pullRequestNumber,
+    pullRequestUrl,
+    pullRequestTitle: pullRequest.title,
+    pullRequestState: getPullRequestApiState({
+      state: pullRequest.state,
+      merged: pullRequest.merged
+    }) === "open" ? "open" : "closed"
+  });
+  invalidateProjectPullRequestCaches(scope);
+  return {
+    paperclipIssueId: resolvedIssue.id,
+    ...resolvedIssue.identifier ? { paperclipIssueKey: resolvedIssue.identifier } : {},
+    alreadyLinked: false
+  };
+}
+async function refreshProjectPullRequests(ctx, input) {
+  const scope = await requireProjectPullRequestScope(ctx, input);
+  invalidateProjectPullRequestCaches(scope);
+  return {
+    status: "refreshed",
+    projectId: scope.projectId,
+    repositoryUrl: scope.repository.url,
+    refreshedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+async function updateProjectPullRequestBranch(ctx, input) {
+  const pullRequestNumber = normalizeToolPositiveInteger(input.pullRequestNumber);
+  if (!pullRequestNumber) {
+    throw new Error("pullRequestNumber is required.");
+  }
+  const scope = await requireProjectPullRequestScope(ctx, input);
+  const octokit = await createGitHubToolOctokit(ctx);
+  const pullRequestResponse = await octokit.rest.pulls.get({
+    owner: scope.repository.owner,
+    repo: scope.repository.repo,
+    pull_number: pullRequestNumber,
+    headers: {
+      "X-GitHub-Api-Version": GITHUB_API_VERSION
+    }
+  });
+  const pullRequest = pullRequestResponse.data;
+  const githubUrl = pullRequest.html_url ?? `${scope.repository.url}/pull/${pullRequestNumber}`;
+  const pullRequestState = getPullRequestApiState({
+    state: pullRequest.state,
+    merged: pullRequest.merged
+  });
+  if (pullRequestState !== "open") {
+    throw new Error("Only open pull requests can be updated with the base branch.");
+  }
+  const behindBy = await getGitHubPullRequestBehindCount(octokit, scope.repository, {
+    baseBranch: pullRequest.base.ref,
+    headBranch: pullRequest.head.ref,
+    headRepositoryOwner: pullRequest.head.repo?.owner?.login
+  });
+  if (typeof behindBy === "number" && behindBy <= 0) {
+    invalidateProjectPullRequestCaches(scope);
+    return {
+      githubUrl,
+      status: "already_up_to_date"
+    };
+  }
+  const mergeableState = typeof pullRequest.mergeable_state === "string" ? pullRequest.mergeable_state.trim().toLowerCase() : "";
+  if ((mergeableState === "dirty" || pullRequest.mergeable === false) && (behindBy === null || behindBy > 0)) {
+    throw new Error("This pull request needs conflict resolution before it can be updated with the base branch.");
+  }
+  try {
+    await octokit.request("PUT /repos/{owner}/{repo}/pulls/{pull_number}/update-branch", {
+      owner: scope.repository.owner,
+      repo: scope.repository.repo,
+      pull_number: pullRequestNumber,
+      ...typeof pullRequest.head.sha === "string" && pullRequest.head.sha.trim() ? { expected_head_sha: pullRequest.head.sha.trim() } : {},
+      headers: {
+        "X-GitHub-Api-Version": GITHUB_API_VERSION
+      }
+    });
+  } catch (error) {
+    throw buildGitHubPullRequestWriteActionError({
+      action: "update_branch",
+      error,
+      repositoryLabel: `${scope.repository.owner}/${scope.repository.repo}`
+    });
+  }
+  invalidateProjectPullRequestCaches(scope);
+  return {
+    githubUrl,
+    status: "update_requested"
+  };
 }
-async function resolveGitHubToolRepository(ctx, runCtx, input) {
-  const explicitRepository = normalizeOptionalToolString(input.repository);
-  if (explicitRepository) {
-    return requireRepositoryReference(explicitRepository);
-  }
-  const paperclipIssueId = normalizeOptionalToolString(input.paperclipIssueId);
-  if (paperclipIssueId) {
-    const link = await resolvePaperclipIssueGitHubLink(ctx, paperclipIssueId, runCtx.companyId);
-    if (!link) {
-      throw new Error("This Paperclip issue is not linked to a GitHub issue yet. Pass repository explicitly.");
+async function mergeProjectPullRequest(ctx, input) {
+  const pullRequestNumber = normalizeToolPositiveInteger(input.pullRequestNumber);
+  if (!pullRequestNumber) {
+    throw new Error("pullRequestNumber is required.");
+  }
+  const scope = await requireProjectPullRequestScope(ctx, input);
+  const octokit = await createGitHubToolOctokit(ctx);
+  const response = await octokit.rest.pulls.merge({
+    owner: scope.repository.owner,
+    repo: scope.repository.repo,
+    pull_number: pullRequestNumber,
+    headers: {
+      "X-GitHub-Api-Version": GITHUB_API_VERSION
     }
-    return requireRepositoryReference(link.repositoryUrl);
+  });
+  if (response.data.merged !== true) {
+    throw new Error(response.data.message ?? `GitHub did not merge pull request #${pullRequestNumber}.`);
   }
-  return resolveRepositoryFromRunContext(ctx, runCtx);
+  invalidateProjectPullRequestCaches(scope);
+  return {
+    githubUrl: `${scope.repository.url}/pull/${pullRequestNumber}`,
+    status: "merged"
+  };
 }
-async function resolveGitHubIssueToolTarget(ctx, runCtx, input) {
-  const paperclipIssueId = normalizeOptionalToolString(input.paperclipIssueId);
-  if (paperclipIssueId) {
-    const link = await resolvePaperclipIssueGitHubLink(ctx, paperclipIssueId, runCtx.companyId);
-    if (!link) {
-      throw new Error("This Paperclip issue is not linked to a GitHub issue yet.");
-    }
-    const repository2 = assertExplicitRepositoryMatchesLinkedRepository(
-      input.repository,
-      link.repositoryUrl,
-      "The provided repository does not match the linked GitHub repository for this Paperclip issue."
-    );
-    const explicitIssueNumber = normalizeToolPositiveInteger(input.issueNumber);
-    if (explicitIssueNumber !== void 0 && explicitIssueNumber !== link.githubIssueNumber) {
-      throw new Error("The provided issue number does not match the linked GitHub issue for this Paperclip issue.");
+async function closeProjectPullRequest(ctx, input) {
+  const pullRequestNumber = normalizeToolPositiveInteger(input.pullRequestNumber);
+  if (!pullRequestNumber) {
+    throw new Error("pullRequestNumber is required.");
+  }
+  const scope = await requireProjectPullRequestScope(ctx, input);
+  const octokit = await createGitHubToolOctokit(ctx);
+  const response = await octokit.rest.pulls.update({
+    owner: scope.repository.owner,
+    repo: scope.repository.repo,
+    pull_number: pullRequestNumber,
+    state: "closed",
+    headers: {
+      "X-GitHub-Api-Version": GITHUB_API_VERSION
     }
-    return {
-      repository: repository2,
-      issueNumber: link.githubIssueNumber,
-      paperclipIssueId,
-      githubIssueId: link.githubIssueId,
-      githubIssueUrl: link.githubIssueUrl
-    };
+  });
+  invalidateProjectPullRequestCaches(scope);
+  return {
+    githubUrl: response.data.html_url ?? `${scope.repository.url}/pull/${pullRequestNumber}`,
+    status: getPullRequestApiState({
+      state: response.data.state,
+      merged: response.data.merged
+    })
+  };
+}
+async function addProjectPullRequestComment(ctx, input) {
+  const pullRequestNumber = normalizeToolPositiveInteger(input.pullRequestNumber);
+  if (!pullRequestNumber) {
+    throw new Error("pullRequestNumber is required.");
   }
-  const repository = await resolveGitHubToolRepository(ctx, runCtx, input);
-  const issueNumber = normalizeToolPositiveInteger(input.issueNumber);
-  if (issueNumber === void 0) {
-    throw new Error("issueNumber is required when paperclipIssueId is not provided.");
+  const body = typeof input.body === "string" ? input.body.trim() : "";
+  if (!body) {
+    throw new Error("Comment body cannot be empty.");
   }
+  const scope = await requireProjectPullRequestScope(ctx, input);
+  const octokit = await createGitHubToolOctokit(ctx);
+  const response = await createProjectPullRequestGitHubComment(octokit, scope, pullRequestNumber, body);
+  invalidateProjectPullRequestCaches(scope);
   return {
-    repository,
-    issueNumber
+    commentId: response.id,
+    commentUrl: response.htmlUrl ?? `${scope.repository.url}/pull/${pullRequestNumber}`
   };
 }
-async function resolveGitHubPullRequestToolTarget(ctx, runCtx, input) {
-  const paperclipIssueId = normalizeOptionalToolString(input.paperclipIssueId);
-  if (paperclipIssueId) {
-    const link = await resolvePaperclipIssueGitHubLink(ctx, paperclipIssueId, runCtx.companyId);
-    if (!link) {
-      throw new Error("This Paperclip issue is not linked to GitHub yet.");
+async function createProjectPullRequestGitHubComment(octokit, scope, pullRequestNumber, body) {
+  let response;
+  try {
+    response = await octokit.rest.issues.createComment({
+      owner: scope.repository.owner,
+      repo: scope.repository.repo,
+      issue_number: pullRequestNumber,
+      body,
+      headers: {
+        "X-GitHub-Api-Version": GITHUB_API_VERSION
+      }
+    });
+  } catch (error) {
+    throw buildGitHubPullRequestWriteActionError({
+      action: "comment",
+      error,
+      repositoryLabel: `${scope.repository.owner}/${scope.repository.repo}`
+    });
+  }
+  return {
+    id: response.data.id,
+    ...response.data.html_url ? { htmlUrl: response.data.html_url } : {}
+  };
+}
+function buildProjectPullRequestCopilotComment(action, options) {
+  const baseBranch = typeof options?.baseBranch === "string" ? options.baseBranch.trim() : "";
+  const baseBranchLabel = baseBranch ? `\`${baseBranch}\`` : "the base branch";
+  switch (action) {
+    case "fix_ci":
+      return "@copilot Please investigate the failing CI on this pull request, push the smallest fix needed to this branch, and summarize the root cause and changes.";
+    case "rebase":
+      return `@copilot This pull request is behind ${baseBranchLabel} and needs conflict resolution. Please bring this branch up to date with ${baseBranchLabel}, resolve the conflicts, push the updated branch, and summarize any non-trivial conflict decisions.`;
+    case "address_review_feedback":
+      return "@copilot Please address the unresolved review feedback on this pull request, push the necessary updates to this branch, and summarize what you changed.";
+    case "review":
+      return "@copilot Please review this pull request and leave feedback as GitHub review comments. Focus on correctness, regressions, and missing tests.";
+  }
+}
+var COPILOT_PULL_REQUEST_REVIEWER_LOGIN = "copilot-pull-request-reviewer[bot]";
+async function requestProjectPullRequestCopilotAction(ctx, input) {
+  const pullRequestNumber = normalizeToolPositiveInteger(input.pullRequestNumber);
+  if (!pullRequestNumber) {
+    throw new Error("pullRequestNumber is required.");
+  }
+  const action = normalizeProjectPullRequestCopilotAction(input.action);
+  if (!action) {
+    throw new Error('action must be one of "fix_ci", "rebase", "address_review_feedback", or "review".');
+  }
+  const scope = await requireProjectPullRequestScope(ctx, input);
+  const octokit = await createGitHubToolOctokit(ctx);
+  const pullRequestResponse = await octokit.rest.pulls.get({
+    owner: scope.repository.owner,
+    repo: scope.repository.repo,
+    pull_number: pullRequestNumber,
+    headers: {
+      "X-GitHub-Api-Version": GITHUB_API_VERSION
     }
-    const repository2 = assertExplicitRepositoryMatchesLinkedRepository(
-      input.repository,
-      link.repositoryUrl,
-      "repository must match the GitHub repository linked to the provided Paperclip issue."
-    );
-    const explicitPullRequestNumber = normalizeToolPositiveInteger(input.pullRequestNumber);
-    if (explicitPullRequestNumber !== void 0) {
-      return {
-        repository: repository2,
-        pullRequestNumber: explicitPullRequestNumber,
-        paperclipIssueId
-      };
+  });
+  const pullRequest = pullRequestResponse.data;
+  const githubUrl = pullRequest.html_url ?? `${scope.repository.url}/pull/${pullRequestNumber}`;
+  const pullRequestState = getPullRequestApiState({
+    state: pullRequest.state,
+    merged: pullRequest.merged
+  });
+  if (pullRequestState !== "open") {
+    throw new Error("Only open pull requests can request Copilot actions.");
+  }
+  switch (action) {
+    case "fix_ci": {
+      const ciState = await getGitHubPullRequestCiState(octokit, scope.repository, pullRequestNumber);
+      if (ciState !== "red") {
+        throw new Error("This pull request does not currently have failing checks.");
+      }
+      break;
     }
-    if (link.linkedPullRequestNumbers.length === 1) {
-      return {
-        repository: repository2,
-        pullRequestNumber: link.linkedPullRequestNumbers[0],
-        paperclipIssueId
-      };
+    case "rebase": {
+      const behindBy = await getGitHubPullRequestBehindCount(octokit, scope.repository, {
+        baseBranch: pullRequest.base.ref,
+        headBranch: pullRequest.head.ref,
+        headRepositoryOwner: pullRequest.head.repo?.owner?.login
+      });
+      if (typeof behindBy === "number" && behindBy <= 0) {
+        throw new Error("This pull request is already up to date with the base branch.");
+      }
+      const mergeableState = typeof pullRequest.mergeable_state === "string" ? pullRequest.mergeable_state.trim().toLowerCase() : "";
+      const needsConflictResolution = (mergeableState === "dirty" || pullRequest.mergeable === false) && (behindBy === null || behindBy > 0);
+      if (!needsConflictResolution) {
+        throw new Error("This pull request can be updated without Copilot. Use Update branch instead.");
+      }
+      break;
     }
-    throw new Error("pullRequestNumber is required unless the linked Paperclip issue has exactly one linked pull request.");
+    case "address_review_feedback": {
+      const reviewThreadSummary = await getOrLoadCachedGitHubPullRequestReviewThreadSummary(
+        octokit,
+        scope.repository,
+        pullRequestNumber
+      );
+      if (reviewThreadSummary.unresolvedReviewThreads <= 0) {
+        throw new Error("This pull request does not currently have unresolved review threads.");
+      }
+      break;
+    }
+    case "review":
+      break;
   }
-  const repository = await resolveGitHubToolRepository(ctx, runCtx, input);
-  const pullRequestNumber = normalizeToolPositiveInteger(input.pullRequestNumber);
-  if (pullRequestNumber === void 0) {
-    throw new Error("pullRequestNumber is required when paperclipIssueId is not provided.");
+  if (action === "review") {
+    const pullRequestId = typeof pullRequest.node_id === "string" && pullRequest.node_id.trim() ? pullRequest.node_id.trim() : null;
+    if (!pullRequestId) {
+      throw new Error("GitHub did not return a pull request node id for this review request.");
+    }
+    let response;
+    try {
+      response = await octokit.graphql(
+        GITHUB_REQUEST_PULL_REQUEST_COPILOT_REVIEW_MUTATION,
+        {
+          pullRequestId,
+          botLogins: [COPILOT_PULL_REQUEST_REVIEWER_LOGIN]
+        }
+      );
+    } catch (error) {
+      throw buildGitHubPullRequestWriteActionError({
+        action: "review",
+        error,
+        repositoryLabel: `${scope.repository.owner}/${scope.repository.repo}`
+      });
+    }
+    const requestedReviewers = (response.requestReviews?.requestedReviewers?.edges ?? []).map((edge) => edge?.node?.login?.trim() ?? "").filter(Boolean);
+    invalidateProjectPullRequestCaches(scope);
+    return {
+      action,
+      actionLabel: getProjectPullRequestCopilotActionLabel(action),
+      requestedReviewer: requestedReviewers[0] ?? COPILOT_PULL_REQUEST_REVIEWER_LOGIN,
+      githubUrl: response.requestReviews?.pullRequest?.url ?? githubUrl
+    };
   }
+  const comment = await createProjectPullRequestGitHubComment(
+    octokit,
+    scope,
+    pullRequestNumber,
+    buildProjectPullRequestCopilotComment(action, {
+      baseBranch: pullRequest.base.ref
+    })
+  );
+  invalidateProjectPullRequestCaches(scope);
   return {
-    repository,
-    pullRequestNumber
+    action,
+    actionLabel: getProjectPullRequestCopilotActionLabel(action),
+    commentId: comment.id,
+    commentUrl: comment.htmlUrl ?? githubUrl,
+    githubUrl
   };
 }
-function formatAiAuthorshipFooter(llmModel) {
-  return `
-
----
-${AI_AUTHORED_COMMENT_FOOTER_PREFIX}${llmModel.trim()}.`;
-}
-function appendAiAuthorshipFooter(body, llmModel) {
-  const trimmedBody = body.trim();
-  if (!trimmedBody) {
-    throw new Error("Comment body cannot be empty.");
+async function reviewProjectPullRequest(ctx, input) {
+  const pullRequestNumber = normalizeToolPositiveInteger(input.pullRequestNumber);
+  if (!pullRequestNumber) {
+    throw new Error("pullRequestNumber is required.");
   }
-  const trimmedModel = llmModel.trim();
-  if (!trimmedModel) {
-    throw new Error("llmModel is required when posting a GitHub comment.");
+  const reviewType = input.review === "approve" ? "APPROVE" : input.review === "request_changes" ? "REQUEST_CHANGES" : void 0;
+  if (!reviewType) {
+    throw new Error('review must be "approve" or "request_changes".');
   }
-  return `${trimmedBody}${formatAiAuthorshipFooter(trimmedModel)}`;
+  const body = typeof input.body === "string" ? input.body.trim() : "";
+  const scope = await requireProjectPullRequestScope(ctx, input);
+  const octokit = await createGitHubToolOctokit(ctx);
+  let response;
+  try {
+    response = await octokit.rest.pulls.createReview({
+      owner: scope.repository.owner,
+      repo: scope.repository.repo,
+      pull_number: pullRequestNumber,
+      event: reviewType,
+      ...body ? { body } : {},
+      headers: {
+        "X-GitHub-Api-Version": GITHUB_API_VERSION
+      }
+    });
+  } catch (error) {
+    throw buildGitHubPullRequestWriteActionError({
+      action: "review",
+      error,
+      repositoryLabel: `${scope.repository.owner}/${scope.repository.repo}`,
+      reviewType,
+      body
+    });
+  }
+  invalidateProjectPullRequestCaches(scope);
+  return {
+    reviewId: response.data.id,
+    review: reviewType === "APPROVE" ? "approved" : "changes_requested",
+    reviewUrl: response.data.html_url ?? `${scope.repository.url}/pull/${pullRequestNumber}`
+  };
 }
-async function listAllGitHubIssueComments(octokit, repository, issueNumber) {
-  const comments = [];
-  for await (const response of octokit.paginate.iterator(octokit.rest.issues.listComments, {
-    owner: repository.owner,
-    repo: repository.repo,
-    issue_number: issueNumber,
-    per_page: 100,
+function isFailedCheckSuiteConclusion(value) {
+  switch (value?.trim().toLowerCase()) {
+    case "action_required":
+    case "cancelled":
+    case "failure":
+    case "stale":
+    case "timed_out":
+      return true;
+    default:
+      return false;
+  }
+}
+async function rerunProjectPullRequestCi(ctx, input) {
+  const pullRequestNumber = normalizeToolPositiveInteger(input.pullRequestNumber);
+  if (!pullRequestNumber) {
+    throw new Error("pullRequestNumber is required.");
+  }
+  const scope = await requireProjectPullRequestScope(ctx, input);
+  const octokit = await createGitHubToolOctokit(ctx);
+  const pullRequestResponse = await octokit.rest.pulls.get({
+    owner: scope.repository.owner,
+    repo: scope.repository.repo,
+    pull_number: pullRequestNumber,
     headers: {
       "X-GitHub-Api-Version": GITHUB_API_VERSION
     }
-  })) {
-    for (const comment of response.data) {
-      comments.push({
-        id: comment.id,
-        body: comment.body ?? "",
-        url: comment.html_url ?? void 0,
-        authorLogin: normalizeGitHubUserLogin(comment.user?.login),
-        createdAt: comment.created_at ?? void 0,
-        updatedAt: comment.updated_at ?? void 0
-      });
+  });
+  const checkSuitesResponse = await octokit.rest.checks.listSuitesForRef({
+    owner: scope.repository.owner,
+    repo: scope.repository.repo,
+    ref: pullRequestResponse.data.head.sha,
+    per_page: 100,
+    headers: {
+      "X-GitHub-Api-Version": GITHUB_API_VERSION
     }
+  });
+  const rerunnableSuites = checkSuitesResponse.data.check_suites.filter(
+    (suite) => suite.status === "completed" && isFailedCheckSuiteConclusion(suite.conclusion)
+  );
+  if (rerunnableSuites.length === 0) {
+    throw new Error("No failed GitHub check suites are available to re-run for this pull request.");
+  }
+  for (const suite of rerunnableSuites) {
+    await octokit.rest.checks.rerequestSuite({
+      owner: scope.repository.owner,
+      repo: scope.repository.repo,
+      check_suite_id: suite.id,
+      headers: {
+        "X-GitHub-Api-Version": GITHUB_API_VERSION
+      }
+    });
   }
-  return comments;
+  invalidateProjectPullRequestCaches(scope);
+  return {
+    rerunCheckSuiteCount: rerunnableSuites.length,
+    githubUrl: `${scope.repository.url}/pull/${pullRequestNumber}/checks`
+  };
 }
 async function listAllPullRequestFiles(octokit, repository, pullRequestNumber) {
   const files = [];
@@ -5163,6 +8677,10 @@ async function performSync(ctx, trigger, options = {}) {
     return next;
   }
   if (!ctx.issues || typeof ctx.issues.create !== "function") {
+    const errorDetails = {
+      phase: "configuration",
+      suggestedAction: "Update Paperclip to a runtime that supports plugin issue creation, then retry sync."
+    };
     const next = {
       ...settings,
       syncState: createErrorSyncState({
@@ -5172,10 +8690,14 @@ async function performSync(ctx, trigger, options = {}) {
         createdIssuesCount: 0,
         skippedIssuesCount: 0,
         erroredIssuesCount: 0,
-        errorDetails: {
-          phase: "configuration",
-          suggestedAction: "Update Paperclip to a runtime that supports plugin issue creation, then retry sync."
-        }
+        errorDetails,
+        recentFailures: appendRecentSyncFailureLogEntry(
+          void 0,
+          createSyncFailureLogEntry({
+            message: "This Paperclip runtime does not expose plugin issue creation yet.",
+            errorDetails
+          })
+        )
       })
     };
     await ctx.state.set(SETTINGS_SCOPE, next);
@@ -5211,14 +8733,23 @@ async function performSync(ctx, trigger, options = {}) {
     erroredIssuesCount: recoverableFailures.length,
     progress: currentProgress
   });
+  async function throwIfSyncCancelled() {
+    const cancellationRequest = await getSyncCancellationRequest(ctx);
+    if (!cancellationRequest) {
+      return;
+    }
+    throw new SyncCancellationError(cancellationRequest.requestedAt);
+  }
   async function persistRunningProgress(force = false) {
     const progress = normalizeSyncProgress(currentProgress);
+    const recentFailures = buildRecentSyncFailureLogEntries(recoverableFailures);
     const signature = JSON.stringify({
       syncedIssuesCount,
       createdIssuesCount,
       skippedIssuesCount,
       erroredIssuesCount: recoverableFailures.length,
-      progress
+      progress,
+      recentFailures
     });
     const now = Date.now();
     if (!force) {
@@ -5237,7 +8768,8 @@ async function performSync(ctx, trigger, options = {}) {
         createdIssuesCount,
         skippedIssuesCount,
         erroredIssuesCount: recoverableFailures.length,
-        progress
+        progress,
+        recentFailures
       })
     );
     activeRunningSyncState = currentSettings;
@@ -5254,7 +8786,9 @@ async function performSync(ctx, trigger, options = {}) {
   }
   const repositoryPlans = [];
   try {
+    await throwIfSyncCancelled();
     for (const [mappingIndex, mapping] of mappings.entries()) {
+      await throwIfSyncCancelled();
       try {
         const repository = requireRepositoryReference(mapping.repositoryUrl);
         const importedIssueRecords = nextRegistry.filter((entry) => doesImportedIssueRecordMatchMapping(entry, mapping)).filter((entry) => doesImportedIssueMatchTarget(entry, options.target));
@@ -5342,7 +8876,7 @@ async function performSync(ctx, trigger, options = {}) {
           trackedIssueCount
         });
       } catch (error) {
-        if (isGitHubRateLimitError(error)) {
+        if (error instanceof SyncCancellationError || isGitHubRateLimitError(error)) {
           throw error;
         }
         recordRecoverableSyncFailure(ctx, recoverableFailures, error, failureContext);
@@ -5371,6 +8905,7 @@ async function performSync(ctx, trigger, options = {}) {
     }
     await persistRunningProgress(true);
     for (const plan of repositoryPlans) {
+      await throwIfSyncCancelled();
       try {
         const { mapping, advancedSettings, repository, repositoryIndex, allIssuesById, issues } = plan;
         const companyId = mapping.companyId;
@@ -5425,8 +8960,9 @@ async function performSync(ctx, trigger, options = {}) {
             openLinkedPullRequestNumbers,
             pullRequestStatusCache
           );
+          await throwIfSyncCancelled();
         } catch (error) {
-          if (isGitHubRateLimitError(error)) {
+          if (error instanceof SyncCancellationError || isGitHubRateLimitError(error)) {
             throw error;
           }
         }
@@ -5441,6 +8977,7 @@ async function performSync(ctx, trigger, options = {}) {
         };
         await persistRunningProgress(true);
         for (const [issueIndex, issue] of issues.entries()) {
+          await throwIfSyncCancelled();
           const createdIssueCountBefore = createdIssueIds.size;
           const skippedIssueCountBefore = skippedIssueIds.size;
           try {
@@ -5489,6 +9026,7 @@ async function performSync(ctx, trigger, options = {}) {
           totalIssueCount: totalTrackedIssueCount
         };
         await persistRunningProgress(true);
+        await throwIfSyncCancelled();
         const synchronizationResult = await synchronizePaperclipIssueStatuses(
           ctx,
           octokit,
@@ -5506,6 +9044,7 @@ async function performSync(ctx, trigger, options = {}) {
           repositoryMaintainerCache,
           failureContext,
           recoverableFailures,
+          throwIfSyncCancelled,
           async (progress) => {
             markTrackedIssueProcessed(mapping, progress.githubIssueId);
             currentProgress = {
@@ -5524,7 +9063,7 @@ async function performSync(ctx, trigger, options = {}) {
         updatedLabelsCount += synchronizationResult.updatedLabelsCount;
         updatedDescriptionsCount += synchronizationResult.updatedDescriptionsCount;
       } catch (error) {
-        if (isGitHubRateLimitError(error)) {
+        if (error instanceof SyncCancellationError || isGitHubRateLimitError(error)) {
           throw error;
         }
         recordRecoverableSyncFailure(ctx, recoverableFailures, error, failureContext);
@@ -5548,7 +9087,8 @@ async function performSync(ctx, trigger, options = {}) {
           skippedIssuesCount,
           erroredIssuesCount: recoverableFailures.length,
           progress: currentProgress,
-          errorDetails
+          errorDetails,
+          recentFailures: buildRecentSyncFailureLogEntries(recoverableFailures)
         })
       };
       await ctx.state.set(SETTINGS_SCOPE, next2);
@@ -5574,6 +9114,24 @@ async function performSync(ctx, trigger, options = {}) {
     await ctx.state.set(IMPORT_REGISTRY_SCOPE, nextRegistry);
     return next;
   } catch (error) {
+    if (error instanceof SyncCancellationError) {
+      const next2 = {
+        ...currentSettings,
+        syncState: createCancelledSyncState({
+          message: buildCancelledSyncMessage(options.target, currentProgress),
+          trigger,
+          syncedIssuesCount,
+          createdIssuesCount,
+          skippedIssuesCount,
+          erroredIssuesCount: recoverableFailures.length,
+          progress: currentProgress
+        })
+      };
+      await ctx.state.set(SETTINGS_SCOPE, next2);
+      await ctx.state.set(SYNC_STATE_SCOPE, next2.syncState);
+      await ctx.state.set(IMPORT_REGISTRY_SCOPE, nextRegistry);
+      return next2;
+    }
     const errorDetails = buildSyncErrorDetails(error, failureContext);
     const next = {
       ...currentSettings,
@@ -5585,7 +9143,11 @@ async function performSync(ctx, trigger, options = {}) {
         skippedIssuesCount,
         erroredIssuesCount: recoverableFailures.length,
         progress: currentProgress,
-        errorDetails
+        errorDetails,
+        recentFailures: appendRecentSyncFailureLogEntry(
+          buildRecentSyncFailureLogEntries(recoverableFailures),
+          buildSyncFailureLogEntry(error, failureContext)
+        )
       })
     };
     await ctx.state.set(SETTINGS_SCOPE, next);
@@ -5639,6 +9201,7 @@ async function startSync(ctx, trigger, options = {}) {
   if (trigger !== "manual" && !token.trim()) {
     return currentSettings;
   }
+  await setSyncCancellationRequest(ctx, null);
   const runningStatePromise = (async () => {
     const syncableMappings = getSyncableMappingsForTarget(currentSettings.mappings, options.target);
     const syncState = createRunningSyncState(currentSettings.syncState, trigger, {
@@ -5668,6 +9231,7 @@ async function startSync(ctx, trigger, options = {}) {
     } catch (error) {
       return await createUnexpectedSyncErrorResult(ctx, trigger, error);
     } finally {
+      await setSyncCancellationRequest(ctx, null);
       activePaperclipApiAuthTokensByCompanyId = null;
       activeRunningSyncState = null;
       activeSyncPromise = null;
@@ -6396,6 +9960,30 @@ var plugin = definePlugin({
       const record = input && typeof input === "object" ? input : {};
       return buildToolbarSyncState(ctx, record);
     });
+    ctx.data.register("settings.tokenPermissionAudit", async (input) => {
+      const record = input && typeof input === "object" ? input : {};
+      return buildSettingsTokenPermissionAuditData(ctx, record);
+    });
+    ctx.data.register("project.pullRequests.page", async (input) => {
+      const record = input && typeof input === "object" ? input : {};
+      return buildProjectPullRequestsPageData(ctx, record);
+    });
+    ctx.data.register("project.pullRequests.metrics", async (input) => {
+      const record = input && typeof input === "object" ? input : {};
+      return buildProjectPullRequestMetricsData(ctx, record);
+    });
+    ctx.data.register("project.pullRequests.count", async (input) => {
+      const record = input && typeof input === "object" ? input : {};
+      return buildProjectPullRequestCountData(ctx, record);
+    });
+    ctx.data.register("project.pullRequests.detail", async (input) => {
+      const record = input && typeof input === "object" ? input : {};
+      return buildProjectPullRequestDetailData(ctx, record);
+    });
+    ctx.data.register("project.pullRequests.paperclipIssue", async (input) => {
+      const record = input && typeof input === "object" ? input : {};
+      return buildProjectPullRequestPaperclipIssueData(ctx, record);
+    });
     ctx.data.register("issue.githubDetails", async (input) => {
       const record = input && typeof input === "object" ? input : {};
       return buildIssueGitHubDetails(ctx, record);
@@ -6461,6 +10049,7 @@ var plugin = definePlugin({
       });
       await ctx.state.set(SETTINGS_SCOPE, next);
       await ctx.state.set(SYNC_STATE_SCOPE, next.syncState);
+      clearGitHubRepositoryTokenCapabilityAudits();
       return {
         ...getPublicSettingsForScope(next, requestedCompanyId),
         availableAssignees: requestedCompanyId ? await listAvailableAssignees(ctx, requestedCompanyId) : []
@@ -6510,6 +10099,42 @@ var plugin = definePlugin({
       }
       return validateGithubToken(trimmedToken);
     });
+    ctx.actions.register("project.pullRequests.createIssue", async (input) => {
+      const record = input && typeof input === "object" ? input : {};
+      return createProjectPullRequestPaperclipIssue(ctx, record);
+    });
+    ctx.actions.register("project.pullRequests.refresh", async (input) => {
+      const record = input && typeof input === "object" ? input : {};
+      return refreshProjectPullRequests(ctx, record);
+    });
+    ctx.actions.register("project.pullRequests.updateBranch", async (input) => {
+      const record = input && typeof input === "object" ? input : {};
+      return updateProjectPullRequestBranch(ctx, record);
+    });
+    ctx.actions.register("project.pullRequests.requestCopilotAction", async (input) => {
+      const record = input && typeof input === "object" ? input : {};
+      return requestProjectPullRequestCopilotAction(ctx, record);
+    });
+    ctx.actions.register("project.pullRequests.merge", async (input) => {
+      const record = input && typeof input === "object" ? input : {};
+      return mergeProjectPullRequest(ctx, record);
+    });
+    ctx.actions.register("project.pullRequests.close", async (input) => {
+      const record = input && typeof input === "object" ? input : {};
+      return closeProjectPullRequest(ctx, record);
+    });
+    ctx.actions.register("project.pullRequests.addComment", async (input) => {
+      const record = input && typeof input === "object" ? input : {};
+      return addProjectPullRequestComment(ctx, record);
+    });
+    ctx.actions.register("project.pullRequests.review", async (input) => {
+      const record = input && typeof input === "object" ? input : {};
+      return reviewProjectPullRequest(ctx, record);
+    });
+    ctx.actions.register("project.pullRequests.rerunCi", async (input) => {
+      const record = input && typeof input === "object" ? input : {};
+      return rerunProjectPullRequestCi(ctx, record);
+    });
     ctx.actions.register("sync.runNow", async (input) => {
       const waitForCompletion = input && typeof input === "object" && "waitForCompletion" in input ? Boolean(input.waitForCompletion) : false;
       const paperclipApiBaseUrl = input && typeof input === "object" && "paperclipApiBaseUrl" in input ? input.paperclipApiBaseUrl : void 0;
@@ -6528,6 +10153,32 @@ var plugin = definePlugin({
         ...target ? { target } : {}
       });
     });
+    ctx.actions.register("sync.cancel", async () => {
+      const currentSettings = await getActiveOrCurrentSyncState(ctx);
+      if (currentSettings.syncState.status !== "running") {
+        return currentSettings;
+      }
+      const existingRequest = currentSettings.syncState.cancelRequestedAt?.trim() ? { requestedAt: currentSettings.syncState.cancelRequestedAt.trim() } : await getSyncCancellationRequest(ctx);
+      const cancellationRequest = existingRequest ?? {
+        requestedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      await setSyncCancellationRequest(ctx, cancellationRequest);
+      const next = await saveSettingsSyncState(
+        ctx,
+        currentSettings,
+        createRunningSyncState(currentSettings.syncState, currentSettings.syncState.lastRunTrigger ?? "manual", {
+          syncedIssuesCount: currentSettings.syncState.syncedIssuesCount ?? 0,
+          createdIssuesCount: currentSettings.syncState.createdIssuesCount ?? 0,
+          skippedIssuesCount: currentSettings.syncState.skippedIssuesCount ?? 0,
+          erroredIssuesCount: currentSettings.syncState.erroredIssuesCount ?? 0,
+          progress: currentSettings.syncState.progress,
+          message: CANCELLING_SYNC_MESSAGE,
+          cancelRequestedAt: cancellationRequest.requestedAt
+        })
+      );
+      activeRunningSyncState = next;
+      return next;
+    });
     registerGitHubAgentTools(ctx);
     ctx.jobs.register("sync.github-issues", async (job) => {
       const settings = normalizeSettings(await ctx.state.get(SETTINGS_SCOPE));