pr-shepherd 0.56.6 → 0.57.0

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

@@ -1,3 +1,5 @@
+import { githubOperation } from "./transport.mjs";
+import { readRestAnnotationCounts } from "./rest-check-read.mjs";
 import { graphqlWithRateLimit } from "./client.mjs";
 import { isCurrentSummaryReady } from "./poll-summary-readiness.mjs";
 import { summarizePollSummaryChecks } from "./poll-summary-checks.mjs";
@@ -78,16 +80,21 @@ async function collectProbePages(oid, repo) {
 }
 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;
+        return await githubOperation("PollSummaryAnnotationProbe", async () => {
+            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;
+        }, async () => ({
+            pageInfo: { hasPreviousPage: false, startCursor: null },
+            nodes: await readRestAnnotationCounts(oid, repo),
+        }));
     }
     catch {
         return null;

package/bin/github/poll-summary-check-blockers.d.mts

@@ -10,7 +10,7 @@ type Routed = Pick<PollSummaryItem, "action" | "reasons">;
 export declare function applyOpenCheckBlockers(raw: RawSummaryPr, repo: {
     owner: string;
     name: string;
-}, routed: Routed, checks: PollSummaryChecks, review: PollSummaryReview, stack: boolean): Promise<Routed & {
+}, routed: Routed, checks: PollSummaryChecks, review: PollSummaryReview, stack: boolean, requiredContexts?: readonly string[]): Promise<Routed & {
     pollProbe?: true;
 }>;
 export {};

package/bin/github/poll-summary-check-blockers.mjs

@@ -6,12 +6,12 @@ import { failingSummaryCheckNames } from "./poll-summary-checks.mjs";
  * deferred stay on the routed action. Stack rows are probed so the planner
  * does not start a one-PR session for a wait it would otherwise shepherd.
  */
