pr-shepherd 0.54.0 → 0.55.0

package/bin/commands/iterate/stack-trunk-conflict.mjs

@@ -0,0 +1,51 @@
+import { graphql } from "../../github/client.mjs";
+import { UPPER_LAYER_CONFLICT_TARGET_QUERY } from "../../github/queries.mjs";
+import { pollRateLimitRetryAfterMs } from "../poll-quota.mjs";
+/** Lowest-position open layer whose base is the stack trunk, if this page contains one. */
+function selectBottomOpenLayer(nodes, trunk) {
+    const onTrunk = nodes.flatMap((node) => {
+        const pull = node?.pullRequest;
+        if (!node || !pull || pull.state !== "OPEN" || pull.baseRefName !== trunk)
+            return [];
+        return [{ position: node.position, number: pull.number }];
+    });
+    onTrunk.sort((a, b) => a.position - b.position);
+    return onTrunk[0]?.number;
+}
+export async function lookupUpperLayerTrunkConflict(input) {
+    let data;
+    try {
+        ({ data } = await graphql(UPPER_LAYER_CONFLICT_TARGET_QUERY, {
+            owner: input.owner,
+            name: input.name,
+            number: input.pr,
+            headRef: input.headRef,
+        }));
+    }
+    catch (err) {
+        if (pollRateLimitRetryAfterMs(err) !== null)
+            throw err;
+        ignore(input.pr, err instanceof Error ? err.message : String(err));
+        return undefined;
+    }
+    const pull = data.repository?.pullRequest;
+    const behindBy = pull?.baseRef?.compare?.behindBy;
+    if (!pull || behindBy == null) {
+        ignore(input.pr, pull ? "base comparison unavailable" : "pull request not found");
+        return undefined;
+    }
+    // behindBy > 0: the layer is still behind its parent. Keep the parent rebase.
+    if (behindBy !== 0)
+        return undefined;
+    const entries = pull.stack?.entries;
+    const bottomPr = entries ? selectBottomOpenLayer(entries.nodes, input.trunk) : undefined;
+    if (bottomPr === undefined) {
+        ignore(input.pr, entries?.pageInfo.hasNextPage
+            ? "stack entry page truncated before the trunk layer"
+            : "bottom open layer not found");
+    }
+    return { trunk: input.trunk, ...(bottomPr !== undefined && { bottomPr }) };
+}
+function ignore(pr, message) {
+    process.stderr.write(`pr-shepherd: upper-layer conflict target unavailable for PR #${pr} (ignored): ${message}\n`);
+}

package/bin/commands/iterate/unreported-required.d.mts

@@ -0,0 +1,18 @@
+import type { IterateResult, IterateResultBase, ShepherdReport } from "../../types.mts";
+interface UnreportedPlan {
+    escalate?: IterateResult;
+    repairInstructions?: string[];
+}
+export declare function planUnreportedRequired(input: {
+    report: ShepherdReport;
+    base: IterateResultBase;
+    stateKey: {
+        owner: string;
+        repo: string;
+        pr: number;
+    };
+    headSha: string;
+    otherAutonomousWork: boolean;
+}): Promise<UnreportedPlan>;
+export declare function buildUnreportedFixResult(base: IterateResultBase, report: ShepherdReport, instructions: string[]): IterateResult;
+export {};

package/bin/commands/iterate/unreported-required.mjs

