pr-shepherd 0.54.1 → 0.55.0

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/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,20 @@
+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>;

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

@@ -0,0 +1,54 @@
+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 { 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;
+}
+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,
+    };
+}

package/bin/github/poll-summary-annotation-probe.d.mts

@@ -0,0 +1,19 @@
+import { type RepoInfo } from "./client.mts";
+import type { RawSummaryPr } from "./poll-summary-raw.mts";
+/**
+ * True when a ready layer's annotation probe failed or stopped short of every
+ * check page. Callers must not store or compare a fingerprint of that snapshot:
+ * it is missing annotation totals a later successful probe would include.
+ */
+export declare function annotationProbeUnavailable(pr: RawSummaryPr): boolean;
+/** Stored hash when the probe missed, so a later complete probe can still match. */
+export declare function readyFingerprint(raw: RawSummaryPr, stored: string | null): string | null;
+/**
+ * Annotation totals are omitted from the always-on summary. A layer that
+ * otherwise looks ready loads them once so a READY receipt still changes when
+ * a check gains an annotation.
+ */
+export declare function hydrateReadyAnnotationProbe(pr: RawSummaryPr, repo: RepoInfo, review: {
+    actionable?: number;
+    incomplete?: true;
+}): Promise<void>;

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

@@ -0,0 +1,88 @@
+import { graphqlWithRateLimit } from "./client.mjs";
+import { isCurrentSummaryReady } from "./poll-summary-readiness.mjs";
+import { summarizePollSummaryChecks } from "./poll-summary-checks.mjs";
+import { fingerprintRawSummaryPr } from "./poll-summary-fingerprint.mjs";
+import { POLL_SUMMARY_ANNOTATION_PROBE_QUERY } from "./queries.mjs";
+const PROBE_UNAVAILABLE = Symbol.for("prShepherd.annotationProbeUnavailable");
+/**
+ * True when a ready layer's annotation probe failed or stopped short of every
+ * check page. Callers must not store or compare a fingerprint of that snapshot:
+ * it is missing annotation totals a later successful probe would include.
+ */
+export function annotationProbeUnavailable(pr) {
+    return Boolean(pr[PROBE_UNAVAILABLE]);
+}
+/** Stored hash when the probe missed, so a later complete probe can still match. */
+export function readyFingerprint(raw, stored) {
+    if (annotationProbeUnavailable(raw))
+        return stored;
+    return fingerprintRawSummaryPr(raw);
+}
+/**
+ * Annotation totals are omitted from the always-on summary. A layer that
+ * otherwise looks ready loads them once so a READY receipt still changes when
+ * a check gains an annotation.
+ */
+export async function hydrateReadyAnnotationProbe(pr, repo, review) {
+    const checks = summarizePollSummaryChecks(pr);
+    if (!isCurrentSummaryReady(pr, checks, review))
+        return;
+    if (!(await hydrateCommitAnnotations(pr, repo))) {
+        pr[PROBE_UNAVAILABLE] = true;
+    }
+}
+async function hydrateCommitAnnotations(pr, repo) {
+    const commit = pr.commits.nodes[0]?.commit;
+    const nodes = commit?.statusCheckRollup?.contexts.nodes;
+    if (!commit || !nodes?.some((node) => node.__typename === "CheckRun" && node.id))
+        return true;
+    const pages = await collectProbePages(commit.oid, repo);
+    if (!pages)
+        return false;
+    const probed = new Map(pages.flatMap((node) => node.__typename === "CheckRun" && node.id ? [[node.id, node.annotations]] : []));
+    for (const node of nodes) {
+        if (node.__typename !== "CheckRun" || !node.id)
+            continue;
+        const annotations = probed.get(node.id);
+        if (annotations)
+            node.annotations = annotations;
+    }
+    return true;
+}
+/** Every check page, oldest last. Null when a page cannot be trusted. */
+async function collectProbePages(oid, repo) {
+    const pages = [];
+    let before = null;
+    const seen = new Set();
+    for (;;) {
+        const contexts = await fetchProbePage(oid, repo, before);
+        if (!contexts)
+            return null;
+        pages.push(...contexts.nodes);
+        const pageInfo = contexts.pageInfo;
+        if (!pageInfo?.hasPreviousPage)
+            return pages;
+        const cursor = pageInfo.startCursor;
+        if (!cursor || seen.has(cursor))
+            return null;
+        seen.add(cursor);
+        before = cursor;
+    }
+}
+async function fetchProbePage(oid, repo, before) {
+    try {
+        const { data } = await graphqlWithRateLimit(POLL_SUMMARY_ANNOTATION_PROBE_QUERY, {
+            owner: repo.owner,
+            repo: repo.name,
+            oid,
+            before,
+        });
+        const object = data.repository?.object;
+        if (object?.__typename !== "Commit" || object.oid !== oid)
+            return null;
+        return object.statusCheckRollup?.contexts ?? null;
+    }
+    catch {
+        return null;
+    }
+}

