pr-shepherd 0.52.0 → 0.52.1

package/bin/commands/stack-stall.mjs

@@ -0,0 +1,69 @@
+import { clearStackStallState, readStackStallState, writeStackStallState, } from "../state/stack-stall.mjs";
+import { formatDurationApprox } from "./iterate/escalate.mjs";
+import { summaryStatusSignature } from "./poll-summary-signature.mjs";
+import { describeIdleLayers } from "./stack-drain.mjs";
+/**
+ * A `--stack` plan that can only wait never reruns its layers' one-PR sessions, so their own
+ * stall guards cannot fire. Escalate `stall-timeout` once that idle plan's fingerprint stays
+ * unchanged for `stallTimeoutSeconds`; any other plan, or `0`, clears the timer. When the enabled
+ * timer cannot be read or written, escalate `stall-state-unavailable` instead of restarting it.
+ */
+export async function applyStackStallGuard(planned, repo, stallTimeoutSeconds) {
+    const { result, idle } = planned;
+    if (result.selection.kind !== "stack")
+        return result;
+    const key = { owner: repo.owner, repo: repo.name, stack: result.selection.stackNumber };
+    if (!idle || stallTimeoutSeconds <= 0) {
+        await clearStackStallState(key);
+        return result;
+    }
+    const fingerprint = stackStallFingerprint(result);
+    const nowSeconds = Math.floor(Date.now() / 1000);
+    const read = await readStackStallState(key);
+    if (!read.ok)
+        return stackStateUnavailable(result, read.reason);
+    const stored = read.state;
+    if (!stored || stored.fingerprint !== fingerprint || stored.firstSeenAt > nowSeconds) {
+        const wrote = await writeStackStallState(key, { fingerprint, firstSeenAt: nowSeconds });
+        if (!wrote.ok)
+            return stackStateUnavailable(result, wrote.reason);
+        return result;
+    }
+    const ageSeconds = nowSeconds - stored.firstSeenAt;
+    if (ageSeconds < stallTimeoutSeconds)
+        return result;
+    return {
+        ...result,
+        reason: "actionable",
+        nextAction: "escalate",
+        stackMergeable: false,
+        instructions: [
+            `1. \`stall-timeout\`: the stack has not changed for ${formatDurationApprox(ageSeconds)} while no one-PR session could advance it: ${describeIdleLayers(idle)}. Stop and ask a human to unblock the waiting layers.`,
+        ],
+    };
+}
+function stackStateUnavailable(result, reason) {
+    return {
+        ...result,
+        reason: "actionable",
+        nextAction: "escalate",
+        stackMergeable: false,
+        instructions: [
+            `1. \`stall-state-unavailable\`: the stack stall timer could not be saved (${reason}). Stop and ask a human to fix the state directory before resuming.`,
+        ],
+    };
+}
+/** The status signature plus the per-layer evidence it omits, so a push resets the timer. */
+function stackStallFingerprint(result) {
+    return JSON.stringify({
+        status: summaryStatusSignature(result),
+        layers: result.prs.map((item) => ({
+            pr: item.pr,
+            headRefOid: item.headRefOid,
+            isDraft: item.isDraft,
+            readyReceipt: item.readyReceipt,
+            reasons: item.reasons,
+            blockedByPr: item.blockedByPr,
+        })),
+    });
+}

package/bin/commands/stack-work.d.mts

@@ -0,0 +1,32 @@
+import type { PollSummaryItem } from "../types.mts";
+type ProbedLayer = PollSummaryItem & {
+    pollCommand: string;
+    pollProbe: true;
+};
+/**
+ * The one-PR hold reason for a `READY` draft that only the disabled setting keeps in draft. The
+ * probe re-reads the draft, so this phrase, not a bare `[WAIT]`, proves it is still clean.
+ */
+export declare const AUTO_MARK_READY_DISABLED_HOLD = "automatic mark-ready is disabled for this session";
+/** How the stack selector routes the autonomous layers that still need work. */
+export interface StackWork {
+    /** Layers that need a one-PR Shepherd session, with or without a known command. */
+    sessions: PollSummaryItem[];
+    /** Clean, unblocked drafts that the agent marks ready because the poll loop will not. */
+    markReady: ProbedLayer[];
+    /** Layers whose bounded probe could only report that they are still waiting. */
+    idle: ProbedLayer[];
+}
+/**
+ * Split autonomous stack candidates by what the agent can do for each. A bounded probe cannot
+ * mark a draft ready, so rerunning it for a waiting layer cannot change the stack. A clean draft
+ * that no lower layer blocks becomes an agent ready-for-review step instead. A stale-ancestry
+ * child keeps its session, which returns the ancestry repair.
+ */
+export declare function splitStackWork(candidates: PollSummaryItem[], staleChildren: ReadonlySet<number>): StackWork;
+/**
+ * The poll loop leaves a disabled draft's ready transition to the agent. The bounded probe runs
+ * first because only the one-PR session reads the full review context and current lower layers.
+ */
+export declare function appendMarkReadyInstructions(instructions: string[], layers: ProbedLayer[]): void;
+export {};

