pr-shepherd 1.0.0 → 1.1.1

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-route.mjs

@@ -1,4 +1,5 @@
 import { loadConfig } from "../config/load.mjs";
+import { hasNoRelevantChecks } from "./poll-summary-unreported.mjs";
 import { isKnownMergeStateStatus, transportReadinessGaps } from "./transport-evidence.mjs";
 import { canGenerateGithubMutation } from "./mutation-policy.mjs";
 import { getGithubTransport, isCcrTransport } from "./transport.mjs";
@@ -25,6 +26,7 @@ export function routePollSummary(raw, checks, review, opts) {
         return { action: "triage", reasons: ["unreported-required-checks"] };
     }
     if ((checks.inProgress ?? 0) > 0 ||
+        (checks.actionsWorkflowInProgress === true && hasNoRelevantChecks(checks)) ||
         !isKnownMergeStateStatus(raw.mergeStateStatus) ||
         raw.mergeable === "UNKNOWN" ||
         raw.mergeStateStatus === "UNKNOWN")

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[]>;

package/bin/github/poll-summary-row-error.mjs

@@ -0,0 +1,74 @@
+import { GitHubRequestError } from "./errors.mjs";
+import { hydratePollSummaryChecks } from "./poll-summary-check-hydration.mjs";
+import { refreshUnknownSummaryMergeability } from "./poll-summary-mergeability.mjs";
+import { pollCommandFields } from "./poll-summary-command.mjs";
+import { normalizePollSummaryState } from "./poll-summary-route.mjs";
+import { rateLimitKind } from "./rate-limit-kind.mjs";
+import { isGithubReadFallbackError } from "./transport.mjs";
+import { formatPrUrl } from "../pr-reference.mjs";
+/**
+ * Whether one PR's failed read becomes a row. Throttles, credential failures, and
+ * errors that switch transport describe the whole tick, so they still reject it.
+ */
+function isIsolatableRowError(error) {
+    if (isGithubReadFallbackError(error))
+        return false;
+    if (!(error instanceof GitHubRequestError))
+        return true;
+    return error.status !== 401 && rateLimitKind(error) === null;
+}
+/** Hydrate each PR's checks and mergeability; one PR's unreadable checks must not fail its siblings. */
+export async function hydrateRowsIsolated(raws, repo) {
+    const failures = new Map();
+    for (const raw of raws) {
+        try {
+            await hydratePollSummaryChecks(raw, repo);
+            await refreshUnknownSummaryMergeability(raw, repo);
+        }
+        catch (error) {
+            if (!isIsolatableRowError(error))
+                throw error;
+            failures.set(raw.number, error);
+        }
+    }
+    return failures;
+}
+/** A non-terminal row whose `pollCommand` runs the authoritative one-PR session. */
+function readFailureRow(raw, repo, opts, error) {
+    const repoName = `${repo.owner}/${repo.name}`;
+    return {
+        pr: raw.number,
+        repo: repoName,
+        ...(raw.transport && { transport: raw.transport }),
+        title: raw.title,
+        url: raw.url || formatPrUrl(repoName, raw.number),
+        action: "triage",
+        reasons: ["summary-read-failed"],
+        error: error instanceof Error ? error.message : String(error),
+        state: normalizePollSummaryState(raw.state),
+        mergeable: raw.mergeable,
+        mergeStateStatus: raw.mergeStateStatus,
+        headRefName: raw.headRefName,
+        headRefOid: raw.headRefOid,
+        baseRefName: raw.baseRefName,
+        ...(raw.isDraft && { isDraft: true }),
+        ...pollCommandFields(repoName, raw.number, raw.isDraft, opts),
+    };
+}
+/**
+ * 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 async function summarizeRowsIsolated(raws, failures, repo, opts, summarize) {
+    const settled = await Promise.allSettled(raws.map((raw) => failures.has(raw.number) ? Promise.reject(failures.get(raw.number)) : summarize(raw)));
+    const rejected = settled.filter((entry) => entry.status === "rejected");
+    const fatal = rejected.find((entry) => !isIsolatableRowError(entry.reason));
+    if (fatal)
+        throw fatal.reason;
+    if (rejected.length === settled.length)
+        throw rejected[0].reason;
+    return settled.map((entry, index) => entry.status === "fulfilled"
+        ? entry.value
+        : readFailureRow(raws[index], repo, opts, entry.reason));
+}

package/bin/github/poll-summary-rule-auto-resolve.d.mts

@@ -0,0 +1,32 @@
+import type { ClassifyAction } from "../classify/types.mts";
+import { type SeenMarker } from "../state/seen-comments.mts";
+import type { PollSummaryRuleAutoResolve } from "../types.mts";
+import type { RawSummaryPr } from "./poll-summary-raw.mts";
+export interface SummaryStateKey {
+    owner: string;
+    repo: string;
+    pr: number;
+}
+export interface SummaryRuleActions {
+    comments: ReadonlyMap<string, ClassifyAction>;
+    summaries: ReadonlyMap<string, ClassifyAction>;
+    threads: ReadonlyMap<string, ClassifyAction>;
+}
+export interface SummaryAutoResolve {
+    /** Items whose mutation GitHub confirmed this tick. */
+    confirmed: ReadonlySet<string>;
+    /** Items Shepherd may mutate whose mutation was not confirmed; the full check still has work. */
+    unconfirmed: ReadonlySet<string>;
+    report?: PollSummaryRuleAutoResolve;
+}
+/**
+ * Apply the rule-driven auto-resolve the one-PR check performs: minimize matching PR comments and
+ * COMMENTED review summaries, resolve matching unresolved threads. Capability, denial, and marker
+ * handling mirror `check.mts`; a denied item is left to the normal first-look gate.
+ */
+export declare function applySummaryRuleAutoResolve(input: {
+    raw: RawSummaryPr;
+    actions: SummaryRuleActions;
+    seen: Map<string, SeenMarker>;
+    key: SummaryStateKey;
+}): Promise<SummaryAutoResolve>;

