pr-shepherd 0.54.0 → 0.55.0

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/gql/upper-layer-conflict-target.gql

@@ -0,0 +1,36 @@
+query UpperLayerConflictTarget($owner: String!, $name: String!, $number: Int!, $headRef: String!) {
+  _shepherdRateLimit: rateLimit {
+    cost
+    limit
+    nodeCount
+    remaining
+    resetAt
+    used
+  }
+  repository(owner: $owner, name: $name) {
+    pullRequest(number: $number) {
+      # compare() is invoked on the PR base. behindBy is commits on that base
+      # that the head does not contain — the same direction as REST base...head.
+      baseRef {
+        compare(headRef: $headRef) {
+          behindBy
+        }
+      }
+      stack {
+        entries(first: 100) {
+          pageInfo {
+            hasNextPage
+          }
+          nodes {
+            position
+            pullRequest {
+              number
+              state
+              baseRefName
+            }
+          }
+        }
+      }
+    }
+  }
+}

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;

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

@@ -1,3 +1,4 @@
+import type { RawBaseRef } from "./batch-raw-rules.mts";
 export interface RawAuthor {
     __typename?: string;
     login: string;
@@ -29,9 +30,11 @@ type RawCheckContext = {
         totalCount: number;
     };
     checkSuite: {
+        createdAt?: string | null;
         workflowRun: {
             databaseId?: string | number;
             event: string;
+            createdAt?: string | null;
             workflow?: {
                 name: string;
                 databaseId: string | number;
@@ -60,11 +63,23 @@ export interface RawSummaryCommit {
     oid: string;
     committedDate?: string;
     statusCheckRollup: RawCheckRollup | null;
+    checkSuites?: {
+        nodes: Array<{
+            status?: string | null;
+            conclusion: string | null;
+            workflowRun: {
+                event: string | null;
+            } | null;
+        }>;
+    } | null;
 }
 export interface RawSummaryPr {
     number: number;
     title: string;
     url: string;
+    author?: {
+        login: string;
+    } | null;
     state: string;
     updatedAt?: string;
     lifecycleEvents?: {
@@ -79,6 +94,7 @@ export interface RawSummaryPr {
     headRefOid: string;
     baseRefOid: string;
     baseRefName: string;
+    baseRef?: RawBaseRef | null;
     mergeable: string;
     mergeStateStatus: string;
     reviewDecision: string | null;

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

@@ -21,5 +21,6 @@ export function isCurrentSummaryReady(raw, checks, review, options = {}) {
         (checks.failing ?? 0) === 0 &&
         (sourceChecks.failing ?? 0) === 0 &&
         (sourceChecks.inProgress ?? 0) === 0 &&
+        (checks.unreportedRequired?.length ?? 0) === 0 &&
         (review.actionable ?? 0) === 0);
 }

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

@@ -16,6 +16,11 @@ export function routePollSummary(raw, checks, review, opts) {
         }
         return { action: "fix_code", reasons: ["review-work"] };
     }
+    if ((checks.unreportedRequired?.length ?? 0) > 0 &&
+        checks.actionsWorkflowInProgress !== true &&
+        (checks.inProgress ?? 0) === 0) {
+        return { action: "fix_code", reasons: ["unreported-required-checks"] };
+    }
     if ((checks.inProgress ?? 0) > 0 ||
         raw.mergeable === "UNKNOWN" ||
         raw.mergeStateStatus === "UNKNOWN" ||

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

@@ -0,0 +1,6 @@
+import type { PollSummaryChecks } from "../types.mts";
+import type { RawSummaryPr } from "./poll-summary-raw.mts";
+/** Required contexts from the open layer whose base is the stack trunk. */
+export declare function trunkRequiredContexts(ordered: readonly RawSummaryPr[]): string[] | undefined;
+/** Record missing required contexts. A running Actions workflow does not clear the names. */
+export declare function applyUnreportedRequiredChecks(raw: RawSummaryPr, checks: PollSummaryChecks, mergeTargetContexts: readonly string[] | undefined): void;