@@ -0,0 +1,122 @@
+import { buildPrShepherdCommand } from "../../cli/runner.mjs";
+import { formatPrUrl } from "../../pr-reference.mjs";
+import { readCiRetrigger, sameCiRetrigger, writeCiRetrigger } from "../../state/ci-retrigger.mjs";
+import { buildFixCompletionInstruction } from "./check-instructions.mjs";
+import { buildEscalateHumanMessage, buildEscalateSuggestion } from "./escalate.mjs";
+import { buildNativeStackRebaseInstruction } from "./native-stack-rebase.mjs";
+/** Rebase when the trunk or the PR base is behind; otherwise close and reopen once. */
+function decideUnreportedRequired(input) {
+    if (input.behind)
+        return "rebase";
+    if (input.alreadyRetriggered)
+        return input.otherAutonomousWork ? "none" : "escalate";
+    return "reopen";
+}
+function buildUnreportedRequiredInstruction(input) {
+    const listed = input.names.map((name) => `\`${name}\``).join(", ");
+    const observed = input.trunkBehindBy !== undefined && input.trunkBehindBy > 0
+        ? `The stack trunk compare is behind by ${input.trunkBehindBy}.`
+        : input.behind
+            ? "This PR's derived merge status is BEHIND."
+            : "The stack trunk compare is not behind and this PR's derived merge status is not BEHIND.";
+    const update = input.stackRebase
+        ? `${input.stackRebase} Then push the rewritten stack with \`gh stack push\`.`
+        : `Rebase or otherwise update the PR branch from \`${input.baseBranch}\` according to repository conventions, then push.`;
+    return [
+        `Required status checks have no check run and no status context on this head, and no Actions workflow is running: ${listed}.`,
+        observed,
+        `If the stack trunk is behind or this PR is behind its base, update the branch so a pull_request synchronize event runs: ${update}`,
+        `Otherwise retrigger workflows once for this head with \`gh pr close ${input.pr} -R ${input.repo}\` then \`gh pr reopen ${input.pr} -R ${input.repo}\`.`,
+        "Do not close the PR again if those checks are still missing on the next poll.",
+    ].join(" ");
+}
+export async function planUnreportedRequired(input) {
+    const names = input.report.unreportedRequiredChecks ?? [];
+    const actionsRunning = input.report.actionsWorkflowInProgress === true || input.report.checks.inProgress.length > 0;
+    const failing = input.report.checks.failing.length > 0;
+    const conflicts = input.report.mergeStatus.status === "CONFLICTS";
+    const inQueue = input.report.mergeQueue?.inQueue === true;
+    if (names.length === 0 || actionsRunning || failing || conflicts || inQueue)
+        return {};
+    const behind = (input.report.trunkBehindBy ?? 0) > 0 || input.report.mergeStatus.status === "BEHIND";
+    const decision = decideUnreportedRequired({
+        behind,
+        alreadyRetriggered: sameCiRetrigger(await readCiRetrigger(input.stateKey), input.headSha, names),
+        otherAutonomousWork: input.otherAutonomousWork,
+    });
+    if (decision === "none")
+        return {};
+    if (decision === "escalate")
+        return { escalate: escalateUnreported(input.base, input.report, names) };
+    const rebase = stackRebase(input.report);
+    const instruction = buildUnreportedRequiredInstruction({
+        names,
+        repo: input.report.repo,
+        pr: input.report.pr,
+        baseBranch: input.report.baseBranch,
+        behind,
+        ...(input.report.trunkBehindBy !== undefined && { trunkBehindBy: input.report.trunkBehindBy }),
+        ...(rebase && { stackRebase: rebase }),
+    });
+    if (decision === "reopen") {
+        await writeCiRetrigger(input.stateKey, { headSha: input.headSha, contexts: names });
+    }
+    return { repairInstructions: [instruction] };
+}
+export function buildUnreportedFixResult(base, report, instructions) {
+    const prUrl = formatPrUrl(report.repo, report.pr);
+    return {
+        ...base,
+        action: "fix_code",
+        fix: {
+            threads: [],
+            resolutionOnlyThreads: [],
+            actionableComments: [],
+            reviewSummaryIds: [],
+            firstLookSummaries: [],
+            editedSummaries: [],
+            surfacedApprovals: [],
+            checks: [],
+            changesRequestedReviews: [],
+            resolveCommand: {
+                argv: buildPrShepherdCommand(["apply", "review", prUrl]).argv,
+                requiresHeadSha: false,
+                requiresDismissMessage: false,
+                hasMutations: false,
+            },
+            instructions: [...instructions, buildFixCompletionInstruction([])],
+            inProgressRunIds: [],
+            protectedRuns: [],
+            firstLookThreads: [],
+            firstLookComments: [],
+        },
+        cancelled: [],
+    };
+}
+function stackRebase(report) {
+    const stack = report.mergeStatus.mergeRequirements?.stack;
+    if (!stack)
+        return undefined;
+    const start = report.stackBottomPr !== undefined
+        ? { bottomPr: report.stackBottomPr }
+        : { trunk: stack.baseRefName };
+    return buildNativeStackRebaseInstruction(report.repo, stack.number, start);
+}
+function escalateUnreported(base, report, names) {
+    const detail = names.map((name) => `\`${name}\``).join(", ");
+    const escalateBase = {
+        triggers: ["required-checks-unreported"],
+        unresolvedThreads: [],
+        ambiguousComments: [],
+        changesRequestedReviews: [],
+        suggestion: buildEscalateSuggestion(["required-checks-unreported"], detail),
+    };
+    return {
+        ...base,
+        action: "escalate",
+        escalate: {
+            ...escalateBase,
+            humanMessage: buildEscalateHumanMessage(escalateBase, report.pr),
+        },
+    };
+}