package/bin/github/poll-summary-rule-auto-resolve.mjs

@@ -0,0 +1,119 @@
+import { normalizeAuthorType } from "../comments/authors.mjs";
+import { buildRuleAutoResolveReport } from "../commands/rule-auto-resolve-format.mjs";
+import { applySuppressedRuleAutoResolve } from "../commands/rule-auto-resolve.mjs";
+import { markSeen, mutationWasDenied } from "../state/seen-comments.mjs";
+import { threadTranscriptBodies } from "../threads/transcript.mjs";
+import { canGenerateGithubMutation } from "./mutation-policy.mjs";
+const NONE = { confirmed: new Set(), unconfirmed: new Set() };
+function matchesAutoResolve(action) {
+    return action?.suppress === true && action.autoResolve === true;
+}
+function toReviewThread(thread) {
+    const root = thread.comments.nodes[0];
+    return {
+        id: thread.id,
+        ...(thread.isResolved !== undefined && { isResolved: thread.isResolved }),
+        ...(thread.isOutdated !== undefined && { isOutdated: thread.isOutdated }),
+        ...(thread.viewerCanResolve !== undefined && { viewerCanResolve: thread.viewerCanResolve }),
+        path: thread.path ?? root?.path ?? null,
+        line: thread.line ?? null,
+        startLine: thread.startLine ?? null,
+        author: root?.author?.login ?? "unknown",
+        authorType: normalizeAuthorType(root?.author?.__typename, root?.author?.login),
+        body: root?.body ?? "",
+        url: root?.url ?? "",
+    };
+}
+/** The transcript the full check hashes is complete only when the window holds every comment. */
+function threadDenied(thread, seen) {
+    const transcript = threadTranscriptBodies(thread.comments.nodes.map((comment) => comment.body));
+    return thread.comments.pageInfo.hasPreviousPage
+        ? seen.get(thread.id)?.deniedMutationBodyHash !== undefined
+        : mutationWasDenied(thread.id, transcript, seen);
+}
+/** Patch the read to match GitHub so a stack handoff does not replay the mutation. */
+function patchRaw(raw, confirmed) {
+    for (const comment of [...raw.comments.nodes, ...raw.reviews.nodes])
+        if (confirmed.has(comment.id))
+            comment.isMinimized = true;
+    for (const thread of raw.reviewThreads.nodes)
+        if (confirmed.has(thread.id))
+            thread.isResolved = true;
+}
+/**
+ * Apply the rule-driven auto-resolve the one-PR check performs: minimize matching PR comments and
+ * COMMENTED review summaries, resolve matching unresolved threads. Capability, denial, and marker
+ * handling mirror `check.mts`; a denied item is left to the normal first-look gate.
+ */
+export async function applySummaryRuleAutoResolve(input) {
+    const { raw, actions, seen, key } = input;
+    const comments = raw.comments.nodes.filter((comment) => !comment.isMinimized &&
+        matchesAutoResolve(actions.comments.get(comment.id)) &&
+        !mutationWasDenied(comment.id, comment.body, seen) &&
+        canGenerateGithubMutation(comment.viewerCanMinimize, "minimize"));
+    const summaries = raw.reviews.nodes.filter((review) => !review.isMinimized &&
+        matchesAutoResolve(actions.summaries.get(review.id)) &&
+        !mutationWasDenied(review.id, review.body, seen) &&
+        canGenerateGithubMutation(review.viewerCanMinimize, "minimize"));
+    const threads = raw.reviewThreads.nodes.filter((thread) => thread.isResolved === false &&
+        thread.isOutdated !== true &&
+        matchesAutoResolve(actions.threads.get(thread.id)) &&
+        !threadDenied(thread, seen) &&
+        canGenerateGithubMutation(thread.viewerCanResolve, "resolve"));
+    if (comments.length + summaries.length + threads.length === 0)
+        return NONE;
+    // The full check marks every non-denied suppressed item before it mutates, whatever the outcome.
+    await Promise.allSettled([
+        ...[...comments, ...summaries].map((item) => markSeen(key, item.id, item.body)),
+        ...threads
+            .filter((thread) => !thread.comments.pageInfo.hasPreviousPage)
+            .map((thread) => markSeen(key, thread.id, threadTranscriptBodies(thread.comments.nodes.map((comment) => comment.body)))),
+    ]);
+    const reviewThreads = threads.map(toReviewThread);
+    const reasonOf = (id, map) => {
+        const reason = map.get(id)?.reason;
+        return [id, reason ? [reason] : []];
+    };
+    const ruleReasons = new Map([
+        ...comments.map((item) => reasonOf(item.id, actions.comments)),
+        ...summaries.map((item) => reasonOf(item.id, actions.summaries)),
+        ...threads.map((item) => reasonOf(item.id, actions.threads)),
+    ]);
+    const partition = {
+        suppressedCommentIds: new Set(comments.map((item) => item.id)),
+        suppressedThreadIds: new Set(threads.map((item) => item.id)),
+        suppressedReviewSummaryIds: new Set(summaries.map((item) => item.id)),
+        suppressedChangesRequestedIds: new Set(),
+        ruleAutoResolveCommentIds: comments.map((item) => item.id),
+        ruleAutoResolveThreadIds: threads.map((item) => item.id),
+        ruleAutoResolveReviewSummaryIds: summaries.map((item) => item.id),
+        ruleReasons,
+    };
+    const applied = await applySuppressedRuleAutoResolve({
+        enabled: true,
+        partition,
+        batch: { comments, reviewSummaries: summaries, reviewThreads },
+    });
+    const confirmed = new Set([
+        ...applied.autoMinimized.map((item) => item.id),
+        ...applied.autoResolved.map((thread) => thread.id),
+    ]);
+    patchRaw(raw, confirmed);
+    const full = buildRuleAutoResolveReport({
+        threads: applied.autoResolved,
+        minimized: applied.autoMinimized,
+        errors: applied.autoResolveErrors,
+        errorReasons: applied.errorReasons,
+    });
+    const report = full && {
+        ...full,
+        ...(full.threads && {
+            threads: full.threads.map((thread) => ({
+                id: thread.id,
+                ...(thread.url && { url: thread.url }),
+            })),
+        }),
+    };
+    const unconfirmed = [...ruleReasons.keys()].filter((id) => !confirmed.has(id));
+    return { confirmed, unconfirmed: new Set(unconfirmed), ...(report && { report }) };
+}

