pr-shepherd 0.22.0 → 0.23.0

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

@@ -3,8 +3,6 @@ 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";
@@ -14,6 +12,8 @@ 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());
@@ -44,50 +44,9 @@ export async function runCheck(opts) {
     const stateKey = { owner: repo.owner, repo: repo.name, pr: prNumber };
     const seenMap = await loadSeenMap(stateKey);
     const triaged = await attachUnseenCheckAnnotations(triagedBase, seenMap, 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 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, threadTranscriptBody(t), 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, threadTranscriptBody(t), 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, threadTranscriptBody(t), 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")
@@ -107,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, threadTranscriptBody(t))),
         ...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;
@@ -139,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/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,
     };
 }

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

@@ -1,25 +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 { markSeen } from "../../state/seen-comments.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,
@@ -38,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 = [
@@ -67,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:

package/bin/commands/iterate/render.mjs

@@ -65,7 +65,7 @@ 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)) {
@@ -83,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}.`);
@@ -105,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-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,9 +23,13 @@ vi.mock("../state/iterate-stall.mts", () => ({
     readStallState: vi.fn().mockResolvedValue(null),
     writeStallState: vi.fn().mockResolvedValue(undefined),
 }));
-vi.mock("../state/seen-comments.mts", () => ({
-    markSeen: 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";