package/bin/commands/stack-work.mjs

@@ -0,0 +1,39 @@
+/**
+ * The one-PR hold reason for a `READY` draft that only the disabled setting keeps in draft. The
+ * probe re-reads the draft, so this phrase, not a bare `[WAIT]`, proves it is still clean.
+ */
+export const AUTO_MARK_READY_DISABLED_HOLD = "automatic mark-ready is disabled for this session";
+/**
+ * Split autonomous stack candidates by what the agent can do for each. A bounded probe cannot
+ * mark a draft ready, so rerunning it for a waiting layer cannot change the stack. A clean draft
+ * that no lower layer blocks becomes an agent ready-for-review step instead. A stale-ancestry
+ * child keeps its session, which returns the ancestry repair.
+ */
+export function splitStackWork(candidates, staleChildren) {
+    const work = { sessions: [], markReady: [], idle: [] };
+    for (const item of candidates) {
+        if (!isProbed(item) || item.action !== "wait" || staleChildren.has(item.pr)) {
+            work.sessions.push(item);
+        }
+        else if (item.blockedByPr === undefined &&
+            item.reasons.includes("draft-auto-mark-ready-disabled")) {
+            work.markReady.push(item);
+        }
+        else {
+            work.idle.push(item);
+        }
+    }
+    return work;
+}
+/**
+ * The poll loop leaves a disabled draft's ready transition to the agent. The bounded probe runs
+ * first because only the one-PR session reads the full review context and current lower layers.
+ */
+export function appendMarkReadyInstructions(instructions, layers) {
+    for (const item of layers) {
+        instructions.push(`${instructions.length + 1}. Automatic mark-ready is disabled, so marking PR #${item.pr} ready for review is your step. Run \`${item.pollCommand}\` first. If it returns \`[WAIT]\` saying PR #${item.pr} stays in draft because ${AUTO_MARK_READY_DISABLED_HOLD}, run \`gh pr ready ${item.pr} -R ${item.repo}\`; otherwise complete its instructions and leave PR #${item.pr} in draft this round.`);
+    }
+}
+function isProbed(item) {
+    return item.pollProbe === true && item.pollCommand !== undefined;
+}

package/bin/config/load.d.mts