package/bin/github/poll-summary-rule-handoff.d.mts

@@ -0,0 +1,7 @@
+import type { PollSummaryItem } from "../types.mts";
+import type { RawSummaryPr } from "./poll-summary-raw.mts";
+/**
+ * A stack handoff clones the read before rows are evaluated. Reflect the rule-driven mutations the
+ * rows confirmed so the one-PR session that consumes the handoff does not repeat them.
+ */
+export declare function patchHandoffLayers(layers: RawSummaryPr[], items: PollSummaryItem[]): void;

package/bin/github/poll-summary-rule-handoff.mjs

@@ -0,0 +1,20 @@
+/**
+ * A stack handoff clones the read before rows are evaluated. Reflect the rule-driven mutations the
+ * rows confirmed so the one-PR session that consumes the handoff does not repeat them.
+ */
+export function patchHandoffLayers(layers, items) {
+    for (const item of items) {
+        const report = item.ruleAutoResolve;
+        const layer = layers.find((candidate) => candidate.number === item.pr);
+        if (!report || !layer)
+            continue;
+        const minimized = new Set(report.minimized?.map((entry) => entry.id));
+        const resolved = new Set(report.threads?.map((thread) => thread.id));
+        for (const node of [...layer.comments.nodes, ...layer.reviews.nodes])
+            if (minimized.has(node.id))
+                node.isMinimized = true;
+        for (const thread of layer.reviewThreads.nodes)
+            if (resolved.has(thread.id))
+                thread.isResolved = true;
+    }
+}

