pr-shepherd 0.16.3 → 0.17.0

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

@@ -0,0 +1,43 @@
+// @ts-nocheck
+import { readFileSync } from "node:fs";
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+vi.mock("./commands/resolve.mts", () => ({
+    runResolveFetch: vi.fn(),
+    runResolveMutate: vi.fn(),
+}));
+vi.mock("./commands/log-file.mts", () => ({
+    runLogFile: vi.fn(),
+}));
+vi.mock("./commands/commit-suggestion.mts", () => ({
+    runCommitSuggestion: vi.fn(),
+}));
+vi.mock("./commands/iterate/index.mts", async (importOriginal) => {
+    const actual = await importOriginal();
+    return { ...actual, runIterate: vi.fn() };
+});
+import { main } from "./cli-parser.mjs";
+import { runLogFile } from "./commands/log-file.mjs";
+import { runResolveFetch, runResolveMutate } from "./commands/resolve.mjs";
+const mockRunResolveFetch = vi.mocked(runResolveFetch);
+const mockRunResolveMutate = vi.mocked(runResolveMutate);
+const mockRunLogFile = vi.mocked(runLogFile);
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+let stdoutSpy;
+let stderrSpy;
+function getStdout() {
+    return stdoutSpy.mock.calls.map((c) => c[0]).join("");
+}
+export function registerHooks() {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        process.exitCode = undefined;
+        stdoutSpy = vi.spyOn(process.stdout, "write").mockImplementation(() => true);
+        stderrSpy = vi.spyOn(process.stderr, "write").mockImplementation(() => true);
+    });
+    afterEach(() => {
+        process.exitCode = undefined;
+        stdoutSpy.mockRestore();
+        stderrSpy.mockRestore();
+    });
+}
+export { getStdout, main, mockRunLogFile, mockRunResolveFetch, mockRunResolveMutate, readFileSync, runLogFile, runResolveFetch, runResolveMutate, stderrSpy, stdoutSpy, };

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

