pr-shepherd 0.21.0 → 0.23.0

package/bin/cli/list-formatters.mjs

@@ -1,4 +1,5 @@
 import { renderLineRange, renderSuggestionBlock } from "./suggestion-renderer.mjs";
+import { threadComments } from "../threads/transcript.mjs";
 const BODY_PREVIEW_MAX = 100;
 export function renderAuthor(author, authorType) {
     return authorType ? `@${author} · ${authorType}` : `@${author}`;
@@ -26,13 +27,62 @@ export function renderThreadBullet(t, opts = {}) {
         ? `\`${t.path}:${renderLineRange(t.startLine ?? undefined, t.line ?? null)}\``
         : "`(no location)`";
     const suggestionMarker = t.suggestion ? " [suggestion]" : "";
+    const editedMarker = t.edited && !opts.suppressEditedMarker ? " [edited since first look]" : "";
     const statusSuffix = opts.statusTag ? ` ${opts.statusTag}` : "";
-    const bodySuffix = opts.noBody ? "" : `: ${renderBodyPreview(t.body)}`;
-    const bulletLine = `- \`threadId=${t.id}\`${link} ${loc} (${renderAuthor(t.author, t.authorType)})${suggestionMarker}${statusSuffix}${bodySuffix}`;
+    const bulletLine = `- \`threadId=${t.id}\`${link} ${loc} (${renderAuthor(t.author, t.authorType)})${suggestionMarker}${editedMarker}${statusSuffix}`;
+    if (!opts.noBody && (!t.comments || t.comments.length === 0)) {
+        const legacyLine = `${bulletLine}: ${renderBodyPreview(t.body)}`;
+        return t.suggestion && opts.renderSuggestion
+            ? `${legacyLine}\n${renderSuggestionBlock(t.suggestion)}`
+            : legacyLine;
+    }
+    const parts = [bulletLine];
+    if (!opts.noBody) {
+        parts.push(renderThreadCommentBullets(t));
+    }
     if (t.suggestion && opts.renderSuggestion) {
-        return `${bulletLine}\n${renderSuggestionBlock(t.suggestion)}`;
+        parts.push(renderSuggestionBlock(t.suggestion));
     }
-    return bulletLine;
+    return parts.join("\n");
+}
+export function renderThreadConversation(t) {
+    if (!t.comments || t.comments.length === 0)
+        return blockquote(t.body);
+    return threadComments(t)
+        .map((c) => {
+        const heading = c.id
+            ? c.url
+                ? `#### [commentId=${c.id}](${c.url}) (${renderAuthor(c.author, c.authorType)})`
+                : `#### \`commentId=${c.id}\` (${renderAuthor(c.author, c.authorType)})`
+            : `#### (${renderAuthor(c.author, c.authorType)})`;
+        return `${heading}\n\n${blockquote(c.body)}`;
+    })
+        .join("\n\n");
+}
+export function blockquote(body) {
+    return body
+        .replace(/\r\n/g, "\n")
+        .split("\n")
+        .map((line) => (line === "" ? ">" : `> ${line}`))
+        .join("\n");
+}
+function renderThreadCommentBullets(t) {
+    return threadComments(t)
+        .map((c) => {
+        const link = c.url ? ` [↗](${c.url})` : "";
+        const id = c.id ? `\`commentId=${c.id}\`` : "comment";
+        return [
+            `  - ${id}${link} (${renderAuthor(c.author, c.authorType)})`,
+            indentBlockquote(c.body, "    "),
+        ].join("\n");
+    })
+        .join("\n");
+}
+function indentBlockquote(body, indent) {
+    return blockquote(body)
+        .split("\n")
+        .map((line) => `${indent}${line}`)
+        .join("\n");
 }
 export function renderCommentBullet(c, opts = {}) {
     const link = c.url ? ` [↗](${c.url})` : "";
@@ -62,6 +112,7 @@ export function buildFirstLookBullets(firstLookThreads, resolutionOnlyIds, first
         bullets.push(renderThreadBullet(t, {
             statusTag: renderFirstLookStatusTag(t),
             noBody: resolutionOnlyIds.has(t.id),
+            suppressEditedMarker: true,
         }));
     }
     for (const c of firstLookComments) {

package/bin/cli/mark-files-as-viewed-flags.mjs

@@ -0,0 +1,34 @@
+import { hasFlag } from "./args.mjs";
+export function parseMarkFilesAsViewedArgs(args) {
+    const files = [];
+    const matchPatterns = [];
+    const tests = hasFlag(args, "--tests");
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (arg === "--tests")
+            continue;
+        if (arg === "--match") {
+            const value = args[i + 1];
+            if (value === undefined || value.startsWith("--")) {
+                return { ok: false, error: "--match requires a regex value" };
+            }
+            matchPatterns.push(value);
+            i += 1;
+            continue;
+        }
+        if (arg.startsWith("--match=")) {
+            const value = arg.slice("--match=".length);
+            if (value === "")
+                return { ok: false, error: "--match requires a regex value" };
+            matchPatterns.push(value);
+            continue;
+        }
+        if (arg.startsWith("--"))
+            return { ok: false, error: `unknown flag: "${arg}"` };
+        files.push(arg);
+    }
+    if (files.length === 0 && !tests && matchPatterns.length === 0) {
+        return { ok: false, error: "provide at least one file, --tests, or --match <regex>" };
+    }
+    return { ok: true, files, tests, matchPatterns };
+}

package/bin/cli/mark-files-as-viewed-formatter.mjs

@@ -0,0 +1,52 @@
+export function formatMarkFilesAsViewedResult(result) {
+    const lines = [];
+    lines.push(`# PR #${result.prNumber} — Mark files as viewed (${result.markedPaths.length} marked)`);
+    lines.push("");
+    lines.push(`repo: ${result.repo}`);
+    appendPathSection(lines, "Matched files", result.matchedPaths);
+    appendPathSection(lines, "Marked viewed", result.markedPaths);
+    appendPathSection(lines, "Already viewed", result.alreadyViewedPaths);
+    appendPathSection(lines, "Missing from PR diff", result.missingPaths);
+    appendTextSection(lines, "Unmatched selectors", result.unmatchedSelectors);
+    if (result.rateLimit) {
+        const details = [
+            result.rateLimit.retryAfterSeconds !== undefined
+                ? `retry after ${result.rateLimit.retryAfterSeconds}s`
+                : null,
+            result.rateLimit.remaining !== undefined && result.rateLimit.limit !== undefined
+                ? `remaining ${result.rateLimit.remaining}/${result.rateLimit.limit}`
+                : null,
+            result.rateLimit.resetAt !== undefined
+                ? `reset at ${new Date(result.rateLimit.resetAt * 1000).toISOString()}`
+                : null,
+        ]
+            .filter(Boolean)
+            .join(", ");
+        lines.push("");
+        lines.push(`Stopped: GitHub rate limit hit — ${result.rateLimit.message}${details ? ` (${details})` : ""}`);
+    }
+    appendPathSection(lines, "Not marked due to rate limit", result.unmarkedPaths ?? []);
+    const errors = result.rateLimit
+        ? result.errors.filter((e) => !e.startsWith("rate limit:"))
+        : result.errors;
+    appendTextSection(lines, "Errors", errors);
+    if (result.matchedPaths.length === 0) {
+        lines.push("");
+        lines.push("No files matched.");
+    }
+    return lines.join("\n");
+}
+function appendPathSection(lines, label, paths) {
+    if (paths.length === 0)
+        return;
+    lines.push("");
+    lines.push(`## ${label} (${paths.length})`);
+    lines.push(paths.map((path) => `- \`${path}\``).join("\n"));
+}
+function appendTextSection(lines, label, values) {
+    if (values.length === 0)
+        return;
+    lines.push("");
+    lines.push(`## ${label} (${values.length})`);
+    lines.push(values.map((value) => `- ${value}`).join("\n"));
+}

package/bin/cli/mutate-formatter.mjs

@@ -0,0 +1,50 @@
+function pushIds(lines, label, ids) {
+    if (ids?.length)
+        lines.push(`${label} (${ids.length}): ${ids.join(", ")}`);
+}
+function formatRateLimit(result) {
+    const rateLimit = result.rateLimit;
+    if (rateLimit) {
+        const details = [
+            typeof rateLimit.retryAfterSeconds === "number"
+                ? `retry after ${rateLimit.retryAfterSeconds}s`
+                : null,
+            typeof rateLimit.remaining === "number" && typeof rateLimit.limit === "number"
+                ? `remaining ${rateLimit.remaining}/${rateLimit.limit}`
+                : null,
+            typeof rateLimit.resetAt === "number"
+                ? `reset at ${new Date(rateLimit.resetAt * 1000).toISOString()}`
+                : null,
+        ]
+            .filter(Boolean)
+            .join(", ");
+        const detailSuffix = details ? ` (${details})` : "";
+        return `Stopped: GitHub rate limit hit — ${rateLimit.message}${detailSuffix}`;
+    }
+    return null;
+}
+export function formatMutateResult(result) {
+    const lines = [];
+    pushIds(lines, "Replied to threads", result.repliedThreads);
+    pushIds(lines, "Resolved threads", result.resolvedThreads);
+    pushIds(lines, "Minimized comments", result.minimizedComments);
+    pushIds(lines, "Dismissed reviews", result.dismissedReviews);
+    pushIds(lines, "Skipped dismissals", result.skippedDismissals);
+    pushIds(lines, "Skipped human thread resolves", result.skippedHumanResolves);
+    pushIds(lines, "Skipped human minimizes", result.skippedHumanMinimizes);
+    pushIds(lines, "Skipped human review dismissals", result.skippedHumanDismissals);
+    pushIds(lines, "Skipped non-human/unknown thread replies", result.skippedNonHumanReplies);
+    const rateLimit = formatRateLimit(result);
+    if (rateLimit)
+        lines.push(rateLimit);
+    pushIds(lines, "Not replied due to rate limit", result.unrepliedThreads);
+    pushIds(lines, "Not resolved due to rate limit", result.unresolvedThreads);
+    pushIds(lines, "Not minimized due to rate limit", result.unminimizedComments);
+    pushIds(lines, "Not dismissed due to rate limit", result.undismissedReviews);
+    const errors = result.rateLimit
+        ? result.errors.filter((e) => !e.startsWith("rate limit:"))
+        : result.errors;
+    if (errors.length)
+        lines.push(`Errors:\n  ${errors.join("\n  ")}`);
+    return lines.join("\n");
+}

package/bin/cli-parser.mjs

@@ -7,9 +7,12 @@
  *                  [--stall-timeout <duration>] [--no-auto-mark-ready]
  *                  [--no-auto-cancel-actionable]
  *   pr-shepherd resolve [PR] [--fetch] [--resolve-thread-ids A,B] [--minimize-comment-ids X,Y]
- *                            [--dismiss-review-ids Q] [--message MSG] [--require-sha SHA]
+ *                            [--reply-thread-ids A,B] [--dismiss-review-ids Q]
+ *                            [--message MSG] [--require-sha SHA]
  *   pr-shepherd commit-suggestion [PR] --thread-id ID --message MSG [--description DESC]
  *                                      [--format text|json]
+ *   pr-shepherd mark-files-as-viewed [PR] [files...] [--tests] [--match REGEX]
+ *                                           [--format text|json]
  *   pr-shepherd iterate [PR] [--format text|json] [--ready-delay Nm]
  *                              [--stall-timeout <duration>] [--no-auto-mark-ready]
  *                              [--no-auto-cancel-actionable]
@@ -25,7 +28,7 @@ import { parseCommonArgs, getFlag, hasFlag, parseList } from "./cli/args.mjs";
 import { isDefaultPollInvocation, validateDefaultPollArgs } from "./cli/default-poll.mjs";
 import { USAGE, maybePrintHelp } from "./cli/help.mjs";
 import { formatFetchResult, formatMutateResult } from "./cli/formatters.mjs";
-import { handleClean, handleCommitSuggestion, handleIterate } from "./cli/handlers.mjs";
+import { handleClean, handleCommitSuggestion, handleIterate, handleMarkFilesAsViewed, } from "./cli/handlers.mjs";
 import { handlePoll } from "./cli/poll-handler.mjs";
 import { setupLog } from "./log/setup.mjs";
 // ---------------------------------------------------------------------------
@@ -75,6 +78,9 @@ export async function main(argv) {
         case "commit-suggestion":
             await handleCommitSuggestion(args.slice(1));
             break;
+        case "mark-files-as-viewed":
+            await handleMarkFilesAsViewed(args.slice(1));
+            break;
         case "iterate":
             await handleIterate(args.slice(1));
             break;
@@ -119,12 +125,14 @@ async function handleLogFile(args) {
 async function handleResolve(args) {
     const { prNumber, global: globalOpts, extra } = parseCommonArgs(args);
     const resolveThreadIds = parseList(getFlag(extra, "--resolve-thread-ids"));
+    const replyThreadIds = parseList(getFlag(extra, "--reply-thread-ids"));
     const minimizeCommentIds = parseList(getFlag(extra, "--minimize-comment-ids"));
     const dismissReviewIds = parseList(getFlag(extra, "--dismiss-review-ids"));
     const dismissMessage = getFlag(extra, "--message") ?? undefined;
     const requireSha = getFlag(extra, "--require-sha") ?? undefined;
     const fetchMode = hasFlag(extra, "--fetch") ||
         (resolveThreadIds.length === 0 &&
+            replyThreadIds.length === 0 &&
             minimizeCommentIds.length === 0 &&
             dismissReviewIds.length === 0);
     if (fetchMode) {
@@ -138,6 +146,7 @@ async function handleResolve(args) {
             ...globalOpts,
             prNumber,
             resolveThreadIds,
+            replyThreadIds,
             minimizeCommentIds,
             dismissReviewIds,
             dismissMessage,

package/bin/cli-parser.test-support.mjs

@@ -10,6 +10,9 @@ vi.mock("./commands/log-file.mts", () => ({
 vi.mock("./commands/commit-suggestion.mts", () => ({
     runCommitSuggestion: vi.fn(),
 }));
+vi.mock("./commands/mark-files-as-viewed.mts", () => ({
+    runMarkFilesAsViewed: vi.fn(),
+}));
 vi.mock("./commands/iterate/index.mts", async (importOriginal) => {
     const actual = await importOriginal();
     return { ...actual, runIterate: vi.fn() };
@@ -17,9 +20,11 @@ vi.mock("./commands/iterate/index.mts", async (importOriginal) => {
 import { main } from "./cli-parser.mjs";
 import { runLogFile } from "./commands/log-file.mjs";
 import { runResolveFetch, runResolveMutate } from "./commands/resolve.mjs";
+import { runMarkFilesAsViewed } from "./commands/mark-files-as-viewed.mjs";
 const mockRunResolveFetch = vi.mocked(runResolveFetch);
 const mockRunResolveMutate = vi.mocked(runResolveMutate);
 const mockRunLogFile = vi.mocked(runLogFile);
+const mockRunMarkFilesAsViewed = vi.mocked(runMarkFilesAsViewed);
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 let stdoutSpy;
 let stderrSpy;
@@ -39,4 +44,4 @@ export function registerHooks() {
         stderrSpy.mockRestore();
     });
 }
-export { getStdout, main, mockRunLogFile, mockRunResolveFetch, mockRunResolveMutate, readFileSync, runLogFile, runResolveFetch, runResolveMutate, stderrSpy, stdoutSpy, };
+export { getStdout, main, mockRunLogFile, mockRunMarkFilesAsViewed, mockRunResolveFetch, mockRunResolveMutate, readFileSync, runLogFile, runResolveFetch, runResolveMutate, stderrSpy, stdoutSpy, };

package/bin/commands/check-annotations.mjs

@@ -0,0 +1,40 @@
+import { fetchCheckRunAnnotations } from "../github/check-annotations.mjs";
+export async function attachUnseenCheckAnnotations(checks, seenMap, prNumber) {
+    const checksWithAnnotations = [];
+    for (const check of checks) {
+        // eslint-disable-next-line no-await-in-loop
+        checksWithAnnotations.push(await attachForCheck(check, seenMap, prNumber));
+    }
+    return checksWithAnnotations;
+}
+async function attachForCheck(check, seenMap, prNumber) {
+    if (check.id == null)
+        return check;
+    let annotations;
+    try {
+        annotations = await fetchCheckRunAnnotations(check.id);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`pr-shepherd: annotation fetch failed for PR #${prNumber} check "${check.name}" (ignored): ${msg}\n`);
+        return check;
+    }
+    const unseen = annotations.filter((a) => !seenMap.has(a.id));
+    if (unseen.length === 0)
+        return check;
+    return { ...check, annotations: unseen };
+}
+export function annotationMarkerBody(a) {
+    return JSON.stringify({
+        path: a.path,
+        startLine: a.startLine,
+        endLine: a.endLine,
+        startColumn: a.startColumn,
+        endColumn: a.endColumn,
+        level: a.level,
+        title: a.title,
+        message: a.message,
+        rawDetails: a.rawDetails,
+        blobUrl: a.blobUrl,
+    });
+}

package/bin/commands/check.mjs

@@ -3,15 +3,17 @@ import { getRepoInfo, getCurrentPrNumber } from "../github/client.mjs";
 import { classifyChecks, getCiVerdict } from "../checks/classify.mjs";
 import { mergeStartupFailureChecks } from "../checks/startup-failures.mjs";
 import { fetchStartupFailureChecks, triageFailingChecks } from "../checks/triage.mjs";
-import { getOutdatedThreads } from "../comments/outdated.mjs";
-import { autoResolveOutdated } from "../comments/resolve.mjs";
 import { deriveMergeStatus } from "../merge-status/derive.mjs";
 import { loadConfig } from "../config/load.mjs";
 import { classifyVisibleComments } from "../comments/visible-comments.mjs";
 import { computeStatus } from "./check-status.mjs";
+import { attachUnseenCheckAnnotations } from "./check-annotations.mjs";
 import { buildTerminalReport } from "./check-terminal-report.mjs";
 import { isBlockedByFilteredCheck, refreshReadyMergeability, refreshUnknownMergeability, } from "./ready-mergeability.mjs";
 import { loadSeenMap, markSeen, classifyItem } from "../state/seen-comments.mjs";
+import { threadTranscriptBody } from "../threads/transcript.mjs";
+import { classifyThreadVisibility } from "../comments/thread-visibility.mjs";
+import { classifyReviewsForDisplay } from "../comments/review-visibility.mjs";
 export async function runCheck(opts) {
     const repo = await getRepoInfo();
     const prNumber = opts.prNumber ?? (await getCurrentPrNumber());
@@ -38,53 +40,13 @@ export async function runCheck(opts) {
     const inProgress = classifiedChecks.filter((c) => c.category === "in_progress");
     const skipped = classifiedChecks.filter((c) => c.category === "skipped");
     const filtered = classifiedChecks.filter((c) => c.category === "filtered");
-    const triaged = failing.length > 0 && !opts.skipTriage ? await triageFailingChecks(failing, repo) : failing;
+    const triagedBase = failing.length > 0 && !opts.skipTriage ? await triageFailingChecks(failing, repo) : failing;
     const stateKey = { owner: repo.owner, repo: repo.name, pr: prNumber };
-    const unresolvedThreads = batchData.reviewThreads.filter((t) => !t.isResolved);
-    const outdated = getOutdatedThreads(unresolvedThreads);
-    let autoResolved = [];
-    let autoResolveErrors = [];
-    if (opts.autoResolve && outdated.length > 0) {
-        const { resolved: resolvedIds, errors } = await autoResolveOutdated(outdated.map((t) => t.id));
-        const resolvedIdsSet = new Set(resolvedIds); // ⚡ Bolt optimization: O(1) lookup
-        autoResolved = outdated.filter((t) => resolvedIdsSet.has(t.id));
-        autoResolveErrors = errors;
-    }
-    const activeThreads = unresolvedThreads.filter((t) => !t.isOutdated && !t.isMinimized);
-    const outdatedCandidates = batchData.reviewThreads.filter((t) => t.isOutdated);
-    const resolvedCandidates = batchData.reviewThreads.filter((t) => t.isResolved && !t.isOutdated);
-    const minimizedThreadCandidates = batchData.reviewThreads.filter((t) => t.isMinimized && !t.isResolved && !t.isOutdated);
-    const minimizedCommentCandidates = batchData.comments.filter((c) => c.isMinimized);
     const seenMap = await loadSeenMap(stateKey);
+    const triaged = await attachUnseenCheckAnnotations(triagedBase, seenMap, prNumber);
+    const minimizedCommentCandidates = batchData.comments.filter((c) => c.isMinimized);
     const visibleCommentClassification = classifyVisibleComments(batchData.comments, seenMap, config.iterate.minimizeComments);
-    const autoResolvedIds = new Set(autoResolved.map((t) => t.id));
-    const firstLookThreads = [
-        ...outdatedCandidates.flatMap((t) => {
-            const cls = classifyItem(t.id, t.body, seenMap);
-            if (cls === "unchanged")
-                return [];
-            const base = {
-                ...t,
-                firstLookStatus: "outdated",
-                autoResolved: autoResolvedIds.has(t.id),
-            };
-            return cls === "edited" ? [{ ...base, edited: true }] : [base];
-        }),
-        ...resolvedCandidates.flatMap((t) => {
-            const cls = classifyItem(t.id, t.body, seenMap);
-            if (cls === "unchanged")
-                return [];
-            const base = { ...t, firstLookStatus: "resolved" };
-            return cls === "edited" ? [{ ...base, edited: true }] : [base];
-        }),
-        ...minimizedThreadCandidates.flatMap((t) => {
-            const cls = classifyItem(t.id, t.body, seenMap);
-            if (cls === "unchanged")
-                return [];
-            const base = { ...t, firstLookStatus: "minimized" };
-            return cls === "edited" ? [{ ...base, edited: true }] : [base];
-        }),
-    ];
+    const threadVisibility = classifyThreadVisibility(batchData.reviewThreads, seenMap);
     const firstLookComments = minimizedCommentCandidates.flatMap((c) => {
         const cls = classifyItem(c.id, c.body, seenMap);
         if (cls === "unchanged")
@@ -104,16 +66,22 @@ export async function runCheck(opts) {
         else
             seenSummaries.push(r);
     }
+    const changesRequestedReviewVisibility = classifyReviewsForDisplay(batchData.changesRequestedReviews, seenMap);
+    const approvedReviewVisibility = classifyReviewsForDisplay(batchData.approvedReviews, seenMap);
     await Promise.allSettled([
-        ...firstLookThreads.map((t) => markSeen(stateKey, t.id, t.body)),
         ...firstLookComments.map((c) => markSeen(stateKey, c.id, c.body)),
+        ...threadVisibility.toMarkSeen.map((t) => markSeen(stateKey, t.id, threadTranscriptBody(t))),
         ...visibleCommentClassification.toMarkSeen.map((c) => markSeen(stateKey, c.id, c.body)),
         ...[...firstLookSummaries, ...editedSummaries].map((r) => markSeen(stateKey, r.id, r.body)),
+        ...changesRequestedReviewVisibility.toMarkSeen.map((r) => markSeen(stateKey, r.id, r.body)),
+        ...approvedReviewVisibility.toMarkSeen.map((r) => markSeen(stateKey, r.id, r.body)),
     ]);
-    const resolutionOnlyThreads = unresolvedThreads.filter((t) => !autoResolvedIds.has(t.id) && (t.isOutdated || t.isMinimized));
-    let status = computeStatus(verdict, activeThreads.length + resolutionOnlyThreads.length, visibleCommentClassification.actionable.length, mergeStatus, batchData.changesRequestedReviews.length);
+    const changesRequestedReviews = changesRequestedReviewVisibility.visible;
+    const changesRequestedReviewCount = batchData.changesRequestedReviews.length;
+    const approvedReviews = approvedReviewVisibility.visible;
+    let status = computeStatus(verdict, threadVisibility.activeThreads.length + threadVisibility.resolutionOnlyThreads.length, visibleCommentClassification.actionable.length, mergeStatus, changesRequestedReviewCount);
     if (status === "READY" && !didRefreshMergeability) {
-        const refreshed = await refreshReadyMergeability(prNumber, repo, batchData, verdict, activeThreads.length + resolutionOnlyThreads.length, visibleCommentClassification.actionable.length);
+        const refreshed = await refreshReadyMergeability(prNumber, repo, batchData, verdict, threadVisibility.activeThreads.length + threadVisibility.resolutionOnlyThreads.length, visibleCommentClassification.actionable.length);
         batchData = refreshed.batchData;
         mergeStatus = refreshed.mergeStatus;
         status = refreshed.status;
@@ -136,22 +104,22 @@ export async function runCheck(opts) {
             blockedByFilteredCheck,
         },
         threads: {
-            actionable: activeThreads,
-            resolutionOnly: resolutionOnlyThreads,
-            autoResolved,
-            autoResolveErrors,
-            firstLook: firstLookThreads,
+            actionable: threadVisibility.activeThreads,
+            resolutionOnly: threadVisibility.resolutionOnlyThreads,
+            autoResolved: [],
+            autoResolveErrors: [],
+            firstLook: threadVisibility.firstLookThreads,
         },
         comments: {
             actionable: visibleCommentClassification.actionable,
             minimizeIds: visibleCommentClassification.minimizeIds,
             firstLook: firstLookComments,
         },
-        changesRequestedReviews: batchData.changesRequestedReviews,
+        changesRequestedReviews,
         reviewSummaries: seenSummaries,
         firstLookSummaries,
         editedSummaries,
-        approvedReviews: batchData.approvedReviews,
+        approvedReviews,
         branchProtection: batchData.branchProtection,
     };
 }

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

@@ -9,6 +9,9 @@ vi.mock("../checks/triage.mts", () => ({
     triageFailingChecks: vi.fn((checks) => Promise.resolve(checks)),
     fetchStartupFailureChecks: vi.fn().mockResolvedValue([]),
 }));
+vi.mock("../github/check-annotations.mts", () => ({
+    fetchCheckRunAnnotations: vi.fn().mockResolvedValue([]),
+}));
 vi.mock("../comments/resolve.mts", () => ({
     autoResolveOutdated: vi.fn().mockResolvedValue({ resolved: [], errors: [] }),
 }));
@@ -26,6 +29,7 @@ import { runCheck } from "./check.mjs";
 import { fetchPrBatch } from "../github/batch.mjs";
 import { getCurrentPrNumber, getMergeableState } from "../github/client.mjs";
 import { fetchStartupFailureChecks, triageFailingChecks } from "../checks/triage.mjs";
+import { fetchCheckRunAnnotations } from "../github/check-annotations.mjs";
 import { loadSeenMap, markSeen, hashBody } from "../state/seen-comments.mjs";
 import { autoResolveOutdated } from "../comments/resolve.mjs";
 const mockFetchPrBatch = vi.mocked(fetchPrBatch);
@@ -33,6 +37,7 @@ const mockGetCurrentPrNumber = vi.mocked(getCurrentPrNumber);
 const mockGetMergeableState = vi.mocked(getMergeableState);
 const mockTriageFailingChecks = vi.mocked(triageFailingChecks);
 const mockFetchStartupFailureChecks = vi.mocked(fetchStartupFailureChecks);
+const mockFetchCheckRunAnnotations = vi.mocked(fetchCheckRunAnnotations);
 const mockLoadSeenMap = vi.mocked(loadSeenMap);
 const mockMarkSeen = vi.mocked(markSeen);
 const mockAutoResolveOutdated = vi.mocked(autoResolveOutdated);
@@ -41,7 +46,7 @@ function defaultConfig() {
     return {
         iterate: {
             fixAttemptsPerThread: 3,
-            stallTimeoutMinutes: 30,
+            stallTimeoutMinutes: 60,
             minimizeApprovals: false,
             minimizeComments: "all",
         },
@@ -63,6 +68,7 @@ function defaultConfig() {
 }
 function makeCheck(overrides = {}) {
     return {
+        id: null,
         name: "tests",
         status: "COMPLETED",
         conclusion: "SUCCESS",
@@ -135,6 +141,7 @@ export function registerHooks() {
         mockFetchPrBatch.mockResolvedValue({ data: makeBatchData() });
         mockGetMergeableState.mockResolvedValue({ mergeable: "MERGEABLE", mergeStateStatus: "CLEAN" });
         mockFetchStartupFailureChecks.mockResolvedValue([]);
+        mockFetchCheckRunAnnotations.mockResolvedValue([]);
     });
 }
-export { BASE_OPTS, autoResolveOutdated, defaultConfig, fetchPrBatch, fetchStartupFailureChecks, getCurrentPrNumber, getMergeableState, hashBody, loadSeenMap, makeBatchData, makeCheck, makeComment, makeThread, markSeen, mockAutoResolveOutdated, mockFetchPrBatch, mockFetchStartupFailureChecks, mockGetCurrentPrNumber, mockGetMergeableState, mockLoadConfig, mockLoadSeenMap, mockMarkSeen, mockTriageFailingChecks, runCheck, triageFailingChecks, };
+export { BASE_OPTS, autoResolveOutdated, defaultConfig, fetchPrBatch, fetchStartupFailureChecks, fetchCheckRunAnnotations, getCurrentPrNumber, getMergeableState, hashBody, loadSeenMap, makeBatchData, makeCheck, makeComment, makeThread, markSeen, mockAutoResolveOutdated, mockFetchPrBatch, mockFetchStartupFailureChecks, mockFetchCheckRunAnnotations, mockGetCurrentPrNumber, mockGetMergeableState, mockLoadConfig, mockLoadSeenMap, mockMarkSeen, mockTriageFailingChecks, runCheck, triageFailingChecks, };

package/bin/commands/commit-suggestion-instruction.mjs

@@ -19,5 +19,5 @@ export function buildCommitSuggestionInstruction(prNumber, sectionName, includeD
     const driftHint = includeDriftHint
         ? " If the patch fails to apply (drift since the suggestion was written), fall through to the manual fix step."
         : " If the patch fails to apply, fall through to the manual-edit step.";
-    return `For each thread marked \`[suggestion]\` under \`${sectionName}\`: run \`${command}\` to retrieve the patch and suggested commit. The CLI does not mutate the working tree — apply the patch yourself (run \`git apply\` with the diff shown, or edit the file directly using the line range), then stage the listed file and run the suggested \`git commit\` from the \`## Instructions\` section. Include the thread ID in \`--resolve-thread-ids\` in the resolve command below (the thread is not auto-resolved).${driftHint} Do not retry the same command.`;
+    return `For each thread marked \`[suggestion]\` under \`${sectionName}\`: run \`${command}\` to retrieve the patch and suggested commit. The CLI does not mutate the working tree — apply the patch yourself (run \`git apply\` with the diff shown, or edit the file directly using the line range), then stage the listed file and run the suggested \`git commit\` from the \`## Instructions\` section. Human-authored thread IDs are replied to by the resolve command below; Shepherd does not auto-resolve them.${driftHint} Do not retry the same command.`;
 }

package/bin/commands/iterate/classify.mjs

@@ -1,5 +1,6 @@
 import { buildPrShepherdCommand } from "../../cli/runner.mjs";
 import { shouldMinimizeAuthor } from "../../comments/minimize-policy.mjs";
+import { isHumanAuthor } from "../../comments/authors.mjs";
 function dedupeIds(ids) {
     const seen = new Set();
     const out = [];
@@ -16,18 +17,21 @@ export function classifyReviewSummaries(summaries, approvals, minimizeApprovals,
     // they are already minimized server-side (body changed after minimize was applied).
     // First-look bodies are rendered so the agent sees them before the minimize happens.
     const minimizeIds = [...summaries.firstLook, ...summaries.seen]
-        .filter((r) => shouldMinimizeAuthor(r.authorType, minimizeComments))
+        .filter((r) => shouldMinimizeAuthor(r.authorType, minimizeComments, r.author))
         .map((r) => r.id);
     if (minimizeApprovals) {
+        const surfacedApprovals = [];
         for (const r of approvals) {
-            if (shouldMinimizeAuthor(r.authorType, minimizeComments))
+            if (shouldMinimizeAuthor(r.authorType, minimizeComments, r.author))
                 minimizeIds.push(r.id);
+            else
+                surfacedApprovals.push(r);
         }
         return {
             minimizeIds,
             firstLookSummaries: summaries.firstLook,
             editedSummaries: summaries.edited,
-            surfacedApprovals: [],
+            surfacedApprovals,
         };
     }
     return {
@@ -37,45 +41,36 @@ export function classifyReviewSummaries(summaries, approvals, minimizeApprovals,
         surfacedApprovals: approvals,
     };
 }
-export function buildResolveCommand(threads, resolutionOnlyThreads, allCommentIds, reviews, checks, prNumber) {
+export function buildResolveCommand(threads, resolutionOnlyThreads, allCommentIds, _reviews, checks, prNumber) {
     const argv = buildPrShepherdCommand(["resolve", String(prNumber)]).argv;
-    const resolveThreadIds = dedupeIds(threads.map((t) => t.id));
-    const threadIds = dedupeIds([...resolveThreadIds, ...resolutionOnlyThreads.map((t) => t.id)]);
-    if (threadIds.length > 0) {
-        argv.push("--resolve-thread-ids", threadIds.join(","));
+    const allThreads = [...threads, ...resolutionOnlyThreads];
+    const replyThreadIds = dedupeIds(allThreads.filter(isHumanAuthor).map((t) => t.id));
+    const resolveThreadIds = dedupeIds(allThreads.filter((t) => !isHumanAuthor(t)).map((t) => t.id));
+    if (replyThreadIds.length > 0) {
+        argv.push("--reply-thread-ids", replyThreadIds.join(","));
+        argv.push("--message", "$DISMISS_MESSAGE");
+    }
+    if (resolveThreadIds.length > 0) {
+        argv.push("--resolve-thread-ids", resolveThreadIds.join(","));
     }
     if (allCommentIds.length > 0) {
         argv.push("--minimize-comment-ids", allCommentIds.join(","));
     }
-    const commentIdSet = new Set(allCommentIds);
-    const filteredReviewIds = [];
-    const droppedDismissReviewIds = [];
-    for (const review of reviews) {
-        if (commentIdSet.has(review.id))
-            droppedDismissReviewIds.push(review.id);
-        else
-            filteredReviewIds.push(review.id);
-    }
-    const hasDismiss = filteredReviewIds.length > 0;
-    if (hasDismiss) {
-        argv.push("--dismiss-review-ids", filteredReviewIds.join(","));
-        argv.push("--message", "$DISMISS_MESSAGE");
-    }
-    // hasMutations = we appended at least one of --resolve-thread-ids,
-    // --minimize-comment-ids, or --dismiss-review-ids. Returned explicitly
+    // hasMutations = we appended at least one reply, resolve, or minimize mutation. Returned explicitly
     // (rather than derived from argv.length) so callers don't couple to the
     // base-argv shape.
-    const hasMutations = threadIds.length > 0 || allCommentIds.length > 0 || filteredReviewIds.length > 0;
+    const hasMutations = replyThreadIds.length > 0 || resolveThreadIds.length > 0 || allCommentIds.length > 0;
     // `requiresHeadSha` is only added when this resolve command includes a
-    // mutation that can race with a moving HEAD: resolving actionable threads,
-    // dismissing CHANGES_REQUESTED reviews, or addressing failing checks.
-    const hasCodeMutations = hasMutations && (threads.length > 0 || checks.length > 0 || filteredReviewIds.length > 0);
+    // mutation that can race with a moving HEAD: replying after actionable
+    // thread fixes or addressing failing checks.
+    const hasCodeMutations = hasMutations && (threads.length > 0 || checks.length > 0);
     const requiresHeadSha = hasCodeMutations;
     return {
         argv,
         requiresHeadSha,
-        requiresDismissMessage: hasDismiss,
-        ...(droppedDismissReviewIds.length > 0 ? { droppedDismissReviewIds } : undefined),
+        requiresDismissMessage: replyThreadIds.length > 0,
+        ...(replyThreadIds.length > 0 ? { replyThreadIds } : undefined),
+        ...(resolveThreadIds.length > 0 ? { resolveThreadIds } : undefined),
         hasMutations,
     };
 }