package/bin/github/poll-summary-rule-items.d.mts

@@ -0,0 +1,20 @@
+import { applyRules } from "../classify/apply.mts";
+import type { ClassifyAction, ClassifyItem } from "../classify/types.mts";
+import type { RawAuthor } from "./poll-summary-raw.mts";
+type Rules = Parameters<typeof applyRules>[0];
+export interface RuleSource {
+    id: string;
+    body: string;
+    author: RawAuthor | null;
+    authorAssociation?: string;
+    url?: string;
+    path?: string | null;
+}
+/** The rule action for one compact item, built like the full check builds its rule items. */
+export declare function summaryRuleAction(rules: Rules, kind: ClassifyItem["kind"], raw: RuleSource | undefined, id?: string, path?: string | null, body?: string): ClassifyAction;
+/**
+ * An auto-resolve match is hidden only once its mutation is confirmed or the item is already
+ * resolved; until then it stays visible so the full check can run or surface it.
+ */
+export declare function ruleHides(action: ClassifyAction, kind: ClassifyItem["kind"], autoResolveSatisfied: boolean): boolean;
+export {};

package/bin/github/poll-summary-rule-items.mjs

@@ -0,0 +1,28 @@
+import { applyRules } from "../classify/apply.mjs";
+import { normalizeAuthorType } from "../comments/authors.mjs";
+/** The rule action for one compact item, built like the full check builds its rule items. */
+export function summaryRuleAction(rules, kind, raw, id = raw?.id ?? "unknown", path, body = raw?.body ?? "") {
+    const item = {
+        kind,
+        id,
+        author: raw?.author?.login ?? "unknown",
+        authorType: normalizeAuthorType(raw?.author?.__typename, raw?.author?.login),
+        ...(raw?.authorAssociation !== undefined && { authorAssociation: raw.authorAssociation }),
+        body,
+        // A changes-requested rule item carries no URL, as in the full check.
+        ...(kind === "review-thread" ? { url: raw?.url ?? "" } : {}),
+        ...(kind !== "review-thread" && kind !== "changes-requested" && raw?.url
+            ? { url: raw.url }
+            : {}),
+        ...(kind === "review-thread" && { path }),
+    };
+    return applyRules(rules, item);
+}
+/**
+ * An auto-resolve match is hidden only once its mutation is confirmed or the item is already
+ * resolved; until then it stays visible so the full check can run or surface it.
+ */
+export function ruleHides(action, kind, autoResolveSatisfied) {
+    return (action.suppress === true &&
+        (action.autoResolve !== true || kind === "changes-requested" || autoResolveSatisfied));
+}

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

