pr-shepherd 0.35.0 → 0.37.0

package/bin/config/load.mjs

@@ -1,24 +1,40 @@
 /* eslint-disable max-lines */
 import { readFileSync, statSync } from "node:fs";
-import { join, dirname } from "node:path";
+import { dirname, join, resolve } from "node:path";
 import { homedir } from "node:os";
 import { parse } from "yaml";
 import builtins from "../config.json" with { type: "json" };
 import { getEffectiveCwd } from "../execution-context.mjs";
 const MINIMIZE_COMMENTS_POLICIES = ["all", "bots", "users", "none"];
 const RC_FILENAME = ".pr-shepherdrc.yml";
-function findRcFile(startDir) {
-    const home = homedir();
-    let current = startDir;
-    while (true) {
-        const candidate = join(current, RC_FILENAME);
+/**
+ * Collect `.pr-shepherdrc.yml` files from `startDir` toward `$HOME` (closest first).
+ * `$HOME/.pr-shepherdrc.yml` is always included when it exists, even if cwd is
+ * outside the home directory. The walk never includes the filesystem root, so a
+ * `/.pr-shepherdrc.yml` cannot override the user-level file.
+ */
+function collectRcFiles(startDir) {
+    const home = resolve(homedir());
+    const seen = new Set();
+    const files = [];
+    const add = (dir) => {
+        const candidate = resolve(join(dir, RC_FILENAME));
+        if (seen.has(candidate))
+            return;
         if (statSync(candidate, { throwIfNoEntry: false })?.isFile()) {
-            return candidate;
+            seen.add(candidate);
+            files.push(candidate);
         }
-        if (current === home || current === dirname(current))
-            return null;
+    };
+    let current = resolve(startDir);
+    while (current !== dirname(current)) {
+        add(current);
+        if (current === home)
+            break;
         current = dirname(current);
     }
+    add(home);
+    return files;
 }
 function deepMerge(base, override) {
     const result = { ...base };
@@ -125,30 +141,56 @@ function warnUnknownConfigKeys(config) {
 }
 const defaults = builtins;
 const configCache = new Map();
+function stripDeprecatedActionKeys(parsed) {
+    const rawActions = parsed.actions;
+    if (rawActions === null || typeof rawActions !== "object" || Array.isArray(rawActions))
+        return;
+    const actions = rawActions;
+    for (const key of ["autoResolveOutdated", "commitSuggestions"]) {
+        if (key in actions) {
+            process.stderr.write(`pr-shepherd: config: actions.${key} is deprecated and ignored.\n`);
+            delete actions[key];
+        }
+    }
+}
+function readRcFile(rcPath) {
+    try {
+        const raw = readFileSync(rcPath, "utf8");
+        const parsed = (parse(raw) ?? {});
+        stripDeprecatedActionKeys(parsed);
+        warnUnknownConfigKeys(parsed);
+        return parsed;
+    }
+    catch (err) {
+        process.stderr.write(`pr-shepherd: failed to parse ${rcPath}: ${err instanceof Error ? err.message : String(err)}\n`);
+        return null;
+    }
+}
 export function loadConfig() {
     const cwd = getEffectiveCwd();
     if (configCache.has(cwd))
         return configCache.get(cwd);
-    const rcPath = findRcFile(cwd);
-    if (!rcPath) {
+    const rcPaths = collectRcFiles(cwd);
+    if (rcPaths.length === 0) {
         configCache.set(cwd, defaults);
         return defaults;
     }
     try {
-        const raw = readFileSync(rcPath, "utf8");
-        const parsed = (parse(raw) ?? {});
-        const rawActions = parsed.actions;
-        if (rawActions !== null && typeof rawActions === "object" && !Array.isArray(rawActions)) {
-            const actions = rawActions;
-            for (const key of ["autoResolveOutdated", "commitSuggestions"]) {
-                if (key in actions) {
-                    process.stderr.write(`pr-shepherd: config: actions.${key} is deprecated and ignored.\n`);
-                    delete actions[key];
-                }
-            }
+        // Farthest file first so closer directories override, ESLint-style.
+        let overlay = {};
+        let loaded = false;
+        for (const rcPath of [...rcPaths].reverse()) {
+            const parsed = readRcFile(rcPath);
+            if (parsed === null)
+                continue;
+            overlay = deepMerge(overlay, parsed);
+            loaded = true;
         }
-        warnUnknownConfigKeys(parsed);
-        const config = deepMerge(defaults, parsed);
+        if (!loaded) {
+            configCache.set(cwd, defaults);
+            return defaults;
+        }
+        const config = deepMerge(structuredClone(defaults), overlay);
         config.botUsernames = parseBotUsernames(config.botUsernames);
         config.ignoreChecks = parseIgnoreChecks(config.ignoreChecks);
         config.actions.neverCancelRuns = parseNeverCancelRuns(config.actions.neverCancelRuns);
@@ -157,7 +199,7 @@ export function loadConfig() {
         return config;
     }
     catch (err) {
-        process.stderr.write(`pr-shepherd: failed to parse ${rcPath}: ${err instanceof Error ? err.message : String(err)}\n`);
+        process.stderr.write(`pr-shepherd: failed to parse ${rcPaths[0]}: ${err instanceof Error ? err.message : String(err)}\n`);
         const fallback = { ...defaults };
         configCache.set(cwd, fallback);
         return fallback;

package/bin/github/batch-page-helpers.d.mts

@@ -0,0 +1,45 @@
+import type { RawContextNode, RawComment, RawPr, RawReview, RawReviewSummary, RawThread } from "./batch-raw-types.mts";
+export interface RawPageResponse {
+    repository: {
+        pullRequest: {
+            reviewThreads?: RawPr["reviewThreads"];
+            comments?: RawPr["comments"];
+            changesRequestedReviews?: RawPr["changesRequestedReviews"];
+            reviewSummaries?: RawPr["reviewSummaries"];
+            approvedReviews?: RawPr["approvedReviews"];
+            commits?: RawPr["commits"];
+        } | null;
+    };
+}
+export declare function backwardCursor(conn: {
+    pageInfo: {
+        hasPreviousPage: boolean;
+        startCursor: string | null;
+    };
+} | undefined): string | undefined;
+export declare function forwardCursor(conn: {
+    pageInfo: {
+        hasNextPage: boolean;
+        endCursor: string | null;
+    };
+} | undefined): string | undefined;
+export interface PageCursors {
+    threads?: string;
+    comments?: string;
+    changesRequested?: string;
+    reviewSummaries?: string;
+    approvedReviews?: string;
+    checks?: string;
+}
+export interface PageAccumulator {
+    threads: RawThread[];
+    comments: RawComment[];
+    changesRequested: RawReview[];
+    reviewSummaries: RawReviewSummary[];
+    approvedReviews: RawReviewSummary[];
+    checks: RawContextNode[];
+}
+export declare function applyIncludedPage(dest: PageAccumulator, pr2: NonNullable<RawPageResponse["repository"]["pullRequest"]>, cursors: PageCursors, firstOid: string | undefined, pageCount: number, pr: number): {
+    cursors: PageCursors;
+    pageCount: number;
+};

package/bin/github/batch-page-helpers.mjs

@@ -0,0 +1,63 @@
+import { requireContextNodes } from "./batch-response.mjs";
+export function backwardCursor(conn) {
+    if (conn?.pageInfo.hasPreviousPage === true && conn.pageInfo.startCursor) {
+        return conn.pageInfo.startCursor;
+    }
+    return undefined;
+}
+export function forwardCursor(conn) {
+    if (conn?.pageInfo.hasNextPage === true && conn.pageInfo.endCursor) {
+        return conn.pageInfo.endCursor;
+    }
+    return undefined;
+}
+function prependConnection(dest, conn, pr) {
+    if (!conn)
+        throw new Error(`PR #${pr} not found`);
+    dest.unshift(...conn.nodes);
+}
+function takeCheckPage(pr2, firstOid, pageCount) {
+    if (!pr2.commits?.nodes[0]?.commit.statusCheckRollup) {
+        throw new Error(`Check-context pagination interrupted: statusCheckRollup disappeared on page ${pageCount + 1} (possible force-push race). Retry after the push stabilizes.`);
+    }
+    const currentOid = pr2.commits.nodes[0]?.commit.oid;
+    if (firstOid !== undefined && currentOid !== undefined && currentOid !== firstOid) {
+        throw new Error(`Check-context pagination interrupted: head commit changed from ${firstOid} to ${currentOid} between pages (force-push race). Retry.`);
+    }
+    const ctxs = pr2.commits.nodes[0]?.commit.statusCheckRollup?.contexts;
+    if (!ctxs) {
+        return { pageInfo: { hasNextPage: false, endCursor: null }, nodes: [] };
+    }
+    return { ...ctxs, nodes: requireContextNodes(ctxs.nodes) };
+}
+export function applyIncludedPage(dest, pr2, cursors, firstOid, pageCount, pr) {
+    const next = {};
+    let nextPageCount = pageCount;
+    if (cursors.threads !== undefined) {
+        prependConnection(dest.threads, pr2.reviewThreads, pr);
+        next.threads = backwardCursor(pr2.reviewThreads);
+    }
+    if (cursors.comments !== undefined) {
+        prependConnection(dest.comments, pr2.comments, pr);
+        next.comments = backwardCursor(pr2.comments);
+    }
+    if (cursors.changesRequested !== undefined) {
+        prependConnection(dest.changesRequested, pr2.changesRequestedReviews, pr);
+        next.changesRequested = backwardCursor(pr2.changesRequestedReviews);
+    }
+    if (cursors.reviewSummaries !== undefined) {
+        prependConnection(dest.reviewSummaries, pr2.reviewSummaries, pr);
+        next.reviewSummaries = backwardCursor(pr2.reviewSummaries);
+    }
+    if (cursors.approvedReviews !== undefined) {
+        prependConnection(dest.approvedReviews, pr2.approvedReviews, pr);
+        next.approvedReviews = backwardCursor(pr2.approvedReviews);
+    }
+    if (cursors.checks !== undefined) {
+        nextPageCount++;
+        const extra = takeCheckPage(pr2, firstOid, nextPageCount);
+        dest.checks.push(...extra.nodes);
+        next.checks = forwardCursor(extra);
+    }
+    return { cursors: next, pageCount: nextPageCount };
+}

package/bin/github/batch-page.d.mts

@@ -0,0 +1,14 @@
+import { type RateLimitInfo, type RepoInfo } from "./client.mts";
+import { type PageAccumulator } from "./batch-page-helpers.mts";
+import type { RawPr } from "./batch-raw-types.mts";
+export interface PaginatedBatchNodes extends PageAccumulator {
+    rateLimit?: RateLimitInfo;
+}
+export interface PaginateBatchOptions {
+    paginateApprovedReviews?: boolean;
+}
+/**
+ * Fetch remaining connection pages with a slim `@include` query. Independent
+ * connections that still have cursors are combined into one request per round.
+ */
+export declare function paginateBatchConnections(pr: number, repo: RepoInfo, raw: RawPr, opts: PaginateBatchOptions, initialRateLimit?: RateLimitInfo): Promise<PaginatedBatchNodes>;

package/bin/github/batch-page.mjs

@@ -0,0 +1,62 @@
+import { graphqlWithRateLimit } from "./client.mjs";
+import { GitHubRequestError } from "./errors.mjs";
+import { BATCH_PR_PAGE_QUERY } from "./queries.mjs";
+import { requireContextNodes } from "./batch-response.mjs";
+import { applyIncludedPage, backwardCursor, forwardCursor, } from "./batch-page-helpers.mjs";
+/**
+ * Fetch remaining connection pages with a slim `@include` query. Independent
+ * connections that still have cursors are combined into one request per round.
+ */
+export async function paginateBatchConnections(pr, repo, raw, opts, initialRateLimit) {
+    const dest = {
+        threads: [...raw.reviewThreads.nodes],
+        comments: [...raw.comments.nodes],
+        changesRequested: [...raw.changesRequestedReviews.nodes],
+        reviewSummaries: [...raw.reviewSummaries.nodes],
+        approvedReviews: [...raw.approvedReviews.nodes],
+        checks: [
+            ...requireContextNodes(raw.commits.nodes[0]?.commit.statusCheckRollup?.contexts.nodes ?? []),
+        ],
+    };
+    const firstOid = raw.commits.nodes[0]?.commit.oid;
+    let cursors = {
+        threads: backwardCursor(raw.reviewThreads),
+        comments: backwardCursor(raw.comments),
+        changesRequested: backwardCursor(raw.changesRequestedReviews),
+        reviewSummaries: backwardCursor(raw.reviewSummaries),
+        approvedReviews: opts.paginateApprovedReviews === true ? backwardCursor(raw.approvedReviews) : undefined,
+        checks: forwardCursor(raw.commits.nodes[0]?.commit.statusCheckRollup?.contexts),
+    };
+    let rateLimit = initialRateLimit;
+    let pageCount = 0;
+    while (Object.values(cursors).some((cursor) => cursor !== undefined)) {
+        if (rateLimit?.remaining === 0) {
+            throw new GitHubRequestError("GitHub GraphQL rate limit remaining is 0; pagination incomplete", { status: 403, rateLimit });
+        }
+        const res = await graphqlWithRateLimit(BATCH_PR_PAGE_QUERY, {
+            owner: repo.owner,
+            repo: repo.name,
+            pr,
+            includeThreads: cursors.threads !== undefined,
+            threadsCursor: cursors.threads ?? null,
+            includeComments: cursors.comments !== undefined,
+            commentsCursor: cursors.comments ?? null,
+            includeChangesRequested: cursors.changesRequested !== undefined,
+            changesRequestedCursor: cursors.changesRequested ?? null,
+            includeReviewSummaries: cursors.reviewSummaries !== undefined,
+            reviewSummariesCursor: cursors.reviewSummaries ?? null,
+            includeApprovedReviews: cursors.approvedReviews !== undefined,
+            approvedReviewsCursor: cursors.approvedReviews ?? null,
+            includeChecks: cursors.checks !== undefined,
+            checksCursor: cursors.checks ?? null,
+        });
+        rateLimit = res.rateLimit ?? rateLimit;
+        const pr2 = res.data.repository.pullRequest;
+        if (!pr2)
+            throw new Error(`PR #${pr} not found`);
+        const applied = applyIncludedPage(dest, pr2, cursors, firstOid, pageCount, pr);
+        cursors = applied.cursors;
+        pageCount = applied.pageCount;
+    }
+    return { ...dest, rateLimit };
+}

package/bin/github/batch-parse-suites.d.mts

@@ -0,0 +1,4 @@
+import type { CheckRun } from "../types.mts";
+import type { RawPr } from "./batch-raw-types.mts";
+export declare function parseCheckSuitesComplete(raw: RawPr): boolean;
+export declare function parseSuiteStartupFailures(raw: RawPr): CheckRun[];

package/bin/github/batch-parse-suites.mjs

@@ -0,0 +1,25 @@
+export function parseCheckSuitesComplete(raw) {
+    return raw.commits.nodes[0]?.commit.checkSuites?.pageInfo.hasNextPage === false;
+}
+export function parseSuiteStartupFailures(raw) {
+    const suites = raw.commits.nodes[0]?.commit.checkSuites;
+    if (!suites)
+        return [];
+    return suites.nodes.flatMap((node) => {
+        if (node.conclusion !== "STARTUP_FAILURE" || node.workflowRun == null)
+            return [];
+        const runId = node.workflowRun.databaseId != null ? String(node.workflowRun.databaseId) : null;
+        const name = node.workflowRun.workflow?.name?.trim() || (runId ? `workflow run ${runId}` : "workflow run");
+        return [
+            {
+                name,
+                status: "COMPLETED",
+                conclusion: "STARTUP_FAILURE",
+                source: "startup_failure",
+                detailsUrl: node.workflowRun.url ?? "",
+                event: node.workflowRun.event,
+                runId,
+            },
+        ];
+    });
+}

package/bin/github/batch-parser-helpers.mjs

@@ -45,6 +45,7 @@ export function mapCheckRunNode(node) {
         ...(completedAtUnix !== undefined && { completedAtUnix }),
         ...(updatedAtUnix !== undefined && { updatedAtUnix }),
         ...(summary !== undefined && { summary }),
+        ...((node.annotations?.nodes.length ?? 0) > 0 && { hasAnnotations: true }),
     };
 }
 function extractCheckRunSummary(title, summary) {

package/bin/github/batch-parsers-rules.d.mts

@@ -0,0 +1,6 @@
+import type { BranchRules, MergeQueueEntryStatus, StackStatus } from "../types.mts";
+import type { RawBaseRef, RawPrMergeFields } from "./batch-raw-rules.mts";
+export declare const EMPTY_BRANCH_RULES: BranchRules;
+export declare function parseBranchRules(baseRef: RawBaseRef | null | undefined): BranchRules;
+export declare function parseMergeQueueEntry(raw: RawPrMergeFields["mergeQueueEntry"]): MergeQueueEntryStatus | null;
+export declare function parseStack(raw: RawPrMergeFields): StackStatus | null;

package/bin/github/batch-parsers-rules.mjs

@@ -0,0 +1,122 @@
+export const EMPTY_BRANCH_RULES = {
+    requiredApprovingReviewCount: 0,
+    requiresConversationResolution: false,
+    requiresCodeOwnerReviews: false,
+    requiresLastPushApproval: false,
+    requiresCommitSignatures: false,
+    requiresLinearHistory: false,
+    requiresStrictStatusChecks: false,
+    requiredStatusCheckContexts: [],
+    requiredDeploymentEnvironments: [],
+    requiresMergeQueue: false,
+    requiresWorkflows: false,
+    requiresCodeScanning: false,
+};
+export function parseBranchRules(baseRef) {
+    const rules = {
+        ...EMPTY_BRANCH_RULES,
+        requiredStatusCheckContexts: [],
+        requiredDeploymentEnvironments: [],
+    };
+    if (!baseRef)
+        return rules;
+    foldClassicProtection(rules, baseRef.branchProtectionRule);
+    for (const node of baseRef.rules?.nodes ?? [])
+        foldRulesetRule(rules, node);
+    return rules;
+}
+export function parseMergeQueueEntry(raw) {
+    if (!raw)
+        return null;
+    return {
+        position: raw.position,
+        state: raw.state,
+        estimatedTimeToMerge: raw.estimatedTimeToMerge,
+    };
+}
+export function parseStack(raw) {
+    if (!raw.stack)
+        return null;
+    return {
+        number: raw.stack.number,
+        size: raw.stack.size,
+        position: raw.stackEntry?.position ?? 0,
+        baseRefName: raw.stack.baseRefName,
+    };
+}
+function foldClassicProtection(rules, bp) {
+    if (!bp)
+        return;
+    if (bp.requiresApprovingReviews) {
+        rules.requiredApprovingReviewCount = Math.max(rules.requiredApprovingReviewCount, bp.requiredApprovingReviewCount ?? 0);
+    }
+    if (bp.requiresConversationResolution)
+        rules.requiresConversationResolution = true;
+    if (bp.requiresCodeOwnerReviews)
+        rules.requiresCodeOwnerReviews = true;
+    if (bp.requireLastPushApproval)
+        rules.requiresLastPushApproval = true;
+    if (bp.requiresCommitSignatures)
+        rules.requiresCommitSignatures = true;
+    if (bp.requiresLinearHistory)
+        rules.requiresLinearHistory = true;
+    if (bp.requiresStrictStatusChecks)
+        rules.requiresStrictStatusChecks = true;
+    if (bp.requiresStatusChecks) {
+        mergeUnique(rules.requiredStatusCheckContexts, bp.requiredStatusCheckContexts ?? []);
+    }
+    if (bp.requiresDeployments) {
+        mergeUnique(rules.requiredDeploymentEnvironments, bp.requiredDeploymentEnvironments ?? []);
+    }
+}
+function foldRulesetRule(rules, node) {
+    const p = node.parameters;
+    switch (node.type) {
+        case "PULL_REQUEST":
+            if (p?.requiredApprovingReviewCount != null) {
+                rules.requiredApprovingReviewCount = Math.max(rules.requiredApprovingReviewCount, p.requiredApprovingReviewCount);
+            }
+            if (p?.requiredReviewThreadResolution)
+                rules.requiresConversationResolution = true;
+            if (p?.requireCodeOwnerReview)
+                rules.requiresCodeOwnerReviews = true;
+            if (p?.requireLastPushApproval)
+                rules.requiresLastPushApproval = true;
+            break;
+        case "REQUIRED_REVIEW_THREAD_RESOLUTION":
+            rules.requiresConversationResolution = true;
+            break;
+        case "REQUIRED_STATUS_CHECKS":
+            if (p?.strictRequiredStatusChecksPolicy)
+                rules.requiresStrictStatusChecks = true;
+            mergeUnique(rules.requiredStatusCheckContexts, (p?.requiredStatusChecks ?? []).map((c) => c.context));
+            break;
+        case "REQUIRED_SIGNATURES":
+            rules.requiresCommitSignatures = true;
+            break;
+        case "REQUIRED_LINEAR_HISTORY":
+            rules.requiresLinearHistory = true;
+            break;
+        case "REQUIRED_DEPLOYMENTS":
+            mergeUnique(rules.requiredDeploymentEnvironments, p?.requiredDeploymentEnvironments ?? []);
+            break;
+        case "MERGE_QUEUE":
+            rules.requiresMergeQueue = true;
+            break;
+        case "WORKFLOWS":
+        case "REQUIRED_WORKFLOW_STATUS_CHECKS":
+            rules.requiresWorkflows = true;
+            break;
+        case "CODE_SCANNING":
+            rules.requiresCodeScanning = true;
+            break;
+        default:
+            break;
+    }
+}
+function mergeUnique(target, values) {
+    for (const value of values) {
+        if (value && !target.includes(value))
+            target.push(value);
+    }
+}

package/bin/github/batch-parsers.mjs

@@ -1,6 +1,7 @@
 import { mapAuthorType, parseCreatedAt, mapStatusContextState, latestApprovedLogins, isReviewStale, mapCheckRunNode, } from "./batch-parser-helpers.mjs";
 import { buildPrActivitySummary } from "./activity.mjs";
 import { parseBranchProtection } from "./branch-protection.mjs";
+import { parseBranchRules, parseMergeQueueEntry, parseStack } from "./batch-parsers-rules.mjs";
 function parseReviewNode(r) {
     const base = {
         id: r.id,
@@ -130,6 +131,11 @@ export function parseRawPr(raw, rawThreadPages, rawCommentNodes, rawReviewNodes,
         approvedReviews,
         checks,
         branchProtection: parseBranchProtection(raw),
+        branchRules: parseBranchRules(raw.baseRef),
+        isInMergeQueue: raw.isInMergeQueue ?? false,
+        isMergeQueueEnabled: raw.isMergeQueueEnabled ?? false,
+        mergeQueueEntry: parseMergeQueueEntry(raw.mergeQueueEntry),
+        stack: parseStack(raw),
         activity: buildPrActivitySummary(raw, comments, reviewThreads, reviewSummaries, allChangesRequestedReviews, approvedReviews),
     };
 }

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

@@ -0,0 +1,59 @@
+export interface RawBranchProtectionRule {
+    requiresApprovingReviews: boolean;
+    requiredApprovingReviewCount: number;
+    requiresConversationResolution: boolean;
+    requiresStatusChecks: boolean;
+    requiredStatusCheckContexts: string[] | null;
+    requiresCodeOwnerReviews?: boolean;
+    requireLastPushApproval?: boolean;
+    requiresCommitSignatures?: boolean;
+    requiresLinearHistory?: boolean;
+    requiresStrictStatusChecks?: boolean;
+    requiresDeployments?: boolean;
+    requiredDeploymentEnvironments?: string[] | null;
+}
+interface RawMergeQueueEntry {
+    position: number;
+    state: string;
+    estimatedTimeToMerge: number | null;
+}
+interface RawStack {
+    number: number;
+    size: number;
+    baseRefName: string;
+}
+export interface RawRepositoryRule {
+    type: string;
+    parameters: RawRuleParameters | null;
+}
+interface RawRuleParameters {
+    requiredApprovingReviewCount?: number;
+    requiredReviewThreadResolution?: boolean;
+    requireCodeOwnerReview?: boolean;
+    requireLastPushApproval?: boolean;
+    strictRequiredStatusChecksPolicy?: boolean;
+    requiredStatusChecks?: Array<{
+        context: string;
+    }>;
+    requiredDeploymentEnvironments?: string[];
+    codeScanningTools?: Array<{
+        tool: string;
+    }>;
+}
+export interface RawBaseRef {
+    branchProtectionRule: RawBranchProtectionRule | null;
+    rules: {
+        nodes: RawRepositoryRule[];
+    } | null;
+}
+export interface RawPrMergeFields {
+    isInMergeQueue?: boolean;
+    isMergeQueueEnabled?: boolean;
+    mergeQueueEntry?: RawMergeQueueEntry | null;
+    stack?: RawStack | null;
+    stackEntry?: {
+        position: number;
+    } | null;
+    baseRef?: RawBaseRef | null;
+}
+export {};

package/bin/github/batch-raw-rules.mjs

@@ -0,0 +1 @@
+export {};

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

@@ -1,10 +1,11 @@
 import type { CommentAuthorAssociation } from "../types/github.mts";
+import type { RawPrMergeFields } from "./batch-raw-rules.mts";
 export interface RawBatchResponse {
     repository: {
         pullRequest: RawPr | null;
     } | null;
 }
-export interface RawPr {
+export interface RawPr extends RawPrMergeFields {
     id: string;
     number: number;
     state: string;
@@ -18,9 +19,7 @@ export interface RawPr {
         nameWithOwner: string;
     } | null;
     baseRefName: string;
-    baseRef: {
-        branchProtectionRule: RawBranchProtectionRule | null;
-    } | null;
+    baseRef: import("./batch-raw-rules.mts").RawBaseRef | null;
     reviewRequests: {
         nodes: Array<{
             requestedReviewer: {
@@ -79,6 +78,7 @@ export interface RawPr {
             commit: {
                 oid: string;
                 committedDate?: string;
+                checkSuites?: RawCheckSuites;
                 statusCheckRollup: {
                     contexts: {
                         pageInfo: {
@@ -92,6 +92,22 @@ export interface RawPr {
         }>;
     };
 }
+interface RawCheckSuites {
+    pageInfo: {
+        hasNextPage: boolean;
+    };
+    nodes: Array<{
+        conclusion: string | null;
+        workflowRun: {
+            databaseId: number | null;
+            event: string | null;
+            url: string | null;
+            workflow: {
+                name: string | null;
+            } | null;
+        } | null;
+    }>;
+}
 interface RawAuthor {
     __typename?: string;
     login: string;
@@ -165,13 +181,6 @@ export interface RawReviewSummary {
     body: string;
     createdAt?: string;
 }
-interface RawBranchProtectionRule {
-    requiresApprovingReviews: boolean;
-    requiredApprovingReviewCount: number;
-    requiresConversationResolution: boolean;
-    requiresStatusChecks: boolean;
-    requiredStatusCheckContexts: string[] | null;
-}
 export type RawContextNode = {
     __typename: "CheckRun";
     id: string;
@@ -183,6 +192,11 @@ export type RawContextNode = {
     startedAt?: string | null;
     title: string | null;
     summary: string | null;
+    annotations?: {
+        nodes: Array<{
+            message: string;
+        }>;
+    };
     checkSuite: {
         createdAt?: string;
         updatedAt?: string;

package/bin/github/batch.d.mts

@@ -3,6 +3,8 @@ import type { BatchPrData } from "../types.mts";
 interface BatchResult {
     data: BatchPrData;
     rateLimit?: RateLimitInfo;
+    /** True when GraphQL returned a complete CheckSuite page; skip REST startup-failure fetch. */
+    checkSuitesComplete?: boolean;
 }
 interface FetchPrBatchOptions {
     /**