package/bin/github/poll-summary-fingerprint.mjs

@@ -33,7 +33,7 @@ export function fingerprintRawSummaryPr(raw) {
             ...raw.commits,
             nodes: raw.commits.nodes.map((node) => ({
                 ...node,
-                commit: { ...node.commit, committedDate: undefined },
+                commit: { ...node.commit, committedDate: undefined, checkSuites: undefined },
             })),
         },
     };

package/bin/github/poll-summary-projector.d.mts

@@ -1,4 +1,4 @@
 import type { PollSummaryCommandOptions, PollSummaryItem } from "../types.mts";
 import type { RepoInfo } from "./client.mts";
 import type { RawSummaryPr } from "./poll-summary-raw.mts";
-export declare function summarizePollSummaryPr(raw: RawSummaryPr, repo: RepoInfo, opts: PollSummaryCommandOptions, viewerCanAdminister?: boolean): Promise<PollSummaryItem>;
+export declare function summarizePollSummaryPr(raw: RawSummaryPr, repo: RepoInfo, opts: PollSummaryCommandOptions, viewerCanAdminister?: boolean, mergeTargetContexts?: readonly string[], viewerLogin?: string | null): Promise<PollSummaryItem>;

package/bin/github/poll-summary-projector.mjs

@@ -6,15 +6,17 @@ import { loadSeenMap } from "../state/seen-comments.mjs";
 import { isReadyReceiptCurrent, readReadyReceipt } from "../state/ready-receipts.mjs";
 import { summarizePollSummaryChecks } from "./poll-summary-checks.mjs";
 import { summarizePollSummaryReview } from "./poll-summary-review.mjs";
-import { fingerprintRawSummaryPr } from "./poll-summary-fingerprint.mjs";
 import { currentQueueRemovalEvent } from "./poll-summary-queue-removal.mjs";
 import { isCurrentSummaryReady } from "./poll-summary-readiness.mjs";
 import { applyOpenCheckBlockers } from "./poll-summary-check-blockers.mjs";
 import { normalizePollSummaryState, routePollSummary } from "./poll-summary-route.mjs";