package/bin/commands/poll-summary.mjs

@@ -31,6 +31,7 @@ async function runPollSummaryCore(opts) {
         reason: allTerminal ? "all_terminal" : actionable ? "actionable" : "waiting",
         prs: fetched.prs,
         ...(fetched.stackAncestry?.length && { stackAncestry: fetched.stackAncestry }),
+        ...(fetched.allowedMergeMethods && { allowedMergeMethods: fetched.allowedMergeMethods }),
     }, opts.merge === true);
     return applyStackStallGuard(planned, repo, opts.stallTimeoutSeconds ?? loadConfig().iterate.stallTimeoutMinutes * 60);
 }

package/bin/commands/poll.mjs

@@ -6,6 +6,10 @@ import { quotaPollIntervalMs } from "./poll-quota.mjs";
 import { onePrCancelFromPulls, onePrRateLimitTargets } from "./poll-rate-limit-cancel.mjs";
 import { createUntilTerminalRateLimitRetry } from "./poll-rate-limit-wait.mjs";
 import { writeDebounceProgress, writeWaitProgress } from "./poll-progress.mjs";
+function noteRuleAutoResolve(result) {
+    if (result.ruleAutoResolve?.summary)
+        process.stderr.write(`${result.ruleAutoResolve.summary}\n`);
+}
 const DEFAULT_POLL_DEBOUNCE_SECONDS = 60;
 const MAX_TIMER_MS = 2 ** 31 - 1;
 const TIMER_DRIFT_TOLERANCE_MS = 500;
