pr-shepherd 0.48.0 → 0.50.0

package/bin/commands/iterate/render.mjs

@@ -69,7 +69,7 @@ isBehind = false, viewerCanUpdate = false, hasExhaustedWorkflowRerun = false) {
         instructions.push(`Apply every warranted review fix in ${filesRef}.`);
     }
     if (resolutionOnlyThreads.length > 0) {
-        instructions.push('Review the threads under `## Review threads to resolve` before running mutations. Use the generated commands as shown — see "Review-mutation routing" in the pr-shepherd skill for which flag applies to which ID.');
+        instructions.push("Review the threads under `## Review threads to resolve` before running the generated mutations.");
     }
     instructions.push(...buildFailingCheckInstructions(failingChecks), ...repeatedWorkflowBranchRecoveryInstructions);
     if (hasAnnotations) {

package/bin/commands/iterate/stall.mjs

@@ -1,8 +1,32 @@
+/* eslint-disable max-lines */
 import { readStallState, writeStallState } from "../../state/iterate-stall.mjs";
 import { toAgentThread, toAgentComment, toAgentStalledCheck } from "../../reporters/agent.mjs";
 import { buildEscalateSuggestion, buildEscalateHumanMessage, formatDurationApprox, } from "./escalate.mjs";
 import { checksWithActionableAnnotations } from "../check-annotations.mjs";
 import { formatPrUrl } from "../../pr-reference.mjs";
+function pendingReviewCommandsFromResult(result) {
+    if (result.action !== "fix_code")
+        return undefined;
+    const pending = {
+        ...(result.fix.resolveOnlyCommand?.hasMutations && {
+            resolveOnlyCommand: result.fix.resolveOnlyCommand,
+        }),
+        ...(result.fix.resolveCommand.hasMutations && { resolveCommand: result.fix.resolveCommand }),
+    };
+    return Object.keys(pending).length > 0 ? pending : undefined;
+}
+function surfacedSummariesFromResult(result) {
+    if (result.action !== "fix_code")
+        return {};
+    return {
+        ...(result.fix.firstLookSummaries.length > 0 && {
+            firstLookSummaries: result.fix.firstLookSummaries,
+        }),
+        ...(result.fix.editedSummaries.length > 0 && {
+            editedSummaries: result.fix.editedSummaries,
+        }),
+    };
+}
 function computeStallFingerprint(action, headSha, base, report, reviewSummaryIds) {
     const checks = [
         ...report.checks.failing.map((f) => `failing:${f.name}:${f.conclusion}:${f.runId ?? "no-run"}:${f.runAttempt ?? "unknown"}`),
@@ -44,13 +68,16 @@ export async function applyStallGuard(stallKey, stallTimeoutSeconds, headSha, ba
         action: prospectiveResult.action,
     });
     if (stalledChecks.length > 0) {
+        const pending = pendingReviewCommandsFromResult(prospectiveResult);
         const stalledDuration = formatDurationApprox(Math.max(...stalledChecks.map((c) => c.ageSeconds)));
         const escalateBase = {
             triggers: ["stall-timeout"],
             unresolvedThreads: [],
             ambiguousComments: [],
             changesRequestedReviews: [],
+            ...surfacedSummariesFromResult(prospectiveResult),
             stalledChecks,
+            ...(pending && { pendingReviewCommands: pending }),
             suggestion: buildEscalateSuggestion(["stall-timeout"], stalledDuration),
         };
         return {
@@ -76,11 +103,14 @@ export async function applyStallGuard(stallKey, stallTimeoutSeconds, headSha, ba
         }
         else if (ageSeconds >= stallTimeoutSeconds) {
             const stalledDuration = formatDurationApprox(ageSeconds);
+            const pending = pendingReviewCommandsFromResult(prospectiveResult);
             const escalateBase = {
                 triggers: ["stall-timeout"],
                 unresolvedThreads: [...report.threads.actionable, ...report.threads.resolutionOnly].map(toAgentThread),
                 ambiguousComments: report.comments.actionable.map(toAgentComment),
                 changesRequestedReviews: report.changesRequestedReviews,
+                ...surfacedSummariesFromResult(prospectiveResult),
+                ...(pending && { pendingReviewCommands: pending }),
                 suggestion: buildEscalateSuggestion(["stall-timeout"], stalledDuration),
             };
             return {

package/bin/commands/iterate/thread-mutation-routing.d.mts

@@ -1,8 +1,6 @@
 import { type NormalizedBotUsernames } from "../../comments/authors.mts";
-import { shouldResolveOtherHumanThread } from "../../comments/thread-resolve-policy.mts";
 import type { ResolveOtherHumanThreads } from "../../config/load.mts";
 import type { AgentThread, ReviewThread } from "../../types.mts";
-export { shouldResolveOtherHumanThread };
 export type RoutableThread = AgentThread | ReviewThread;
 export interface ThreadMutationRouting {
     replyThreadIds: string[];

package/bin/commands/iterate/thread-mutation-routing.mjs

@@ -1,7 +1,6 @@
 import { isConfiguredBotAuthor, isHumanAuthor, isViewerAuthoredHuman, } from "../../comments/authors.mjs";
 import { threadEndedByShepherd } from "../../comments/marker.mjs";
 import { shouldResolveOtherHumanThread } from "../../comments/thread-resolve-policy.mjs";
-export { shouldResolveOtherHumanThread };
 function dedupeIds(ids) {
     return [...new Set(ids)];
 }
@@ -32,7 +31,7 @@ export function buildThreadMutationRouting(threads, botUsernames, ruleAutoResolv
         .filter((thread) => shouldPairResolve(thread, botUsernames, policy) && !threadEndedByShepherd(thread))
         .map((thread) => thread.id));
     const pairedResolveIdSet = new Set(pairedResolveThreadIds);
-    // Rule-matched threads bypass author routing; resolve-mutate retains the human-author guard.
+    // Rule-matched threads bypass the generated-command author routing.
     const standaloneResolveThreadIds = dedupeIds([
         ...threads
             .filter((thread) => shouldPairResolve(thread, botUsernames, policy) && threadEndedByShepherd(thread))

package/bin/commands/poll-summary.d.mts

@@ -0,0 +1,10 @@
+import type { PollSummaryCommandOptions, PollSummaryResult } from "../types.mts";
+export interface AggregatePollCommandOptions extends PollSummaryCommandOptions {
+    intervalSeconds: number;
+    timeoutSeconds: number;
+    debounceSeconds?: number;
+    quietStatus?: boolean;
+    untilTerminal?: boolean;
+}
+export declare function runPollSummary(opts: PollSummaryCommandOptions): Promise<PollSummaryResult>;
+export declare function runAggregatePoll(opts: AggregatePollCommandOptions): Promise<PollSummaryResult>;

package/bin/commands/poll-summary.mjs

@@ -0,0 +1,163 @@
+import { loadConfig } from "../config/load.mjs";
+import { ShepherdError } from "../exit-codes.mjs";
+import { getRepoInfo } from "../github/client.mjs";
+import { withApiTelemetryScope, summarizeApiTelemetry } from "../github/api-telemetry.mjs";
+import { fetchPollSummary } from "../github/poll-summary.mjs";
+import { sleep } from "../util/sleep.mjs";
+import { graphqlQuotaPollIntervalMs, pollGraphQlRetryAfterMs } from "./poll-quota.mjs";
+import { evaluateWorktreeGraphqlQuotaWarning } from "../state/graphql-quota-warnings.mjs";
+const MAX_TIMER_MS = 2 ** 31 - 1;
+const TIMER_DRIFT_TOLERANCE_MS = 500;
+export function runPollSummary(opts) {
+    return withApiTelemetryScope(async () => attachUsage(await runPollSummaryCore(opts)));
+}
+export function runAggregatePoll(opts) {
+    return withApiTelemetryScope(() => runAggregatePollCore(opts));
+}
+async function runPollSummaryCore(opts) {
+    const repo = opts.targetRepository ?? (await getRepoInfo());
+    const fetched = await fetchPollSummary(opts, repo);
+    const allTerminal = fetched.prs.every((item) => item.action === "cancel");
+    const actionable = fetched.prs.some((item) => item.action !== "wait" && item.action !== "cancel");
+    return {
+        mode: "summary",
+        repo: `${repo.owner}/${repo.name}`,
+        selection: fetched.selection,
+        reason: allTerminal ? "all_terminal" : actionable ? "actionable" : "waiting",
+        prs: fetched.prs,
+    };
+}
+async function runAggregatePollCore(opts) {
+    const intervalMs = Math.min(opts.intervalSeconds * 1000, MAX_TIMER_MS);
+    const timeoutMs = Math.min(opts.timeoutSeconds * 1000, MAX_TIMER_MS);
+    const debounceMs = Math.min((opts.debounceSeconds ?? 60) * 1000, MAX_TIMER_MS);
+    const quotaBands = loadConfig().watch.graphqlQuotaWarnings;
+    const start = Date.now();
+    let tick = 0;
+    let debounceUntil = null;
+    let last;
+    let lastStatusSignature = null;
+    let rateLimitRetries = 0;
+    let pendingQuotaWarning;
+    while (true) {
+        tick += 1;
+        try {
+            last = await runPollSummaryCore(opts);
+            rateLimitRetries = 0;
+        }
+        catch (error) {
+            if (last?.selection.kind === "stack" && isMissingStack(error)) {
+                const explicit = await runPollSummaryCore({
+                    ...opts,
+                    stackPrNumber: undefined,
+                    prNumbers: last.prs.map((item) => item.pr),
+                });
+                if (explicit.prs.every((item) => item.action === "cancel")) {
+                    const warning = await aggregateQuotaWarning(explicit, quotaBands, opts.intervalSeconds);
+                    if (warning)
+                        pendingQuotaWarning = warning;
+                    return attachUsage({
+                        ...explicit,
+                        reason: "all_terminal",
+                        ...(pendingQuotaWarning && { quotaWarning: pendingQuotaWarning }),
+                    });
+                }
+            }
+            const retryMs = opts.untilTerminal ? pollGraphQlRetryAfterMs(error) : null;
+            if (retryMs === null || rateLimitRetries >= 1)
+                throw error;
+            rateLimitRetries += 1;
+            process.stderr.write(`[aggregate poll tick ${tick} / +${Math.round((Date.now() - start) / 1000)}s] GraphQL rate limit — retrying in ${Math.round(retryMs / 1000)}s\n`);
+            await sleep(retryMs);
+            continue;
+        }
+        const allTerminal = last.prs.every((item) => item.action === "cancel");
+        const immediate = last.prs.some((item) => ["escalate", "merge", "mark_ready"].includes(item.action));
+        const hasFix = last.prs.some((item) => item.action === "fix_code");
+        const warning = await aggregateQuotaWarning(last, quotaBands, opts.intervalSeconds);
+        if (warning)
+            pendingQuotaWarning = warning;
+        if (allTerminal) {
+            return attachUsage({
+                ...last,
+                reason: "all_terminal",
+                ...(pendingQuotaWarning && { quotaWarning: pendingQuotaWarning }),
+            });
+        }
+        if (immediate) {
+            return attachUsage({
+                ...last,
+                reason: "actionable",
+                ...(pendingQuotaWarning && { quotaWarning: pendingQuotaWarning }),
+            });
+        }
+        if (hasFix) {
+            if (debounceMs === 0)
+                return attachUsage({
+                    ...last,
+                    reason: "actionable",
+                    ...(pendingQuotaWarning && { quotaWarning: pendingQuotaWarning }),
+                });
+            debounceUntil ??= Date.now() + debounceMs;
+            if (Date.now() >= debounceUntil)
+                return attachUsage({
+                    ...last,
+                    reason: "actionable",
+                    ...(pendingQuotaWarning && { quotaWarning: pendingQuotaWarning }),
+                });
+        }
+        else {
+            debounceUntil = null;
+            if (opts.untilTerminal && pendingQuotaWarning) {
+                return attachUsage({ ...last, quotaWarning: pendingQuotaWarning });
+            }
+        }
+        const elapsedMs = Date.now() - start;
+        const sleepMs = debounceUntil
+            ? Math.min(intervalMs, Math.max(debounceUntil - Date.now(), 0))
+            : graphqlQuotaPollIntervalMs(quotaBands, summarizeApiTelemetry()?.graphql, intervalMs, MAX_TIMER_MS);
+        if (!opts.untilTerminal && debounceUntil === null) {
+            const remainingMs = timeoutMs - elapsedMs;
+            if (remainingMs <= 0 || remainingMs + TIMER_DRIFT_TOLERANCE_MS < sleepMs) {
+                return attachUsage({ ...last, reason: "timeout" });
+            }
+        }
+        const statusSignature = summaryStatusSignature(last);
+        if (!opts.quietStatus || hasFix || statusSignature !== lastStatusSignature) {
+            process.stderr.write(`[aggregate poll tick ${tick} / +${Math.round(elapsedMs / 1000)}s] ${last.prs
+                .map((item) => `#${item.pr} ${item.action.toUpperCase()}`)
+                .join(", ")}\n`);
+        }
+        lastStatusSignature = statusSignature;
+        await sleep(sleepMs);
+    }
+}
+async function aggregateQuotaWarning(result, bands, intervalSeconds) {
+    const usage = summarizeApiTelemetry()?.graphql;
+    const [owner, repo] = result.repo.split("/");
+    if (!usage || !owner || !repo)
+        return undefined;
+    return evaluateWorktreeGraphqlQuotaWarning({ owner, repo }, bands.map((band) => ({
+        ...band,
+        pollIntervalMinutes: Math.max(band.pollIntervalMinutes, intervalSeconds / 60),
+    })), usage, true);
+}
+function summaryStatusSignature(result) {
+    return JSON.stringify(result.prs.map((item) => ({
+        pr: item.pr,
+        action: item.action,
+        state: item.state,
+        mergeable: item.mergeable,
+        mergeStateStatus: item.mergeStateStatus,
+        reviewDecision: item.reviewDecision,
+        checks: item.checks,
+        review: item.review,
+    })));
+}
+function isMissingStack(error) {
+    return (error instanceof ShepherdError && error.message.includes("not part of a native GitHub stack"));
+}
+function attachUsage(result) {
+    const apiUsage = summarizeApiTelemetry();
+    return apiUsage ? { ...result, apiUsage } : result;
+}

package/bin/commands/ready-delay.d.mts

@@ -25,5 +25,7 @@ interface ReadyDelayState {
  * When `shouldCancel == true`, the formatter tells loop-capable agents to cancel
  * the loop and tells one-shot agents to stop.
  */
-export declare function updateReadyDelay(prNumber: number, isReady: boolean, readyDelaySeconds: number, owner: string, repo: string): Promise<ReadyDelayState>;
+export declare function updateReadyDelay(prNumber: number, isReady: boolean, readyDelaySeconds: number, owner: string, repo: string, options?: {
+    retainElapsed?: boolean;
+}): Promise<ReadyDelayState>;
 export {};

package/bin/commands/ready-delay.mjs

@@ -18,7 +18,7 @@ import { resolvePrStatePath } from "../state/base.mjs";
  * When `shouldCancel == true`, the formatter tells loop-capable agents to cancel
  * the loop and tells one-shot agents to stop.
  */
-export async function updateReadyDelay(prNumber, isReady, readyDelaySeconds, owner, repo) {
+export async function updateReadyDelay(prNumber, isReady, readyDelaySeconds, owner, repo, options = {}) {
     const markerPath = readySincePath(prNumber, owner, repo);
     if (!isReady) {
         // Reset the timer.
@@ -47,7 +47,8 @@ export async function updateReadyDelay(prNumber, isReady, readyDelaySeconds, own
     const elapsed = now - readySince;
     const remaining = readyDelaySeconds - elapsed;
     if (remaining <= 0) {
-        await safeUnlink(markerPath);
+        if (!options.retainElapsed)
+            await safeUnlink(markerPath);
         return { isReady: true, shouldCancel: true, remainingSeconds: 0 };
     }
     return { isReady: true, shouldCancel: false, remainingSeconds: remaining };

package/bin/commands/resolve-mutate.mjs

@@ -1,12 +1,9 @@
 import { getRepoInfo, getCurrentPrNumber } from "../github/client.mjs";
 import { applyResolveOptions } from "../comments/resolve.mjs";
 import { fetchPrBatch } from "../github/batch.mjs";
-import { loadConfig } from "../config/load.mjs";
-import { isConfiguredBotAuthor, isHumanAuthor, isViewerAuthoredHuman, normalizeBotUsernames, } from "../comments/authors.mjs";
-import { shouldResolveOtherHumanThread } from "./iterate/thread-mutation-routing.mjs";
 import { markReplySeen } from "../state/seen-comments.mjs";
 import { threadTranscriptBody } from "../threads/transcript.mjs";
-import { addPrShepherdMarker, threadEndedByShepherd } from "../comments/marker.mjs";
+import { addPrShepherdMarker } from "../comments/marker.mjs";
 import { EXIT, ShepherdError } from "../exit-codes.mjs";
 /** @deprecated Hidden implementation for `resolve`; use `apply review`. */
 export async function runResolveMutate(opts) {
@@ -15,73 +12,30 @@ export async function runResolveMutate(opts) {
     if (prNumber === null) {
         throw new ShepherdError("No open PR found for current branch. Pass a PR number explicitly.", EXIT.UNAVAILABLE);
     }
-    const { data } = await fetchPrBatch(prNumber, repo, { paginateApprovedReviews: true });
-    const config = loadConfig();
-    const botUsernames = normalizeBotUsernames(config.botUsernames);
-    const threadById = new Map(data.reviewThreads.map((t) => [t.id, t]));
-    const humanThreadIds = new Set(data.reviewThreads
-        .filter((t) => isHumanAuthor(t) && !isConfiguredBotAuthor(t, botUsernames))
-        .map((t) => t.id));
-    const humanCommentIds = new Set(data.comments
-        .filter((c) => isHumanAuthor(c) && !isConfiguredBotAuthor(c, botUsernames))
-        .map((c) => c.id));
-    const humanReviewIds = new Set([...data.reviewSummaries, ...data.approvedReviews, ...data.changesRequestedReviews]
-        .filter((r) => isHumanAuthor(r) && !isConfiguredBotAuthor(r, botUsernames))
-        .map((r) => r.id));
-    // Iterate uses viewer capability fields while deciding which commands to
-    // print. Once a caller explicitly runs apply, GitHub's mutation response is
-    // authoritative and this path must not second-guess that intent.
-    const requestedReplyIds = new Set(opts.replyThreadIds ?? []);
-    const policy = config.iterate?.resolveOtherHumanThreads ?? "none";
-    const allowedHumanResolveIds = new Set(data.reviewThreads
-        .filter((thread) => {
-        if (!humanThreadIds.has(thread.id))
-            return false;
-        const paired = requestedReplyIds.has(thread.id) || threadEndedByShepherd(thread);
-        if (!paired)
-            return false;
-        if (isViewerAuthoredHuman(thread, botUsernames))
-            return true;
-        return shouldResolveOtherHumanThread(thread, policy);
-    })
-        .map((thread) => thread.id));
-    const resolveThreadIds = (opts.resolveThreadIds ?? []).filter((id) => !humanThreadIds.has(id) || allowedHumanResolveIds.has(id));
-    const skippedHumanResolves = (opts.resolveThreadIds ?? []).filter((id) => humanThreadIds.has(id) && !allowedHumanResolveIds.has(id));
-    const knownThreadIds = new Set(data.reviewThreads.map((thread) => thread.id));
-    const replyThreadIds = opts.replyThreadIds?.filter((id) => knownThreadIds.has(id));
-    const skippedNonHumanReplies = (opts.replyThreadIds ?? []).filter((id) => !knownThreadIds.has(id));
-    const minimizeCommentIds = (opts.minimizeCommentIds ?? []).filter((id) => !humanCommentIds.has(id) && !humanReviewIds.has(id));
-    const skippedHumanMinimizes = (opts.minimizeCommentIds ?? []).filter((id) => humanCommentIds.has(id) || humanReviewIds.has(id));
-    const dismissReviewIds = (opts.dismissReviewIds ?? []).filter((id) => !humanReviewIds.has(id) && data.changesRequestedReviews.some((review) => review.id === id));
-    const skippedHumanDismissals = (opts.dismissReviewIds ?? []).filter((id) => humanReviewIds.has(id));
-    const skippedIneligibleDismissals = (opts.dismissReviewIds ?? []).filter((id) => !humanReviewIds.has(id) && !dismissReviewIds.includes(id));
-    const hasMutation = resolveThreadIds.length > 0 ||
-        (replyThreadIds?.length ?? 0) > 0 ||
-        minimizeCommentIds.length > 0 ||
-        dismissReviewIds.length > 0;
+    // Fetch only to retain the pre-reply transcript for successful-reply seen
+    // markers. It never determines which user-supplied IDs are sent to GitHub.
+    let threadById;
+    if (opts.replyThreadIds?.length) {
+        try {
+            threadById = new Map((await fetchPrBatch(prNumber, repo, { paginateApprovedReviews: true })).data.reviewThreads.map((thread) => [thread.id, thread]));
+        }
+        catch {
+            // Seen-marker bookkeeping is best-effort. A failed read must not block
+            // the explicit mutation request; GitHub's mutation response is authoritative.
+        }
+    }
+    // Iterate capability-checks and routes its generated commands. Direct apply
+    // requests are user-directed: forward every supplied ID unchanged and let
+    // GitHub report whether each requested mutation is permitted or applicable.
     const result = await applyResolveOptions(prNumber, repo, {
-        resolveThreadIds,
-        replyThreadIds,
-        minimizeCommentIds,
-        dismissReviewIds,
+        resolveThreadIds: opts.resolveThreadIds,
+        replyThreadIds: opts.replyThreadIds,
+        minimizeCommentIds: opts.minimizeCommentIds,
+        dismissReviewIds: opts.dismissReviewIds,
         dismissMessage: opts.dismissMessage,
-        requireSha: hasMutation ? opts.requireSha : undefined,
+        requireSha: opts.requireSha,
     });
-    if (skippedHumanResolves.length > 0)
-        result.skippedHumanResolves = skippedHumanResolves;
-    if (skippedHumanMinimizes.length > 0)
-        result.skippedHumanMinimizes = skippedHumanMinimizes;
-    if (skippedHumanDismissals.length > 0)
-        result.skippedHumanDismissals = skippedHumanDismissals;
-    if (skippedNonHumanReplies.length > 0)
-        result.skippedNonHumanReplies = skippedNonHumanReplies;
-    if (skippedIneligibleDismissals.length > 0) {
-        result.skippedDismissals = [
-            ...(result.skippedDismissals ?? []),
-            ...skippedIneligibleDismissals,
-        ];
-    }
-    if (opts.dismissMessage) {
+    if (opts.dismissMessage && threadById) {
         const markedMessage = addPrShepherdMarker(opts.dismissMessage);
         await Promise.all(result.repliedThreads.map((id) => {
             const thread = threadById.get(id);

package/bin/comments/resolve.d.mts

@@ -7,10 +7,15 @@ export interface ResolveResult {
     minimizedComments: string[];
     dismissedReviews: string[];
     errors: string[];
+    /** @deprecated Direct apply forwards every supplied dismissal ID to GitHub. */
     skippedDismissals?: string[];
+    /** @deprecated Direct apply no longer applies author policy. */
     skippedHumanResolves?: string[];
+    /** @deprecated Direct apply no longer applies author policy. */
     skippedHumanMinimizes?: string[];
+    /** @deprecated Direct apply no longer applies author policy. */
     skippedHumanDismissals?: string[];
+    /** @deprecated Direct apply forwards every supplied reply ID to GitHub. */
     skippedNonHumanReplies?: string[];
     /** @deprecated Direct apply requests now rely on GitHub's mutation response. */
     skippedUnauthorizedReplies?: string[];

package/bin/comments/resolve.mjs

@@ -35,9 +35,6 @@ export async function applyResolveOptions(pr, repo, opts) {
     const replyThreadIds = dedupeIds(opts.replyThreadIds ?? []);
     const minimizeCommentIds = opts.minimizeCommentIds ?? [];
     const dismissReviewIds = dedupeIds(opts.dismissReviewIds ?? []);
-    const minimizeCommentIdSet = new Set(minimizeCommentIds);
-    const filteredDismissReviewIds = dismissReviewIds.filter((id) => !minimizeCommentIdSet.has(id));
-    const overlappingDismissIds = dismissReviewIds.filter((id) => minimizeCommentIdSet.has(id));
     const result = {
         repliedThreads: [],
         resolvedThreads: [],
@@ -45,13 +42,7 @@ export async function applyResolveOptions(pr, repo, opts) {
         dismissedReviews: [],
         errors: [],
     };
-    if (overlappingDismissIds.length > 0) {
-        result.skippedDismissals = [];
-        for (const id of overlappingDismissIds) {
-            result.skippedDismissals.push(id);
-        }
-    }
-    if ((filteredDismissReviewIds.length > 0 || replyThreadIds.length > 0) && !opts.dismissMessage) {
+    if ((dismissReviewIds.length > 0 || replyThreadIds.length > 0) && !opts.dismissMessage) {
         throw new Error("--message is required when replying to threads or dismissing reviews");
     }
     if (opts.requireSha) {
@@ -59,7 +50,7 @@ export async function applyResolveOptions(pr, repo, opts) {
         // before reviewers see the fix.
         await waitForSha(pr, repo, opts.requireSha);
     }
-    await bulkApply(replyThreadIds, resolveThreadIds, minimizeCommentIds, filteredDismissReviewIds, opts.dismissMessage ?? "", result);
+    await bulkApply(replyThreadIds, resolveThreadIds, minimizeCommentIds, dismissReviewIds, opts.dismissMessage ?? "", result);
     return result;
 }
 /** @deprecated Compatibility alias; use `autoResolveThreads`. */

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

@@ -0,0 +1,33 @@
+query PollStackSummary($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 {
+              ...PollSummaryPr
+            }
+          }
+        }
+      }
+    }
+  }
+}