pr-shepherd 0.60.1 → 1.1.0

package/bin/github/poll-summary-annotation-probe.d.mts

@@ -19,3 +19,8 @@ export declare function hydrateReadyAnnotationProbe(pr: RawSummaryPr, repo: Repo
     actionable?: number;
     incomplete?: true;
 }): Promise<void>;
+/**
+ * Load annotation totals once per summary row, from the same probe the READY receipt
+ * hash uses. False when a page could not be read, so no total is trustworthy.
+ */
+export declare function hydrateAnnotationTotals(pr: RawSummaryPr, repo: RepoInfo): Promise<boolean>;

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

@@ -7,6 +7,7 @@ import { fingerprintRawSummaryPr } from "./poll-summary-fingerprint.mjs";
 import { POLL_SUMMARY_ANNOTATION_PROBE_QUERY } from "./queries.mjs";
 const PROBE_UNAVAILABLE = Symbol.for("prShepherd.annotationProbeUnavailable");
 const COMPLETE_FROM_BATCH = new WeakSet();
+const HYDRATED = new WeakSet();
 /** Annotation totals copied from the same full-snapshot request; no follow-up probe is needed. */
 export function markReadyAnnotationProbeComplete(pr) {
     COMPLETE_FROM_BATCH.add(pr);
@@ -36,9 +37,22 @@ export async function hydrateReadyAnnotationProbe(pr, repo, review) {
     const checks = summarizePollSummaryChecks(pr);
     if (!isCurrentSummaryReady(pr, checks, review))
         return;
-    if (!(await hydrateCommitAnnotations(pr, repo))) {
-        pr[PROBE_UNAVAILABLE] = true;
-    }
+    await hydrateAnnotationTotals(pr, repo);
+}
+/**
+ * Load annotation totals once per summary row, from the same probe the READY receipt
+ * hash uses. False when a page could not be read, so no total is trustworthy.
+ */
+export async function hydrateAnnotationTotals(pr, repo) {
+    if (COMPLETE_FROM_BATCH.has(pr))
+        return true;
+    if (HYDRATED.has(pr))
+        return !annotationProbeUnavailable(pr);
+    HYDRATED.add(pr);
+    if (await hydrateCommitAnnotations(pr, repo))
+        return true;
+    pr[PROBE_UNAVAILABLE] = true;
+    return false;
 }
 async function hydrateCommitAnnotations(pr, repo) {
     const commit = pr.commits.nodes[0]?.commit;

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

@@ -0,0 +1,14 @@
+import type { PollSummaryChecks, PollSummaryItem } from "../types.mts";
+import type { RepoInfo } from "./client.mts";
+import type { RawSummaryPr } from "./poll-summary-raw.mts";
+type Routed = Pick<PollSummaryItem, "action" | "reasons">;
+/**
+ * The one-PR check treats unseen annotations on any non-SUCCESS check (failing, skipped,
+ * filtered, ignored or neutral) as actionable work. The compact summary only has annotation
+ * totals, and only for a row that otherwise claims readiness, so it loads them then and reads
+ * the annotations of just the non-SUCCESS checks that have any. A row with unseen annotations,
+ * or whose annotations cannot be read, goes to its one-PR `pollCommand` instead of
+ * claiming `appears-ready`, `cancel`, `mark_ready` or `merge`.
+ */
+export declare function applyUnseenCheckAnnotations(raw: RawSummaryPr, repo: RepoInfo, routed: Routed, checks: PollSummaryChecks, seen: ReadonlyMap<string, unknown>, required: readonly string[]): Promise<Routed>;
+export {};

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

@@ -0,0 +1,75 @@
+import { pollRateLimitRetryAfterMs } from "../commands/poll-quota.mjs";
+import { fetchCheckRunAnnotationsBatch } from "./check-annotations-batch.mjs";
+import { hydrateAnnotationTotals } from "./poll-summary-annotation-probe.mjs";
+import { classifiedSummaryChecks } from "./poll-summary-checks.mjs";
+/** Routes whose action claims the row has nothing left to do. */
+const READY_CLAIMS = new Set([
+    "appears-ready",
+    "draft-appears-ready",
+    "already-in-merge-queue",
+    "already-auto-merging",
+]);
+/**
+ * The one-PR check treats unseen annotations on any non-SUCCESS check (failing, skipped,
+ * filtered, ignored or neutral) as actionable work. The compact summary only has annotation
+ * totals, and only for a row that otherwise claims readiness, so it loads them then and reads
+ * the annotations of just the non-SUCCESS checks that have any. A row with unseen annotations,
+ * or whose annotations cannot be read, goes to its one-PR `pollCommand` instead of
+ * claiming `appears-ready`, `cancel`, `mark_ready` or `merge`.
+ */
+export async function applyUnseenCheckAnnotations(raw, repo, routed, checks, seen, required) {
+    if (!routed.reasons.some((reason) => READY_CLAIMS.has(reason)))
+        return routed;
+    // Successful checks never carry actionable annotations: skip the probe when none can.
+    if (nonSuccessCheckTotals(raw, required, false).size === 0)
+        return routed;
+    const totalsKnown = await hydrateAnnotationTotals(raw, repo);
+    const candidates = nonSuccessCheckTotals(raw, required, totalsKnown);
+    if (candidates.size === 0)
+        return routed;
+    const count = totalsKnown
+        ? await countChecksWithUnseen(raw, repo, candidates, seen)
+        : candidates.size;
+    if (count === 0)
+        return routed;
+    checks.annotated = count;
+    return { action: "triage", reasons: ["check-annotations"] };
+}
+/** Completed, non-SUCCESS head checks with their annotation totals (all of them when totals are unknown). */
+function nonSuccessCheckTotals(raw, required, totalsKnown) {
+    const head = new Map((raw.commits.nodes[0]?.commit.statusCheckRollup?.contexts.nodes ?? []).flatMap((node) => node.__typename === "CheckRun" && node.id
+        ? [[node.id, node.annotations?.totalCount]]
+        : []));
+    const totals = new Map();
+    for (const check of classifiedSummaryChecks(raw, required)) {
+        if (check.scope || check.id == null || !head.has(check.id))
+            continue;
+        if (check.category === "in_progress" || check.category === "superseded")
+            continue;
+        if (check.status !== "COMPLETED" || check.conclusion === "SUCCESS")
+            continue;
+        const total = head.get(check.id) ?? 0;
+        if (!totalsKnown || total > 0)
+            totals.set(check.id, total);
+    }
+    return totals;
+}
+async function countChecksWithUnseen(raw, repo, totals, seen) {
+    const ids = [...totals.keys()];
+    try {
+        const batch = await fetchCheckRunAnnotationsBatch(ids, {
+            stateKey: { owner: repo.owner, repo: repo.name, pr: raw.number },
+            headSha: raw.headRefOid,
+            expectedCounts: totals,
+        });
+        // A check whose annotations could not be read may still hold unseen work.
+        const unread = ids.filter((id) => !batch.annotations.has(id)).length;
+        const unseen = [...batch.annotations.values()].filter((list) => list.some((annotation) => !seen.has(annotation.id))).length;
+        return unread + unseen;
+    }
+    catch (error) {
+        if (pollRateLimitRetryAfterMs(error) !== null)
+            throw error;
+        return ids.length;
+    }
+}

package/bin/github/poll-summary-blocking-reviewer.d.mts

@@ -0,0 +1,2 @@
+import type { RawSummaryPr } from "./poll-summary-raw.mts";
+export declare function detectBlockingReviewer(raw: RawSummaryPr): boolean;

package/bin/github/poll-summary-blocking-reviewer.mjs

@@ -0,0 +1,9 @@
+import { loadConfig } from "../config/load.mjs";
+export function detectBlockingReviewer(raw) {
+    const prefixes = loadConfig()["mark-ready"]["blocking-reviewer-logins"].map((login) => login.toLowerCase());
+    // 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)));
+}

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

@@ -7,7 +7,7 @@ import { failingSummaryCheckNames } from "./poll-summary-checks.mjs";
  * does not start a one-PR session for a wait it would otherwise shepherd.
  */
 export async function applyOpenCheckBlockers(raw, repo, routed, checks, review, stack, requiredContexts) {
-    if (routed.action !== "fix_code" || !routed.reasons.includes("failing-checks"))
+    if (routed.action !== "triage" || !routed.reasons.includes("failing-checks"))
         return routed;
     if ((review.actionable ?? 0) > 0 || checks.incomplete)
         return routed;

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

@@ -3,3 +3,4 @@ import type { RawSummaryPr } from "./poll-summary-raw.mts";
 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, requiredContexts?: readonly string[]): string[];
+export declare function classifiedSummaryChecks(raw: RawSummaryPr, requiredContexts?: readonly string[]): import("../types.mts").ClassifiedCheck[];

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

@@ -1,4 +1,6 @@
 import { classifyChecks } from "../checks/classify.mjs";
+import { mergeStartupFailureChecks } from "../checks/startup-failures.mjs";
+import { startupFailureChecksFromSuites } from "./batch-parse-suites.mjs";
 import { parseCreatedAt } from "./batch-parser-helpers.mjs";
 export function summarizePollSummaryChecks(raw, requiredContexts) {
     const rollups = summaryRollups(raw);
@@ -19,6 +21,11 @@ export function summarizePollSummaryChecks(raw, requiredContexts) {
     if (rollups.some(({ rollup }) => rollup.contexts.pageInfo.hasPreviousPage)) {
         summary.incomplete = true;
     }
+    // The first 50 check suites are all the summary reads. The one-PR check lists the
+    // remaining workflow runs for startup failures; here an unread suite stays unverified.
+    if (raw.commits.nodes[0]?.commit.checkSuites?.pageInfo?.hasNextPage === true) {
+        summary.incomplete = true;
+    }
     return summary;
 }
 /** Names of failing checks in the loaded summary rollup. */
@@ -36,13 +43,24 @@ function summaryRollups(raw) {
         },
     ].flatMap(({ rollup, scope }) => (rollup ? [{ rollup, scope }] : []));
 }
-function classifiedSummaryChecks(raw, requiredContexts) {
+export 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), {
+    const groups = summaryRollups(raw).map(({ rollup, scope }) => ({
+        runs: checkRuns(rollup, scope),
+        scope,
+    }));
+    if (!groups.some(({ scope }) => scope === undefined))
+        groups.unshift({ runs: [], scope: undefined });
+    return groups.flatMap(({ runs, scope }) => classifyChecks(scope ? runs : withStartupFailures(raw, runs), {
         ...(scope === "merge_group" && { additionalRelevantEvents: ["merge_group"] }),
         ...(requiredContexts && { requiredContexts }),
     }));
 }
+/** A workflow run that never started has no check run; the one-PR check synthesizes it as failing. */
+function withStartupFailures(raw, runs) {
+    const suites = raw.commits.nodes[0]?.commit.checkSuites;
+    return mergeStartupFailureChecks(runs, startupFailureChecksFromSuites(suites));
+}
 function checkRuns(rollup, scope) {
     return rollup.contexts.nodes.map((context) => {
         if (context.__typename === "StatusContext") {

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

@@ -2,11 +2,15 @@ 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 autoMarkReadyDisabled = opts.noAutoMarkReady || loadConfig()["mark-ready"].auto === false;
     const boundedDraft = isDraft && autoMarkReadyDisabled;
-    const args = boundedDraft
-        ? [formatPrUrl(repo, pr), "--timeout", "1s", "--debounce", "0s", "--no-auto-mark-ready"]
-        : [formatPrUrl(repo, pr), "--until-terminal"];
+    const url = formatPrUrl(repo, pr);
+    // A single tick routes each PR to one `iterate` tick rather than a sleeping poll.
+    const args = opts.tick
+        ? ["iterate", url, ...(boundedDraft ? ["--no-auto-mark-ready"] : [])]
+        : boundedDraft
+            ? [url, "--timeout", "1s", "--debounce", "0s", "--no-auto-mark-ready"]
+            : [url, "--until-terminal"];
     if (opts.merge && opts.stackPrNumber === undefined)
         args.push("--merge");
     if (opts.readyDelaySeconds !== undefined)
@@ -15,8 +19,6 @@ export function pollCommandFields(repo, pr, isDraft, opts) {
         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;

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

@@ -4,5 +4,12 @@ import type { RawSummaryPr } from "./poll-summary-raw.mts";
  * 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.
+ *
+ * Deliberately conservative: every comment, review and thread node and the ignored
+ * checks are hashed without applying classification rules. A rule-suppressed bot
+ * comment or an ignored-check change therefore invalidates a receipt, but a miss only
+ * costs one more one-PR session (`no-ready-receipt`), whereas a hash that skipped
+ * evidence could certify a state the one-PR check never examined. Do not narrow this
+ * to post-rule state unless the one-PR check hashes the same projection.
  */
 export declare function fingerprintRawSummaryPr(summary: RawSummaryPr): string | null;

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

@@ -5,6 +5,13 @@ import { withoutHandoffFields } from "./poll-summary-handoff-fields.mjs";
  * 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.
+ *
+ * Deliberately conservative: every comment, review and thread node and the ignored
+ * checks are hashed without applying classification rules. A rule-suppressed bot
+ * comment or an ignored-check change therefore invalidates a receipt, but a miss only
+ * costs one more one-PR session (`no-ready-receipt`), whereas a hash that skipped
+ * evidence could certify a state the one-PR check never examined. Do not narrow this
+ * to post-rule state unless the one-PR check hashes the same projection.
  */
 export function fingerprintRawSummaryPr(summary) {
     const raw = withoutHandoffFields(summary);

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

@@ -1,4 +1,6 @@
 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 | undefined, 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, 
+/** Aggregate polls only: apply rule-driven auto-resolve. Receipt and merge validation reads never mutate. */
+applyRuleAutoResolve?: boolean): Promise<PollSummaryItem>;

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

@@ -5,8 +5,9 @@ import { formatPrUrl } from "../pr-reference.mjs";
 import { loadSeenMap } from "../state/seen-comments.mjs";
 import { isReadyReceiptCurrent, readReadyReceipt } from "../state/ready-receipts.mjs";
 import { summarizePollSummaryChecks } from "./poll-summary-checks.mjs";
-import { summarizePollSummaryReview } from "./poll-summary-review.mjs";
-import { currentQueueRemovalEvent } from "./poll-summary-queue-removal.mjs";
+import { evaluatePollSummaryReview } from "./poll-summary-review.mjs";
+import { currentQueueRemovalEvent, projectQueueRemoval } from "./poll-summary-queue-removal.mjs";
+import { applyUnseenCheckAnnotations } from "./poll-summary-annotations.mjs";
 import { isCurrentSummaryReady } from "./poll-summary-readiness.mjs";
 import { applyOpenCheckBlockers } from "./poll-summary-check-blockers.mjs";
 import { normalizePollSummaryState, routePollSummary } from "./poll-summary-route.mjs";
@@ -14,14 +15,19 @@ import { hydrateReadyAnnotationProbe, readyFingerprint } from "./poll-summary-an
 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) {
+import { detectBlockingReviewer } from "./poll-summary-blocking-reviewer.mjs";
+export async function summarizePollSummaryPr(raw, repo, opts, viewerCanAdminister = undefined, mergeTargetContexts, viewerLogin = null, 
+/** Aggregate polls only: apply rule-driven auto-resolve. Receipt and merge validation reads never mutate. */
+applyRuleAutoResolve = false) {
     const repoName = `${repo.owner}/${repo.name}`;
     const seen = await loadSeenMap({ owner: repo.owner, repo: repo.name, pr: raw.number });
     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 { review, ruleAutoResolve } = await evaluatePollSummaryReview(raw, seen, viewerCanAdminister, applyRuleAutoResolve && normalizePollSummaryState(raw.state) === "OPEN"
+        ? { owner: repo.owner, repo: repo.name, pr: raw.number }
+        : undefined);
     const blockingReviewerInProgress = detectBlockingReviewer(raw);
     const removalEvent = currentQueueRemovalEvent(raw);
     let { action, reasons } = routePollSummary(raw, checks, review, opts);
@@ -34,10 +40,11 @@ export async function summarizePollSummaryPr(raw, repo, opts, viewerCanAdministe
         action = "wait";
         reasons = ["blocking-reviewer-in-progress"];
     }
+    ({ action, reasons } = await applyUnseenCheckAnnotations(raw, repo, { action, reasons }, checks, seen, required));
     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, { headSha: raw.headRefOid });
+        const readyDelaySeconds = opts.readyDelaySeconds ?? loadConfig().iterate["ready-delay-minutes"] * 60;
+        const readyState = await updateReadyDelay(raw.number, appearsReady, readyDelaySeconds, repo.owner, repo.name, { headSha: raw.headRefOid, summary: true });
         if (appearsReady && !readyState.shouldCancel) {
             action = "wait";
             reasons = ["ready-delay"];
@@ -112,6 +119,7 @@ export async function summarizePollSummaryPr(raw, repo, opts, viewerCanAdministe
         ...(remainingSeconds !== undefined && { remainingSeconds }),
         ...(Object.keys(checks).length > 0 && { checks }),
         ...(Object.keys(review).length > 0 && { review }),
+        ...(ruleAutoResolve && { ruleAutoResolve }),
         ...(stack && { stack }),
         ...(readyReceipt && { readyReceipt: true }),
         ...((opts.stackPrNumber !== undefined && raw.state === "OPEN") ||
@@ -122,22 +130,3 @@ export async function summarizePollSummaryPr(raw, repo, opts, viewerCanAdministe
         ...(blocked.pollProbe ? { pollProbe: true } : {}),
     };
 }
-function projectQueueRemoval(removal) {
-    const removalTime = Date.parse(removal.createdAt);
-    const parents = removal.beforeCommit?.parents?.nodes.map((parent) => parent.oid) ?? [];
-    return {
-        reason: removal.reason,
-        createdAtUnix: Math.floor(removalTime / 1000),
-        ...(removal.actor?.login && { actor: removal.actor.login }),
-        ...(removal.beforeCommit?.oid && { beforeCommitOid: removal.beforeCommit.oid }),
-        beforeCommitParentOids: parents,
-    };
-}
-function detectBlockingReviewer(raw) {
-    const prefixes = (loadConfig().mergeStatus?.blockingReviewerLogins ?? []).map((login) => login.toLowerCase());
-    // 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)));
-}

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

@@ -1,5 +1,7 @@
+import type { PollSummaryItem } from "../types.mts";
 import type { RawSummaryPr } from "./poll-summary-raw.mts";
 type QueueRemovalEvent = NonNullable<RawSummaryPr["mergeQueueRemovals"]>["nodes"][number];
 /** Latest queue removal that still applies to this PR head, not an older attempt. */
 export declare function currentQueueRemovalEvent(raw: RawSummaryPr): QueueRemovalEvent | null;
+export declare function projectQueueRemoval(removal: QueueRemovalEvent): PollSummaryItem["queueRemoval"];
 export {};

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

@@ -28,3 +28,14 @@ export function currentQueueRemovalEvent(raw) {
     }
     return removal;
 }
+export function projectQueueRemoval(removal) {
+    const removalTime = Date.parse(removal.createdAt);
+    const parents = removal.beforeCommit?.parents?.nodes.map((parent) => parent.oid) ?? [];
+    return {
+        reason: removal.reason,
+        createdAtUnix: Math.floor(removalTime / 1000),
+        ...(removal.actor?.login && { actor: removal.actor.login }),
+        ...(removal.beforeCommit?.oid && { beforeCommitOid: removal.beforeCommit.oid }),
+        beforeCommitParentOids: parents,
+    };
+}

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

@@ -38,6 +38,7 @@ export function isCurrentSummaryReady(raw, checks, review, options = {}) {
         (queued || raw.mergeable === "MERGEABLE") &&
         (queued || !blockedStates.includes(raw.mergeStateStatus)) &&
         (checks.failing ?? 0) === 0 &&
+        (checks.annotated ?? 0) === 0 &&
         (sourceChecks.failing ?? 0) === 0 &&
         (sourceChecks.inProgress ?? 0) === 0 &&
         (checks.unreportedRequired?.length ?? 0) === 0 &&

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

@@ -0,0 +1,24 @@
+import { type NormalizedBotUsernames } from "../comments/authors.mts";
+import type { MinimizeCommentsPolicy, ResolveOtherHumanThreads } from "../config/load.mts";
+import { type SeenMarker } from "../state/seen-comments.mts";
+import type { RawSummaryPr } from "./poll-summary-raw.mts";
+type RawComment = RawSummaryPr["comments"]["nodes"][number];
+type RawThread = RawSummaryPr["reviewThreads"]["nodes"][number];
+/**
+ * Count PR comments the full check would route to work, through the same classifier it uses: a new
+ * comment, plus any seen comment eligible for minimization under `iterate.minimize-comments`.
+ */
+export declare function countCommentWork(eligible: RawComment[], unconfirmed: ReadonlySet<string>, seen: Map<string, SeenMarker>, minimizeComments: MinimizeCommentsPolicy | undefined, bots: NormalizedBotUsernames): number;
+export interface SummaryThreadView {
+    thread: RawThread;
+    root: RawThread["comments"]["nodes"][number] | undefined;
+    truncated: boolean;
+    transcript: string;
+}
+/**
+ * Unresolved thread ids that keep returning every tick once seen. This is the full check's
+ * `classifyThreadVisibility` repeat rule, including `iterate.resolve-other-human-threads`,
+ * shared rather than re-derived.
+ */
+export declare function repeatingThreadIds(views: SummaryThreadView[], seen: Map<string, SeenMarker>, bots: NormalizedBotUsernames, policy: ResolveOtherHumanThreads): Set<string>;
+export {};

package/bin/github/poll-summary-review-parity.mjs

@@ -0,0 +1,82 @@
+import { buildThreadMutationRouting, threadHasAuthorizedMutation, } from "../commands/iterate/thread-mutation-routing.mjs";
+import { normalizeAuthorType } from "../comments/authors.mjs";
+import { threadEndedByShepherd } from "../comments/marker.mjs";
+import { unresolvedThreadRepeats } from "../comments/thread-visibility.mjs";
+import { classifyVisibleComments } from "../comments/visible-comments.mjs";
+import { mutationWasDenied } from "../state/seen-comments.mjs";
+const asPrComment = (c) => ({
+    id: c.id,
+    isMinimized: c.isMinimized === true,
+    ...(c.viewerCanMinimize !== undefined && { viewerCanMinimize: c.viewerCanMinimize }),
+    author: c.author?.login ?? "unknown",
+    authorType: normalizeAuthorType(c.author?.__typename, c.author?.login),
+    body: c.body,
+    url: c.url ?? "",
+    createdAtUnix: 0,
+});
+/**
+ * Count PR comments the full check would route to work, through the same classifier it uses: a new
+ * comment, plus any seen comment eligible for minimization under `iterate.minimize-comments`.
+ */
+export function countCommentWork(eligible, unconfirmed, seen, minimizeComments, bots) {
+    const denied = new Set(eligible.filter((c) => mutationWasDenied(c.id, c.body, seen)).map((c) => c.id));
+    const work = new Set(classifyVisibleComments(eligible.map(asPrComment), seen, minimizeComments, bots, denied).actionable.map((c) => c.id));
+    // An edited PR comment is shown once by iterate but never blocks readiness.
+    return eligible.filter((c) => work.has(c.id) || unconfirmed.has(c.id)).length;
+}
+const asReviewThread = ({ thread, root, truncated }) => {
+    const author = root?.author?.login ?? "unknown";
+    const authorType = normalizeAuthorType(root?.author?.__typename, root?.author?.login);
+    return {
+        id: thread.id,
+        ...(thread.isResolved !== undefined && { isResolved: thread.isResolved }),
+        ...(thread.isOutdated !== undefined && { isOutdated: thread.isOutdated }),
+        isMinimized: root?.isMinimized === true,
+        ...(thread.viewerCanReply !== undefined && { viewerCanReply: thread.viewerCanReply }),
+        ...(thread.viewerCanResolve !== undefined && { viewerCanResolve: thread.viewerCanResolve }),
+        path: thread.path,
+        line: null,
+        startLine: null,
+        author,
+        authorType,
+        ...(root?.viewerDidAuthor === true && { viewerDidAuthor: true }),
+        body: root?.body ?? "",
+        url: "",
+        // A window never shows a truncated thread's last comment, so it cannot prove the thread ended.
+        comments: truncated
+            ? []
+            : thread.comments.nodes.map((c) => ({
+                id: c.id,
+                author: c.author?.login ?? "unknown",
+                authorType: normalizeAuthorType(c.author?.__typename, c.author?.login),
+                body: c.body,
+                url: "",
+                createdAtUnix: 0,
+            })),
+    };
+};
+/**
+ * Unresolved thread ids that keep returning every tick once seen. This is the full check's
+ * `classifyThreadVisibility` repeat rule, including `iterate.resolve-other-human-threads`,
+ * shared rather than re-derived.
+ */
+export function repeatingThreadIds(views, seen, bots, policy) {
+    const threads = views.map((view) => asReviewThread(view));
+    const routing = buildThreadMutationRouting(threads, bots, [], policy);
+    const replyIds = new Set(routing.replyThreadIds);
+    const resolveIds = new Set(routing.resolveThreadIds);
+    const repeating = new Set();
+    views.forEach((view, index) => {
+        const thread = threads[index];
+        if (thread.isResolved !== false || thread.isOutdated === undefined)
+            return;
+        if (mutationWasDenied(thread.id, view.transcript, seen))
+            return;
+        if (!threadHasAuthorizedMutation(thread, replyIds, resolveIds))
+            return;
+        const ended = !view.truncated && threadEndedByShepherd(thread);
+        if (unresolvedThreadRepeats(thread, ended, bots, policy))
+            repeating.add(thread.id);
+    });
+    return repeating;
+}

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

@@ -1,4 +1,13 @@
 import { type SeenMarker } from "../state/seen-comments.mts";
-import type { PollSummaryReview } from "../types.mts";
+import type { PollSummaryReview, PollSummaryRuleAutoResolve } from "../types.mts";
 import type { RawSummaryPr } from "./poll-summary-raw.mts";
-export declare function summarizePollSummaryReview(raw: RawSummaryPr, seen: Map<string, SeenMarker>, viewerCanAdminister: boolean | undefined): Promise<PollSummaryReview>;
+import { type SummaryStateKey } from "./poll-summary-rule-auto-resolve.mts";
+/**
+ * Count the review work a compact row routes to the full check. With `autoResolveKey` and
+ * `actions.auto-minimize-suppressed` on, rule-driven auto-resolve runs first, exactly as in the
+ * one-PR path, so a handled bot notice never sends the row to triage.
+ */
+export declare function evaluatePollSummaryReview(raw: RawSummaryPr, seen: Map<string, SeenMarker>, viewerCanAdminister: boolean | undefined, autoResolveKey?: SummaryStateKey): Promise<{
+    review: PollSummaryReview;
+    ruleAutoResolve?: PollSummaryRuleAutoResolve;
+}>;