-export async function summarizePollSummaryPr(raw, repo, opts, viewerCanAdminister = false) {
+import { hydrateReadyAnnotationProbe, readyFingerprint } from "./poll-summary-annotation-probe.mjs";
+import { applyUnreportedRequiredChecks } from "./poll-summary-unreported.mjs";
+export async function summarizePollSummaryPr(raw, repo, opts, viewerCanAdminister = false, mergeTargetContexts, viewerLogin = null) {
     const repoName = `${repo.owner}/${repo.name}`;
     const seen = await loadSeenMap({ owner: repo.owner, repo: repo.name, pr: raw.number });
     const checks = summarizePollSummaryChecks(raw);
+    applyUnreportedRequiredChecks(raw, checks, mergeTargetContexts);
     const review = await summarizePollSummaryReview(raw, seen, viewerCanAdminister);
     const blockingReviewerInProgress = detectBlockingReviewer(raw);
     const removalEvent = currentQueueRemovalEvent(raw);
@@ -44,15 +46,17 @@ export async function summarizePollSummaryPr(raw, repo, opts, viewerCanAdministe
             baseRefName: raw.stack.baseRefName,
         }
         : undefined;
-    const fingerprint = opts.stackPrNumber !== undefined ? fingerprintRawSummaryPr(raw) : null;
-    const receipt = fingerprint
-        ? await readReadyReceipt({ owner: repo.owner, repo: repo.name, pr: raw.number })
-        : null;
-    // A queued PR's target branch can advance as earlier queue entries merge.
-    // Keep the pre-enqueue base binding for the receipt comparison while the
-    // merge group itself supplies the current mergeability evidence.
+    if (opts.stackPrNumber !== undefined)
+        await hydrateReadyAnnotationProbe(raw, repo, review);
+    const receipt = opts.stackPrNumber === undefined
+        ? null
+        : await readReadyReceipt({ owner: repo.owner, repo: repo.name, pr: raw.number });
+    const fingerprint = opts.stackPrNumber === undefined
+        ? null
+        : readyFingerprint(raw, receipt?.readinessFingerprint ?? null);
+    // A queued PR's base can advance. Keep the receipt base while the probe is complete.
     const receiptFingerprint = raw.isInMergeQueue && receipt
-        ? fingerprintRawSummaryPr({ ...raw, baseRefOid: receipt.baseRefOid })
+        ? readyFingerprint({ ...raw, baseRefOid: receipt.baseRefOid }, receipt.readinessFingerprint)
         : fingerprint;
     const currentReady = isCurrentSummaryReady(raw, checks, review, {
         allowQueuedProgress: opts.stackPrNumber !== undefined && raw.isInMergeQueue,
@@ -78,6 +82,10 @@ export async function summarizePollSummaryPr(raw, repo, opts, viewerCanAdministe
         repo: repoName,
         title: raw.title,
         url: raw.url || formatPrUrl(repoName, raw.number),
+        ...(raw.author?.login && { authorLogin: raw.author.login }),
+        ...(raw.author?.login &&
+            viewerLogin !== null &&
+            raw.author.login.toLowerCase() === viewerLogin.toLowerCase() && { owned: true }),
         action,
         reasons,
         state: normalizePollSummaryState(raw.state),
@@ -131,9 +139,8 @@ function pollCommandFields(repo, pr, isDraft, opts) {
         args.push("--merge");
     if (opts.readyDelaySeconds !== undefined)
         args.push("--ready-delay", `${opts.readyDelaySeconds}s`);
-    if (opts.stallTimeoutSeconds !== undefined) {
+    if (opts.stallTimeoutSeconds !== undefined)
         args.push("--stall-timeout", `${opts.stallTimeoutSeconds}s`);
-    }
     if (opts.noAutoMarkReady && !boundedDraft)
         args.push("--no-auto-mark-ready");
     const pollCommand = buildPrShepherdCommand(args).text;

package/bin/github/poll-summary-queue-removal.mjs

@@ -1,4 +1,4 @@
-import { queueRemovalAppliesToHead } from "./queue-removal-freshness.mjs";
+import { headPushUnixFromCheckNodes, queueRemovalAppliesToHead, } from "./queue-removal-freshness.mjs";
 import { parseCreatedAt } from "./batch-parser-helpers.mjs";
 /** Latest queue removal that still applies to this PR head, not an older attempt. */
 export function currentQueueRemovalEvent(raw) {
@@ -12,11 +12,15 @@ export function currentQueueRemovalEvent(raw) {
     if (addition && Date.parse(addition.createdAt) > removalTime)
         return null;
     const parents = removal.beforeCommit?.parents?.nodes.map((parent) => parent.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: parents,
         headOid: raw.headRefOid,
-        ...(headCommittedAt && { headCommittedAtUnix: parseCreatedAt(headCommittedAt) }),
+        ...(headCommit?.committedDate && {
+            headCommittedAtUnix: parseCreatedAt(headCommit.committedDate),
+        }),
+        ...(headPushedAtUnix !== undefined && { headPushedAtUnix }),
         removedAtUnix: Math.floor(removalTime / 1000),
     })) {
         return null;