@@ -0,0 +1,140 @@
+// @ts-nocheck
+import { describe, it, expect, vi, beforeEach } from "vitest";
+vi.mock("../github/batch.mts", () => ({ fetchPrBatch: vi.fn() }));
+vi.mock("../github/client.mts", () => ({
+    getRepoInfo: vi.fn().mockResolvedValue({ owner: "owner", name: "repo" }),
+    getCurrentPrNumber: vi.fn().mockResolvedValue(42),
+    getMergeableState: vi.fn(),
+}));
+vi.mock("../checks/triage.mts", () => ({
+    triageFailingChecks: vi.fn((checks) => Promise.resolve(checks)),
+    fetchStartupFailureChecks: vi.fn().mockResolvedValue([]),
+}));
+vi.mock("../comments/resolve.mts", () => ({
+    autoResolveOutdated: vi.fn().mockResolvedValue({ resolved: [], errors: [] }),
+}));
+vi.mock("../state/seen-comments.mts", async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        loadSeenMap: vi.fn().mockResolvedValue(new Map()),
+        markSeen: vi.fn().mockResolvedValue(undefined),
+    };
+});
+const { mockLoadConfig } = vi.hoisted(() => ({ mockLoadConfig: vi.fn() }));
+vi.mock("../config/load.mts", () => ({ loadConfig: mockLoadConfig }));
+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 { loadSeenMap, markSeen, hashBody } from "../state/seen-comments.mjs";
+import { autoResolveOutdated } from "../comments/resolve.mjs";
+const mockFetchPrBatch = vi.mocked(fetchPrBatch);
+const mockGetCurrentPrNumber = vi.mocked(getCurrentPrNumber);
+const mockGetMergeableState = vi.mocked(getMergeableState);
+const mockTriageFailingChecks = vi.mocked(triageFailingChecks);
+const mockFetchStartupFailureChecks = vi.mocked(fetchStartupFailureChecks);
+const mockLoadSeenMap = vi.mocked(loadSeenMap);
+const mockMarkSeen = vi.mocked(markSeen);
+const mockAutoResolveOutdated = vi.mocked(autoResolveOutdated);
+const BASE_OPTS = { format: "text" };
+function defaultConfig() {
+    return {
+        iterate: {
+            fixAttemptsPerThread: 3,
+            stallTimeoutMinutes: 30,
+            minimizeApprovals: false,
+            minimizeComments: "all",
+        },
+        watch: { readyDelayMinutes: 10 },
+        resolve: {
+            shaPoll: { intervalMs: 2000, maxAttempts: 10 },
+            fetchReviewSummaries: true,
+        },
+        checks: {
+            ciTriggerEvents: ["pull_request", "pull_request_target"],
+        },
+        mergeStatus: { blockingReviewerLogins: ["copilot"] },
+        actions: {
+            autoResolveOutdated: true,
+            autoMarkReady: true,
+            commitSuggestions: true,
+        },
+    };
+}
+function makeCheck(overrides = {}) {
+    return {
+        name: "tests",
+        status: "COMPLETED",
+        conclusion: "SUCCESS",
+        detailsUrl: "",
+        event: "pull_request",
+        runId: null,
+        category: "passed",
+        ...overrides,
+    };
+}
+function makeBatchData(overrides = {}) {
+    return {
+        nodeId: "PR_kgDOAAA",
+        number: 42,
+        state: "OPEN",
+        isDraft: false,
+        mergeable: "MERGEABLE",
+        mergeStateStatus: "CLEAN",
+        reviewDecision: "APPROVED",
+        headRefOid: "abc123",
+        headRefName: "feature",
+        headRepoWithOwner: "owner/repo",
+        baseRefName: "main",
+        reviewRequests: [],
+        latestReviews: [],
+        reviewThreads: [],
+        comments: [],
+        changesRequestedReviews: [],
+        reviewSummaries: [],
+        approvedReviews: [],
+        checks: [makeCheck()],
+        ...overrides,
+    };
+}
+function makeThread(overrides = {}) {
+    return {
+        id: "t1",
+        isResolved: false,
+        isOutdated: false,
+        isMinimized: false,
+        path: "src/foo.mts",
+        line: 10,
+        startLine: null,
+        author: "reviewer",
+        authorType: "Unknown",
+        body: "fix this",
+        url: "",
+        createdAtUnix: 0,
+        ...overrides,
+    };
+}
+function makeComment(overrides = {}) {
+    return {
+        id: "c1",
+        author: "commenter",
+        authorType: "Unknown",
+        body: "comment body",
+        url: "",
+        createdAtUnix: 0,
+        isMinimized: false,
+        ...overrides,
+    };
+}
+// No PR found
+export function registerHooks() {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockLoadConfig.mockReturnValue(defaultConfig());
+        mockFetchPrBatch.mockResolvedValue({ data: makeBatchData() });
+        mockGetMergeableState.mockResolvedValue({ mergeable: "MERGEABLE", mergeStateStatus: "CLEAN" });
+        mockFetchStartupFailureChecks.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, };

package/bin/commands/clean.mjs