-export async function applyOpenCheckBlockers(raw, repo, routed, checks, review, stack) {
+export async function applyOpenCheckBlockers(raw, repo, routed, checks, review, stack, requiredContexts) {
     if (routed.action !== "fix_code" || !routed.reasons.includes("failing-checks"))
         return routed;
     if ((review.actionable ?? 0) > 0 || checks.incomplete)
         return routed;
-    const names = failingSummaryCheckNames(raw);
+    const names = failingSummaryCheckNames(raw, requiredContexts);
     if (names.length === 0)
         return routed;
     const gate = await resolveCheckBlockerGate({ owner: repo.owner, repo: repo.name, pr: raw.number }, names.map((name) => ({ name })));

package/bin/github/poll-summary-check-hydration.mjs

@@ -1,3 +1,5 @@
+import { githubOperation } from "./transport.mjs";
+import { readRestCommitChecks } from "./rest-check-read.mjs";
 import { graphqlWithRateLimit } from "./client.mjs";
 import { POLL_SUMMARY_CHECK_PAGE_QUERY } from "./queries.mjs";
 /**
@@ -27,7 +29,10 @@ async function hydrateCommitContexts(commit, repo) {
         const older = await fetchOlderContexts(commit.oid, pageInfo.startCursor, repo);
         if (!older)
             break;
-        nodes.unshift(...older.nodes);
+        if (older.fullSnapshot)
+            nodes.splice(0, nodes.length, ...older.nodes);
+        else
+            nodes.unshift(...older.nodes);
         pageInfo = older.pageInfo;
     }
     // A window that shifted between pages can repeat or skip contexts; the
@@ -42,14 +47,24 @@ async function hydrateCommitContexts(commit, repo) {
     };
 }
 async function fetchOlderContexts(oid, before, repo) {
-    const { data } = await graphqlWithRateLimit(POLL_SUMMARY_CHECK_PAGE_QUERY, {
-        owner: repo.owner,
-        repo: repo.name,
-        oid,
-        before,
+    return githubOperation("PollSummaryCheckPage", async () => {
+        const { data } = await graphqlWithRateLimit(POLL_SUMMARY_CHECK_PAGE_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;
+    }, async () => {
+        const checks = await readRestCommitChecks(oid, repo);
+        return {
+            fullSnapshot: true,
+            totalCount: checks.nodes.length,
+            pageInfo: { hasPreviousPage: false },
+            nodes: checks.nodes,
+        };
     });
-    const object = data.repository?.object;
-    if (object?.__typename !== "Commit" || object.oid !== oid)
-        return null;
-    return object.statusCheckRollup?.contexts ?? null;
 }

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

@@ -1,5 +1,5 @@
 import type { PollSummaryChecks } from "../types.mts";
 import type { RawSummaryPr } from "./poll-summary-raw.mts";
-export declare function summarizePollSummaryChecks(raw: RawSummaryPr): PollSummaryChecks;
+export declare function summarizePollSummaryChecks(raw: RawSummaryPr, requiredContexts?: readonly string[]): PollSummaryChecks;
 /** Names of failing checks in the loaded summary rollup. */
-export declare function failingSummaryCheckNames(raw: RawSummaryPr): string[];
+export declare function failingSummaryCheckNames(raw: RawSummaryPr, requiredContexts?: readonly string[]): string[];

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

@@ -1,9 +1,9 @@
 import { classifyChecks } from "../checks/classify.mjs";
 import { parseCreatedAt } from "./batch-parser-helpers.mjs";
-export function summarizePollSummaryChecks(raw) {
+export function summarizePollSummaryChecks(raw, requiredContexts) {
     const rollups = summaryRollups(raw);
     const counts = {};
-    for (const check of classifiedSummaryChecks(raw)) {
+    for (const check of classifiedSummaryChecks(raw, requiredContexts)) {
         const key = {
             passed: "passing",
             failing: "failing",
@@ -22,8 +22,8 @@ export function summarizePollSummaryChecks(raw) {
     return summary;
 }
 /** Names of failing checks in the loaded summary rollup. */
-export function failingSummaryCheckNames(raw) {
-    return classifiedSummaryChecks(raw)
+export function failingSummaryCheckNames(raw, requiredContexts) {
+    return classifiedSummaryChecks(raw, requiredContexts)
         .filter((check) => check.category === "failing")
         .map((check) => check.name);
 }
@@ -36,9 +36,12 @@ function summaryRollups(raw) {
         },
     ].flatMap(({ rollup, scope }) => (rollup ? [{ rollup, scope }] : []));
 }
-function classifiedSummaryChecks(raw) {
+function classifiedSummaryChecks(raw, requiredContexts) {
     // A successful check on the queue commit cannot cover a PR-head cancellation, or vice versa.
-    return summaryRollups(raw).flatMap(({ rollup, scope }) => classifyChecks(checkRuns(rollup, scope), scope === "merge_group" ? { additionalRelevantEvents: ["merge_group"] } : {}));
+    return summaryRollups(raw).flatMap(({ rollup, scope }) => classifyChecks(checkRuns(rollup, scope), {
+        ...(scope === "merge_group" && { additionalRelevantEvents: ["merge_group"] }),
+        ...(requiredContexts && { requiredContexts }),
+    }));
 }
 function checkRuns(rollup, scope) {
     return rollup.contexts.nodes.map((context) => {

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

@@ -0,0 +1,2 @@
+import type { PollSummaryCommandOptions, PollSummaryItem } from "../types.mts";
+export declare function pollCommandFields(repo: string, pr: number, isDraft: boolean, opts: PollSummaryCommandOptions): Pick<PollSummaryItem, "pollCommand" | "pollProbe">;

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

@@ -0,0 +1,24 @@
+import { loadConfig } from "../config/load.mjs";
+import { formatPrUrl } from "../pr-reference.mjs";
+import { buildPrShepherdCommand } from "../cli/runner.mjs";
+export function pollCommandFields(repo, pr, isDraft, opts) {
+    const autoMarkReadyDisabled = opts.noAutoMarkReady || loadConfig().actions.autoMarkReady === false;
+    const boundedDraft = isDraft && autoMarkReadyDisabled;
+    const args = boundedDraft
+        ? [formatPrUrl(repo, pr), "--timeout", "1s", "--debounce", "0s", "--no-auto-mark-ready"]
+        : [formatPrUrl(repo, pr), "--until-terminal"];
+    if (opts.merge && opts.stackPrNumber === undefined)
+        args.push("--merge");
+    if (opts.readyDelaySeconds !== undefined)
+        args.push("--ready-delay", `${opts.readyDelaySeconds}s`);
+    if (opts.stallTimeoutSeconds !== undefined)
+        args.push("--stall-timeout", `${opts.stallTimeoutSeconds}s`);
+    if (opts.instructions)
+        args.push("--instructions", opts.instructions);
+    if (opts.pollMode === "event")
+        args.push("--poll-mode", "event");
+    if (opts.noAutoMarkReady && !boundedDraft)
+        args.push("--no-auto-mark-ready");
+    const pollCommand = buildPrShepherdCommand(args).text;
+    return boundedDraft ? { pollCommand, pollProbe: true } : { pollCommand };
+}

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

@@ -5,4 +5,4 @@ import type { RawSummaryPr } from "./poll-summary-raw.mts";
  * computed merge state are checked separately: including them here would
  * invalidate a READY receipt merely because a ready PR entered the queue.
  */
-export declare function fingerprintRawSummaryPr(raw: RawSummaryPr): string | null;
+export declare function fingerprintRawSummaryPr(summary: RawSummaryPr): string | null;

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

@@ -1,11 +1,13 @@
 import { createHash } from "node:crypto";
+import { withoutHandoffFields } from "./poll-summary-handoff-fields.mjs";
 /**
  * Bind receipts to the review and head-commit CI evidence shared by one-PR
  * completion and stack reconciliation. Queue entry, queue checks, and GitHub's
  * computed merge state are checked separately: including them here would
  * invalidate a READY receipt merely because a ready PR entered the queue.
  */
-export function fingerprintRawSummaryPr(raw) {
+export function fingerprintRawSummaryPr(summary) {
+    const raw = withoutHandoffFields(summary);
     if (!raw.updatedAt || !raw.headRefOid || !raw.baseRefOid)
         return null;
     const reviewTruncated = raw.comments.pageInfo.hasPreviousPage ||
@@ -13,6 +15,7 @@ export function fingerprintRawSummaryPr(raw) {
         raw.reviewThreads.pageInfo.hasPreviousPage ||
         raw.reviewThreads.nodes.some((thread) => thread.comments.pageInfo.hasPreviousPage);
     const evidence = {
+        ...(raw.transport === "rest" && { transport: "rest" }),
         number: raw.number,
         state: raw.state,
         lifecycleEvents: raw.lifecycleEvents,
@@ -32,7 +35,6 @@ export function fingerprintRawSummaryPr(raw) {
             ...raw.reviewThreads,
             nodes: raw.reviewThreads.nodes.map((thread) => ({
                 ...thread,
-                rootComments: thread.rootComments && hideBodies(thread.rootComments),
                 comments: hideBodies(thread.comments),
             })),
         },

package/bin/github/poll-summary-handoff-fields.d.mts

@@ -0,0 +1,3 @@
+import type { RawSummaryPr } from "./poll-summary-raw.mts";
+/** `raw` without the fields only the handoff reads. */
+export declare function withoutHandoffFields(raw: RawSummaryPr): RawSummaryPr;

package/bin/github/poll-summary-handoff-fields.mjs

@@ -0,0 +1,73 @@
+/**
+ * The GraphQL summary selects these fields only so a routed stack layer's first
+ * tick can skip `BatchPr` (see `stack-handoff.mts`). They are not readiness
+ * evidence, and some (an edited hidden comment's `updatedAt`) change after a PR
+ * settles, so READY-receipt fingerprints leave them out. REST summaries never
+ * carry them. A thread comment's `isMinimized` stays: the fingerprint hides
+ * minimized bodies, as it already did for comments and reviews.
+ */
+const COMMENT = ["viewerCanMinimize", "createdAt", "updatedAt"];
+const REVIEW = [...COMMENT, "url", "commit"];
+const THREAD = ["viewerCanReply", "viewerCanResolve", "line", "startLine"];
+const THREAD_COMMENT = ["pullRequestReview", "path", "line", "startLine", "createdAt", "updatedAt"];
+const STATUS_CONTEXT = ["createdAt", "targetUrl", "description"];
+function omit(value, keys) {
+    const copy = { ...value };
+    for (const key of keys)
+        delete copy[key];
+    return copy;
+}
+function omitEach(connection, keys) {
+    return { ...connection, nodes: connection.nodes.map((node) => omit(node, keys)) };
+}
+/** `raw` without the fields only the handoff reads. */
+export function withoutHandoffFields(raw) {
+    if (raw.transport === "rest")
+        return raw;
+    return {
+        ...raw,
+        ...(raw.reviewRequests && {
+            reviewRequests: {
+                nodes: raw.reviewRequests.nodes.map(({ requestedReviewer }) => ({
+                    requestedReviewer: requestedReviewer && omit(requestedReviewer, ["name"]),
+                })),
+            },
+        }),
+        comments: omitEach(raw.comments, COMMENT),
+        reviews: omitEach(raw.reviews, REVIEW),
+        reviewThreads: {
+            ...raw.reviewThreads,
+            nodes: raw.reviewThreads.nodes.map((thread) => ({
+                ...omit(thread, THREAD),
+                comments: omitEach(thread.comments, THREAD_COMMENT),
+            })),
+        },
+        commits: {
+            ...omit(raw.commits, ["totalCount"]),
+            nodes: raw.commits.nodes.map(({ commit }) => {
+                const rollup = commit.statusCheckRollup;
+                return {
+                    commit: {
+                        ...commit,
+                        statusCheckRollup: rollup && {
+                            ...omit(rollup, ["state"]),
+                            contexts: {
+                                ...rollup.contexts,
+                                nodes: rollup.contexts.nodes.map((node) => node.__typename === "StatusContext"
+                                    ? omit(node, STATUS_CONTEXT)
+                                    : {
+                                        ...node,
+                                        checkSuite: node.checkSuite && {
+                                            ...omit(node.checkSuite, ["updatedAt"]),
+                                            workflowRun: node.checkSuite.workflowRun &&
+                                                omit(node.checkSuite.workflowRun, ["updatedAt"]),
+                                        },
+                                    }),
+                            },
+                        },
+                    },
+                };
+            }),
+        },
+    };
+}

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, mergeTargetContexts?: readonly string[], viewerLogin?: string | null): Promise<PollSummaryItem>;
+export declare function summarizePollSummaryPr(raw: RawSummaryPr, repo: RepoInfo, opts: PollSummaryCommandOptions, viewerCanAdminister?: boolean | undefined, mergeTargetContexts?: readonly string[], viewerLogin?: string | null): Promise<PollSummaryItem>;

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

@@ -1,7 +1,7 @@
+import { pollCommandFields } from "./poll-summary-command.mjs";
 import { loadConfig } from "../config/load.mjs";
 import { updateReadyDelay } from "../commands/ready-delay.mjs";
 import { formatPrUrl } from "../pr-reference.mjs";
-import { buildPrShepherdCommand } from "../cli/runner.mjs";
 import { loadSeenMap } from "../state/seen-comments.mjs";
 import { isReadyReceiptCurrent, readReadyReceipt } from "../state/ready-receipts.mjs";
 import { summarizePollSummaryChecks } from "./poll-summary-checks.mjs";
@@ -11,12 +11,16 @@ import { isCurrentSummaryReady } from "./poll-summary-readiness.mjs";
 import { applyOpenCheckBlockers } from "./poll-summary-check-blockers.mjs";
 import { normalizePollSummaryState, routePollSummary } from "./poll-summary-route.mjs";
 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) {
+import { applyUnreportedRequiredChecks, summaryRequiredContexts, } from "./poll-summary-unreported.mjs";
+import { aliasThreadSeenMarkers } from "./rest-identities.mjs";
+import { restQueueRequirement } from "./poll-summary-rest-queue.mjs";
+export async function summarizePollSummaryPr(raw, repo, opts, viewerCanAdminister = undefined, 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);
+    await aliasThreadSeenMarkers(repo, raw.number, raw.reviewThreads.nodes.map(({ id }) => id), seen);
+    const required = summaryRequiredContexts(raw, mergeTargetContexts);
+    const checks = summarizePollSummaryChecks(raw, required);
+    applyUnreportedRequiredChecks(raw, checks, required);
     const review = await summarizePollSummaryReview(raw, seen, viewerCanAdminister);
     const blockingReviewerInProgress = detectBlockingReviewer(raw);
     const removalEvent = currentQueueRemovalEvent(raw);
@@ -74,12 +78,15 @@ export async function summarizePollSummaryPr(raw, repo, opts, viewerCanAdministe
         : removalEvent
             ? projectQueueRemoval(removalEvent)
             : undefined;
-    const blocked = await applyOpenCheckBlockers(raw, repo, { action, reasons }, checks, review, opts.stackPrNumber !== undefined);
+    const blocked = await applyOpenCheckBlockers(raw, repo, { action, reasons }, checks, review, opts.stackPrNumber !== undefined, required);
     action = blocked.action;
     reasons = blocked.reasons;
+    const requiresMergeQueue = raw.transport === "rest" ? restQueueRequirement(raw) : undefined;
     return {
         pr: raw.number,
         repo: repoName,
+        ...(raw.transport && { transport: raw.transport }),
+        ...(raw.transportUnavailable?.length && { transportUnavailable: raw.transportUnavailable }),
         title: raw.title,
         url: raw.url || formatPrUrl(repoName, raw.number),
         ...(raw.author?.login && { authorLogin: raw.author.login }),
@@ -97,6 +104,7 @@ export async function summarizePollSummaryPr(raw, repo, opts, viewerCanAdministe
         baseRefName: raw.baseRefName,
         ...(raw.isDraft && { isDraft: true }),
         ...(raw.isInMergeQueue && { isInMergeQueue: true }),
+        ...(requiresMergeQueue !== undefined && { requiresMergeQueue }),
         ...(queueRemoval && { queueRemoval }),
         ...(blockingReviewerInProgress && { blockingReviewerInProgress: true }),
         ...(remainingSeconds !== undefined && { remainingSeconds }),
@@ -125,24 +133,9 @@ function projectQueueRemoval(removal) {
 }
 function detectBlockingReviewer(raw) {
     const prefixes = (loadConfig().mergeStatus?.blockingReviewerLogins ?? []).map((login) => login.toLowerCase());
-    const matches = (author) => author !== null && prefixes.some((prefix) => author.login.toLowerCase().startsWith(prefix));
+    // A team reviewer has a name, not a login, so it never matches a login prefix.
+    const matches = (author) => typeof author?.login === "string" &&
+        prefixes.some((prefix) => author.login.toLowerCase().startsWith(prefix));
     return ((raw.reviewRequests?.nodes ?? []).some((request) => matches(request.requestedReviewer)) ||
         (raw.latestReviews?.nodes ?? []).some((review) => review.state === "PENDING" && matches(review.author)));
 }
-function pollCommandFields(repo, pr, isDraft, opts) {
-    const autoMarkReadyDisabled = opts.noAutoMarkReady || loadConfig().actions.autoMarkReady === false;
-    const boundedDraft = isDraft && autoMarkReadyDisabled;
-    const args = boundedDraft
-        ? [formatPrUrl(repo, pr), "--timeout", "1s", "--debounce", "0s", "--no-auto-mark-ready"]
-        : [formatPrUrl(repo, pr), "--until-terminal"];
-    if (opts.merge && opts.stackPrNumber === undefined)
-        args.push("--merge");
-    if (opts.readyDelaySeconds !== undefined)
-        args.push("--ready-delay", `${opts.readyDelaySeconds}s`);
-    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;
-    return boundedDraft ? { pollCommand, pollProbe: true } : { pollCommand };
-}

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

@@ -1,4 +1,5 @@
 import type { RawBaseRef } from "./batch-raw-rules.mts";
+import type { AutoMergeRequestStatus } from "../types/merge-requirements.mts";
 export interface RawAuthor {
     __typename?: string;
     login: string;
@@ -6,11 +7,24 @@ export interface RawAuthor {
 interface RawSummaryComment {
     id: string;
     body: string;
-    isMinimized: boolean;
+    isMinimized?: boolean;
     viewerDidAuthor?: boolean;
     authorAssociation?: string;
     url?: string;
     author: RawAuthor | null;
+    /** GraphQL handoff fields; absent on REST summaries. */
+    viewerCanMinimize?: boolean;
+    createdAt?: string;
+    updatedAt?: string;
+    pullRequestReview?: {
+        id: string;
+    } | null;
+    path?: string | null;
+    line?: number | null;
+    startLine?: number | null;
+    commit?: {
+        oid: string;
+    } | null;
 }
 interface SummaryConnection<T> {
     totalCount: number;
@@ -25,7 +39,7 @@ type RawCheckContext = {
     name: string;
     status: string;
     conclusion: string | null;
-    detailsUrl?: string;
+    detailsUrl?: string | null;
     startedAt?: string | null;
     completedAt?: string | null;
     annotations?: {
@@ -33,10 +47,12 @@ type RawCheckContext = {
     };
     checkSuite: {
         createdAt?: string | null;
+        updatedAt?: string | null;
         workflowRun: {
             databaseId?: string | number;
             event: string;
             createdAt?: string | null;
+            updatedAt?: string | null;
             workflow?: {
                 name: string;
                 databaseId: string | number;
@@ -47,6 +63,9 @@ type RawCheckContext = {
     __typename: "StatusContext";
     context: string;
     state: string;
+    createdAt?: string;
+    targetUrl?: string | null;
+    description?: string | null;
 };
 interface RawCheckContexts {
     totalCount: number;
@@ -58,6 +77,7 @@ interface RawCheckContexts {
     nodes: RawCheckContext[];
 }
 export interface RawCheckRollup {
+    state?: string | null;
     contexts: RawCheckContexts;
 }
 /** A commit whose status contexts the compact summary reads. */
@@ -66,16 +86,47 @@ export interface RawSummaryCommit {
     committedDate?: string;
     statusCheckRollup: RawCheckRollup | null;
     checkSuites?: {
+        pageInfo?: {
+            hasNextPage: boolean;
+        };
         nodes: Array<{
+            id?: string;
             status?: string | null;
             conclusion: string | null;
             workflowRun: {
+                databaseId?: number | null;
                 event: string | null;
+                url?: string | null;
+                workflow?: {
+                    name: string | null;
+                } | null;
             } | null;
         }>;
     } | null;
 }
 export interface RawSummaryPr {
+    transport?: "rest";
+    transportUnavailable?: Array<{
+        field: string;
+        reason: string;
+    }>;
+    /** GraphQL handoff fields (see `stack-handoff.mts`); absent on REST summaries. */
+    id?: string;
+    viewerDidAuthor?: boolean;
+    viewerCanEnableAutoMerge?: boolean;
+    viewerCanEditFiles?: boolean;
+    headRepository?: {
+        nameWithOwner: string;
+        viewerPermission: string | null;
+    } | null;
+    isMergeQueueEnabled?: boolean;
+    batchAutoMergeRequest?: {
+        enabledAt: string;
+        mergeMethod: string;
+        enabledBy?: {
+            login: string;
+        } | null;
+    } | null;
     number: number;
     title: string;
     url: string;
@@ -91,7 +142,7 @@ export interface RawSummaryPr {
         }>;
     } | null;
     isDraft: boolean;
-    viewerCanUpdate: boolean;
+    viewerCanUpdate?: boolean;
     headRefName: string;
     headRefOid: string;
     baseRefOid: string;
@@ -102,7 +153,9 @@ export interface RawSummaryPr {
     reviewDecision: string | null;
     reviewRequests?: {
         nodes: Array<{
-            requestedReviewer: RawAuthor | null;
+            requestedReviewer: (Partial<RawAuthor> & {
+                name?: string;
+            }) | null;
         }>;
     };
     latestReviews?: {
@@ -111,7 +164,8 @@ export interface RawSummaryPr {
             author: RawAuthor | null;
         }>;
     };
-    isInMergeQueue: boolean;
+    isInMergeQueue?: boolean;
+    autoMergeRequest?: AutoMergeRequestStatus | null;
     mergeQueueAdditions?: {
         nodes: Array<{
             createdAt: string;
@@ -158,15 +212,21 @@ export interface RawSummaryPr {
     }>;
     reviewThreads: SummaryConnection<{
         id: string;
-        isResolved: boolean;
-        isOutdated: boolean;
+        isResolved?: boolean;
+        isOutdated?: boolean;
+        viewerCanReply?: boolean;
+        viewerCanResolve?: boolean;
         path: string | null;
-        rootComments?: {
-            nodes: RawSummaryComment[];
-        };
+        line?: number | null;
+        startLine?: number | null;
+        /**
+         * The first comments from the root. `pageInfo.hasPreviousPage` is GraphQL's
+         * `hasNextPage` (aliased): true when comments exist outside this window.
+         */
         comments: SummaryConnection<RawSummaryComment>;
     }>;
     commits: {
+        totalCount?: number;
         nodes: Array<{
             commit: RawSummaryCommit;
         }>;

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

@@ -1,6 +1,7 @@
 import { summarizePollSummaryChecks } from "./poll-summary-checks.mjs";
 import { parseBranchRules } from "./batch-parsers-rules.mjs";
 import { rulesComplete } from "./fingerprint-fields.mjs";
+import { isKnownMergeStateStatus, transportReadinessGaps } from "./transport-evidence.mjs";
 /** Fresh compact evidence required before a READY receipt can be used. */
 export function isCurrentSummaryReady(raw, checks, review, options = {}) {
     const queued = options.allowQueuedProgress === true && raw.isInMergeQueue;
@@ -16,7 +17,9 @@ export function isCurrentSummaryReady(raw, checks, review, options = {}) {
     // satisfied. BLOCKED is not conversation-specific, and queue progress
     // alone is not that proof.
     const requiresConversationResolution = parseBranchRules(raw.baseRef).requiresConversationResolution;
-    return (checks.incomplete !== true &&
+    return (isKnownMergeStateStatus(raw.mergeStateStatus) &&
+        transportReadinessGaps(raw, raw.mergeStateStatus).length === 0 &&
+        checks.incomplete !== true &&
         sourceChecks.incomplete !== true &&
         (review.incomplete !== true ||
             raw.mergeStateStatus === "CLEAN" ||

package/bin/github/poll-summary-rest-queue.d.mts

@@ -0,0 +1,3 @@
+import type { RawSummaryPr } from "./poll-summary-raw.mts";
+/** Positive rules remain authoritative even when other branch policy is unavailable. */
+export declare function restQueueRequirement(raw: Pick<RawSummaryPr, "baseRef" | "transportUnavailable">): boolean | undefined;

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

@@ -0,0 +1,12 @@
+import { parseBranchRules } from "./batch-parsers-rules.mjs";
+/** Positive rules remain authoritative even when other branch policy is unavailable. */
+export function restQueueRequirement(raw) {
+    if (parseBranchRules(raw.baseRef).requiresMergeQueue)
+        return true;
+    if (!raw.baseRef?.rules ||
+        raw.baseRef.rules.pageInfo?.hasNextPage !== false ||
+        raw.baseRef.branchProtectionRule !== null ||
+        raw.transportUnavailable?.some(({ field }) => ["branchProtection", "branchRules"].includes(field)))
+        return undefined;
+    return false;
+}

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

@@ -1,4 +1,4 @@
 import { type SeenMarker } from "../state/seen-comments.mts";
 import type { PollSummaryReview } from "../types.mts";
 import type { RawSummaryPr } from "./poll-summary-raw.mts";
-export declare function summarizePollSummaryReview(raw: RawSummaryPr, seen: Map<string, SeenMarker>, viewerCanAdminister: boolean): Promise<PollSummaryReview>;
+export declare function summarizePollSummaryReview(raw: RawSummaryPr, seen: Map<string, SeenMarker>, viewerCanAdminister: boolean | undefined): Promise<PollSummaryReview>;