pr-shepherd 0.16.3 → 0.17.0

package/bin/commands/iterate/escalate.mjs

@@ -55,7 +55,7 @@ export function validateBaseBranch(raw) {
 }
 export function buildEscalateHumanMessage(escalate, pr) {
     const lines = [];
-    lines.push("⚠️ /pr-shepherd:pr-shepherd paused — needs human direction");
+    lines.push("⚠️ /pr-shepherd:pr-shepherd paused — manual intervention required");
     lines.push("");
     lines.push(`**Triggers:** ${escalate.triggers.map((t) => `\`${t}\``).join(", ")}`);
     lines.push("");
@@ -66,6 +66,7 @@ export function buildEscalateHumanMessage(escalate, pr) {
     if (hasItems) {
         lines.push("");
         lines.push("## Items needing attention");
+        lines.push("");
         for (const t of escalate.unresolvedThreads) {
             const loc = t.path ? `\`${t.path}:${t.line ?? "?"}\`` : "(no location)";
             const firstLine = t.body.split("\n")[0] ?? "";
@@ -83,6 +84,7 @@ export function buildEscalateHumanMessage(escalate, pr) {
     if (escalate.thrashHistory && escalate.thrashHistory.length > 0) {
         lines.push("");
         lines.push("## Fix attempts");
+        lines.push("");
         for (const a of escalate.thrashHistory) {
             lines.push(`- thread \`${a.threadId}\` attempted ${a.attempts} times`);
         }
@@ -90,26 +92,26 @@ export function buildEscalateHumanMessage(escalate, pr) {
     lines.push("");
     lines.push("---");
     lines.push("");
-    lines.push(`After fixing manually, rerun \`/pr-shepherd:pr-shepherd ${pr}\` to resume.`);
+    lines.push(`After completing manual fixes (and pushing if required), rerun \`/pr-shepherd:pr-shepherd ${pr}\` to resume.`);
     return lines.join("\n");
 }
 export function buildEscalateSuggestion(triggers, detail) {
     if (triggers.includes("stall-timeout")) {
         const mins = detail ?? "30";
-        return `No progress detected for ${mins} minute${parseInt(mins, 10) === 1 ? "" : "s"} — state has not changed. Inspect the PR and resume manually once the blocking issue is resolved.`;
+        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")) {
         const reason = detail ? ` (${detail})` : "";
-        return `Could not determine the PR's base branch${reason} — refusing to emit a rebase that could force-push onto the wrong base. Run the rebase manually against the PR's real target branch.`;
+        return `Could not determine the PR's base branch${reason} — automated rebases are paused because branch safety is unclear. Run the rebase manually against the PR's real target branch.`;
     }
     if (triggers.includes("fix-thrash")) {
-        return "Same thread(s) attempted multiple times without resolution — fix manually then rerun /pr-shepherd:pr-shepherd";
+        return "Same thread(s) reached the automated attempt limit — treat this as a manual handoff. Apply the fix by hand.";
     }
     if (triggers.includes("pr-level-changes-requested")) {
-        return "Reviewer requested changes but left no inline comments — read the review and act manually";
+        return "Reviewer requested changes but left no inline comments — read the review and act manually.";
     }
     if (triggers.includes("thread-missing-location")) {
-        return "Review thread has no file/line reference — cannot locate code to edit automatically";
+        return "Review thread has no file/line reference — automated location routing failed and manual handling is required.";
     }
-    return "Ambiguous state — inspect the PR and act manually";
+    return "Ambiguous state — automated handling cannot proceed safely. Inspect the PR and act manually.";
 }

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

@@ -1,3 +1,4 @@
+/* eslint-disable max-lines */
 import { readFixAttempts, writeFixAttempts } from "../../state/fix-attempts.mjs";
 import { toAgentThread, toAgentComment, toAgentChecks } from "../../reporters/agent.mjs";
 import { checkEscalateTriggers, validateBaseBranch, buildEscalateSuggestion, buildEscalateHumanMessage, } from "./escalate.mjs";
@@ -52,14 +53,24 @@ export async function handleFixCode(ctx) {
     const checks = toAgentChecks(failingChecks);
     const { changesRequestedReviews } = report;
     const hasConflicts = report.mergeStatus.status === "CONFLICTS";
-    const hasGuaranteedSupersedingPush = threads.length > 0 || checks.length > 0 || changesRequestedReviews.length > 0 || hasConflicts;
-    const inProgressRunIds = hasGuaranteedSupersedingPush
-        ? buildInProgressRunIds(report, cancelledSet)
-        : [];
+    const hasReviewRequestedCodeLikeChanges = changesRequestedReviews.length > 0 &&
+        (actionableComments.length > 0 || resolutionOnlyThreads.length > 0);
+    const hasGuaranteedPush = threads.length > 0 || checks.length > 0 || hasConflicts || hasReviewRequestedCodeLikeChanges;
+    const shouldPush = hasGuaranteedPush;
+    // Only cancel in-progress runs for paths that produce a new code commit. A
+    // conflict-only rebase push will supersede any in-progress run on its own.
+    const hasCodeLikePush = threads.length > 0 || checks.length > 0 || hasReviewRequestedCodeLikeChanges;
+    const inProgressRunIds = hasCodeLikePush ? buildInProgressRunIds(report, cancelledSet) : [];
     const commentMinimizeIds = report.comments.minimizeIds ?? actionableComments.map((c) => c.id);
     const allCommentIds = [...commentMinimizeIds, ...reviewSummaryIds];
     const resolveCommand = buildResolveCommand(threads, resolutionOnlyThreads, allCommentIds, changesRequestedReviews, checks, prNumber, cliRunner);
-    if (baseLookup.isFallback && (resolveCommand.requiresHeadSha || hasConflicts)) {
+    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`);
+    }
+    if (baseLookup.isFallback && shouldPush) {
         const fallbackEscalateBase = {
             triggers: ["base-branch-unknown"],
             unresolvedThreads: [...threads, ...resolutionOnlyThreads.map(toAgentThread)],
@@ -78,7 +89,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, cliRunner);
+    const instructions = buildFixInstructions(threads, actionableComments, checks, changesRequestedReviews, baseLookup.branch, resolveCommand, hasConflicts, prNumber, cancelled.length, firstLookThreads, firstLookComments, firstLookSummaries, editedSummaries, inProgressRunIds, resolutionOnlyThreads, cliRunner, shouldPush);
     return applyStallGuard(stallKey, stallTimeoutSeconds, headSha, base, prNumber, {
         ...base,
         baseBranch: baseLookup.branch,

package/bin/commands/iterate/index.mjs

@@ -51,8 +51,25 @@ export async function runIterate(opts) {
             log: `CANCEL: PR #${report.pr} is ${state} — stopping`,
         };
     }
-    const isReady = report.status === "READY";
-    const readyState = await updateReadyDelay(report.pr, isReady, readyDelaySeconds, repoOwner, repoName);
+    const { minimizeIds: reviewSummaryIds, firstLookSummaries, editedSummaries, surfacedApprovals, } = classifyReviewSummaries({
+        firstLook: report.firstLookSummaries,
+        seen: report.reviewSummaries,
+        edited: report.editedSummaries,
+    }, report.approvedReviews, config.iterate.minimizeApprovals, config.iterate.minimizeComments);
+    const hasActionableWork = report.threads.actionable.length > 0 ||
+        report.threads.resolutionOnly.length > 0 ||
+        report.threads.firstLook.length > 0 ||
+        report.comments.actionable.length > 0 ||
+        (report.comments.minimizeIds?.length ?? 0) > 0 ||
+        report.comments.firstLook.length > 0 ||
+        report.changesRequestedReviews.length > 0 ||
+        report.checks.failing.length > 0 ||
+        report.mergeStatus.status === "CONFLICTS" ||
+        reviewSummaryIds.length > 0 ||
+        firstLookSummaries.length > 0 ||
+        editedSummaries.length > 0;
+    const isCleanReadyHandoff = report.status === "READY" && !hasActionableWork;
+    const readyState = await updateReadyDelay(report.pr, isCleanReadyHandoff, readyDelaySeconds, repoOwner, repoName);
     const base = {
         pr: report.pr,
         repo: report.repo,
@@ -88,20 +105,6 @@ export async function runIterate(opts) {
         };
     }
     const headSha = (await getCurrentHeadSha()) ?? "unknown";
-    const { minimizeIds: reviewSummaryIds, firstLookSummaries, editedSummaries, surfacedApprovals, } = classifyReviewSummaries({
-        firstLook: report.firstLookSummaries,
-        seen: report.reviewSummaries,
-        edited: report.editedSummaries,
-    }, report.approvedReviews, config.iterate.minimizeApprovals, config.iterate.minimizeComments);
-    const hasActionableWork = report.threads.actionable.length > 0 ||
-        report.threads.resolutionOnly.length > 0 ||
-        report.comments.actionable.length > 0 ||
-        report.changesRequestedReviews.length > 0 ||
-        report.checks.failing.length > 0 ||
-        report.mergeStatus.status === "CONFLICTS" ||
-        reviewSummaryIds.length > 0 ||
-        firstLookSummaries.length > 0 ||
-        editedSummaries.length > 0;
     if (hasActionableWork) {
         return handleFixCode({
             base,

package/bin/commands/iterate/render.mjs

@@ -16,8 +16,10 @@ export function renderResolveCommand(rc) {
     }
     return renderShellCommand(parts);
 }
-export function buildFixInstructions(threads, actionableComments, checks, reviews, baseBranch, resolveCommand, hasConflicts, prNumber, cancelledCount, firstLookThreads = [], firstLookComments = [], firstLookSummaries = [], editedSummaries = [], inProgressRunIds = [], resolutionOnlyThreads = [], runner) {
+export function buildFixInstructions(threads, actionableComments, checks, changesRequestedReviews, baseBranch, resolveCommand, hasConflicts, prNumber, cancelledCount, firstLookThreads = [], firstLookComments = [], firstLookSummaries = [], editedSummaries = [], inProgressRunIds = [], resolutionOnlyThreads = [], runner, needsPushInput) {
     const instructions = [];
+    const hasCodeWork = threads.length > 0 || checks.length > 0;
+    const needsPush = needsPushInput ?? (hasCodeWork || hasConflicts);
     if (inProgressRunIds.length > 0) {
         instructions.push(`Cancel in-progress CI runs first: for each ID under \`## In-progress runs\`, run \`gh run cancel <id>\` before applying code fixes. If \`gh\` reports a run is already completed, ignore it and continue with the next ID.`);
     }
@@ -35,15 +37,18 @@ export function buildFixInstructions(threads, actionableComments, checks, review
         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(...buildFailingCheckInstructions(checks));
-    if (reviews.length > 0) {
+    if (changesRequestedReviews.length > 0) {
         instructions.push(`For each bullet under \`## Changes-requested reviews\` above: read the review body and apply the requested changes.`);
     }
-    const hasCodeChanges = threads.length > 0 || checks.length > 0 || reviews.length > 0;
-    const needsPush = hasCodeChanges || hasConflicts;
-    if (hasCodeChanges) {
+    if (needsPush && (hasCodeWork || changesRequestedReviews.length > 0)) {
         instructions.push(`Commit changed files: \`git add <files> && git commit -m "<descriptive message>"\``);
+    }
+    if (changesRequestedReviews.length > 0) {
         instructions.push(`Keep the PR title and description current: if the changes alter the PR's scope or intent, run \`gh pr edit ${prNumber} --title "<new title>" --body "<new body>"\` to reflect them. Skip if the existing title/body still accurately describe the PR.`);
     }
+    if (!needsPush && resolveCommand.requiresHeadSha) {
+        instructions.push("Capture the current HEAD SHA before resolving with: `HEAD_SHA=$(git rev-parse HEAD)`.");
+    }
     if (needsPush) {
         const captureHint = resolveCommand.requiresHeadSha
             ? ` — capture \`HEAD_SHA=$(git rev-parse HEAD)\``
@@ -71,7 +76,8 @@ export function buildFixInstructions(threads, actionableComments, checks, review
     if (resolveCommand.hasMutations) {
         const substituteParts = [];
         if (resolveCommand.requiresHeadSha) {
-            substituteParts.push(`"$HEAD_SHA" with the pushed commit SHA`);
+            const shaSource = needsPush ? "pushed commit SHA" : "current HEAD SHA";
+            substituteParts.push(`"$HEAD_SHA" with the ${shaSource}`);
         }
         if (resolveCommand.requiresDismissMessage) {
             substituteParts.push(`$DISMISS_MESSAGE with a one-sentence description of what you changed`);

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

@@ -0,0 +1,25 @@
+// @ts-nocheck
+import { vi } from "vitest";
+import { NOW, makeOpts } from "./iterate-test-support.mjs";
+import { readStallState, writeStallState } from "../state/iterate-stall.mjs";
+const mockReadStallState = vi.mocked(readStallState);
+const mockWriteStallState = vi.mocked(writeStallState);
+const STALL_TIMEOUT_S = 1800;
+const RESOLUTION_ONLY_THREAD = {
+    id: "thread-resolution-only",
+    isResolved: false,
+    isOutdated: true,
+    isMinimized: false,
+    path: "src/old.mts",
+    line: null,
+    startLine: null,
+    author: "reviewer",
+    authorType: "Unknown",
+    body: "Already addressed on an old diff",
+    url: "",
+    createdAtUnix: NOW - 3600,
+};
+function makeOpts30mStall(overrides = {}) {
+    return makeOpts({ stallTimeoutSeconds: STALL_TIMEOUT_S, noAutoMarkReady: true, ...overrides });
+}
+export { RESOLUTION_ONLY_THREAD, STALL_TIMEOUT_S, makeOpts30mStall, mockReadStallState, mockWriteStallState, };

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

@@ -0,0 +1,149 @@
+import { vi, beforeEach, afterEach } from "vitest";
+const mockFetch = vi.fn();
+vi.stubGlobal("fetch", mockFetch);
+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("./check.mts", () => ({ runCheck: vi.fn() }));
+vi.mock("./ready-delay.mts", () => ({ updateReadyDelay: vi.fn() }));
+vi.mock("../github/client.mts", () => ({ getCurrentPrNumber: vi.fn().mockResolvedValue(42) }));
+vi.mock("../state/fix-attempts.mts", () => ({
+    readFixAttempts: vi.fn().mockResolvedValue(null),
+    writeFixAttempts: vi.fn().mockResolvedValue(undefined),
+}));
+vi.mock("../state/iterate-stall.mts", () => ({
+    readStallState: vi.fn().mockResolvedValue(null),
+    writeStallState: vi.fn().mockResolvedValue(undefined),
+    clearStallState: vi.fn().mockResolvedValue(undefined),
+}));
+const { mockLoadConfig } = vi.hoisted(() => ({ mockLoadConfig: vi.fn() }));
+vi.mock("../config/load.mts", () => ({ loadConfig: mockLoadConfig }));
+import { runCheck } from "./check.mjs";
+import { updateReadyDelay } from "./ready-delay.mjs";
+import { getCurrentPrNumber } from "../github/client.mjs";
+import { readFixAttempts, writeFixAttempts } from "../state/fix-attempts.mjs";
+import { clearStallState, readStallState, writeStallState } from "../state/iterate-stall.mjs";
+import { buildEscalateHumanMessage, buildEscalateSuggestion, checkEscalateTriggers, } from "./iterate/escalate.mjs";
+import { buildRelevantChecks, buildWaitLog, getCurrentHeadSha } from "./iterate/helpers.mjs";
+const mockRunCheck = vi.mocked(runCheck);
+const mockUpdateReadyDelay = vi.mocked(updateReadyDelay);
+const mockGetCurrentPrNumber = vi.mocked(getCurrentPrNumber);
+const mockReadFixAttempts = vi.mocked(readFixAttempts);
+const mockWriteFixAttempts = vi.mocked(writeFixAttempts);
+const mockReadStallState = vi.mocked(readStallState);
+const mockWriteStallState = vi.mocked(writeStallState);
+const mockClearStallState = vi.mocked(clearStallState);
+const NOW = 1_700_000_000;
+const READY_STATE_DEFAULT = { isReady: true, shouldCancel: false, remainingSeconds: 300 };
+function makeReport(overrides = {}) {
+    return {
+        pr: 42,
+        nodeId: "PR_kgDOAAA",
+        repo: "owner/repo",
+        status: "READY",
+        baseBranch: "main",
+        mergeStatus: {
+            status: "CLEAN",
+            state: "OPEN",
+            isDraft: false,
+            mergeable: "MERGEABLE",
+            reviewDecision: "APPROVED",
+            blockingBotReviewInProgress: false,
+            mergeStateStatus: "CLEAN",
+        },
+        checks: {
+            passing: [
+                {
+                    name: "ci",
+                    status: "COMPLETED",
+                    conclusion: "SUCCESS",
+                    detailsUrl: "https://github.com/owner/repo/actions/runs/1",
+                    event: "pull_request",
+                    runId: "run-1",
+                    category: "passed",
+                },
+            ],
+            failing: [],
+            inProgress: [],
+            skipped: [],
+            filtered: [],
+            filteredNames: [],
+            blockedByFilteredCheck: false,
+        },
+        threads: {
+            actionable: [],
+            resolutionOnly: [],
+            autoResolved: [],
+            autoResolveErrors: [],
+            firstLook: [],
+        },
+        comments: { actionable: [], firstLook: [] },
+        changesRequestedReviews: [],
+        reviewSummaries: [],
+        firstLookSummaries: [],
+        editedSummaries: [],
+        approvedReviews: [],
+        ...overrides,
+    };
+}
+function makeOpts(overrides = {}) {
+    return { prNumber: 42, format: "json", readyDelaySeconds: 600, ...overrides };
+}
+function makeReview(id, author, body) {
+    return { id, author, authorType: "Unknown", body };
+}
+function defaultConfig() {
+    return {
+        iterate: {
+            fixAttemptsPerThread: 3,
+            stallTimeoutMinutes: 30,
+            minimizeApprovals: false,
+            minimizeComments: "all",
+        },
+        watch: { readyDelayMinutes: 10 },
+        resolve: {
+            concurrency: 4,
+            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 registerIterateHooks(config = defaultConfig) {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockLoadConfig.mockReturnValue(config());
+        process.env["GH_TOKEN"] = "test-token";
+        mockExecFile.mockImplementation((cmd, args) => {
+            if (cmd === "git" && args[0] === "rev-parse") {
+                return Promise.resolve({ stdout: "abc123", stderr: "" });
+            }
+            return Promise.resolve({ stdout: "", stderr: "" });
+        });
+        mockFetch.mockResolvedValue({
+            ok: true,
+            status: 200,
+            headers: new Headers({ "content-type": "application/json" }),
+            json: () => Promise.resolve({ data: {} }),
+            text: () => Promise.resolve('{"data":{}}'),
+        });
+        vi.useFakeTimers();
+        vi.setSystemTime(NOW * 1000);
+        mockUpdateReadyDelay.mockResolvedValue(READY_STATE_DEFAULT);
+        mockReadFixAttempts.mockResolvedValue(null);
+        mockWriteFixAttempts.mockResolvedValue(undefined);
+        mockReadStallState.mockResolvedValue(null);
+        mockWriteStallState.mockResolvedValue(undefined);
+        mockClearStallState.mockResolvedValue(undefined);
+    });
+    afterEach(() => vi.useRealTimers());
+}
+export { NOW, buildEscalateHumanMessage, buildEscalateSuggestion, buildRelevantChecks, buildWaitLog, checkEscalateTriggers, defaultConfig, getCurrentHeadSha, makeOpts, makeReport, makeReview, mockExecFile, mockFetch, mockGetCurrentPrNumber, mockClearStallState, mockLoadConfig, mockReadFixAttempts, mockReadStallState, mockRunCheck, mockUpdateReadyDelay, mockWriteFixAttempts, mockWriteStallState, registerIterateHooks, };

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

@@ -0,0 +1,118 @@
+// @ts-nocheck
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+const mockFetch = vi.fn();
+vi.stubGlobal("fetch", mockFetch);
+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("./check.mts", () => ({ runCheck: vi.fn() }));
+vi.mock("./ready-delay.mts", () => ({ updateReadyDelay: vi.fn() }));
+vi.mock("../github/client.mts", () => ({
+    getCurrentPrNumber: vi.fn().mockResolvedValue(42),
+}));
+vi.mock("../state/fix-attempts.mts", () => ({
+    readFixAttempts: vi.fn().mockResolvedValue(null),
+    writeFixAttempts: vi.fn().mockResolvedValue(undefined),
+}));
+vi.mock("../state/iterate-stall.mts", () => ({
+    readStallState: vi.fn().mockResolvedValue(null),
+    writeStallState: vi.fn().mockResolvedValue(undefined),
+}));
+const { mockLoadConfig } = vi.hoisted(() => ({ mockLoadConfig: vi.fn() }));
+vi.mock("../config/load.mts", () => ({ loadConfig: mockLoadConfig }));
+import { runIterate } from "./iterate/index.mjs";
+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";
+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);
+function makeReport(overrides = {}) {
+    return {
+        pr: 42,
+        nodeId: "PR_kgDOAAA",
+        repo: "owner/repo",
+        status: "READY",
+        baseBranch: "main",
+        mergeStatus: {
+            status: "CLEAN",
+            state: "OPEN",
+            isDraft: false,
+            mergeable: "MERGEABLE",
+            reviewDecision: "APPROVED",
+            blockingBotReviewInProgress: false,
+            mergeStateStatus: "CLEAN",
+        },
+        checks: {
+            passing: [],
+            failing: [],
+            inProgress: [],
+            skipped: [],
+            filtered: [],
+            filteredNames: [],
+            blockedByFilteredCheck: false,
+        },
+        threads: {
+            actionable: [],
+            resolutionOnly: [],
+            autoResolved: [],
+            autoResolveErrors: [],
+            firstLook: [],
+        },
+        comments: { actionable: [], firstLook: [] },
+        changesRequestedReviews: [],
+        reviewSummaries: [],
+        firstLookSummaries: [],
+        editedSummaries: [],
+        approvedReviews: [],
+        ...overrides,
+    };
+}
+function makeOpts(overrides = {}) {
+    return {
+        prNumber: 42,
+        format: "json",
+        readyDelaySeconds: 600,
+        ...overrides,
+    };
+}
+export function registerHooks() {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockExecFile.mockResolvedValue({ stdout: "abc1234\n", stderr: "" });
+        mockLoadConfig.mockReturnValue({
+            iterate: {
+                fixAttemptsPerThread: 3,
+                stallTimeoutMinutes: 60,
+                minimizeApprovals: false,
+            },
+            watch: { readyDelayMinutes: 10 },
+            resolve: {
+                concurrency: 4,
+                shaPoll: { intervalMs: 2000, maxAttempts: 10 },
+                fetchReviewSummaries: true,
+            },
+            checks: { ciTriggerEvents: ["pull_request"] },
+            mergeStatus: { blockingReviewerLogins: [] },
+            actions: { autoResolveOutdated: false, autoMarkReady: false, commitSuggestions: false },
+        });
+        mockReadFixAttempts.mockResolvedValue(null);
+        mockWriteFixAttempts.mockResolvedValue(undefined);
+        mockReadStallState.mockResolvedValue(null);
+        mockWriteStallState.mockResolvedValue(undefined);
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+}
+export { makeOpts, makeReport, mockExecFile, mockFetch, mockLoadConfig, mockReadFixAttempts, mockReadStallState, mockRunCheck, mockUpdateReadyDelay, mockWriteFixAttempts, mockWriteStallState, readFixAttempts, readStallState, runCheck, runIterate, updateReadyDelay, writeFixAttempts, writeStallState, };

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

@@ -0,0 +1,114 @@
+// @ts-nocheck
+import { describe, it, expect, vi, beforeEach } from "vitest";
+vi.mock("../github/client.mts", () => ({
+    getRepoInfo: vi.fn().mockResolvedValue({ owner: "owner", name: "repo" }),
+    getCurrentPrNumber: vi.fn().mockResolvedValue(42),
+}));
+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),
+    };
+});
+vi.mock("../github/batch.mts", () => ({
+    fetchPrBatch: vi.fn(),
+}));
+vi.mock("../comments/resolve.mts", () => ({
+    autoResolveOutdated: vi.fn(),
+    applyResolveOptions: vi.fn(),
+}));
+vi.mock("../config/load.mts", () => ({
+    loadConfig: vi.fn().mockReturnValue({
+        resolve: {
+            shaPoll: { intervalMs: 2000, maxAttempts: 10 },
+            fetchReviewSummaries: true,
+        },
+        actions: {
+            autoResolveOutdated: true,
+            autoMarkReady: true,
+            commitSuggestions: true,
+        },
+    }),
+}));
+import { runResolveFetch, runResolveMutate } from "./resolve.mjs";
+import { getCurrentPrNumber } from "../github/client.mjs";
+import { fetchPrBatch } from "../github/batch.mjs";
+import { autoResolveOutdated, applyResolveOptions } from "../comments/resolve.mjs";
+import { loadConfig } from "../config/load.mjs";
+import { loadSeenMap, markSeen, hashBody } from "../state/seen-comments.mjs";
+const mockGetCurrentPrNumber = vi.mocked(getCurrentPrNumber);
+const mockFetchPrBatch = vi.mocked(fetchPrBatch);
+const mockAutoResolveOutdated = vi.mocked(autoResolveOutdated);
+const mockApplyResolveOptions = vi.mocked(applyResolveOptions);
+const mockLoadConfig = vi.mocked(loadConfig);
+const mockLoadSeenMap = vi.mocked(loadSeenMap);
+const mockMarkSeen = vi.mocked(markSeen);
+const BASE_OPTS = { format: "text" };
+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: [],
+        ...overrides,
+    };
+}
+function makeThread(overrides = {}) {
+    return {
+        id: "t-1",
+        isResolved: false,
+        isOutdated: false,
+        isMinimized: false,
+        path: "src/foo.ts",
+        line: 1,
+        startLine: null,
+        author: "alice",
+        authorType: "Unknown",
+        body: "fix this",
+        url: "",
+        createdAtUnix: 1_700_000_000,
+        ...overrides,
+    };
+}
+function makeComment(overrides = {}) {
+    return {
+        id: "c-1",
+        isMinimized: false,
+        author: "bob",
+        authorType: "Unknown",
+        body: "nit",
+        url: "",
+        createdAtUnix: 1_700_000_000,
+        ...overrides,
+    };
+}
+export function registerHooks() {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockAutoResolveOutdated.mockResolvedValue({ resolved: [], errors: [] });
+        mockApplyResolveOptions.mockResolvedValue({
+            resolvedThreads: [],
+            minimizedComments: [],
+            dismissedReviews: [],
+            errors: [],
+        });
+    });
+}
+export { BASE_OPTS, applyResolveOptions, autoResolveOutdated, fetchPrBatch, getCurrentPrNumber, hashBody, loadConfig, loadSeenMap, makeBatchData, makeComment, makeThread, markSeen, mockApplyResolveOptions, mockAutoResolveOutdated, mockFetchPrBatch, mockGetCurrentPrNumber, mockLoadConfig, mockLoadSeenMap, mockMarkSeen, runResolveFetch, runResolveMutate, };

package/bin/commands/shepherd-journal.test-support.mjs

@@ -0,0 +1,9 @@
+// @ts-nocheck
+import { describe, expect, it } from "vitest";
+import { buildShepherdJournalInstruction, SHEPHERD_JOURNAL_APPEND_HINT, SHEPHERD_JOURNAL_FIRST_LOOK_GUIDANCE, SHEPHERD_JOURNAL_REFERENCE_GUIDANCE_THREADS_AND_COMMENTS_IN_ITEM_HEADINGS, SHEPHERD_JOURNAL_REFERENCE_GUIDANCE_THREADS_AND_COMMENTS_IN_ITEMS, SHEPHERD_JOURNAL_SECTION, SHEPHERD_JOURNAL_SECTION_PATTERN, } from "./shepherd-journal.mjs";
+import { buildFixInstructions } from "./iterate/render.mjs";
+import { buildFetchInstructions } from "./resolve-instructions.mjs";
+function countMentions(text, phrase) {
+    return (text.match(new RegExp(phrase, "g")) ?? []).length;
+}
+export { SHEPHERD_JOURNAL_APPEND_HINT, SHEPHERD_JOURNAL_FIRST_LOOK_GUIDANCE, SHEPHERD_JOURNAL_REFERENCE_GUIDANCE_THREADS_AND_COMMENTS_IN_ITEMS, SHEPHERD_JOURNAL_REFERENCE_GUIDANCE_THREADS_AND_COMMENTS_IN_ITEM_HEADINGS, SHEPHERD_JOURNAL_SECTION, SHEPHERD_JOURNAL_SECTION_PATTERN, buildFetchInstructions, buildFixInstructions, buildShepherdJournalInstruction, countMentions, };