@@ -0,0 +1,156 @@
+import { rm, readdir, realpath, stat } from "node:fs/promises";
+import { join } from "node:path";
+import { resolveStateBase } from "../state/base.mjs";
+import { getRepoInfo, getCurrentPrNumber, getCurrentBranch, getPrNumberForBranch, } from "../github/client.mjs";
+import { SAFE_SEGMENT } from "../util/path-segment.mjs";
+export async function runClean(opts) {
+    const dryRun = opts.dryRun ?? false;
+    const rawBase = resolveStateBase();
+    const base = await realpath(rawBase).catch(() => rawBase);
+    let target;
+    try {
+        target = await resolveTarget(base, opts);
+    }
+    catch (e) {
+        return {
+            ok: false,
+            variant: opts.variant,
+            dryRun,
+            base,
+            target: "",
+            deleted: [],
+            skipped: [],
+            error: e instanceof Error ? e.message : String(e),
+        };
+    }
+    let targetExists = false;
+    try {
+        await stat(target);
+        targetExists = true;
+    }
+    catch (e) {
+        if (e.code !== "ENOENT") {
+            return {
+                ok: false,
+                variant: opts.variant,
+                dryRun,
+                base,
+                target,
+                deleted: [],
+                skipped: [],
+                error: `Failed to stat target: ${e.message}`,
+            };
+        }
+    }
+    if (!targetExists) {
+        return {
+            ok: true,
+            variant: opts.variant,
+            dryRun,
+            base,
+            target,
+            deleted: [],
+            skipped: [target],
+        };
+    }
+    let entries;
+    try {
+        const names = await readdir(target);
+        entries = names.map((n) => join(target, n));
+    }
+    catch {
+        entries = [target];
+    }
+    if (dryRun) {
+        return {
+            ok: true,
+            variant: opts.variant,
+            dryRun: true,
+            base,
+            target,
+            deleted: entries,
+            skipped: [],
+        };
+    }
+    try {
+        await rm(target, { recursive: true, force: true });
+    }
+    catch (e) {
+        return {
+            ok: false,
+            variant: opts.variant,
+            dryRun: false,
+            base,
+            target,
+            deleted: [],
+            skipped: [],
+            error: `Failed to remove target: ${e.message}`,
+        };
+    }
+    return {
+        ok: true,
+        variant: opts.variant,
+        dryRun: false,
+        base,
+        target,
+        deleted: entries,
+        skipped: [],
+    };
+}
+async function resolveTarget(base, opts) {
+    const { variant, value } = opts;
+    if (variant === "all") {
+        if (value !== undefined) {
+            throw new Error(`"clean all" does not accept a positional argument; got "${value}". Did you mean "clean repo" or "clean pr"?`);
+        }
+        return base;
+    }
+    const repo = await getRepoInfo();
+    const { owner, name } = repo;
+    for (const [field, val] of [
+        ["owner", owner],
+        ["repo", name],
+    ]) {
+        if (!SAFE_SEGMENT.test(val)) {
+            throw new Error(`Invalid repository segment "${field}": ${val}`);
+        }
+    }
+    const ownerRepo = `${owner}-${name}`;
+    if (variant === "repo") {
+        if (value !== undefined) {
+            throw new Error(`"clean repo" does not accept a positional argument; got "${value}". Did you mean "clean pr" or "clean branch"?`);
+        }
+        return join(base, ownerRepo);
+    }
+    let prNumber;
+    if (variant === "pr") {
+        if (value !== undefined) {
+            const n = parseInt(value, 10);
+            if (!Number.isFinite(n) || n <= 0 || String(n) !== value.trim()) {
+                throw new Error(`Invalid PR number: ${value}`);
+            }
+            prNumber = n;
+        }
+        else {
+            const n = await getCurrentPrNumber();
+            if (n === null)
+                throw new Error("No open PR found for current branch");
+            prNumber = n;
+        }
+    }
+    else {
+        // "branch" or "current"
+        if (variant === "current" && value !== undefined) {
+            throw new Error(`"clean current" does not accept a positional argument; got "${value}". Did you mean "clean branch"?`);
+        }
+        const branchName = value ?? (await getCurrentBranch());
+        if (branchName === "HEAD") {
+            throw new Error("Could not resolve current branch (detached HEAD)");
+        }
+        const n = await getPrNumberForBranch(branchName, owner, name);
+        if (n === null)
+            throw new Error(`No open PR found for branch: ${branchName}`);
+        prNumber = n;
+    }
+    return join(base, ownerRepo, String(prNumber));
+}

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