@@ -38,8 +42,7 @@ async function runPollCore(opts) {
         const remainingBefore = untilTerminal
             ? Number.POSITIVE_INFINITY
             : timeoutMs - (Date.now() - start);
-        // Cache only internal continuation ticks. Last bounded tick, FIX_CODE debounce,
-        // and any tick we return to the caller must fetch BatchPr.
+        // Cache only internal continuation ticks; returned ticks must fetch BatchPr.
         const allowCache = debounceUntil === null && remainingBefore + TIMER_DRIFT_TOLERANCE_MS >= intervalMs;
         const iterateTick = (fingerprintCache) => runIterate({
             ...iterateOpts,
@@ -89,6 +92,7 @@ async function runPollCore(opts) {
             if (lastResult.action === "fix_code" && debounceSeconds > 0 && !pastDebounce) {
                 debounceUntil ??= Date.now() + debounceMs;
                 const remainingMs = Math.max(debounceUntil - Date.now(), 0);
+                noteRuleAutoResolve(lastResult);
                 writeDebounceProgress(tick, Date.now() - start, remainingMs);
                 await sleep(Math.min(intervalMs, remainingMs));
                 continue;
@@ -123,6 +127,7 @@ async function runPollCore(opts) {
                 verbose,
                 lastWaitSignature,
             });
+            noteRuleAutoResolve(lastResult);
             await sleep(sleepMs);
             continue;
         }
@@ -139,10 +144,12 @@ async function runPollCore(opts) {
                     break;
                 }
             }
+            noteRuleAutoResolve(lastResult);
             await sleep(sleepMs);
             continue;
         }
         if (lastResult.action === "fix_code" && debounceSeconds > 0 && !pastDebounce) {
+            noteRuleAutoResolve(lastResult);
             debounceUntil ??= Date.now() + debounceMs;
             const remainingMs = debounceUntil - Date.now();
             if (remainingMs > 0) {

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

@@ -10,6 +10,6 @@ export declare function refreshUnknownMergeability(prNumber: number, repo: RepoI
     batchData: BatchPrData;
     didRefresh: boolean;
 }>;
-export declare function refreshReadyMergeability(prNumber: number, repo: RepoInfo, batchData: BatchPrData, verdict: CiVerdict, unresolvedThreads: number, unresolvedComments: number, changesRequestedCount: number): Promise<ReadyMergeabilityRefresh>;
+export declare function refreshReadyMergeability(prNumber: number, repo: RepoInfo, batchData: BatchPrData, verdict: CiVerdict, unresolvedThreads: number, unresolvedComments: number, changesRequestedCount: number, hasUnreportedRequired?: boolean): Promise<ReadyMergeabilityRefresh>;
 export declare function isBlockedByFilteredCheck(mergeStatus: MergeStatusResult, verdict: CiVerdict): boolean;
 export {};

package/bin/commands/ready-mergeability.mjs

@@ -8,10 +8,10 @@ export async function refreshUnknownMergeability(prNumber, repo, batchData) {
     }
     return { batchData: await readMergeability(prNumber, repo, batchData), didRefresh: true };
 }
-export async function refreshReadyMergeability(prNumber, repo, batchData, verdict, unresolvedThreads, unresolvedComments, changesRequestedCount) {
+export async function refreshReadyMergeability(prNumber, repo, batchData, verdict, unresolvedThreads, unresolvedComments, changesRequestedCount, hasUnreportedRequired = false) {
     const refreshedBatchData = await readMergeability(prNumber, repo, batchData);
     const mergeStatus = deriveMergeStatus(refreshedBatchData);
-    const status = computeStatus(verdict, unresolvedThreads, unresolvedComments, mergeStatus, changesRequestedCount);
+    const status = computeStatus(verdict, unresolvedThreads, unresolvedComments, mergeStatus, changesRequestedCount, hasUnreportedRequired);
     return { batchData: refreshedBatchData, mergeStatus, status };
 }
 export function isBlockedByFilteredCheck(mergeStatus, verdict) {

package/bin/commands/rule-auto-resolve-format.d.mts

@@ -0,0 +1,22 @@
+import type { AutoMinimizedItem, AutoResolvedThread, RuleAutoResolveReport, ShepherdReport } from "../types.mts";
+export declare function uniqueReasons(reasons: readonly string[]): string[];
+export declare function reasonClause(reasons: readonly string[]): string | undefined;
+export declare function ruleAutoResolveBody(counts: {
+    threads: number;
+    comments: number;
+    reviewSummaries: number;
+}): string | undefined;
+export declare function formatRuleAutoResolveJournalItem(input: {
+    body: string;
+    reasons: readonly string[];
+    viewerLogin?: string;
+    urls: readonly string[];
+}): string;
+export declare function decorateAutoResolveError(error: string, reasons: readonly string[]): string;
+export declare function reasonsForError(error: string, ids: readonly string[], ruleReasons: ReadonlyMap<string, readonly string[]>): string[];
+export declare function ruleAutoResolveFromReport(report: ShepherdReport): RuleAutoResolveReport | undefined;
+export declare function projectRuleAutoResolve(event: RuleAutoResolveReport): Record<string, unknown>;
+export declare function insertRuleAutoResolveSection(text: string, event: RuleAutoResolveReport | undefined): string;
+export declare function stripReplayedRuleAutoResolve(report: ShepherdReport): ShepherdReport;
+export declare function minimizedItem(kind: AutoMinimizedItem["kind"], id: string, url: string | undefined, reasons: readonly string[]): AutoMinimizedItem;
+export declare function resolvedThread(thread: AutoResolvedThread, reasons: readonly string[]): AutoResolvedThread;

package/bin/commands/rule-auto-resolve-format.mjs

@@ -0,0 +1,151 @@
+export function uniqueReasons(reasons) {
+    const unique = [];
+    for (const reason of reasons) {
+        const cleaned = reason.trim();
+        if (cleaned && !unique.includes(cleaned))
+            unique.push(cleaned);
+    }
+    return unique;
+}
+export function reasonClause(reasons) {
+    const unique = uniqueReasons(reasons);
+    if (unique.length === 0)
+        return undefined;
+    const label = unique.length === 1 ? "rule" : "rules";
+    return `(${label}: ${unique.join("; ")})`;
+}
+function joinedReason(reasons) {
+    const unique = uniqueReasons(reasons);
+    return unique.length > 0 ? unique.join("; ") : undefined;
+}
+function plural(count, singular, pluralForm = `${singular}s`) {
+    return `${count} ${count === 1 ? singular : pluralForm}`;
+}
+export function ruleAutoResolveBody(counts) {
+    const parts = [];
+    if (counts.threads > 0)
+        parts.push(`auto-resolved ${plural(counts.threads, "thread")}`);
+    const minimized = [];
+    if (counts.comments > 0)
+        minimized.push(plural(counts.comments, "comment"));
+    if (counts.reviewSummaries > 0) {
+        minimized.push(plural(counts.reviewSummaries, "review summary", "review summaries"));
+    }
+    if (minimized.length > 0)
+        parts.push(`minimized ${minimized.join(" and ")}`);
+    return parts.length > 0 ? parts.join(", ") : undefined;
+}
+function withReasonClause(body, reasons) {
+    const clause = reasonClause(reasons);
+    return clause ? `${body} ${clause}` : body;
+}
+export function formatRuleAutoResolveJournalItem(input) {
+    const login = input.viewerLogin?.trim();
+    const actor = login ? `as @${login}` : "(token login unavailable)";
+    const clause = reasonClause(input.reasons);
+    const links = input.urls.map((url) => url.trim()).filter(Boolean);
+    const reasonSuffix = clause ? ` ${clause}` : "";
+    const linkSuffix = links.length > 0 ? `: ${links.join(", ")}` : "";
+    return `- ${input.body} ${actor}${reasonSuffix}${linkSuffix}`;
+}
+export function decorateAutoResolveError(error, reasons) {
+    const clause = reasonClause(reasons);
+    return clause ? `${error} ${clause}` : error;
+}
+export function reasonsForError(error, ids, ruleReasons) {
+    const id = ids.find((candidate) => error.startsWith(`${candidate}:`));
+    if (id)
+        return [...(ruleReasons.get(id) ?? [])];
+    if (!error.startsWith("rate limit:"))
+        return [];
+    return uniqueReasons(ids.flatMap((candidate) => [...(ruleReasons.get(candidate) ?? [])]));
+}
+function splitJoined(reason) {
+    if (!reason)
+        return [];
+    return reason.split("; ").filter(Boolean);
+}
+export function ruleAutoResolveFromReport(report) {
+    const threads = report.threads.autoResolved;
+    const minimized = report.comments.autoMinimized ?? [];
+    const errors = report.threads.autoResolveErrors;
+    if (threads.length === 0 && minimized.length === 0 && errors.length === 0)
+        return undefined;
+    const comments = minimized.filter((item) => item.kind === "pr-comment").length;
+    const reviewSummaries = minimized.filter((item) => item.kind === "review-summary").length;
+    const success = threads.length + minimized.length > 0;
+    const reasons = success
+        ? uniqueReasons([
+            ...threads.flatMap((thread) => splitJoined(thread.ruleReason)),
+            ...minimized.flatMap((item) => splitJoined(item.ruleReason)),
+        ])
+        : uniqueReasons(report.threads.autoResolveErrorReasons ?? []);
+    const body = ruleAutoResolveBody({ threads: threads.length, comments, reviewSummaries }) ??
+        `auto-resolve failed for ${plural(errors.length, "mutation")}`;
+    return {
+        summary: withReasonClause(body, reasons),
+        ...(threads.length > 0 && { threads }),
+        ...(minimized.length > 0 && { minimized }),
+        ...(errors.length > 0 && { errors }),
+    };
+}
+function formatRuleAutoResolveSection(event) {
+    if (!event)
+        return null;
+    const lines = ["## Classification auto-resolve", "", event.summary];
+    const links = [
+        ...(event.threads ?? []).map((thread) => thread.url.trim() || `\`${thread.id}\``),
+        ...(event.minimized ?? []).map((item) => item.url?.trim() || `\`${item.id}\``),
+    ];
+    if (links.length > 0)
+        lines.push("", ...links.map((link) => `- ${link}`));
+    if ((event.errors?.length ?? 0) > 0) {
+        lines.push("", ...(event.errors ?? []).map((error) => `- ${error}`));
+    }
+    return lines.join("\n");
+}
+export function projectRuleAutoResolve(event) {
+    return {
+        summary: event.summary,
+        ...((event.threads?.length ?? 0) > 0 && { threads: event.threads }),
+        ...((event.minimized?.length ?? 0) > 0 && { minimized: event.minimized }),
+        ...((event.errors?.length ?? 0) > 0 && { errors: event.errors }),
+    };
+}
+export function insertRuleAutoResolveSection(text, event) {
+    const section = formatRuleAutoResolveSection(event);
+    if (!section)
+        return text;
+    const index = text.lastIndexOf("## Instructions");
+    if (index === -1)
+        return `${text}\n\n${section}`;
+    return `${text.slice(0, index)}${section}\n\n${text.slice(index)}`;
+}
+export function stripReplayedRuleAutoResolve(report) {
+    const hasEvent = report.threads.autoResolved.length > 0 ||
+        report.threads.autoResolveErrors.length > 0 ||
+        (report.threads.autoResolveErrorReasons?.length ?? 0) > 0 ||
+        (report.comments.autoMinimized?.length ?? 0) > 0;
+    if (!hasEvent)
+        return report;
+    const { autoMinimized: _autoMinimized, ...comments } = report.comments;
+    const { autoResolveErrorReasons: _autoResolveErrorReasons, ...threads } = report.threads;
+    return {
+        ...report,
+        threads: { ...threads, autoResolved: [], autoResolveErrors: [] },
+        comments,
+    };
+}
+export function minimizedItem(kind, id, url, reasons) {
+    const ruleReason = joinedReason(reasons);
+    return {
+        id,
+        kind,
+        ...(url?.trim() ? { url: url.trim() } : {}),
+        ...(ruleReason ? { ruleReason } : {}),
+    };
+}
+export function resolvedThread(thread, reasons) {
+    const ruleReason = joinedReason(reasons);
+    return { ...thread, isResolved: true, ...(ruleReason ? { ruleReason } : {}) };
+}

package/bin/commands/rule-auto-resolve.d.mts

@@ -0,0 +1,21 @@
+import type { BatchPartition } from "../classify/apply.mts";
+import type { AutoMinimizedItem, AutoResolvedThread, BatchPrData } from "../types.mts";
+export interface RuleAutoResolveApplied {
+    threadIds: string[];
+    commentIds: string[];
+    reviewSummaryIds: string[];
+    autoResolved: AutoResolvedThread[];
+    autoMinimized: AutoMinimizedItem[];
+    autoResolveErrors: string[];
+    errorReasons: string[];
+}
+export declare function applySuppressedRuleAutoResolve(input: {
+    enabled: boolean;
+    partition: BatchPartition;
+    batch: BatchPrData;
+    prNumber: number;
+    repo: {
+        owner: string;
+        name: string;
+    };
+}): Promise<RuleAutoResolveApplied>;

package/bin/commands/rule-auto-resolve.mjs

@@ -0,0 +1,113 @@
+import { autoMinimizeComments, autoResolveThreads } from "../comments/resolve.mjs";
+import { runJournal } from "./journal/index.mjs";
+import { decorateAutoResolveError, formatRuleAutoResolveJournalItem, minimizedItem, reasonClause, reasonsForError, resolvedThread, ruleAutoResolveBody, uniqueReasons, } from "./rule-auto-resolve-format.mjs";
+const EMPTY = {
+    threadIds: [],
+    commentIds: [],
+    reviewSummaryIds: [],
+    autoResolved: [],
+    autoMinimized: [],
+    autoResolveErrors: [],
+    errorReasons: [],
+};
+function idsIn(ids, confirmed) {
+    return ids.filter((id) => confirmed.has(id));
+}
+function decorateErrors(errors, ids, ruleReasons) {
+    return errors.map((error) => decorateAutoResolveError(error, reasonsForError(error, ids, ruleReasons)));
+}
+function successReasons(ids, ruleReasons) {
+    return uniqueReasons(ids.flatMap((id) => [...(ruleReasons.get(id) ?? [])]));
+}
+export async function applySuppressedRuleAutoResolve(input) {
+    if (!input.enabled) {
+        return {
+            ...EMPTY,
+            threadIds: input.partition.ruleAutoResolveThreadIds,
+            commentIds: input.partition.ruleAutoResolveCommentIds,
+            reviewSummaryIds: input.partition.ruleAutoResolveReviewSummaryIds,
+        };
+    }
+    const commentIds = input.partition.ruleAutoResolveCommentIds.filter((id) => input.partition.suppressedCommentIds.has(id));
+    const reviewSummaryIds = input.partition.ruleAutoResolveReviewSummaryIds.filter((id) => input.partition.suppressedReviewSummaryIds.has(id));
+    const threadIds = input.partition.ruleAutoResolveThreadIds.filter((id) => input.partition.suppressedThreadIds.has(id));
+    const minimizeIds = [...commentIds, ...reviewSummaryIds];
+    const [minimized, resolved] = await Promise.all([
+        minimizeIds.length > 0
+            ? autoMinimizeComments(minimizeIds)
+            : Promise.resolve({ minimized: [], errors: [] }),
+        threadIds.length > 0
+            ? autoResolveThreads(threadIds)
+            : Promise.resolve({ resolved: [], errors: [] }),
+    ]);
+    const minimizedSet = new Set(minimized.minimized);
+    const resolvedSet = new Set(resolved.resolved);
+    const resolvedIds = idsIn(threadIds, resolvedSet);
+    const minimizedCommentIds = idsIn(commentIds, minimizedSet);
+    const minimizedSummaryIds = idsIn(reviewSummaryIds, minimizedSet);
+    const threadsById = new Map(input.batch.reviewThreads.map((thread) => [thread.id, thread]));
+    const commentsById = new Map(input.batch.comments.map((comment) => [comment.id, comment]));
+    const summariesById = new Map(input.batch.reviewSummaries.map((review) => [review.id, review]));
+    const autoResolved = resolvedIds.flatMap((id) => {
+        const thread = threadsById.get(id);
+        return thread ? [resolvedThread(thread, input.partition.ruleReasons.get(id) ?? [])] : [];
+    });
+    const autoMinimized = [
+        ...minimizedCommentIds.map((id) => minimizedItem("pr-comment", id, commentsById.get(id)?.url, input.partition.ruleReasons.get(id) ?? [])),
+        ...minimizedSummaryIds.map((id) => minimizedItem("review-summary", id, summariesById.get(id)?.url, input.partition.ruleReasons.get(id) ?? [])),
+    ];
+    const autoResolveErrors = [
+        ...decorateErrors(minimized.errors, minimizeIds, input.partition.ruleReasons),
+        ...decorateErrors(resolved.errors, threadIds, input.partition.ruleReasons),
+    ];
+    const errorReasons = uniqueReasons([
+        ...minimized.errors.flatMap((error) => reasonsForError(error, minimizeIds, input.partition.ruleReasons)),
+        ...resolved.errors.flatMap((error) => reasonsForError(error, threadIds, input.partition.ruleReasons)),
+    ]);
+    const journalError = await journalSuccesses(input, autoResolved, autoMinimized);
+    if (journalError)
+        autoResolveErrors.push(journalError);
+    return {
+        threadIds: input.partition.ruleAutoResolveThreadIds.filter((id) => !resolvedSet.has(id)),
+        commentIds: input.partition.ruleAutoResolveCommentIds.filter((id) => !minimizedSet.has(id)),
+        reviewSummaryIds: input.partition.ruleAutoResolveReviewSummaryIds.filter((id) => !minimizedSet.has(id)),
+        autoResolved,
+        autoMinimized,
+        autoResolveErrors,
+        errorReasons,
+    };
+}
+async function journalSuccesses(input, autoResolved, autoMinimized) {
+    const body = ruleAutoResolveBody({
+        threads: autoResolved.length,
+        comments: autoMinimized.filter((item) => item.kind === "pr-comment").length,
+        reviewSummaries: autoMinimized.filter((item) => item.kind === "review-summary").length,
+    });
+    if (!body)
+        return undefined;
+    const ids = [...autoResolved.map((thread) => thread.id), ...autoMinimized.map((item) => item.id)];
+    const reasons = successReasons(ids, input.partition.ruleReasons);
+    const item = formatRuleAutoResolveJournalItem({
+        body,
+        reasons,
+        ...(input.batch.viewerLogin ? { viewerLogin: input.batch.viewerLogin } : {}),
+        urls: [
+            ...autoResolved.map((thread) => thread.url),
+            ...autoMinimized.map((item) => item.url ?? ""),
+        ],
+    });
+    try {
+        await runJournal({
+            prNumber: input.prNumber,
+            targetRepository: { owner: input.repo.owner, name: input.repo.name },
+            rawItem: item,
+            dryRun: false,
+        });
+        return undefined;
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        const clause = reasonClause(reasons);
+        return clause ? `journal: ${message} ${clause}` : `journal: ${message}`;
+    }
+}

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

@@ -7,11 +7,6 @@ export interface StackPlan {
     idle?: PollSummaryItem[];
     instructions: string[];
 }
-/**
- * Merge the ready prefix by its highest PR number. `gh stack merge <n>` tries a
- * stack number first, but stack numbers come from the repository's issue and
- * pull request sequence, so a PR number never names a stack.
- */
 export declare function planPrefixDrain(result: PollSummaryResult, mergeRequested: boolean): StackPlan | undefined;
 /**
  * A merge-requested, fully ready stack whose bottom open layer still targets