pr-shepherd 1.0.0 → 1.1.0

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-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-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().iterate["ready-delay-minutes"] * 60;
-        const readyState = await updateReadyDelay(raw.number, appearsReady, readyDelaySeconds, repo.owner, repo.name, { headSha: raw.headRefOid });
+        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()["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-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;
+}>;

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

@@ -1,15 +1,24 @@
-import { normalizeBotUsernames } from "../comments/authors.mjs";
-import { applyRules } from "../classify/apply.mjs";
-import { normalizeAuthorType } from "../comments/authors.mjs";
+import { isConfiguredBotAuthor, isHumanAuthor, normalizeAuthorType, normalizeBotUsernames, } from "../comments/authors.mjs";
 import { loadClassifyRules } from "../classify/loader.mjs";
 import { loadConfig } from "../config/load.mjs";
 import { getEffectiveCwd } from "../execution-context.mjs";
-import { classifyItem } from "../state/seen-comments.mjs";
-import { mutationWasDenied } from "../state/seen-comments.mjs";
-import { canGenerateGithubMutation } from "./mutation-policy.mjs";
+import { classifyItem, mutationWasDenied } from "../state/seen-comments.mjs";
 import { threadEndedByShepherd } from "../comments/marker.mjs";
-const THREAD_COMMENT_SEPARATOR = "\n\n--- thread comment ---\n\n";
-export async function summarizePollSummaryReview(raw, seen, viewerCanAdminister) {
+import { threadTranscriptBodies } from "../threads/transcript.mjs";
+import { canGenerateGithubMutation } from "./mutation-policy.mjs";
+import { applySummaryRuleAutoResolve, } from "./poll-summary-rule-auto-resolve.mjs";
+import { countCommentWork, repeatingThreadIds } from "./poll-summary-review-parity.mjs";
+import { ruleHides, summaryRuleAction } from "./poll-summary-rule-items.mjs";
+const authorOf = (author) => ({
+    login: author?.login ?? "",
+    authorType: normalizeAuthorType(author?.__typename, author?.login),
+});
+/**
+ * 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 async function evaluatePollSummaryReview(raw, seen, viewerCanAdminister, autoResolveKey) {
     const config = loadConfig();
     const bots = normalizeBotUsernames(config["bot-usernames"]);
     const rules = await loadClassifyRules(getEffectiveCwd(), config.standardRules);
@@ -17,18 +26,54 @@ export async function summarizePollSummaryReview(raw, seen, viewerCanAdminister)
     let incomplete = raw.comments.pageInfo.hasPreviousPage ||
         raw.reviews.pageInfo.hasPreviousPage ||
         raw.reviewThreads.pageInfo.hasPreviousPage;
-    for (const comment of raw.comments.nodes) {
-        if (!isSuppressed(rules, "pr-comment", comment, comment.id, undefined, comment.body, comment.isMinimized) &&
-            // An edited PR comment is shown once by iterate but never blocks readiness.
-            classifyItem(comment.id, comment.body, seen) === "new")
-            actionable += 1;
-    }
+    // A pre-minimized comment is a first-look acknowledgement, never readiness work.
+    const actions = {
+        comments: new Map(),
+        summaries: new Map(),
+        threads: new Map(),
+    };
+    for (const comment of raw.comments.nodes)
+        if (!comment.isMinimized)
+            actions.comments.set(comment.id, summaryRuleAction(rules, "pr-comment", comment));
+    for (const review of raw.reviews.nodes)
+        if (review.state === "COMMENTED" && review.body.trim() !== "" && !review.isMinimized)
+            actions.summaries.set(review.id, summaryRuleAction(rules, "review-summary", review));
+    const threadView = raw.reviewThreads.nodes.map((thread) => {
+        const truncated = thread.comments.pageInfo.hasPreviousPage;
+        if (truncated)
+            incomplete = true;
+        const root = thread.comments.nodes[0];
+        const transcript = threadTranscriptBodies(thread.comments.nodes.map((c) => c.body));
+        // The window's last comment is the thread's last only when nothing lies beyond it.
+        const ended = thread.isResolved === true &&
+            !truncated &&
+            threadEndedByShepherd({ body: root?.body ?? "", comments: thread.comments.nodes });
+        if (!ended)
+            actions.threads.set(thread.id, summaryRuleAction(rules, "review-thread", root, thread.id, thread.path ?? root?.path ?? null, root?.body ?? ""));
+        return { thread, truncated, root, transcript, ended };
+    });
+    const handled = autoResolveKey && config.actions["auto-minimize-suppressed"]
+        ? await applySummaryRuleAutoResolve({ raw, actions, seen, key: autoResolveKey })
+        : { confirmed: new Set(), unconfirmed: new Set() };
+    const { confirmed, unconfirmed } = handled;
+    actionable += countCommentWork(raw.comments.nodes.filter((comment) => {
+        const action = actions.comments.get(comment.id);
+        return action !== undefined && !ruleHides(action, "pr-comment", confirmed.has(comment.id));
+    }), unconfirmed, seen, config.iterate["minimize-comments"], bots);
     const latestStateByAuthor = new Map((raw.latestReviews?.nodes ?? []).flatMap((review) => review.author ? [[review.author.login.toLowerCase(), review.state]] : []));
     for (const review of raw.reviews.nodes) {
         if (review.state === "COMMENTED") {
-            if (review.body.trim() !== "" &&
+            const action = actions.summaries.get(review.id);
+            if (!action || ruleHides(action, "review-summary", confirmed.has(review.id)))
+                continue;
+            if (unconfirmed.has(review.id) || classifyItem(review.id, review.body, seen) !== "unchanged")
+                actionable += 1;
+            continue;
+        }
+        // An approval is surfaced once, as work, when iterate.minimize-approvals is on.
+        if (review.state === "APPROVED") {
+            if (config.iterate["minimize-approvals"] &&
                 !review.isMinimized &&
-                !isSuppressed(rules, "review-summary", review) &&
                 classifyItem(review.id, review.body, seen) !== "unchanged")
                 actionable += 1;
             continue;
@@ -38,63 +83,46 @@ export async function summarizePollSummaryReview(raw, seen, viewerCanAdminister)
         const login = review.author?.login.toLowerCase();
         if (login && latestStateByAuthor.get(login) === "APPROVED")
             continue;
-        if (isSuppressed(rules, "changes-requested", review))
+        if (ruleHides(summaryRuleAction(rules, "changes-requested", review), "changes-requested", false))
             continue;
-        const isBot = review.author?.__typename === "Bot" || bots.has(review.author?.login.toLowerCase() ?? "");
-        if ((isBot &&
-            canGenerateGithubMutation(viewerCanAdminister, "dismiss") &&
-            !mutationWasDenied(review.id, review.body, seen)) ||
+        const author = authorOf(review.author);
+        const isBot = !isHumanAuthor(author) || isConfiguredBotAuthor(author, bots);
+        // The full check counts a human changes-requested review whether or not it was seen.
+        if (!isBot ||
+            (canGenerateGithubMutation(viewerCanAdminister, "dismiss") &&
+                !mutationWasDenied(review.id, review.body, seen)) ||
             classifyItem(review.id, review.body, seen) !== "unchanged")
             actionable += 1;
     }
-    for (const thread of raw.reviewThreads.nodes) {
-        // The window holds the first comments. Past it, a new reply leaves the window
-        // unchanged, so a long thread cannot prove it was seen.
-        const truncated = thread.comments.pageInfo.hasPreviousPage;
-        if (truncated)
-            incomplete = true;
-        const root = thread.comments.nodes[0];
-        const transcript = thread.comments.nodes
-            .map((comment) => comment.body)
-            .join(THREAD_COMMENT_SEPARATOR);
-        const completeResolved = thread.isResolved === true && !truncated;
-        if (completeResolved &&
-            threadEndedByShepherd({ body: root?.body ?? "", comments: thread.comments.nodes }))
+    const repeating = repeatingThreadIds(threadView, seen, bots, config.iterate["resolve-other-human-threads"]);
+    for (const { thread, truncated, transcript, ended } of threadView) {
+        const action = actions.threads.get(thread.id);
+        if (ended || !action)
             continue;
-        if (isSuppressed(rules, "review-thread", root, thread.id, thread.path ?? root?.path ?? null, root?.body ?? "", completeResolved))
+        // Rules read the root, so a resolved or outdated thread satisfies its auto-resolve match.
+        const satisfied = confirmed.has(thread.id) || thread.isResolved === true || thread.isOutdated === true;
+        if (ruleHides(action, "review-thread", satisfied))
             continue;
-        const repeatable = !mutationWasDenied(thread.id, transcript, seen) &&
-            (root?.viewerDidAuthor === true ||
-                root?.author?.__typename === "Bot" ||
-                bots.has(root?.author?.login.toLowerCase() ?? ""));
-        const unseen = truncated || classifyItem(thread.id, transcript, seen) !== "unchanged";
-        if ((thread.isResolved === false && (repeatable || unseen)) ||
+        if (unconfirmed.has(thread.id)) {
+            actionable += 1;
+            continue;
+        }
+        // The marker hashes the full transcript, which a window never reproduces. A long resolved
+        // thread is seen once any marker exists; any other long thread cannot prove it was seen.
+        const unseen = truncated
+            ? !(thread.isResolved === true && seen.has(thread.id))
+            : classifyItem(thread.id, transcript, seen) !== "unchanged";
+        if ((thread.isResolved === false && (repeating.has(thread.id) || unseen)) ||
             (thread.isResolved === undefined && unseen) ||
             ((thread.isResolved || thread.isOutdated) && unseen))
             actionable += 1;
     }
-    return {
+    const review = {
         ...(raw.comments.totalCount > 0 && { comments: raw.comments.totalCount }),
         ...(raw.reviews.totalCount > 0 && { reviews: raw.reviews.totalCount }),
         ...(raw.reviewThreads.totalCount > 0 && { threads: raw.reviewThreads.totalCount }),
         ...(actionable > 0 && { actionable }),
         ...(incomplete && { incomplete: true }),
     };
-}
-function isSuppressed(rules, kind, raw, id = raw?.id ?? "unknown", path, body = raw?.body ?? "", autoResolveSatisfied = false) {
-    const item = {
-        kind,
-        id,
-        author: raw?.author?.login ?? "unknown",
-        authorType: normalizeAuthorType(raw?.author?.__typename, raw?.author?.login),
-        ...(raw?.authorAssociation !== undefined && { authorAssociation: raw.authorAssociation }),
-        body,
-        ...(kind === "review-thread" ? { url: raw?.url ?? "" } : raw?.url ? { url: raw.url } : {}),
-        ...(kind === "review-thread" && { path }),
-    };
-    const action = applyRules(rules, item);
-    // An auto-resolve match is hidden only once the full check minimizes or resolves it, or
-    // surfaces a denied mutation once; until then it stays actionable so that check runs.
-    return (action.suppress === true &&
-        (action.autoResolve !== true || kind === "changes-requested" || autoResolveSatisfied));
+    return { review, ...(handled.report && { ruleAutoResolve: handled.report }) };
 }

package/bin/github/poll-summary-row-error.d.mts

@@ -0,0 +1,16 @@
+import type { PollSummaryCommandOptions, PollSummaryItem } from "../types.mts";
+import type { RepoInfo } from "./client.mts";
+import type { RawSummaryPr } from "./poll-summary-raw.mts";
+/** `failures` maps a PR to the isolatable error that stopped its chunk-time hydration. */
+export interface ExplicitChunk {
+    prs: RawSummaryPr[];
+    failures?: Map<number, unknown>;
+}
+/** Hydrate each PR's checks and mergeability; one PR's unreadable checks must not fail its siblings. */
+export declare function hydrateRowsIsolated(raws: RawSummaryPr[], repo: RepoInfo): Promise<Map<number, unknown>>;
+/**
+ * Summarize each PR, turning an isolatable failure into a row. `failures` holds
+ * PRs whose chunk-time hydration already failed. A fatal error, or no readable
+ * row at all, rejects the tick with the first such error.
+ */
+export declare function summarizeRowsIsolated(raws: RawSummaryPr[], failures: Map<number, unknown>, repo: RepoInfo, opts: PollSummaryCommandOptions, summarize: (raw: RawSummaryPr) => Promise<PollSummaryItem>): Promise<PollSummaryItem[]>;