@@ -0,0 +1,48 @@
+// @ts-nocheck
+import { vi, beforeEach, afterEach } from "vitest";
+import { join } from "node:path";
+import { mkdtemp, realpath, rm, mkdir, writeFile, stat } from "node:fs/promises";
+import { tmpdir } from "node:os";
+vi.mock("../github/client.mts", () => ({
+    getRepoInfo: vi.fn().mockResolvedValue({ owner: "acme", name: "widgets" }),
+    getCurrentBranch: vi.fn().mockResolvedValue("feature/test"),
+    getCurrentPrNumber: vi.fn().mockResolvedValue(42),
+    getPrNumberForBranch: vi.fn().mockResolvedValue(42),
+}));
+import { getRepoInfo, getCurrentBranch, getCurrentPrNumber, getPrNumberForBranch, } from "../github/client.mjs";
+export const mockGetRepoInfo = vi.mocked(getRepoInfo);
+export const mockGetCurrentBranch = vi.mocked(getCurrentBranch);
+export const mockGetCurrentPrNumber = vi.mocked(getCurrentPrNumber);
+export const mockGetPrNumberForBranch = vi.mocked(getPrNumberForBranch);
+export let stateDir;
+export function registerHooks() {
+    beforeEach(async () => {
+        const tmpPath = await mkdtemp(join(tmpdir(), "shepherd-clean-test-"));
+        stateDir = await realpath(tmpPath);
+        process.env["PR_SHEPHERD_STATE_DIR"] = stateDir;
+        vi.clearAllMocks();
+        mockGetRepoInfo.mockResolvedValue({ owner: "acme", name: "widgets" });
+        mockGetCurrentBranch.mockResolvedValue("feature/test");
+        mockGetCurrentPrNumber.mockResolvedValue(42);
+        mockGetPrNumberForBranch.mockResolvedValue(42);
+    });
+    afterEach(async () => {
+        delete process.env["PR_SHEPHERD_STATE_DIR"];
+        await rm(stateDir, { recursive: true, force: true });
+    });
+}
+export async function seedPrDir(dir, pr) {
+    const prDir = join(dir, "acme-widgets", String(pr));
+    await mkdir(join(prDir, "seen"), { recursive: true });
+    await writeFile(join(prDir, "fix-attempts.json"), "{}", "utf8");
+    return prDir;
+}
+export async function pathExists(p) {
+    try {
+        await stat(p);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/bin/commands/commit-suggestion.apply.test-support.mjs

@@ -0,0 +1,87 @@
+// @ts-nocheck
+import { describe, it, expect, vi, beforeEach } from "vitest";
+// ---------------------------------------------------------------------------
+// Hoisted mocks
+// ---------------------------------------------------------------------------
+const { mockExecFile } = vi.hoisted(() => ({ mockExecFile: vi.fn() }));
+vi.mock("node:child_process", () => ({
+    execFile: (cmd, args, optsOrCb, maybeCb) => {
+        const cb = typeof optsOrCb === "function" ? optsOrCb : maybeCb;
+        mockExecFile(cmd, args)
+            .then((result) => cb(null, result))
+            .catch((err) => cb(err, { stdout: "", stderr: err.stderr ?? "" }));
+    },
+}));
+vi.mock("node:fs/promises", () => ({
+    readFile: vi.fn(),
+}));
+vi.mock("../github/client.mts", () => ({
+    getRepoInfo: vi.fn().mockResolvedValue({ owner: "owner", name: "repo" }),
+    getCurrentPrNumber: vi.fn().mockResolvedValue(42),
+    getCurrentBranch: vi.fn().mockResolvedValue("feature/foo"),
+}));
+vi.mock("../github/batch.mts", () => ({
+    fetchPrBatch: vi.fn(),
+}));
+import { runCommitSuggestion } from "./commit-suggestion.mjs";
+import { getCurrentBranch } from "../github/client.mjs";
+import { fetchPrBatch } from "../github/batch.mjs";
+import { readFile } from "node:fs/promises";
+const mockGetCurrentBranch = vi.mocked(getCurrentBranch);
+const mockFetchBatch = vi.mocked(fetchPrBatch);
+const mockReadFile = vi.mocked(readFile);
+function makeThread(overrides = {}) {
+    return {
+        id: "PRRT_x",
+        isResolved: false,
+        isOutdated: false,
+        isMinimized: false,
+        path: "src/foo.ts",
+        line: 5,
+        startLine: null,
+        author: "alice",
+        authorType: "Unknown",
+        body: "Use a const here.\n\n```suggestion\nconst x = 10;\n```",
+        url: "",
+        createdAtUnix: 0,
+        ...overrides,
+    };
+}
+function makeBatch(threads) {
+    return {
+        nodeId: "PR_kgDOAAA",
+        number: 42,
+        state: "OPEN",
+        isDraft: false,
+        mergeable: "MERGEABLE",
+        mergeStateStatus: "CLEAN",
+        reviewDecision: "APPROVED",
+        headRefOid: "headsha",
+        headRefName: "feature/foo",
+        headRepoWithOwner: "owner/repo",
+        baseRefName: "main",
+        reviewRequests: [],
+        latestReviews: [],
+        reviewThreads: threads,
+        checks: [],
+        comments: [],
+        changesRequestedReviews: [],
+        reviewSummaries: [],
+        approvedReviews: [],
+    };
+}
+const FILE_CONTENT = "line1\n" +
+    "line2\n" +
+    "line3\n" +
+    "line4\n" +
+    "const x = 1;\n" + // line 5 — matches the suggestion anchor
+    "line6\n" +
+    "line7\n";
+const GLOBAL_OPTS = { format: "text" };
+function makeGitSuccess(stdout = "") {
+    return Promise.resolve({ stdout, stderr: "" });
+}
+// ---------------------------------------------------------------------------
+// Output shape and instruction content
+// ---------------------------------------------------------------------------
+export { FILE_CONTENT, GLOBAL_OPTS, fetchPrBatch, getCurrentBranch, makeBatch, makeGitSuccess, makeThread, mockExecFile, mockFetchBatch, mockGetCurrentBranch, mockReadFile, readFile, runCommitSuggestion, };

package/bin/commands/commit-suggestion.test-support.mjs

@@ -0,0 +1,112 @@
+// @ts-nocheck
+import { describe, it, expect, vi, beforeEach } from "vitest";
+// ---------------------------------------------------------------------------
+// Hoisted mocks
+// ---------------------------------------------------------------------------
+const { mockExecFile } = vi.hoisted(() => ({ mockExecFile: vi.fn() }));
+vi.mock("node:child_process", () => ({
+    execFile: (cmd, args, optsOrCb, maybeCb) => {
+        const cb = typeof optsOrCb === "function" ? optsOrCb : maybeCb;
+        mockExecFile(cmd, args)
+            .then((result) => cb(null, result))
+            .catch((err) => cb(err, { stdout: "", stderr: err.stderr ?? "" }));
+    },
+}));
+vi.mock("node:fs/promises", () => ({
+    readFile: vi.fn(),
+}));
+vi.mock("../github/client.mts", () => ({
+    getRepoInfo: vi.fn().mockResolvedValue({ owner: "owner", name: "repo" }),
+    getCurrentPrNumber: vi.fn().mockResolvedValue(42),
+    getCurrentBranch: vi.fn().mockResolvedValue("feature/foo"),
+}));
+vi.mock("../github/batch.mts", () => ({
+    fetchPrBatch: vi.fn(),
+}));
+const { mockLoadConfig } = vi.hoisted(() => ({ mockLoadConfig: vi.fn() }));
+vi.mock("../config/load.mts", () => ({
+    loadConfig: mockLoadConfig,
+}));
+import { runCommitSuggestion } from "./commit-suggestion.mjs";
+import { getCurrentBranch, getCurrentPrNumber } from "../github/client.mjs";
+import { fetchPrBatch } from "../github/batch.mjs";
+import { readFile } from "node:fs/promises";
+const mockGetCurrentBranch = vi.mocked(getCurrentBranch);
+const mockGetCurrentPrNumber = vi.mocked(getCurrentPrNumber);
+const mockFetchBatch = vi.mocked(fetchPrBatch);
+const mockReadFile = vi.mocked(readFile);
+// ---------------------------------------------------------------------------
+// Fixtures
+// ---------------------------------------------------------------------------
+function makeThread(overrides = {}) {
+    return {
+        id: "PRRT_x",
+        isResolved: false,
+        isOutdated: false,
+        isMinimized: false,
+        path: "src/foo.ts",
+        line: 5,
+        startLine: null,
+        author: "alice",
+        authorType: "Unknown",
+        body: "Use a const here.\n\n```suggestion\nconst x = 10;\n```",
+        url: "",
+        createdAtUnix: 0,
+        ...overrides,
+    };
+}
+function makeBatch(threads, headRepoWithOwner = "owner/repo") {
+    return {
+        nodeId: "PR_kgDOAAA",
+        number: 42,
+        state: "OPEN",
+        isDraft: false,
+        mergeable: "MERGEABLE",
+        mergeStateStatus: "CLEAN",
+        reviewDecision: "APPROVED",
+        headRefOid: "headsha",
+        headRefName: "feature/foo",
+        headRepoWithOwner,
+        baseRefName: "main",
+        reviewRequests: [],
+        latestReviews: [],
+        reviewThreads: threads,
+        checks: [],
+        comments: [],
+        changesRequestedReviews: [],
+        reviewSummaries: [],
+        approvedReviews: [],
+    };
+}
+const FILE_CONTENT = "line1\n" +
+    "line2\n" +
+    "line3\n" +
+    "line4\n" +
+    "const x = 1;\n" + // line 5 — matches the suggestion anchor
+    "line6\n" +
+    "line7\n";
+const GLOBAL_OPTS = { format: "text" };
+function makeGitSuccess(stdout = "") {
+    return Promise.resolve({ stdout, stderr: "" });
+}
+function setupHappyPath() {
+    mockFetchBatch.mockResolvedValue({ data: makeBatch([makeThread()]) });
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    mockReadFile.mockResolvedValue(FILE_CONTENT);
+    mockExecFile.mockImplementation((cmd, args) => {
+        if (cmd === "git" && args[0] === "rev-parse")
+            return makeGitSuccess("headsha\n");
+        if (cmd === "git" && args[0] === "status")
+            return makeGitSuccess(""); // file is clean
+        throw new Error(`Unexpected execFile call: ${cmd} ${args.join(" ")}`);
+    });
+}
+// ---------------------------------------------------------------------------
+// Validation
+// ---------------------------------------------------------------------------
+export function registerHooks() {
+    beforeEach(() => {
+        mockLoadConfig.mockReturnValue({ cli: { runner: "auto" } });
+    });
+}
+export { FILE_CONTENT, GLOBAL_OPTS, fetchPrBatch, getCurrentBranch, getCurrentPrNumber, makeBatch, makeGitSuccess, makeThread, mockExecFile, mockFetchBatch, mockGetCurrentBranch, mockGetCurrentPrNumber, mockLoadConfig, mockReadFile, readFile, runCommitSuggestion, setupHappyPath, };

package/bin/commands/iterate/classify.mjs

@@ -1,5 +1,16 @@
 import { buildPrShepherdCommand } from "../../cli/runner.mjs";
 import { shouldMinimizeAuthor } from "../../comments/minimize-policy.mjs";
+function dedupeIds(ids) {
+    const seen = new Set();
+    const out = [];
+    for (const id of ids) {
+        if (seen.has(id))
+            continue;
+        seen.add(id);
+        out.push(id);
+    }
+    return out;
+}
 export function classifyReviewSummaries(summaries, approvals, minimizeApprovals, minimizeComments = "all") {
     // First-look and seen summaries go into the minimize mutation; edited summaries do NOT —
     // they are already minimized server-side (body changed after minimize was applied).
@@ -28,26 +39,43 @@ export function classifyReviewSummaries(summaries, approvals, minimizeApprovals,
 }
 export function buildResolveCommand(threads, resolutionOnlyThreads, allCommentIds, reviews, checks, prNumber, runner) {
     const argv = buildPrShepherdCommand(["resolve", String(prNumber)], { runner }).argv;
-    const threadIds = [...threads.map((t) => t.id), ...resolutionOnlyThreads.map((t) => t.id)];
+    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(","));
     }
     if (allCommentIds.length > 0) {
         argv.push("--minimize-comment-ids", allCommentIds.join(","));
     }
-    const hasDismiss = reviews.length > 0;
+    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", reviews.map((r) => r.id).join(","));
+        argv.push("--dismiss-review-ids", filteredReviewIds.join(","));
         argv.push("--message", "$DISMISS_MESSAGE");
     }
-    // A push is required when threads, CI failures, or changes-requested reviews are present — the
-    // CLI knows those imply code edits. Comments are surfaced for the agent to evaluate; the CLI
-    // cannot know whether a given comment will require a push, so comments are excluded here.
-    const requiresHeadSha = threads.length > 0 || checks.length > 0 || reviews.length > 0;
     // hasMutations = we appended at least one of --resolve-thread-ids,
     // --minimize-comment-ids, or --dismiss-review-ids. 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 || reviews.length > 0;
-    return { argv, requiresHeadSha, requiresDismissMessage: hasDismiss, hasMutations };
+    const hasMutations = threadIds.length > 0 || allCommentIds.length > 0 || filteredReviewIds.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);
+    const requiresHeadSha = hasCodeMutations;
+    return {
+        argv,
+        requiresHeadSha,
+        requiresDismissMessage: hasDismiss,
+        ...(droppedDismissReviewIds.length > 0 ? { droppedDismissReviewIds } : undefined),
+        hasMutations,
+    };
 }