pr-shepherd 0.54.1 → 0.55.1

package/bin/github/batch-parsers.mjs

@@ -1,8 +1,10 @@
 import { mapAuthorType, parseCreatedAt, latestApprovedLogins, isReviewStale, } from "./batch-parser-helpers.mjs";
 import { parseCheckNodes } from "./batch-parse-checks.mjs";
+import { headPushUnixFromCheckNodes } from "./queue-removal-freshness.mjs";
 import { requireContextNodes } from "./batch-response.mjs";
 import { buildPrActivitySummary } from "./activity.mjs";
 import { parseBranchProtection } from "./branch-protection.mjs";
+import { readAllowedMergeMethods } from "../config/merge-method.mjs";
 import { parseAutoMergeRequest, parseBranchRules, parseLatestMergeQueueRemoval, parseMergeQueueEntry, parseStack, } from "./batch-parsers-rules.mjs";
 function parseReviewNode(r) {
     const base = {
@@ -13,6 +15,7 @@ function parseReviewNode(r) {
         viewerCanMinimize: "viewerCanMinimize" in r && r.viewerCanMinimize === true,
         body: r.body,
         createdAtUnix: r.createdAt ? parseCreatedAt(r.createdAt) : 0,
+        ...("url" in r && r.url ? { url: r.url } : {}),
     };
     if ("commit" in r && r.commit?.oid) {
         base.commitOid = r.commit.oid;
@@ -100,9 +103,11 @@ export function parseRawPr(raw, rawThreadPages, rawCommentNodes, rawReviewNodes,
     const mergeQueueChecks = parseCheckNodes(queueHead?.statusCheckRollup
         ? requireContextNodes(queueHead.statusCheckRollup.contexts.nodes)
         : undefined, queueHead?.oid);
+    const headPushedAtUnix = headPushUnixFromCheckNodes(rawCheckNodes);
     const removedMergeQueueChecks = parseCheckNodes(removedQueueHead?.statusCheckRollup
         ? requireContextNodes(removedQueueHead.statusCheckRollup.contexts.nodes)
         : undefined, removedQueueHead?.oid);
+    const allowedMergeMethods = readAllowedMergeMethods(repository);
     return {
         nodeId: raw.id,
         number: raw.number,
@@ -112,6 +117,7 @@ export function parseRawPr(raw, rawThreadPages, rawCommentNodes, rawReviewNodes,
         mergeStateStatus: raw.mergeStateStatus,
         reviewDecision: (raw.reviewDecision ?? null),
         headRefOid: raw.headRefOid,
+        ...(headPushedAtUnix !== undefined && { headPushedAtUnix }),
         headRefName: raw.headRefName,
         headRepoWithOwner: raw.headRepository?.nameWithOwner ?? null,
         viewerAuthorization: {
@@ -135,6 +141,7 @@ export function parseRawPr(raw, rawThreadPages, rawCommentNodes, rawReviewNodes,
         approvedReviews,
         checks,
         branchProtection: parseBranchProtection(raw),
+        ...(allowedMergeMethods && { allowedMergeMethods }),
         branchRules: parseBranchRules(raw.baseRef),
         isInMergeQueue: raw.isInMergeQueue ?? false,
         isMergeQueueEnabled: raw.isMergeQueueEnabled ?? false,

package/bin/github/batch-raw-types.d.mts

@@ -7,6 +7,9 @@ export interface RawBatchResponse {
     repository: {
         viewerPermission: string | null;
         viewerCanAdminister: boolean;
+        mergeCommitAllowed?: boolean;
+        squashMergeAllowed?: boolean;
+        rebaseMergeAllowed?: boolean;
         pullRequest: RawPr | null;
     } | null;
 }
@@ -118,6 +121,7 @@ interface RawCheckSuites {
     };
     nodes: Array<{
         id?: string;
+        status?: string | null;
         conclusion: string | null;
         workflowRun: {
             databaseId: number | null;
@@ -208,6 +212,7 @@ export interface RawReviewSummary {
     author: RawAuthor | null;
     body: string;
     createdAt?: string;
+    url?: string;
 }
 export type RawContextNode = {
     __typename: "CheckRun";

package/bin/github/batch.d.mts

@@ -1,4 +1,5 @@
 import { type RateLimitInfo, type RepoInfo } from "./client.mts";
+import type { WorkflowSuiteSnapshot } from "../checks/unreported-required.mts";
 import type { BatchPrData } from "../types.mts";
 import { type PrFingerprint } from "./fingerprint.mts";
 interface BatchResult {
@@ -9,6 +10,8 @@ interface BatchResult {
     checkSuitesComplete?: boolean;
     /** True when that complete page listed no check suites on the head commit. */
     headCheckSuitesEmpty?: true;
+    /** Actions workflow suites on the head, excluding apps that have no workflow run. */
+    headWorkflowSuites?: WorkflowSuiteSnapshot[];
 }
 interface FetchPrBatchOptions {
     /**

package/bin/github/batch.mjs

@@ -2,7 +2,7 @@ import { graphqlWithRateLimit } from "./client.mjs";
 import { hydrateThreadCommentPages } from "./thread-comments.mjs";
 import { BATCH_PR_QUERY } from "./queries.mjs";
 import { parseRawPr } from "./batch-parsers.mjs";
-import { parseCheckSuitesComplete, parseHeadCheckSuitesEmpty, parseSuiteStartupFailures, } from "./batch-parse-suites.mjs";
+import { parseCheckSuitesComplete, parseHeadCheckSuitesEmpty, parseHeadWorkflowSuites, parseSuiteStartupFailures, } from "./batch-parse-suites.mjs";
 import { mergeStartupFailureChecks } from "../checks/startup-failures.mjs";
 import { paginateBatchConnections } from "./batch-page.mjs";
 import { requireRawPr } from "./batch-response.mjs";
@@ -22,6 +22,9 @@ export async function fetchPrBatch(pr, repo, opts = {}) {
     const paged = await paginateBatchConnections(pr, repo, raw, opts, result.rateLimit);
     const rawThreadPages = await hydrateThreadCommentPages(paged.threads);
     const data = parseRawPr(raw, rawThreadPages, paged.comments, paged.changesRequested, paged.reviewSummaries, paged.approvedReviews, paged.checks, result.data.repository);
+    const viewerLogin = result.data.viewer?.login;
+    if (viewerLogin)
+        data.viewerLogin = viewerLogin;
     data.checks = mergeStartupFailureChecks(data.checks, parseSuiteStartupFailures(raw));
     return {
         data,
@@ -29,5 +32,10 @@ export async function fetchPrBatch(pr, repo, opts = {}) {
         rateLimit: paged.rateLimit ?? result.rateLimit,
         ...(parseCheckSuitesComplete(raw) && { checkSuitesComplete: true }),
         ...(parseHeadCheckSuitesEmpty(raw) && { headCheckSuitesEmpty: true }),
+        ...workflowSuites(raw),
     };
 }
+function workflowSuites(raw) {
+    const suites = parseHeadWorkflowSuites(raw);
+    return suites.length > 0 ? { headWorkflowSuites: suites } : {};
+}

package/bin/github/errors.d.mts

@@ -10,6 +10,12 @@ export interface GitHubGraphQlError {
 }
 /** GitHub GraphQL engine crash: HTTP 200, `data: null`, INTERNAL type/code or message. */
 export declare function isRetryableGraphQlInternal(graphqlErrors?: GitHubGraphQlError[]): boolean;
+/**
+ * GitHub refused the query for size or load (`Resource limits for this query
+ * exceeded`). The same document can succeed on a later attempt, and a smaller
+ * page can succeed when the full one cannot.
+ */
+export declare function isRetryableGraphQlResourceLimit(graphqlErrors?: GitHubGraphQlError[]): boolean;
 /** HTTP 200 GraphQL response whose `repository` field resolved to null. */
 export declare function missingRepositoryError(repo: {
     owner: string;

package/bin/github/errors.mjs

@@ -6,8 +6,9 @@ import { EXIT, ShepherdError } from "../exit-codes.mjs";
 // GraphQL error messages themselves.
 const GRAPHQL_PERMISSION_ERROR = /resource not accessible/i;
 const GRAPHQL_INTERNAL_MESSAGE = /something went wrong while executing your query/i;
-function isInternalToken(value) {
-    return typeof value === "string" && value.toUpperCase() === "INTERNAL";
+const GRAPHQL_RESOURCE_LIMIT_MESSAGE = /resource limits for this query exceeded/i;
+function isToken(value, token) {
+    return typeof value === "string" && value.toUpperCase() === token;
 }
 function extensionsCode(extensions) {
     if (typeof extensions !== "object" || extensions === null || Array.isArray(extensions)) {
@@ -23,13 +24,29 @@ export function isRetryableGraphQlInternal(graphqlErrors) {
     if (!graphqlErrors?.length)
         return false;
     return graphqlErrors.some((error) => {
-        if (isInternalToken(error.type))
+        if (isToken(error.type, "INTERNAL"))
             return true;
-        if (isInternalToken(extensionsCode(error.extensions)))
+        if (isToken(extensionsCode(error.extensions), "INTERNAL"))
             return true;
         return GRAPHQL_INTERNAL_MESSAGE.test(error.message);
     });
 }
+/**
+ * GitHub refused the query for size or load (`Resource limits for this query
+ * exceeded`). The same document can succeed on a later attempt, and a smaller
+ * page can succeed when the full one cannot.
+ */
+export function isRetryableGraphQlResourceLimit(graphqlErrors) {
+    if (!graphqlErrors?.length)
+        return false;
+    return graphqlErrors.some((error) => {
+        if (isToken(error.type, "RESOURCE_LIMITS_EXCEEDED"))
+            return true;
+        if (isToken(extensionsCode(error.extensions), "RESOURCE_LIMITS_EXCEEDED"))
+            return true;
+        return GRAPHQL_RESOURCE_LIMIT_MESSAGE.test(error.message);
+    });
+}
 function classifyStatus(status, rateLimit, retryAfterSeconds, graphqlErrors) {
     // Retry signals take priority over everything else: GitHub's secondary rate limit
     // returns 403 with a Retry-After header, which is a transient throttle — not the
@@ -40,7 +57,8 @@ function classifyStatus(status, rateLimit, retryAfterSeconds, graphqlErrors) {
         status >= 500 ||
         retryAfterSeconds !== undefined ||
         rateLimitExhausted ||
-        isRetryableGraphQlInternal(graphqlErrors)) {
+        isRetryableGraphQlInternal(graphqlErrors) ||
+        isRetryableGraphQlResourceLimit(graphqlErrors)) {
         return EXIT.TEMPFAIL;
     }
     if (status === 401 || status === 403 || hasPermissionError(graphqlErrors))

package/bin/github/fingerprint-fields.d.mts

@@ -5,6 +5,7 @@ export interface FingerprintSuites {
     };
     nodes?: Array<{
         id?: string;
+        status?: string | null;
         conclusion: string | null;
         workflowRun?: {
             databaseId: number | null;

package/bin/github/fingerprint-fields.mjs

@@ -4,7 +4,7 @@ export function suiteFingerprint(suites) {
         return { checkSuiteConclusions: "", checkSuitesComplete: false };
     return {
         checkSuiteConclusions: (suites.nodes ?? [])
-            .map((node) => `${node.id ?? node.workflowRun?.databaseId ?? ""}:${node.conclusion ?? ""}`)
+            .map((node) => `${node.id ?? node.workflowRun?.databaseId ?? ""}:${node.status ?? ""}:${node.conclusion ?? ""}`)
             .join(","),
         checkSuitesComplete: suites.pageInfo?.hasNextPage === false,
     };

package/bin/github/gql/base-behind.gql

@@ -0,0 +1,20 @@
+# Commits on the PR base that the head branch does not contain.
+# Fetched only when required checks never reported, so a BLOCKED merge state
+# cannot hide a behind base.
+query BaseBehind($owner: String!, $repo: String!, $qualifiedName: String!, $headRef: String!) {
+  _shepherdRateLimit: rateLimit {
+    cost
+    limit
+    nodeCount
+    remaining
+    resetAt
+    used
+  }
+  repository(owner: $owner, name: $repo) {
+    ref(qualifiedName: $qualifiedName) {
+      compare(headRef: $headRef) {
+        behindBy
+      }
+    }
+  }
+}

package/bin/github/gql/batch-pr-page.gql

@@ -128,6 +128,7 @@ query BatchPrPage(
           }
           body
           createdAt
+          url
         }
       }
       approvedReviews: reviews(states: APPROVED, last: 50, before: $approvedReviewsCursor)
@@ -147,6 +148,7 @@ query BatchPrPage(
           }
           body
           createdAt
+          url
         }
       }
       commits(last: 1) @include(if: $includeChecks) {

package/bin/github/gql/batch-pr.gql

@@ -15,6 +15,9 @@ query BatchPr($owner: String!, $repo: String!, $pr: Int!) {
   repository(owner: $owner, name: $repo) {
     viewerPermission
     viewerCanAdminister
+    mergeCommitAllowed
+    squashMergeAllowed
+    rebaseMergeAllowed
     pullRequest(number: $pr) {
       id
       number
@@ -220,6 +223,7 @@ query BatchPr($owner: String!, $repo: String!, $pr: Int!) {
           }
           body
           createdAt
+          url
         }
       }
       allReviews: reviews(last: 100) {
@@ -245,6 +249,7 @@ query BatchPr($owner: String!, $repo: String!, $pr: Int!) {
           }
           body
           createdAt
+          url
         }
       }
       commits(last: 1) {

package/bin/github/gql/commit-check-suites.gql

@@ -5,6 +5,7 @@ fragment CommitCheckSuites on Commit {
     }
     nodes {
       id
+      status
       conclusion
       workflowRun {
         databaseId

package/bin/github/gql/poll-stack-summary.gql

@@ -13,8 +13,14 @@ query PollStackSummary(
     resetAt
     used
   }
+  viewer {
+    login
+  }
   repository(owner: $owner, name: $repo) {
     viewerCanAdminister
+    mergeCommitAllowed
+    squashMergeAllowed
+    rebaseMergeAllowed
     pullRequest(number: $anchor) {
       stack {
         id

package/bin/github/gql/poll-summary-annotation-probe.gql

@@ -0,0 +1,32 @@
+query PollSummaryAnnotationProbe(
+  $owner: String!
+  $repo: String!
+  $oid: GitObjectID!
+  $before: String
+) {
+  repository(owner: $owner, name: $repo) {
+    object(oid: $oid) {
+      __typename
+      ... on Commit {
+        oid
+        statusCheckRollup {
+          contexts(last: 100, before: $before) {
+            pageInfo {
+              hasPreviousPage
+              startCursor
+            }
+            nodes {
+              __typename
+              ... on CheckRun {
+                id
+                annotations(first: 1) {
+                  totalCount
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}

package/bin/github/gql/poll-summary-check-contexts.gql

@@ -12,13 +12,12 @@ fragment PollSummaryCheckContexts on StatusCheckRollupContextConnection {
       status
       conclusion
       detailsUrl
-      annotations(first: 1) {
-        totalCount
-      }
       checkSuite {
+        createdAt
         workflowRun {
           databaseId
           event
+          createdAt
           workflow {
             databaseId
             name

package/bin/github/gql/poll-summary-fragment.gql

@@ -2,6 +2,10 @@ fragment PollSummaryPr on PullRequest {
   number
   title
   url
+  author {
+    __typename
+    login
+  }
   state
   updatedAt
   isDraft
@@ -10,6 +14,9 @@ fragment PollSummaryPr on PullRequest {
   headRefOid
   baseRefName
   baseRefOid
+  baseRef {
+    ...RefRules
+  }
   mergeable
   mergeStateStatus
   lifecycleEvents: timelineItems(
@@ -185,6 +192,15 @@ fragment PollSummaryPr on PullRequest {
       commit {
         oid
         committedDate
+        checkSuites(first: 50) {
+          nodes {
+            status
+            conclusion
+            workflowRun {
+              event
+            }
+          }
+        }
         statusCheckRollup {
           contexts(last: 100) {
             ...PollSummaryCheckContexts

package/bin/github/gql/pr-merge-policy.gql

@@ -1,49 +1,6 @@
 fragment PrMergePolicy on PullRequest {
   isMergeQueueEnabled
   baseRef {
-    branchProtectionRule {
-      requiresApprovingReviews
-      requiredApprovingReviewCount
-      requiresConversationResolution
-      requiresCodeOwnerReviews
-      requireLastPushApproval
-      requiresCommitSignatures
-      requiresLinearHistory
-      requiresStatusChecks
-      requiredStatusCheckContexts
-      requiresStrictStatusChecks
-      requiresDeployments
-      requiredDeploymentEnvironments
-    }
-    rules(first: 100) {
-      pageInfo {
-        hasNextPage
-      }
-      nodes {
-        type
-        parameters {
-          ... on PullRequestParameters {
-            requiredApprovingReviewCount
-            requiredReviewThreadResolution
-            requireCodeOwnerReview
-            requireLastPushApproval
-          }
-          ... on RequiredStatusChecksParameters {
-            strictRequiredStatusChecksPolicy
-            requiredStatusChecks {
-              context
-            }
-          }
-          ... on RequiredDeploymentsParameters {
-            requiredDeploymentEnvironments
-          }
-          ... on CodeScanningParameters {
-            codeScanningTools {
-              tool
-            }
-          }
-        }
-      }
-    }
+    ...RefRules
   }
 }

package/bin/github/gql/ref-rules-query.gql

@@ -0,0 +1,18 @@
+query RefRules($owner: String!, $repo: String!, $qualifiedName: String!, $headRef: String!) {
+  _shepherdRateLimit: rateLimit {
+    cost
+    limit
+    nodeCount
+    remaining
+    resetAt
+    used
+  }
+  repository(owner: $owner, name: $repo) {
+    ref(qualifiedName: $qualifiedName) {
+      ...RefRules
+      compare(headRef: $headRef) {
+        behindBy
+      }
+    }
+  }
+}

package/bin/github/gql/ref-rules.gql

@@ -0,0 +1,46 @@
+fragment RefRules on Ref {
+  branchProtectionRule {
+    requiresApprovingReviews
+    requiredApprovingReviewCount
+    requiresConversationResolution
+    requiresCodeOwnerReviews
+    requireLastPushApproval
+    requiresCommitSignatures
+    requiresLinearHistory
+    requiresStatusChecks
+    requiredStatusCheckContexts
+    requiresStrictStatusChecks
+    requiresDeployments
+    requiredDeploymentEnvironments
+  }
+  rules(first: 100) {
+    pageInfo {
+      hasNextPage
+    }
+    nodes {
+      type
+      parameters {
+        ... on PullRequestParameters {
+          requiredApprovingReviewCount
+          requiredReviewThreadResolution
+          requireCodeOwnerReview
+          requireLastPushApproval
+        }
+        ... on RequiredStatusChecksParameters {
+          strictRequiredStatusChecksPolicy
+          requiredStatusChecks {
+            context
+          }
+        }
+        ... on RequiredDeploymentsParameters {
+          requiredDeploymentEnvironments
+        }
+        ... on CodeScanningParameters {
+          codeScanningTools {
+            tool
+          }
+        }
+      }
+    }
+  }
+}

package/bin/github/graphql-internal-retry.d.mts

@@ -1,2 +1,2 @@
-/** Retry GitHub GraphQL engine crashes (HTTP 200, data: null, INTERNAL) on reads. */
+/** Retry GitHub GraphQL engine crashes and resource-limit failures on reads. */
 export declare function withGraphQlInternalRetry<T>(document: string, run: () => Promise<T>): Promise<T>;

package/bin/github/graphql-internal-retry.mjs

@@ -1,5 +1,5 @@
 import { sleep } from "../util/sleep.mjs";
-import { GitHubRequestError, isRetryableGraphQlInternal } from "./errors.mjs";
+import { GitHubRequestError, isRetryableGraphQlInternal, isRetryableGraphQlResourceLimit, } from "./errors.mjs";
 const GRAPHQL_INTERNAL_RETRY_DELAYS = [500, 1500];
 /** True when the root operation is a mutation. Anonymous `{...}` is a query. */
 function isGraphQlMutationDocument(document) {
@@ -25,7 +25,7 @@ function hasServerBackoff(err) {
         return true;
     return err.rateLimit !== undefined && err.rateLimit.remaining <= 0;
 }
-/** Retry GitHub GraphQL engine crashes (HTTP 200, data: null, INTERNAL) on reads. */
+/** Retry GitHub GraphQL engine crashes and resource-limit failures on reads. */
 export async function withGraphQlInternalRetry(document, run) {
     let lastErr;
     for (let attempt = 1; attempt <= GRAPHQL_INTERNAL_RETRY_DELAYS.length + 1; attempt++) {
@@ -34,7 +34,8 @@ export async function withGraphQlInternalRetry(document, run) {
         }
         catch (err) {
             if (!(err instanceof GitHubRequestError) ||
-                !isRetryableGraphQlInternal(err.graphqlErrors) ||
+                !(isRetryableGraphQlInternal(err.graphqlErrors) ||
+                    isRetryableGraphQlResourceLimit(err.graphqlErrors)) ||
                 isGraphQlMutationDocument(document) ||
                 hasServerBackoff(err)) {
                 throw err;

package/bin/github/merge-queue-checks.mjs

@@ -1,6 +1,6 @@
 import { parseCreatedAt } from "./batch-parser-helpers.mjs";
 import { graphql } from "./client.mjs";
-import { queueRemovalAppliesToHead } from "./queue-removal-freshness.mjs";
+import { headPushUnixFromCheckNodes, queueRemovalAppliesToHead, } from "./queue-removal-freshness.mjs";
 import { requireContextNodes } from "./batch-response.mjs";
 import { COMMIT_CHECK_CONTEXTS_QUERY } from "./queries.mjs";
 function omittedCursorError(oid) {
@@ -62,11 +62,15 @@ function currentRemovalCommit(raw) {
     if (addition && Date.parse(removal.createdAt) < Date.parse(addition.createdAt))
         return undefined;
     const parentOids = removal.beforeCommit.parents?.nodes.map((node) => node.oid);
-    const headCommittedAt = raw.commits?.nodes[0]?.commit.committedDate;
+    const headCommit = raw.commits?.nodes[0]?.commit;
+    const headPushedAtUnix = headPushUnixFromCheckNodes(headCommit?.statusCheckRollup?.contexts.nodes);
     if (!queueRemovalAppliesToHead({
         parentOids,
         headOid: raw.headRefOid,
-        ...(headCommittedAt && { headCommittedAtUnix: parseCreatedAt(headCommittedAt) }),
+        ...(headCommit?.committedDate && {
+            headCommittedAtUnix: parseCreatedAt(headCommit.committedDate),
+        }),
+        ...(headPushedAtUnix !== undefined && { headPushedAtUnix }),
         removedAtUnix: Math.floor(Date.parse(removal.createdAt) / 1000),
     })) {
         return undefined;

package/bin/github/merge-target-rules.d.mts

@@ -0,0 +1,28 @@
+export interface MergeTargetStatus {
+    contexts: string[];
+    trunkBehindBy?: number;
+    stackBottomPr?: number;
+}
+/**
+ * Required status contexts for the branch GitHub actually merges into.
+ * A native stack uses the trunk ref, and `behindBy` is that trunk against the bottom open layer.
+ */
+export declare function loadMergeTargetStatus(input: {
+    owner: string;
+    name: string;
+    pr: number;
+    baseRefName: string;
+    headRefName: string;
+    localContexts: readonly string[];
+    stack?: {
+        baseRefName: string;
+    } | null;
+}): Promise<MergeTargetStatus>;
+/**
+ * Commits on the PR base that `headRef` does not contain.
+ * Pass the head commit OID. A fork's branch name can exist on the base
+ * repository, or fail to resolve, and either result hides a real behind count.
+ * `mergeStateStatus` stays `BLOCKED` when a conversation or an expected check
+ * is also open, so this compare is the behind count that status hides.
+ */
+export declare function loadBaseBehindBy(owner: string, name: string, baseRefName: string, headRef: string): Promise<number>;

package/bin/github/merge-target-rules.mjs

@@ -0,0 +1,77 @@
+import { EXIT, ShepherdError } from "../exit-codes.mjs";
+import { parseBranchRules } from "./batch-parsers-rules.mjs";
+import { graphqlWithRateLimit } from "./client.mjs";
+import { missingRepositoryError } from "./errors.mjs";
+import { BASE_BEHIND_QUERY, REF_RULES_QUERY } from "./queries.mjs";
+import { readStackTopology } from "./stack-read.mjs";
+/**
+ * Required status contexts for the branch GitHub actually merges into.
+ * A native stack uses the trunk ref, and `behindBy` is that trunk against the bottom open layer.
+ */
+export async function loadMergeTargetStatus(input) {
+    const trunk = input.stack?.baseRefName;
+    if (!trunk)
+        return { contexts: [...input.localContexts] };
+    let headRef = input.headRefName;
+    let stackBottomPr = input.pr;
+    if (trunk !== input.baseRefName) {
+        const bottom = await bottomOpenLayer(input.pr, { owner: input.owner, name: input.name }, trunk);
+        headRef = bottom.headRefName;
+        stackBottomPr = bottom.number;
+    }
+    const loaded = await fetchRefRules(input.owner, input.name, `refs/heads/${trunk}`, headRef);
+    return {
+        contexts: loaded.contexts,
+        ...(loaded.behindBy > 0 && { trunkBehindBy: loaded.behindBy }),
+        stackBottomPr,
+    };
+}
+async function bottomOpenLayer(pr, repo, trunk) {
+    const topology = await readStackTopology(pr, repo);
+    const bottom = topology.ordered.find((member) => member.state === "OPEN" && member.baseRefName === trunk);
+    if (!bottom) {
+        throw new ShepherdError(`Native stack for PR #${pr} has no open layer based on ${trunk}`, EXIT.TEMPFAIL);
+    }
+    return bottom;
+}
+/**
+ * Commits on the PR base that `headRef` does not contain.
+ * Pass the head commit OID. A fork's branch name can exist on the base
+ * repository, or fail to resolve, and either result hides a real behind count.
+ * `mergeStateStatus` stays `BLOCKED` when a conversation or an expected check
+ * is also open, so this compare is the behind count that status hides.
+ */
+export async function loadBaseBehindBy(owner, name, baseRefName, headRef) {
+    const qualifiedName = `refs/heads/${baseRefName}`;
+    const { data } = await graphqlWithRateLimit(BASE_BEHIND_QUERY, {
+        owner,
+        repo: name,
+        qualifiedName,
+        headRef,
+    });
+    if (!data.repository)
+        throw missingRepositoryError({ owner, name });
+    const ref = data.repository.ref;
+    if (!ref) {
+        throw new ShepherdError(`Branch ${qualifiedName} was not found in ${owner}/${name}`, EXIT.TEMPFAIL);
+    }
+    return ref.compare?.behindBy ?? 0;
+}
+async function fetchRefRules(owner, name, qualifiedName, headRef) {
+    const { data } = await graphqlWithRateLimit(REF_RULES_QUERY, {
+        owner,
+        repo: name,
+        qualifiedName,
+        headRef,
+    });
+    if (!data.repository)
+        throw missingRepositoryError({ owner, name });
+    const ref = data.repository.ref;
+    if (!ref) {
+        throw new ShepherdError(`Branch ${qualifiedName} was not found in ${owner}/${name}`, EXIT.TEMPFAIL);
+    }
+    return {
+        contexts: parseBranchRules(ref).requiredStatusCheckContexts,
+        behindBy: ref.compare?.behindBy ?? 0,
+    };
+}