@@ -7,3 +7,10 @@ export declare function trunkRequiredContexts(ordered: readonly RawSummaryPr[],
 export declare function summaryRequiredContexts(raw: RawSummaryPr, mergeTargetContexts: readonly string[] | undefined): string[];
 /** Record missing required contexts. A running Actions workflow does not clear the names. */
 export declare function applyUnreportedRequiredChecks(raw: RawSummaryPr, checks: PollSummaryChecks, required: readonly string[]): void;
+/** No relevant check yet. A skipped, filtered, ignored or superseded check is not relevant. */
+export declare function hasNoRelevantChecks(checks: PollSummaryChecks): boolean;
+/**
+ * Flag a running Actions workflow suite when the head has no relevant check yet. Suites exist
+ * before their check runs, so CLEAN with no checks is not proof that CI passed.
+ */
+export declare function applyPendingWorkflowSuites(raw: RawSummaryPr, checks: PollSummaryChecks): void;

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

@@ -37,6 +37,22 @@ export function applyUnreportedRequiredChecks(raw, checks, required) {
         checks.actionsWorkflowInProgress = true;
     }
 }
+/** No relevant check yet. A skipped, filtered, ignored or superseded check is not relevant. */
+export function hasNoRelevantChecks(checks) {
+    return (checks.passing ?? 0) + (checks.failing ?? 0) + (checks.inProgress ?? 0) === 0;
+}
+/**
+ * Flag a running Actions workflow suite when the head has no relevant check yet. Suites exist
+ * before their check runs, so CLEAN with no checks is not proof that CI passed.
+ */
+export function applyPendingWorkflowSuites(raw, checks) {
+    if (checks.actionsWorkflowInProgress === true || !hasNoRelevantChecks(checks))
+        return;
+    const suites = raw.commits.nodes[0]?.commit.checkSuites?.nodes ?? [];
+    if (actionsWorkflowInProgress(suites, new Set(loadConfig().checks["ci-trigger-events"]))) {
+        checks.actionsWorkflowInProgress = true;
+    }
+}
 function reportedNames(raw) {
     const names = new Set();
     const rollups = [

package/bin/github/poll-summary.mjs

@@ -8,11 +8,13 @@ import { missingRepositoryError } from "./errors.mjs";
 import { hydratePollSummaryChecks } from "./poll-summary-check-hydration.mjs";
 import { refreshUnknownSummaryMergeability } from "./poll-summary-mergeability.mjs";
 import { summarizePollSummaryPr } from "./poll-summary-projector.mjs";
+import { hydrateRowsIsolated, summarizeRowsIsolated, } from "./poll-summary-row-error.mjs";
 import { trunkRequiredContexts } from "./poll-summary-unreported.mjs";
 import { loadStackSizeHint, storeStackSizeHint } from "./stack-size-hint.mjs";
 import { POLL_SUMMARY_FRAGMENT } from "./queries.mjs";
 import { stackAncestryGaps } from "./stack-read.mjs";
 import { readGraphqlStackSummary } from "./poll-summary-stack-page.mjs";
+import { patchHandoffLayers } from "./poll-summary-rule-handoff.mjs";
 import { stackHandoffSource } from "./stack-handoff.mjs";
 const MAX_EXPLICIT_PRS_PER_QUERY = 50;
 async function fetchSelectedPollSummary(opts, repo) {
@@ -23,21 +25,27 @@ async function fetchSelectedPollSummary(opts, repo) {
         throw new ShepherdError("Aggregate poll requires at least two PRs or a stack PR", EXIT.USAGE);
     }
     const raw = [];
+    const failures = new Map();
     let viewerCanAdminister;
     for (let offset = 0; offset < requested.length; offset += MAX_EXPLICIT_PRS_PER_QUERY) {
         const chunk = requested.slice(offset, offset + MAX_EXPLICIT_PRS_PER_QUERY);
         const fetched = await fetchExplicitChunk(chunk, repo);
         viewerCanAdminister = fetched.viewerCanAdminister;
         raw.push(...fetched.prs);
+        for (const [pr, error] of fetched.failures ?? [])
+            failures.set(pr, error);
     }
     return {
         selection: { kind: "prs", requested },
-        prs: await Promise.all(raw.map((pr) => summarizePollSummaryPr(pr, repo, opts, viewerCanAdminister))),
+        // One explicit PR's failed read becomes a row; stack selections stay fail-closed.
+        prs: await summarizeRowsIsolated(raw, failures, repo, opts, (pr) => summarizePollSummaryPr(pr, repo, opts, viewerCanAdminister, undefined, null, true)),
     };
 }
 /** Fresh, read-only snapshot used to bind a one-PR READY receipt to stack routing. */
 export async function fetchRawSummaryPr(pr, repo) {
     const fetched = await fetchExplicitChunk([pr], repo);
+    if (fetched.failures?.has(pr))
+        throw fetched.failures.get(pr);
     return fetched.prs[0];
 }
 async function fetchGraphqlExplicitChunk(prs, repo) {
@@ -60,11 +68,8 @@ async function fetchGraphqlExplicitChunk(prs, repo) {
             throw new ShepherdError(`PR #${pr} not found`, EXIT.UNAVAILABLE);
         return raw;
     });
-    for (const raw of rawPrs) {
-        await hydratePollSummaryChecks(raw, repo);
-        await refreshUnknownSummaryMergeability(raw, repo);
-    }
-    return { prs: rawPrs, viewerCanAdminister: result.data.repository.viewerCanAdminister };
+    const failures = await hydrateRowsIsolated(rawPrs, repo);
+    return { prs: rawPrs, viewerCanAdminister: result.data.repository.viewerCanAdminister, failures };
 }
 async function fetchExplicitChunk(prs, repo) {
     return githubOperation("PollSummary", () => runWithGithubTransport("graphql", () => fetchGraphqlExplicitChunk(prs, repo)), async () => ({
@@ -101,9 +106,12 @@ async function fetchStackSummary(opts, repo) {
     const handoffSource = getGithubTransport() === "rest" ? undefined : stackHandoffSource(read);
     const stackAncestry = stackAncestryGaps(ordered);
     const required = await trunkRequiredContexts(ordered, repo);
+    const prs = await Promise.all(ordered.map((pr) => summarizePollSummaryPr(pr, repo, opts, viewerCanAdminister, required, viewerLogin, true)));
+    if (handoffSource)
+        patchHandoffLayers(handoffSource.layers, prs);
     return {
         selection: { kind: "stack", anchor, stackNumber, stackSize },
-        prs: await Promise.all(ordered.map((pr) => summarizePollSummaryPr(pr, repo, opts, viewerCanAdminister, required, viewerLogin))),
+        prs,
         ...(stackAncestry.length > 0 && { stackAncestry }),
         ...(allowedMergeMethods && { allowedMergeMethods }),
         ...(handoffSource && { handoffSource }),