@@ -15,6 +15,8 @@ interface PollConfig {
 export interface PrShepherdConfig {
     /** Optional user classification configuration; preserved for rule consumers. */
     classify?: unknown;
+    /** Argv prefix for every pr-shepherd command Shepherd emits, e.g. `["pnpm", "exec", "pr-shepherd"]`. */
+    cliCommand: string[];
     /** GitHub logins that should be treated as bots even when GitHub reports User/Unknown. */
     botUsernames: string[];
     /** Case-insensitive glob patterns for check/status context names Shepherd should ignore. */

package/bin/config/load.mjs

@@ -76,6 +76,14 @@ function parseResolveOtherHumanThreads(value) {
     }
     throw new Error(`Invalid config: iterate.resolveOtherHumanThreads must be one of "none", "outdated", or "always", got ${JSON.stringify(value)}`);
 }
+function parseCliCommand(value) {
+    if (!Array.isArray(value) ||
+        value.length === 0 ||
+        !value.every((arg) => typeof arg === "string" && arg.trim() !== "")) {
+        throw new Error("Invalid config: cliCommand must be a non-empty array of non-empty strings");
+    }
+    return value;
+}
 function parseBotUsernames(value) {
     if (!Array.isArray(value) || !value.every((item) => typeof item === "string")) {
         throw new Error(`Invalid config: botUsernames must be an array of strings`);
@@ -223,6 +231,7 @@ function parseGraphqlQuotaWarnings(value, pollIntervalSeconds) {
 }
 const KNOWN_CONFIG_KEYS = new Set([
     "classify",
+    "cliCommand",
     "botUsernames",
     "ignoreChecks",
     "iterate",
@@ -284,6 +293,7 @@ function warnUnknownConfigKeys(config) {
 const rawDefaults = builtins;
 function parseConfig(value, normalizeMergeArgs = true) {
     const config = value;
+    config.cliCommand = parseCliCommand(config.cliCommand);
     config.botUsernames = parseBotUsernames(config.botUsernames);
     config.ignoreChecks = parseIgnoreChecks(config.ignoreChecks);
     config.actions.neverCancelRuns = parseNeverCancelRuns(config.actions.neverCancelRuns);

package/bin/config.json

@@ -1,4 +1,5 @@
 {
+  "cliCommand": ["pr-shepherd"],
   "botUsernames": [
     "chatgpt-connector",
     "openai-codex",

package/bin/github/batch-parsers.mjs

@@ -125,7 +125,7 @@ export function parseRawPr(raw, rawThreadPages, rawCommentNodes, rawReviewNodes,
                 null,
         },
         baseRefName: raw.baseRefName,
-        ...(raw.baseRef?.target?.oid && { baseRefOid: raw.baseRef.target.oid }),
+        ...(raw.baseRefOid && { baseRefOid: raw.baseRefOid }),
         reviewRequests,
         latestReviews,
         reviewThreads,

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

@@ -80,9 +80,6 @@ interface RawRuleParameters {
     }>;
 }
 export interface RawBaseRef {
-    target?: {
-        oid: string;
-    } | null;
     branchProtectionRule: RawBranchProtectionRule | null;
     rules: {
         pageInfo?: {

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

@@ -30,6 +30,8 @@ export interface RawPr extends RawPrMergeFields {
         viewerPermission: string | null;
     } | null;
     baseRefName: string;
+    /** `PullRequest.baseRefOid`: the base commit GitHub recorded for this PR, not the branch's live tip. */
+    baseRefOid?: string;
     baseRef: import("./batch-raw-rules.mts").RawBaseRef | null;
     reviewRequests: {
         nodes: Array<{

package/bin/github/errors.d.mts

@@ -10,6 +10,11 @@ export interface GitHubGraphQlError {
 }
 /** GitHub GraphQL engine crash: HTTP 200, `data: null`, INTERNAL type/code or message. */
 export declare function isRetryableGraphQlInternal(graphqlErrors?: GitHubGraphQlError[]): boolean;
+/** HTTP 200 GraphQL response whose `repository` field resolved to null. */
+export declare function missingRepositoryError(repo: {
+    owner: string;
+    name: string;
+}): GitHubRequestError;
 export declare class GitHubRequestError extends ShepherdError {
     readonly status: number;
     readonly rateLimit?: RateLimitInfo;

package/bin/github/errors.mjs

@@ -47,6 +47,10 @@ function classifyStatus(status, rateLimit, retryAfterSeconds, graphqlErrors) {
         return EXIT.NOPERM;
     return EXIT.UNAVAILABLE;
 }
+/** HTTP 200 GraphQL response whose `repository` field resolved to null. */
+export function missingRepositoryError(repo) {
+    return new GitHubRequestError(`GitHub GraphQL response did not include repository ${repo.owner}/${repo.name} (not found or access denied)`, { status: 200 });
+}
 export class GitHubRequestError extends ShepherdError {
     status;
     rateLimit;

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

@@ -35,6 +35,7 @@ query BatchPr($owner: String!, $repo: String!, $pr: Int!) {
         viewerPermission
       }
       baseRefName
+      baseRefOid
       isInMergeQueue
       ...PrMergePolicy
       autoMergeRequest {

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

@@ -1,4 +1,10 @@
-query PollStackSummary($owner: String!, $repo: String!, $anchor: Int!, $after: String) {
+query PollStackSummary(
+  $owner: String!
+  $repo: String!
+  $anchor: Int!
+  $first: Int!
+  $after: String
+) {
   _shepherdRateLimit: rateLimit {
     cost
     limit
@@ -15,7 +21,7 @@ query PollStackSummary($owner: String!, $repo: String!, $anchor: Int!, $after: S
         number
         size
         baseRefName
-        entries(first: 50, after: $after) {
+        entries(first: $first, after: $after) {
           pageInfo {
             hasNextPage
             endCursor

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

@@ -0,0 +1,38 @@
+query PollStackTopology($owner: String!, $repo: String!, $anchor: Int!, $after: String) {
+  _shepherdRateLimit: rateLimit {
+    cost
+    limit
+    nodeCount
+    remaining
+    resetAt
+    used
+  }
+  repository(owner: $owner, name: $repo) {
+    viewerCanAdminister
+    pullRequest(number: $anchor) {
+      stack {
+        id
+        number
+        size
+        baseRefName
+        entries(first: 50, after: $after) {
+          pageInfo {
+            hasNextPage
+            endCursor
+          }
+          nodes {
+            position
+            pullRequest {
+              number
+              state
+              headRefName
+              headRefOid
+              baseRefName
+              baseRefOid
+            }
+          }
+        }
+      }
+    }
+  }
+}

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

@@ -0,0 +1,34 @@
+fragment PollSummaryCheckContexts on StatusCheckRollupContextConnection {
+  totalCount
+  pageInfo {
+    hasPreviousPage
+    startCursor
+  }
+  nodes {
+    __typename
+    ... on CheckRun {
+      id
+      name
+      status
+      conclusion
+      detailsUrl
+      annotations(first: 1) {
+        totalCount
+      }
+      checkSuite {
+        workflowRun {
+          databaseId
+          event
+          workflow {
+            databaseId
+            name
+          }
+        }
+      }
+    }
+    ... on StatusContext {
+      context
+      state
+    }
+  }
+}

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

@@ -0,0 +1,23 @@
+query PollSummaryCheckPage($owner: String!, $repo: String!, $oid: GitObjectID!, $before: String!) {
+  _shepherdRateLimit: rateLimit {
+    cost
+    limit
+    nodeCount
+    remaining
+    resetAt
+    used
+  }
+  repository(owner: $owner, name: $repo) {
+    object(oid: $oid) {
+      __typename
+      ... on Commit {
+        oid
+        statusCheckRollup {
+          contexts(last: 100, before: $before) {
+            ...PollSummaryCheckContexts
+          }
+        }
+      }
+    }
+  }
+}

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

@@ -88,39 +88,10 @@ fragment PollSummaryPr on PullRequest {
   }
   mergeQueueEntry {
     headCommit {
+      oid
       statusCheckRollup {
         contexts(last: 100) {
-          totalCount
-          pageInfo {
-            hasPreviousPage
-          }
-          nodes {
-            __typename
-            ... on CheckRun {
-              id
-              name
-              status
-              conclusion
-              detailsUrl
-              annotations(first: 1) {
-                totalCount
-              }
-              checkSuite {
-                workflowRun {
-                  databaseId
-                  event
-                  workflow {
-                    databaseId
-                    name
-                  }
-                }
-              }
-            }
-            ... on StatusContext {
-              context
-              state
-            }
-          }
+          ...PollSummaryCheckContexts
         }
       }
     }
@@ -212,39 +183,11 @@ fragment PollSummaryPr on PullRequest {
   commits(last: 1) {
     nodes {
       commit {
+        oid
+        committedDate
         statusCheckRollup {
           contexts(last: 100) {
-            totalCount
-            pageInfo {
-              hasPreviousPage
-            }
-            nodes {
-              __typename
-              ... on CheckRun {
-                id
-                name
-                status
-                conclusion
-                detailsUrl
-                annotations(first: 1) {
-                  totalCount
-                }
-                checkSuite {
-                  workflowRun {
-                    databaseId
-                    event
-                    workflow {
-                      databaseId
-                      name
-                    }
-                  }
-                }
-              }
-              ... on StatusContext {
-                context
-                state
-              }
-            }
+            ...PollSummaryCheckContexts
           }
         }
       }

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

@@ -1,9 +1,6 @@
 fragment PrMergePolicy on PullRequest {
   isMergeQueueEnabled
   baseRef {
-    target {
-      oid
-    }
     branchProtectionRule {
       requiresApprovingReviews
       requiredApprovingReviewCount

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

@@ -1,4 +1,6 @@
+import { parseCreatedAt } from "./batch-parser-helpers.mjs";
 import { graphql } from "./client.mjs";
+import { queueRemovalAppliesToHead } from "./queue-removal-freshness.mjs";
 import { requireContextNodes } from "./batch-response.mjs";
 import { COMMIT_CHECK_CONTEXTS_QUERY } from "./queries.mjs";
 function omittedCursorError(oid) {
@@ -60,8 +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);
-    if (!parentOids?.includes(raw.headRefOid))
+    const headCommittedAt = raw.commits?.nodes[0]?.commit.committedDate;
+    if (!queueRemovalAppliesToHead({
+        parentOids,
+        headOid: raw.headRefOid,
+        ...(headCommittedAt && { headCommittedAtUnix: parseCreatedAt(headCommittedAt) }),
+        removedAtUnix: Math.floor(Date.parse(removal.createdAt) / 1000),
+    })) {
         return undefined;
+    }
     return removal.beforeCommit;
 }
 /** Hydrate all status contexts for the active or most recently removed queue commit. */

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

@@ -0,0 +1,12 @@
+import { type RepoInfo } from "./client.mts";
+import type { RawSummaryPr } from "./poll-summary-raw.mts";
+/**
+ * Complete the compact summary's `last: 100` status-context windows in place.
+ *
+ * Without this, a PR with more than 100 contexts always reports incomplete
+ * checks, so it can never earn or match a READY receipt. Every summary fetch
+ * path runs this before anything fingerprints `commits`, so one-PR receipts and
+ * aggregate stack reads hash the same evidence. A window that cannot be
+ * completed stays incomplete, which already fails readiness closed.
+ */
+export declare function hydratePollSummaryChecks(raw: RawSummaryPr, repo: RepoInfo): Promise<void>;

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

@@ -0,0 +1,55 @@
+import { graphqlWithRateLimit } from "./client.mjs";
+import { POLL_SUMMARY_CHECK_PAGE_QUERY } from "./queries.mjs";
+/**
+ * Complete the compact summary's `last: 100` status-context windows in place.
+ *
+ * Without this, a PR with more than 100 contexts always reports incomplete
+ * checks, so it can never earn or match a READY receipt. Every summary fetch
+ * path runs this before anything fingerprints `commits`, so one-PR receipts and
+ * aggregate stack reads hash the same evidence. A window that cannot be
+ * completed stays incomplete, which already fails readiness closed.
+ */
+export async function hydratePollSummaryChecks(raw, repo) {
+    const headCommit = raw.commits.nodes[0]?.commit;
+    if (headCommit)
+        await hydrateCommitContexts(headCommit, repo);
+    const queueCommit = raw.mergeQueueEntry?.headCommit;
+    if (queueCommit)
+        await hydrateCommitContexts(queueCommit, repo);
+}
+async function hydrateCommitContexts(commit, repo) {
+    const contexts = commit.statusCheckRollup?.contexts;
+    if (!contexts)
+        return;
+    const nodes = [...contexts.nodes];
+    let pageInfo = contexts.pageInfo;
+    while (pageInfo.hasPreviousPage && pageInfo.startCursor) {
+        const older = await fetchOlderContexts(commit.oid, pageInfo.startCursor, repo);
+        if (!older)
+            break;
+        nodes.unshift(...older.nodes);
+        pageInfo = older.pageInfo;
+    }
+    // A window that shifted between pages can repeat or skip contexts; the
+    // first page's total is the snapshot the hydrated list must account for.
+    const complete = !pageInfo.hasPreviousPage && nodes.length === contexts.totalCount;
+    commit.statusCheckRollup = {
+        contexts: {
+            totalCount: contexts.totalCount,
+            pageInfo: { hasPreviousPage: !complete },
+            nodes,
+        },
+    };
+}
+async function fetchOlderContexts(oid, before, repo) {
+    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;
+}

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

@@ -19,10 +19,30 @@ export function fingerprintRawSummaryPr(raw) {
         reviewDecision: raw.reviewDecision,
         reviewRequests: raw.reviewRequests,
         latestReviews: raw.latestReviews,
-        comments: raw.comments,
-        reviews: raw.reviews,
-        reviewThreads: raw.reviewThreads,
-        commits: raw.commits,
+        comments: hideBodies(raw.comments),
+        reviews: hideBodies(raw.reviews),
+        reviewThreads: {
+            ...raw.reviewThreads,
+            nodes: raw.reviewThreads.nodes.map((thread) => ({
+                ...thread,
+                rootComments: thread.rootComments && hideBodies(thread.rootComments),
+                comments: hideBodies(thread.comments),
+            })),
+        },
+        commits: {
+            ...raw.commits,
+            nodes: raw.commits.nodes.map((node) => ({
+                ...node,
+                commit: { ...node.commit, committedDate: undefined },
+            })),
+        },
     };
     return createHash("sha256").update(JSON.stringify(evidence)).digest("hex");
 }
+/** Hidden bodies are not readiness evidence: bots keep editing hidden notices after a PR settles. */
+function hideBodies(connection) {
+    return {
+        ...connection,
+        nodes: connection.nodes.map((node) => (node.isMinimized ? { ...node, body: undefined } : node)),
+    };
+}

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

@@ -19,14 +19,16 @@ export async function summarizePollSummaryPr(raw, repo, opts, viewerCanAdministe
     const removalEvent = currentQueueRemovalEvent(raw);
     let { action, reasons } = routePollSummary(raw, checks, review, opts);
     let remainingSeconds;
-    if (raw.isDraft && blockingReviewerInProgress && action === "mark_ready") {
+    if (raw.isDraft &&
+        blockingReviewerInProgress &&
+        (action === "mark_ready" || reasons.includes("draft-auto-mark-ready-disabled"))) {
         action = "wait";
         reasons = ["blocking-reviewer-in-progress"];
     }
     const appearsReady = reasons.includes("appears-ready");
     if (opts.stackPrNumber === undefined) {
         const readyDelaySeconds = opts.readyDelaySeconds ?? (loadConfig().watch?.readyDelayMinutes ?? 10) * 60;
-        const readyState = await updateReadyDelay(raw.number, appearsReady, readyDelaySeconds, repo.owner, repo.name, { retainElapsed: true });
+        const readyState = await updateReadyDelay(raw.number, appearsReady, readyDelaySeconds, repo.owner, repo.name, { headSha: raw.headRefOid });
         if (appearsReady && !readyState.shouldCancel) {
             action = "wait";
             reasons = ["ready-delay"];
@@ -93,9 +95,7 @@ export async function summarizePollSummaryPr(raw, repo, opts, viewerCanAdministe
         ...((opts.stackPrNumber !== undefined && raw.state === "OPEN") ||
             (!["wait", "cancel"].includes(action) &&
                 !(opts.stackPrNumber !== undefined && raw.stack && action === "merge"))
-            ? {
-                pollCommand: buildPollCommand(repoName, raw.number, raw.isDraft, opts),
-            }
+            ? pollCommandFields(repoName, raw.number, raw.isDraft, opts)
             : {}),
     };
 }
@@ -116,7 +116,7 @@ function detectBlockingReviewer(raw) {
     return ((raw.reviewRequests?.nodes ?? []).some((request) => matches(request.requestedReviewer)) ||
         (raw.latestReviews?.nodes ?? []).some((review) => review.state === "PENDING" && matches(review.author)));
 }
-function buildPollCommand(repo, pr, isDraft, opts) {
+function pollCommandFields(repo, pr, isDraft, opts) {
     const autoMarkReadyDisabled = opts.noAutoMarkReady || loadConfig().actions.autoMarkReady === false;
     const boundedDraft = isDraft && autoMarkReadyDisabled;
     const args = boundedDraft
@@ -131,5 +131,6 @@ function buildPollCommand(repo, pr, isDraft, opts) {
     }
     if (opts.noAutoMarkReady && !boundedDraft)
         args.push("--no-auto-mark-ready");
-    return buildPrShepherdCommand(args).text;
+    const pollCommand = buildPrShepherdCommand(args).text;
+    return boundedDraft ? { pollCommand, pollProbe: true } : { pollCommand };
 }

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

@@ -1,3 +1,5 @@
+import { 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) {
     const removal = raw.mergeQueueRemovals?.nodes[0];
@@ -10,7 +12,14 @@ export function currentQueueRemovalEvent(raw) {
     if (addition && Date.parse(addition.createdAt) > removalTime)
         return null;
     const parents = removal.beforeCommit?.parents?.nodes.map((parent) => parent.oid);
-    if (!parents?.includes(raw.headRefOid))
+    const headCommittedAt = raw.commits?.nodes[0]?.commit.committedDate;
+    if (!queueRemovalAppliesToHead({
+        parentOids: parents,
+        headOid: raw.headRefOid,
+        ...(headCommittedAt && { headCommittedAtUnix: parseCreatedAt(headCommittedAt) }),
+        removedAtUnix: Math.floor(removalTime / 1000),
+    })) {
         return null;
+    }
     return removal;
 }