pr-shepherd 0.21.0 → 0.23.0

package/bin/commands/iterate/escalate.mjs

@@ -52,11 +52,25 @@ export function buildEscalateHumanMessage(escalate, pr) {
     lines.push(escalate.suggestion);
     const hasItems = escalate.unresolvedThreads.length > 0 ||
         escalate.changesRequestedReviews.length > 0 ||
-        escalate.ambiguousComments.length > 0;
+        escalate.ambiguousComments.length > 0 ||
+        (escalate.stalledChecks?.length ?? 0) > 0;
     if (hasItems) {
         lines.push("");
         lines.push("## Items needing attention");
         lines.push("");
+        for (const c of escalate.stalledChecks ?? []) {
+            const target = c.runId
+                ? `run \`${c.runId}\``
+                : c.detailsUrl
+                    ? `external \`${c.detailsUrl}\``
+                    : "no run ID";
+            const ageMinutes = Math.floor(c.ageSeconds / 60);
+            lines.push(`- check \`${c.name}\` — ${c.status} ${c.source}, ${target}, waiting ${ageMinutes} minute${ageMinutes === 1 ? "" : "s"}`);
+            if (c.summary)
+                lines.push(`  > ${c.summary}`);
+        }
+        if ((escalate.stalledChecks?.length ?? 0) > 0)
+            lines.push("");
         for (const t of escalate.unresolvedThreads) {
             const loc = t.path ? `\`${t.path}:${t.line ?? "?"}\`` : "(no location)";
             lines.push(`- thread \`${t.id}\` — ${loc} (@${t.author}):`);
@@ -96,7 +110,7 @@ export function buildEscalateHumanMessage(escalate, pr) {
 }
 export function buildEscalateSuggestion(triggers, detail) {
     if (triggers.includes("stall-timeout")) {
-        const mins = detail ?? "30";
+        const mins = detail ?? "60";
         return `No progress detected for ${mins} minute${parseInt(mins, 10) === 1 ? "" : "s"} — state has not changed. This is a manual checkpoint: inspect the PR and apply a manual fix before resuming.`;
     }
     if (triggers.includes("base-branch-unknown")) {

package/bin/commands/iterate/fix-code.mjs

@@ -1,23 +1,35 @@
 /* eslint-disable max-lines */
-import { readFixAttempts, writeFixAttempts } from "../../state/fix-attempts.mjs";
+import { readFixAttempts, writeFixAttempts, } from "../../state/fix-attempts.mjs";
 import { toAgentThread, toAgentComment, toAgentChecks } from "../../reporters/agent.mjs";
+import { hashBody, markSeen } from "../../state/seen-comments.mjs";
 import { checkEscalateTriggers, validateBaseBranch, buildEscalateSuggestion, buildEscalateHumanMessage, } from "./escalate.mjs";
 import { buildResolveCommand } from "./classify.mjs";
 import { buildFixInstructions } from "./render.mjs";
 import { applyStallGuard } from "./stall.mjs";
 import { tryCancelRun, buildInProgressRunIds } from "./helpers.mjs";
+import { annotationMarkerBody } from "../check-annotations.mjs";
+import { threadTranscriptBody } from "../../threads/transcript.mjs";
+function nextFixAttempts(stored, headSha, threads) {
+    const threadAttempts = stored ? { ...stored.threadAttempts } : {};
+    const threadBodyHashes = stored?.threadBodyHashes
+        ? { ...stored.threadBodyHashes }
+        : {};
+    for (const t of threads) {
+        const bodyHash = hashBody(threadTranscriptBody(t));
+        const previousHash = threadBodyHashes[t.id];
+        if (stored?.headSha === headSha && (previousHash === undefined || previousHash === bodyHash))
+            continue;
+        threadAttempts[t.id] = previousHash === bodyHash ? (threadAttempts[t.id] ?? 0) + 1 : 1;
+        threadBodyHashes[t.id] = bodyHash;
+    }
+    return { threadAttempts, threadBodyHashes };
+}
 export async function handleFixCode(ctx) {
     const { base, report, opts, headSha, stallKey, prNumber, stallTimeoutSeconds, repoOwner, repoName, reviewSummaryIds, firstLookSummaries, editedSummaries, surfacedApprovals, } = ctx;
     const failingChecks = report.checks.failing;
     const stored = await readFixAttempts({ owner: repoOwner, repo: repoName, pr: prNumber });
-    const isNewSha = stored?.headSha !== headSha;
-    const currentAttempts = stored ? { ...stored.threadAttempts } : {};
-    if (isNewSha) {
-        for (const t of report.threads.actionable) {
-            currentAttempts[t.id] = (currentAttempts[t.id] ?? 0) + 1;
-        }
-    }
-    const escalateTriggers = checkEscalateTriggers(report.threads.actionable, currentAttempts);
+    const { threadAttempts, threadBodyHashes } = nextFixAttempts(stored, headSha, report.threads.actionable);
+    const escalateTriggers = checkEscalateTriggers(report.threads.actionable, threadAttempts);
     if (escalateTriggers.triggers.length > 0) {
         const escalateBase = {
             triggers: escalateTriggers.triggers,
@@ -36,7 +48,7 @@ export async function handleFixCode(ctx) {
             },
         };
     }
-    await writeFixAttempts({ owner: repoOwner, repo: repoName, pr: prNumber }, { headSha, threadAttempts: currentAttempts });
+    await writeFixAttempts({ owner: repoOwner, repo: repoName, pr: prNumber }, { headSha, threadAttempts, threadBodyHashes });
     let cancelled = [];
     if (!opts.noAutoCancelActionable) {
         const uniqueRunIds = [
@@ -65,12 +77,6 @@ export async function handleFixCode(ctx) {
     const commentMinimizeIds = report.comments.minimizeIds ?? actionableComments.map((c) => c.id);
     const allCommentIds = [...commentMinimizeIds, ...reviewSummaryIds];
     const resolveCommand = buildResolveCommand(threads, resolutionOnlyThreads, allCommentIds, changesRequestedReviews, checks, prNumber);
-    const overlappingReviewIds = resolveCommand.droppedDismissReviewIds ?? [];
-    if (overlappingReviewIds.length > 0) {
-        process.stderr.write(`pr-shepherd: resolve command overlap: ${overlappingReviewIds.length} ` +
-            `review IDs were also in minimize/comment IDs and were dropped from --dismiss-review-ids: ` +
-            `${overlappingReviewIds.join(", ")}\n`);
-    }
     // Safety: if the base branch is unknown, escalate when a push is plausible — the agent
     // would need the correct base to rebase safely. This is a conservative guard, not a
     // prediction that the agent *will* push. Intentionally broader than `pushLikely` above:
@@ -101,7 +107,7 @@ export async function handleFixCode(ctx) {
     const firstLookThreads = report.threads.firstLook;
     const firstLookComments = report.comments.firstLook;
     const instructions = buildFixInstructions(threads, actionableComments, checks, changesRequestedReviews, baseLookup.branch, resolveCommand, hasConflicts, prNumber, cancelled.length, firstLookThreads, firstLookComments, firstLookSummaries, editedSummaries, inProgressRunIds, resolutionOnlyThreads);
-    return applyStallGuard(stallKey, stallTimeoutSeconds, headSha, base, prNumber, {
+    const prospectiveResult = {
         ...base,
         baseBranch: baseLookup.branch,
         action: "fix_code",
@@ -122,5 +128,10 @@ export async function handleFixCode(ctx) {
             inProgressRunIds,
         },
         cancelled,
-    }, report, reviewSummaryIds);
+    };
+    const result = await applyStallGuard(stallKey, stallTimeoutSeconds, headSha, base, prNumber, prospectiveResult, report, reviewSummaryIds);
+    if (result.action === "fix_code") {
+        await Promise.allSettled(result.fix.checks.flatMap((ch) => (ch.annotations ?? []).map((a) => markSeen(stallKey, a.id, annotationMarkerBody(a)))));
+    }
+    return result;
 }

package/bin/commands/iterate/helpers.mjs

@@ -53,6 +53,7 @@ export function buildRelevantChecks(report) {
                 ...(c.jobName !== undefined && { jobName: c.jobName }),
                 ...(c.failedStep !== undefined && { failedStep: c.failedStep }),
                 ...(c.summary !== undefined && { summary: c.summary }),
+                ...(c.annotations !== undefined && { annotations: c.annotations }),
             },
         ];
     });

package/bin/commands/iterate/render.mjs

@@ -30,6 +30,9 @@ export function buildFixInstructions(threads, actionableComments, checks, change
             actionableSections.push("`## Actionable comments`");
         if (checks.length > 0)
             actionableSections.push("`## Failing checks`");
+        if (checks.some((c) => (c.annotations?.length ?? 0) > 0)) {
+            actionableSections.push("`## Check annotations`");
+        }
         if (changesRequestedReviews.length > 0)
             actionableSections.push("`## Changes-requested reviews`");
         const sectionRef = actionableSections.length > 0 ? `under ${actionableSections.join(", ")}` : "above";
@@ -62,9 +65,12 @@ export function buildFixInstructions(threads, actionableComments, checks, change
         instructions.push(`Apply code fixes: read and edit each file referenced under \`## Review threads\` and \`## Actionable comments\` above.${suggestionFallback}`);
     }
     if (resolutionOnlyThreads.length > 0) {
-        instructions.push(`Resolve the threads under \`## Review threads to resolve\` with the \`resolve:\` command shown below. These threads are already outdated or minimized, so no code edit is required for them unless their body reveals separate work you choose to do.`);
+        instructions.push(`Review the threads under \`## Review threads to resolve\`. Human-authored threads are replied to by the \`resolve:\` command shown below; Shepherd does not resolve them. Bot/non-human threads are included in \`--resolve-thread-ids\`.`);
     }
     instructions.push(...buildFailingCheckInstructions(checks));
+    if (checks.some((c) => (c.annotations?.length ?? 0) > 0)) {
+        instructions.push(`For each item under \`## Check annotations\`: inspect the referenced file range and decide whether the annotation requires a code change. These annotations are surfaced once per PR and do not need any resolve/minimize mutation.`);
+    }
     if (changesRequestedReviews.length > 0) {
         instructions.push(`For each bullet under \`## Changes-requested reviews\` above: read the review body and apply the requested changes.`);
     }
@@ -77,7 +83,7 @@ export function buildFixInstructions(threads, actionableComments, checks, change
             substituteParts.push(`\`$HEAD_SHA\` with the pushed commit SHA (or \`$(git rev-parse HEAD)\` if you did not push)`);
         }
         if (resolveCommand.requiresDismissMessage) {
-            substituteParts.push(`\`$DISMISS_MESSAGE\` with a one-sentence description of what you changed`);
+            substituteParts.push(`\`$DISMISS_MESSAGE\` with a one-sentence reply/description of what you changed`);
         }
         const substituteHint = substituteParts.length > 0 ? `, substituting ${substituteParts.join(" and ")}` : "";
         instructions.push(`Run the \`resolve:\` command shown above${substituteHint}.`);
@@ -99,7 +105,7 @@ export function buildFixInstructions(threads, actionableComments, checks, change
     if (editedTotal > 0) {
         instructions.push(`Items marked \`[edited since first look]\`, items under \`## Review summaries (edited since first look)\`, and any first-look bullet tagged \`, edited\` were updated by their author after you previously acknowledged them. Read the updated body before deciding whether any matching \`## Review threads to resolve\` item should be resolved.`);
     }
-    if (resolveCommand.hasMutations) {
+    if (resolveCommand.hasMutations || hasNonConflictHints || firstLookTotal > 0) {
         instructions.push(buildShepherdJournalInstruction(prNumber, SHEPHERD_JOURNAL_REFERENCE_GUIDANCE_THREADS_AND_COMMENTS_IN_ITEM_HEADINGS));
     }
     instructions.push(FIX_INSTRUCTION_STOP);

package/bin/commands/iterate/stall.mjs

@@ -1,5 +1,5 @@
 import { readStallState, writeStallState } from "../../state/iterate-stall.mjs";
-import { toAgentThread, toAgentComment } from "../../reporters/agent.mjs";
+import { toAgentThread, toAgentComment, toAgentStalledCheck } from "../../reporters/agent.mjs";
 import { buildEscalateSuggestion, buildEscalateHumanMessage } from "./escalate.mjs";
 export function computeStallFingerprint(action, headSha, base, report, reviewSummaryIds) {
     const checks = [
@@ -27,8 +27,31 @@ export function computeStallFingerprint(action, headSha, base, report, reviewSum
     });
 }
 export async function applyStallGuard(stallKey, stallTimeoutSeconds, headSha, base, prNumber, prospectiveResult, report, reviewSummaryIds) {
-    const fingerprint = computeStallFingerprint(prospectiveResult.action, headSha, base, report, reviewSummaryIds);
     const nowSeconds = Math.floor(Date.now() / 1000);
+    const stalledChecks = findCiStartStalledChecks(report.checks.inProgress, nowSeconds, {
+        stallTimeoutSeconds,
+        action: prospectiveResult.action,
+    });
+    if (stalledChecks.length > 0) {
+        const stalledMinutes = Math.floor(Math.max(...stalledChecks.map((c) => c.ageSeconds)) / 60);
+        const escalateBase = {
+            triggers: ["stall-timeout"],
+            unresolvedThreads: [],
+            ambiguousComments: [],
+            changesRequestedReviews: [],
+            stalledChecks,
+            suggestion: buildEscalateSuggestion(["stall-timeout"], String(stalledMinutes)),
+        };
+        return {
+            ...base,
+            action: "escalate",
+            escalate: {
+                ...escalateBase,
+                humanMessage: buildEscalateHumanMessage(escalateBase, prNumber),
+            },
+        };
+    }
+    const fingerprint = computeStallFingerprint(prospectiveResult.action, headSha, base, report, reviewSummaryIds);
     const stored = await readStallState(stallKey);
     if (stored && stored.fingerprint === fingerprint) {
         const ageSeconds = nowSeconds - stored.firstSeenAt;
@@ -65,3 +88,21 @@ export async function applyStallGuard(stallKey, stallTimeoutSeconds, headSha, ba
     await writeStallState(stallKey, { fingerprint, firstSeenAt: nowSeconds });
     return prospectiveResult;
 }
+function findCiStartStalledChecks(checks, nowSeconds, opts) {
+    if (opts.stallTimeoutSeconds <= 0 || opts.action !== "wait")
+        return [];
+    return checks
+        .filter((c) => isUnstartedCheck(c))
+        .map((c) => toAgentStalledCheck(c, nowSeconds))
+        .filter((c) => c.createdAtUnix !== undefined && c.ageSeconds >= opts.stallTimeoutSeconds);
+}
+function isUnstartedCheck(check) {
+    if (check.source === "status_context")
+        return true;
+    if (check.startedAtUnix !== undefined)
+        return false;
+    return (check.status === "PENDING" ||
+        check.status === "QUEUED" ||
+        check.status === "REQUESTED" ||
+        check.status === "WAITING");
+}

package/bin/commands/iterate-test-support.mjs

@@ -103,7 +103,7 @@ function defaultConfig() {
     return {
         iterate: {
             fixAttemptsPerThread: 3,
-            stallTimeoutMinutes: 30,
+            stallTimeoutMinutes: 60,
             minimizeApprovals: false,
             minimizeComments: "all",
         },

package/bin/commands/iterate-thread-test-support.mjs

@@ -0,0 +1,18 @@
+import { NOW } from "./iterate-test-support.mjs";
+export function makeThread(overrides = {}) {
+    return {
+        id: "thread-1",
+        isResolved: false,
+        isOutdated: false,
+        isMinimized: false,
+        path: "src/foo.mts",
+        line: 10,
+        startLine: null,
+        author: "reviewer",
+        authorType: "Unknown",
+        body: "Fix this",
+        url: "",
+        createdAtUnix: NOW - 3600,
+        ...overrides,
+    };
+}

package/bin/commands/iterate.fix-code-in-progress.test-support.mjs

@@ -23,6 +23,13 @@ vi.mock("../state/iterate-stall.mts", () => ({
     readStallState: vi.fn().mockResolvedValue(null),
     writeStallState: vi.fn().mockResolvedValue(undefined),
 }));
+vi.mock("../state/seen-comments.mts", async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        markSeen: vi.fn().mockResolvedValue(undefined),
+    };
+});
 const { mockLoadConfig } = vi.hoisted(() => ({ mockLoadConfig: vi.fn() }));
 vi.mock("../config/load.mts", () => ({ loadConfig: mockLoadConfig }));
 import { runIterate } from "./iterate/index.mjs";
@@ -30,12 +37,14 @@ import { runCheck } from "./check.mjs";
 import { updateReadyDelay } from "./ready-delay.mjs";
 import { readFixAttempts, writeFixAttempts } from "../state/fix-attempts.mjs";
 import { readStallState, writeStallState } from "../state/iterate-stall.mjs";
+import { markSeen } from "../state/seen-comments.mjs";
 const mockRunCheck = vi.mocked(runCheck);
 const mockUpdateReadyDelay = vi.mocked(updateReadyDelay);
 const mockReadFixAttempts = vi.mocked(readFixAttempts);
 const mockWriteFixAttempts = vi.mocked(writeFixAttempts);
 const mockReadStallState = vi.mocked(readStallState);
 const mockWriteStallState = vi.mocked(writeStallState);
+const mockMarkSeen = vi.mocked(markSeen);
 function makeReport(overrides = {}) {
     return {
         pr: 42,
@@ -115,4 +124,4 @@ export function registerHooks() {
         vi.restoreAllMocks();
     });
 }
-export { makeOpts, makeReport, mockExecFile, mockFetch, mockLoadConfig, mockReadFixAttempts, mockReadStallState, mockRunCheck, mockUpdateReadyDelay, mockWriteFixAttempts, mockWriteStallState, readFixAttempts, readStallState, runCheck, runIterate, updateReadyDelay, writeFixAttempts, writeStallState, };
+export { makeOpts, makeReport, mockExecFile, mockFetch, mockLoadConfig, mockReadFixAttempts, mockReadStallState, mockMarkSeen, mockRunCheck, mockUpdateReadyDelay, mockWriteFixAttempts, mockWriteStallState, readFixAttempts, readStallState, runCheck, runIterate, updateReadyDelay, writeFixAttempts, writeStallState, };

package/bin/commands/mark-files-as-viewed.mjs

@@ -0,0 +1,220 @@
+/* eslint-disable max-lines */
+import { graphql, graphqlWithRateLimit, getCurrentPrNumber, getRepoInfo, } from "../github/client.mjs";
+import { paginateForward } from "../github/pagination.mjs";
+import { isRateLimitMessage, rateLimitFromError, rateLimitFromGraphQlResult, } from "../comments/rate-limit.mjs";
+const FILES_QUERY = `query PullRequestFiles($owner: String!, $repo: String!, $pr: Int!, $filesCursor: String) {
+  repository(owner: $owner, name: $repo) {
+    pullRequest(number: $pr) {
+      id
+      number
+      files(first: 100, after: $filesCursor) {
+        pageInfo {
+          hasNextPage
+          endCursor
+        }
+        nodes {
+          path
+          viewerViewedState
+        }
+      }
+    }
+  }
+}`;
+const TEST_FILE_RE = /(^|\/)(tests?|__tests__|spec)(\/|$)|\.(test|spec)\.[cm]?[jt]sx?$|_tests?\.rs$|(^|\/)tests?\.rs$/i;
+const BULK_CHUNK_SIZE = 10;
+export async function runMarkFilesAsViewed(opts) {
+    const repo = await getRepoInfo();
+    const prNumber = opts.prNumber ?? (await getCurrentPrNumber());
+    if (!prNumber)
+        throw new Error("No PR number provided and no current branch PR found");
+    const matchPatterns = opts.matchPatterns ?? [];
+    const matchRegexes = matchPatterns.map((pattern) => compilePattern(pattern));
+    const fetched = await fetchPullRequestFiles(prNumber, repo);
+    const selected = selectChangedFiles(fetched.files, {
+        files: opts.files,
+        tests: opts.tests === true,
+        matchPatterns,
+        matchRegexes,
+    });
+    const result = {
+        repo: `${repo.owner}/${repo.name}`,
+        prNumber,
+        pullRequestId: fetched.pullRequestId,
+        requestedPaths: opts.files,
+        testSelector: opts.tests === true,
+        matchPatterns,
+        matchedPaths: selected.matchedPaths,
+        markedPaths: [],
+        alreadyViewedPaths: selected.alreadyViewedPaths,
+        missingPaths: selected.missingPaths,
+        unmatchedSelectors: selected.unmatchedSelectors,
+        errors: [],
+    };
+    await bulkMarkFilesAsViewed(fetched.pullRequestId, selected.pathsToMark, result);
+    return result;
+}
+async function fetchPullRequestFiles(pr, repo) {
+    const first = await graphql(FILES_QUERY, {
+        owner: repo.owner,
+        repo: repo.name,
+        pr,
+    });
+    const raw = first.data.repository?.pullRequest;
+    if (!raw)
+        throw new Error(`PR #${pr} not found`);
+    let files = raw.files.nodes;
+    if (raw.files.pageInfo.hasNextPage && raw.files.pageInfo.endCursor) {
+        const extra = await paginateForward(async (cursor) => {
+            const res = await graphql(FILES_QUERY, {
+                owner: repo.owner,
+                repo: repo.name,
+                pr,
+                ...(cursor ? { filesCursor: cursor } : {}),
+            });
+            const pr2 = res.data.repository?.pullRequest;
+            if (!pr2)
+                throw new Error(`PR #${pr} not found`);
+            return pr2.files;
+        }, raw.files.pageInfo.endCursor);
+        files = [...files, ...extra];
+    }
+    return { pullRequestId: raw.id, files };
+}
+function compilePattern(pattern) {
+    try {
+        return new RegExp(pattern, "i");
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        throw new Error(`Invalid --match regex ${JSON.stringify(pattern)}: ${msg}`);
+    }
+}
+function selectChangedFiles(changedFiles, opts) {
+    const byPath = new Map(changedFiles.map((f) => [f.path, f]));
+    const matched = new Set();
+    const missingPaths = [];
+    const unmatchedSelectors = [];
+    for (const path of opts.files) {
+        if (byPath.has(path))
+            matched.add(path);
+        else
+            missingPaths.push(path);
+    }
+    if (opts.tests) {
+        let matchedAny = false;
+        for (const file of changedFiles) {
+            if (TEST_FILE_RE.test(file.path)) {
+                matched.add(file.path);
+                matchedAny = true;
+            }
+        }
+        if (!matchedAny)
+            unmatchedSelectors.push("--tests");
+    }
+    for (let i = 0; i < opts.matchRegexes.length; i += 1) {
+        let matchedAny = false;
+        const regex = opts.matchRegexes[i];
+        for (const file of changedFiles) {
+            if (regex.test(file.path)) {
+                matched.add(file.path);
+                matchedAny = true;
+            }
+        }
+        if (!matchedAny)
+            unmatchedSelectors.push(`--match ${opts.matchPatterns[i]}`);
+    }
+    const matchedPaths = [...matched];
+    const alreadyViewedPaths = matchedPaths.filter((path) => byPath.get(path)?.viewerViewedState === "VIEWED");
+    const alreadyViewedSet = new Set(alreadyViewedPaths);
+    const pathsToMark = matchedPaths.filter((path) => !alreadyViewedSet.has(path));
+    return { matchedPaths, alreadyViewedPaths, missingPaths, unmatchedSelectors, pathsToMark };
+}
+function buildBulkMutation(paths) {
+    const ops = paths.map((path, i) => `  m${i}: markFileAsViewed(input: { pullRequestId: $pullRequestId, path: ${JSON.stringify(path)} }) { pullRequest { id } }`);
+    return `mutation BulkMarkFilesAsViewed($pullRequestId: ID!) {\n${ops.join("\n")}\n}`;
+}
+async function bulkMarkFilesAsViewed(pullRequestId, paths, result) {
+    for (let i = 0; i < paths.length; i += BULK_CHUNK_SIZE) {
+        const chunk = paths.slice(i, i + BULK_CHUNK_SIZE);
+        // eslint-disable-next-line no-await-in-loop
+        const stopped = await bulkMarkFilesAsViewedChunk(pullRequestId, chunk, result, i + BULK_CHUNK_SIZE < paths.length);
+        if (stopped) {
+            const markedSet = new Set(result.markedPaths);
+            result.unmarkedPaths = paths.slice(i).filter((path) => !markedSet.has(path));
+            return;
+        }
+    }
+}
+async function bulkMarkFilesAsViewedChunk(pullRequestId, paths, result, hasPendingAfter) {
+    if (paths.length === 0)
+        return false;
+    let data = {};
+    let graphQlErrors = [];
+    let suppressCurrentChunkErrors = false;
+    let rateLimitStop;
+    try {
+        const resp = await graphqlWithRateLimit(buildBulkMutation(paths), {
+            pullRequestId,
+        });
+        data = resp.data;
+        graphQlErrors = (resp.errors ?? []);
+        const messages = graphQlErrors.map((e) => e.message);
+        suppressCurrentChunkErrors = messages.some(isRateLimitMessage);
+        rateLimitStop = rateLimitFromGraphQlResult(messages, {
+            rateLimit: resp.rateLimit,
+            retryAfterSeconds: resp.retryAfterSeconds,
+            stopOnZeroRemaining: hasPendingAfter,
+        });
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        const stop = rateLimitFromError(err, msg);
+        if (stop) {
+            result.errors.push(`rate limit: ${stop.message}`);
+            result.rateLimit = stop;
+            return true;
+        }
+        for (const path of paths)
+            result.errors.push(`${path}: ${msg}`);
+        return false;
+    }
+    const errorMessagesByAlias = mapAliasErrors(graphQlErrors);
+    for (let i = 0; i < paths.length; i += 1) {
+        const alias = `m${i}`;
+        const m = data[alias];
+        if (m?.pullRequest?.id === pullRequestId) {
+            result.markedPaths.push(paths[i]);
+        }
+        else if (!suppressCurrentChunkErrors) {
+            result.errors.push(`${paths[i]}: ${errorMessagesByAlias.get(alias) ?? "mark returned null"}`);
+        }
+    }
+    if (rateLimitStop) {
+        result.errors.push(`rate limit: ${rateLimitStop.message}`);
+        result.rateLimit = rateLimitStop;
+        return true;
+    }
+    return false;
+}
+function mapAliasErrors(errors) {
+    const out = new Map();
+    for (const error of errors) {
+        if (!Array.isArray(error.path))
+            continue;
+        const alias = error.path.find((part) => typeof part === "string" && isMarkAlias(part));
+        if (typeof alias === "string")
+            out.set(alias, error.message);
+    }
+    return out;
+}
+function isMarkAlias(value) {
+    if (!value.startsWith("m"))
+        return false;
+    if (value.length === 1)
+        return false;
+    for (const char of value.slice(1)) {
+        if (char < "0" || char > "9")
+            return false;
+    }
+    return true;
+}

package/bin/commands/resolve-mutate.mjs

@@ -1,16 +1,53 @@
 import { getRepoInfo, getCurrentPrNumber } from "../github/client.mjs";
 import { applyResolveOptions } from "../comments/resolve.mjs";
+import { fetchPrBatch } from "../github/batch.mjs";
+import { isHumanAuthor } from "../comments/authors.mjs";
+import { markSeen } from "../state/seen-comments.mjs";
+import { threadTranscriptBody } from "../threads/transcript.mjs";
 export async function runResolveMutate(opts) {
     const repo = await getRepoInfo();
     const prNumber = opts.prNumber ?? (await getCurrentPrNumber());
     if (prNumber === null) {
         throw new Error("No open PR found for current branch. Pass a PR number explicitly.");
     }
-    return applyResolveOptions(prNumber, repo, {
-        resolveThreadIds: opts.resolveThreadIds,
-        minimizeCommentIds: opts.minimizeCommentIds,
-        dismissReviewIds: opts.dismissReviewIds,
+    const { data } = await fetchPrBatch(prNumber, repo, { paginateApprovedReviews: true });
+    const threadById = new Map(data.reviewThreads.map((t) => [t.id, t]));
+    const humanThreadIds = new Set(data.reviewThreads.filter(isHumanAuthor).map((t) => t.id));
+    const humanCommentIds = new Set(data.comments.filter(isHumanAuthor).map((c) => c.id));
+    const humanReviewIds = new Set([...data.reviewSummaries, ...data.approvedReviews, ...data.changesRequestedReviews]
+        .filter(isHumanAuthor)
+        .map((r) => r.id));
+    const resolveThreadIds = (opts.resolveThreadIds ?? []).filter((id) => !humanThreadIds.has(id));
+    const skippedHumanResolves = (opts.resolveThreadIds ?? []).filter((id) => humanThreadIds.has(id));
+    const replyThreadIds = opts.replyThreadIds?.filter((id) => humanThreadIds.has(id));
+    const skippedNonHumanReplies = (opts.replyThreadIds ?? []).filter((id) => !humanThreadIds.has(id));
+    const minimizeCommentIds = (opts.minimizeCommentIds ?? []).filter((id) => !humanCommentIds.has(id) && !humanReviewIds.has(id));
+    const skippedHumanMinimizes = (opts.minimizeCommentIds ?? []).filter((id) => humanCommentIds.has(id) || humanReviewIds.has(id));
+    const dismissReviewIds = (opts.dismissReviewIds ?? []).filter((id) => !humanReviewIds.has(id));
+    const skippedHumanDismissals = (opts.dismissReviewIds ?? []).filter((id) => humanReviewIds.has(id));
+    const result = await applyResolveOptions(prNumber, repo, {
+        resolveThreadIds,
+        replyThreadIds,
+        minimizeCommentIds,
+        dismissReviewIds,
         dismissMessage: opts.dismissMessage,
         requireSha: opts.requireSha,
     });
+    if (skippedHumanResolves.length > 0)
+        result.skippedHumanResolves = skippedHumanResolves;
+    if (skippedHumanMinimizes.length > 0)
+        result.skippedHumanMinimizes = skippedHumanMinimizes;
+    if (skippedHumanDismissals.length > 0)
+        result.skippedHumanDismissals = skippedHumanDismissals;
+    if (skippedNonHumanReplies.length > 0)
+        result.skippedNonHumanReplies = skippedNonHumanReplies;
+    if (opts.dismissMessage) {
+        await Promise.all(result.repliedThreads.map((id) => {
+            const thread = threadById.get(id);
+            if (!thread)
+                return Promise.resolve();
+            return markSeen({ owner: repo.owner, repo: repo.name, pr: prNumber }, id, threadTranscriptBody(thread, [opts.dismissMessage]));
+        }));
+    }
+    return result;
 }