pr-shepherd 0.10.3 → 0.12.0

package/bin/cli/iterate-formatter.mjs

@@ -1,5 +1,6 @@
 import { formatFixCodeResult } from "./fix-formatter.mjs";
 import { joinSections } from "../util/markdown.mjs";
+import { adaptIterateLog, buildSimpleIterateInstructions, numberInstructions, } from "./iterate-instructions.mjs";
 /**
  * Format an IterateResult as human-readable Markdown.
  *
@@ -17,6 +18,9 @@ import { joinSections } from "../util/markdown.mjs";
  */
 export function formatIterateResult(result, opts) {
     const verbose = opts?.verbose ?? false;
+    const runtime = opts?.runtime ?? "claude";
+    const readyDelaySuffix = opts?.readyDelaySuffix;
+    const retryInterval = opts?.retryInterval;
     const heading = `# PR #${result.pr} [${result.action.toUpperCase()}]`;
     const reviewDecisionSeg = result.mergeStatus === "BLOCKED" && result.reviewDecision
         ? ` · **reviewDecision** \`${result.reviewDecision}\``
@@ -51,34 +55,34 @@ export function formatIterateResult(result, opts) {
             // placeholders that add no value. Emit only heading + log + Instructions.
             return joinSections([
                 verbose ? header : heading,
-                result.log,
-                "## Instructions\n\n1. End this iteration — the next cron fire will recheck once CI starts reporting.",
+                adaptIterateLog(result.log, runtime),
+                `## Instructions\n\n${numberInstructions(buildSimpleIterateInstructions(result, runtime, readyDelaySuffix, retryInterval))}`,
             ]);
         case "wait":
             return joinSections([
                 header,
-                result.log,
-                "## Instructions\n\n1. End this iteration — the next cron fire will recheck.",
+                adaptIterateLog(result.log, runtime),
+                `## Instructions\n\n${numberInstructions(buildSimpleIterateInstructions(result, runtime, readyDelaySuffix, retryInterval))}`,
             ]);
         case "mark_ready":
             return joinSections([
                 header,
-                result.log,
-                "## Instructions\n\n1. The CLI already marked the PR ready for review — end this iteration.",
+                adaptIterateLog(result.log, runtime),
+                `## Instructions\n\n${numberInstructions(buildSimpleIterateInstructions(result, runtime, readyDelaySuffix, retryInterval))}`,
             ]);
         case "cancel":
             return joinSections([
                 [`${heading} — ${result.reason}`, "", baseLine, summaryLine].join("\n"),
-                result.log,
-                "## Instructions\n\n1. Invoke `/loop cancel` via the Skill tool.\n2. Stop.",
+                adaptIterateLog(result.log, runtime),
+                `## Instructions\n\n${numberInstructions(buildSimpleIterateInstructions(result, runtime, readyDelaySuffix, retryInterval))}`,
             ]);
         case "escalate":
             return joinSections([
                 header,
                 result.escalate.humanMessage,
-                "## Instructions\n\n1. Invoke `/loop cancel` via the Skill tool.\n2. Stop — the PR needs human direction before monitoring can resume.",
+                `## Instructions\n\n${numberInstructions(buildSimpleIterateInstructions(result, runtime, readyDelaySuffix, retryInterval))}`,
             ]);
         case "fix_code":
-            return formatFixCodeResult(header, result);
+            return formatFixCodeResult(header, result, { runtime, readyDelaySuffix, retryInterval });
     }
 }

package/bin/cli/iterate-instructions.mjs

@@ -0,0 +1,75 @@
+import { FIX_INSTRUCTION_END_ITERATION, FIX_INSTRUCTION_STOP_AFTER_PUSH, FIX_INSTRUCTION_STOP_BEFORE_NEXT_TICK, } from "../commands/iterate/render.mjs";
+const DEFAULT_CODEX_RETRY_INTERVAL = "4m";
+const VALID_RETRY_INTERVAL = /^\d+[smhd]$/;
+export function buildSimpleIterateInstructions(result, runtime, readyDelaySuffix, retryInterval) {
+    const rerunCommand = buildCodexIterateCommand(result.pr, readyDelaySuffix);
+    const retryDelay = buildCodexRetryDelay(retryInterval);
+    switch (result.action) {
+        case "cooldown":
+            return [
+                runtime === "codex"
+                    ? `Continue the active Codex goal — wait about ${retryDelay}, then rerun \`${rerunCommand}\` after CI starts reporting.`
+                    : "End this iteration — the next cron fire will recheck once CI starts reporting.",
+            ];
+        case "wait":
+            return [
+                runtime === "codex"
+                    ? `Continue the active Codex goal — wait about ${retryDelay}, then rerun \`${rerunCommand}\` to recheck.`
+                    : "End this iteration — the next cron fire will recheck.",
+            ];
+        case "mark_ready":
+            return [
+                runtime === "codex"
+                    ? `The CLI already marked the PR ready for review. Continue the active Codex goal until the ready-delay completes — wait about ${retryDelay}, then rerun \`${rerunCommand}\` to recheck.`
+                    : "The CLI already marked the PR ready for review — end this iteration.",
+            ];
+        case "cancel":
+            return [
+                runtime === "codex"
+                    ? "Stop — no recurring Codex monitor is running to cancel."
+                    : "Invoke `/loop cancel` via the Skill tool.",
+                "Stop.",
+            ];
+        case "escalate":
+            return [
+                runtime === "codex"
+                    ? "Stop — no recurring Codex monitor is running to cancel."
+                    : "Invoke `/loop cancel` via the Skill tool.",
+                "Stop — the PR needs human direction before monitoring can resume.",
+            ];
+    }
+}
+export function adaptFixCodeInstructions(instructions, pr, runtime, readyDelaySuffix, retryInterval) {
+    if (runtime !== "codex")
+        return instructions;
+    const rerunCommand = buildCodexIterateCommand(pr, readyDelaySuffix);
+    const retryDelay = buildCodexRetryDelay(retryInterval);
+    return instructions.map((instruction) => {
+        if (instruction === FIX_INSTRUCTION_STOP_AFTER_PUSH) {
+            return `Continue the active Codex goal — CI needs time to run on the new push. Wait about ${retryDelay}, then rerun \`${rerunCommand}\` to recheck.`;
+        }
+        if (instruction === FIX_INSTRUCTION_STOP_BEFORE_NEXT_TICK ||
+            instruction === FIX_INSTRUCTION_END_ITERATION) {
+            return `Continue the active Codex goal — wait about ${retryDelay}, then rerun \`${rerunCommand}\` to recheck.`;
+        }
+        return instruction;
+    });
+}
+export function adaptIterateLog(log, runtime) {
+    if (runtime !== "codex")
+        return log;
+    return log.replace(/\s+—\s+\d+s until auto-cancel/g, "");
+}
+export function buildCodexIterateCommand(pr, readyDelaySuffix) {
+    const suffix = readyDelaySuffix?.trim();
+    return `npx pr-shepherd ${pr}${suffix ? ` --ready-delay ${suffix}` : ""}`;
+}
+export function buildCodexRetryDelay(retryInterval) {
+    const interval = typeof retryInterval === "string" ? retryInterval.trim() : "";
+    return VALID_RETRY_INTERVAL.test(interval)
+        ? `the configured interval (${interval})`
+        : `the configured interval (default ${DEFAULT_CODEX_RETRY_INTERVAL})`;
+}
+export function numberInstructions(instructions) {
+    return instructions.map((instruction, i) => `${i + 1}. ${instruction}`).join("\n");
+}

package/bin/cli/iterate-lean.mjs

@@ -1,9 +1,14 @@
+import { adaptIterateLog, adaptFixCodeInstructions, buildSimpleIterateInstructions, } from "./iterate-instructions.mjs";
 /**
  * Project an IterateResult to a lean JSON shape for the default (non-verbose) output.
  * Omits fields that are the trivial default (false, 0, empty) or state-gated fields
  * outside the state where they are meaningful.
  */
-export function projectIterateLean(result) {
+export function projectIterateLean(result, opts) {
+    const runtime = opts?.runtime ?? "claude";
+    const readyDelaySuffix = opts?.readyDelaySuffix;
+    const retryInterval = opts?.retryInterval;
+    const simpleInstructions = (r) => buildSimpleIterateInstructions(r, runtime, readyDelaySuffix, retryInterval);
     const base = {
         action: result.action,
         pr: result.pr,
@@ -30,14 +35,31 @@ export function projectIterateLean(result) {
     };
     switch (result.action) {
         case "cooldown":
-            return { ...base, log: result.log };
+            return {
+                ...base,
+                log: adaptIterateLog(result.log, runtime),
+                instructions: simpleInstructions(result),
+            };
         case "wait":
-            return { ...base, log: result.log };
+            return {
+                ...base,
+                log: adaptIterateLog(result.log, runtime),
+                instructions: simpleInstructions(result),
+            };
         case "cancel":
-            return { ...base, reason: result.reason, log: result.log };
+            return {
+                ...base,
+                reason: result.reason,
+                log: adaptIterateLog(result.log, runtime),
+                instructions: simpleInstructions(result),
+            };
         case "mark_ready":
             // drop markedReady — always true, redundant with action discriminator
-            return { ...base, log: result.log };
+            return {
+                ...base,
+                log: adaptIterateLog(result.log, runtime),
+                instructions: simpleInstructions(result),
+            };
         case "fix_code":
             return {
                 ...base,
@@ -46,6 +68,9 @@ export function projectIterateLean(result) {
                 fix: {
                     mode: result.fix.mode,
                     ...(result.fix.threads.length > 0 && { threads: result.fix.threads }),
+                    ...(result.fix.resolutionOnlyThreads.length > 0 && {
+                        resolutionOnlyThreads: result.fix.resolutionOnlyThreads,
+                    }),
                     ...(result.fix.actionableComments.length > 0 && {
                         actionableComments: result.fix.actionableComments,
                     }),
@@ -67,12 +92,17 @@ export function projectIterateLean(result) {
                     ...(result.fix.firstLookComments.length > 0 && {
                         firstLookComments: result.fix.firstLookComments,
                     }),
+                    ...(result.fix.inProgressRunIds.length > 0 && {
+                        inProgressRunIds: result.fix.inProgressRunIds,
+                    }),
                     ...(result.fix.checks.length > 0 && { checks: result.fix.checks }),
                     ...(result.fix.changesRequestedReviews.length > 0 && {
                         changesRequestedReviews: result.fix.changesRequestedReviews,
                     }),
                     resolveCommand: result.fix.resolveCommand,
-                    ...(result.fix.instructions.length > 0 && { instructions: result.fix.instructions }),
+                    ...(result.fix.instructions.length > 0 && {
+                        instructions: adaptFixCodeInstructions(result.fix.instructions, result.pr, runtime, readyDelaySuffix, retryInterval),
+                    }),
                 },
             };
         case "escalate":
@@ -96,6 +126,29 @@ export function projectIterateLean(result) {
                     suggestion: result.escalate.suggestion,
                     humanMessage: result.escalate.humanMessage,
                 },
+                instructions: simpleInstructions(result),
             };
     }
 }
+export function projectIterateVerbose(result, opts) {
+    const runtime = opts?.runtime ?? "claude";
+    const readyDelaySuffix = opts?.readyDelaySuffix;
+    const retryInterval = opts?.retryInterval;
+    if (result.action === "fix_code") {
+        return {
+            ...result,
+            fix: {
+                ...result.fix,
+                instructions: adaptFixCodeInstructions(result.fix.instructions, result.pr, runtime, readyDelaySuffix, retryInterval),
+            },
+        };
+    }
+    const log = "log" in result && typeof result.log === "string"
+        ? { log: adaptIterateLog(result.log, runtime) }
+        : {};
+    return {
+        ...result,
+        ...log,
+        instructions: buildSimpleIterateInstructions(result, runtime, readyDelaySuffix, retryInterval),
+    };
+}

package/bin/cli/list-formatters.mjs

@@ -11,6 +11,12 @@ export function renderFirstLookStatusTag(t) {
         ? `[status: outdated, auto-resolved${editedSuffix}]`
         : `[status: ${t.firstLookStatus}${editedSuffix}]`;
 }
+export function renderThreadResolutionStatusTag(t) {
+    const status = [t.isOutdated ? "outdated" : null, t.isMinimized ? "minimized" : null]
+        .filter(Boolean)
+        .join(", ");
+    return status ? `[status: ${status}]` : "[status: unresolved]";
+}
 export function renderThreadBullet(t, opts = {}) {
     const link = t.url ? ` [↗](${t.url})` : "";
     const loc = t.path
@@ -33,3 +39,8 @@ export function renderReviewBullet(r, opts = {}) {
     const bodySuffix = opts.includeBody && r.body != null && r.body !== "" ? `: ${renderBodyPreview(r.body)}` : "";
     return `- \`reviewId=${r.id}\` (@${r.author})${bodySuffix}`;
 }
+export function renderReviewListSection(heading, items) {
+    if (items.length === 0)
+        return null;
+    return `## ${heading}\n\n${items.map((r) => renderReviewBullet(r, { includeBody: true })).join("\n")}`;
+}

package/bin/cli-parser.iterate-fixtures.mjs

@@ -28,6 +28,7 @@ export function makeIterateResult(action = "wait") {
             fix: {
                 mode: "rebase-and-push",
                 threads: [],
+                resolutionOnlyThreads: [],
                 actionableComments: [],
                 reviewSummaryIds: [],
                 firstLookSummaries: [],
@@ -44,6 +45,7 @@ export function makeIterateResult(action = "wait") {
                 instructions: ["End this iteration."],
                 firstLookThreads: [],
                 firstLookComments: [],
+                inProgressRunIds: [],
             },
             cancelled: [],
         };

package/bin/cli-parser.mjs

@@ -3,6 +3,9 @@
  *
  * Usage:
  *   pr-shepherd --version
+ *   pr-shepherd [PR] [--format text|json] [--cooldown-seconds N] [--ready-delay Nm]
+ *                  [--stall-timeout <duration>] [--no-auto-mark-ready]
+ *                  [--no-auto-cancel-actionable]
  *   pr-shepherd check [PR] [--format text|json]
  *   pr-shepherd resolve [PR] [--fetch] [--resolve-thread-ids A,B] [--minimize-comment-ids X,Y]
  *                            [--dismiss-review-ids Q] [--message MSG] [--require-sha SHA]
@@ -22,10 +25,12 @@ import { runLogFile } from "./commands/log-file.mjs";
 import { formatJson } from "./reporters/json.mjs";
 import { formatText } from "./reporters/text.mjs";
 import { parseCommonArgs, getFlag, hasFlag, parseList } from "./cli/args.mjs";
+import { isDefaultIterateInvocation, validateDefaultIterateArgs } from "./cli/default-iterate.mjs";
 import { statusToExitCode } from "./cli/exit-codes.mjs";
 import { formatFetchResult, formatMutateResult } from "./cli/formatters.mjs";
 import { handleCommitSuggestion, handleIterate, handleMonitor, handleStatus, } from "./cli/handlers.mjs";
 import { setupLog } from "./log/setup.mjs";
+import { detectAgentRuntime } from "./agent-runtime.mjs";
 // ---------------------------------------------------------------------------
 // Entry
 // ---------------------------------------------------------------------------
@@ -43,6 +48,12 @@ export async function main(argv) {
     }
     // Initialize the per-worktree log and install a stdout tee.
     await setupLog(argv);
+    if (isDefaultIterateInvocation(subcommand)) {
+        if (!validateDefaultIterateArgs(args))
+            return;
+        await handleIterate(args);
+        return;
+    }
     switch (subcommand) {
         case "check":
             await handleCheck(args.slice(1));
@@ -80,8 +91,11 @@ function readVersion() {
 // ---------------------------------------------------------------------------
 async function handleCheck(args) {
     const { prNumber, global: globalOpts } = parseCommonArgs(args);
+    const runtime = detectAgentRuntime();
     const report = await runCheck({ ...globalOpts, prNumber, autoResolve: false });
-    const output = globalOpts.format === "json" ? formatJson(report) : formatText(report);
+    const output = globalOpts.format === "json"
+        ? formatJson(report, { runtime })
+        : formatText(report, { runtime });
     process.stdout.write(`${output}\n`);
     process.exitCode = statusToExitCode(report.status);
 }

package/bin/commands/check.mjs

@@ -35,11 +35,9 @@ 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, config.checks.logTailLines, config.checks.logTailChars)
-        : failing;
+    const triaged = 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 && !t.isMinimized);
+    const unresolvedThreads = batchData.reviewThreads.filter((t) => !t.isResolved);
     const visibleComments = batchData.comments.filter((c) => !c.isMinimized);
     const outdated = getOutdatedThreads(unresolvedThreads);
     let autoResolved = [];
@@ -49,7 +47,7 @@ export async function runCheck(opts) {
         autoResolved = outdated.filter((t) => resolvedIds.includes(t.id));
         autoResolveErrors = errors;
     }
-    const activeThreads = unresolvedThreads.filter((t) => !t.isOutdated);
+    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);
@@ -108,13 +106,14 @@ export async function runCheck(opts) {
         ...[...firstLookSummaries, ...editedSummaries].map((r) => markSeen(stateKey, r.id, r.body)),
     ]);
     const actionableThreads = activeThreads;
+    const resolutionOnlyThreads = unresolvedThreads.filter((t) => !autoResolvedIds.has(t.id) && (t.isOutdated || t.isMinimized));
     const actionableComments = visibleComments;
     const mergeStatus = deriveMergeStatus(batchData);
     const blockedByFilteredCheck = mergeStatus.status === "BLOCKED" &&
         !verdict.anyFailing &&
         !verdict.anyInProgress &&
         verdict.filteredNames.length > 0;
-    const status = computeStatus(verdict, actionableThreads.length, actionableComments.length, mergeStatus, batchData.changesRequestedReviews.length);
+    const status = computeStatus(verdict, actionableThreads.length + resolutionOnlyThreads.length, actionableComments.length, mergeStatus, batchData.changesRequestedReviews.length);
     return {
         pr: prNumber,
         nodeId: batchData.nodeId,
@@ -133,6 +132,7 @@ export async function runCheck(opts) {
         },
         threads: {
             actionable: actionableThreads,
+            resolutionOnly: resolutionOnlyThreads,
             autoResolved,
             autoResolveErrors,
             firstLook: firstLookThreads,

package/bin/commands/commit-suggestion.mjs

@@ -1,11 +1,8 @@
 import { execFile as execFileCb } from "node:child_process";
-import { readFile, writeFile, unlink } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
+import { readFile } from "node:fs/promises";
 import { promisify } from "node:util";
 import { getRepoInfo, getCurrentPrNumber, getCurrentBranch } from "../github/client.mjs";
 import { fetchPrBatch } from "../github/batch.mjs";
-import { applyResolveOptions } from "../comments/resolve.mjs";
 import { parseSuggestion, isCommittableSuggestion } from "../suggestions/parse.mjs";
 import { buildUnifiedDiff } from "../suggestions/patch.mjs";
 const execFile = promisify(execFileCb);
@@ -13,13 +10,9 @@ export async function runCommitSuggestion(opts) {
     if (!opts.threadId) {
         throw new Error("--thread-id is required");
     }
-    if (!opts.dryRun && (!opts.message || opts.message.trim() === "")) {
+    if (!opts.message || opts.message.trim() === "") {
         throw new Error("--message is required and must be non-empty");
     }
-    const { stdout: statusOut } = await execFile("git", ["status", "--porcelain"]);
-    if (statusOut.trim() !== "") {
-        throw new Error("Working tree has uncommitted changes. Commit or stash them before running commit-suggestion.");
-    }
     const repo = await getRepoInfo();
     const prNumber = opts.prNumber ?? (await getCurrentPrNumber());
     if (prNumber === null) {
@@ -56,6 +49,17 @@ export async function runCommitSuggestion(opts) {
     if (!thread.path || thread.line === null) {
         throw new Error(`Thread ${opts.threadId} has no file/line anchor.`);
     }
+    // Validate the target file is clean before generating the patch, so the emitted
+    // `git add -- <file>` instruction cannot accidentally stage unrelated local edits.
+    const { stdout: fileStatus } = await execFile("git", [
+        "status",
+        "--porcelain",
+        "--",
+        thread.path,
+    ]);
+    if (fileStatus.trim() !== "") {
+        throw new Error(`${thread.path} has uncommitted changes. Commit or stash them before running commit-suggestion.`);
+    }
     const parsed = parseSuggestion(thread.body);
     if (!parsed) {
         throw new Error(`Thread ${opts.threadId} has no suggestion block in the comment body.`);
@@ -75,74 +79,25 @@ export async function runCommitSuggestion(opts) {
         endLine,
         replacementLines: parsed.lines,
     });
-    const patchFile = join(tmpdir(), `pr-shepherd-${Date.now()}-${Math.random().toString(36).slice(2)}.patch`);
-    let patchError = null;
-    try {
-        await writeFile(patchFile, patch, { mode: 0o600 });
-        try {
-            await execFile("git", ["apply", "--check", patchFile]);
-        }
-        catch (err) {
-            patchError = (err.stderr?.trim() || String(err)).trim();
-        }
-        if (opts.dryRun) {
-            return {
-                pr: prNumber,
-                repo: `${repo.owner}/${repo.name}`,
-                threadId: opts.threadId,
-                path: filePath,
-                startLine,
-                endLine,
-                author: thread.author,
-                applied: false,
-                dryRun: true,
-                valid: patchError === null,
-                reason: patchError !== null ? `git apply rejected the patch: ${patchError}` : null,
-                patch,
-                postActionInstruction: patchError === null ? "Re-run without --dry-run to apply and commit." : "",
-            };
-        }
-        if (patchError !== null) {
-            return {
-                pr: prNumber,
-                repo: `${repo.owner}/${repo.name}`,
-                threadId: opts.threadId,
-                path: filePath,
-                startLine,
-                endLine,
-                author: thread.author,
-                applied: false,
-                reason: `git apply rejected the patch: ${patchError}`,
-                patch,
-                postActionInstruction: "",
-            };
-        }
-        try {
-            await execFile("git", ["apply", patchFile]);
-        }
-        catch (applyErr) {
-            try {
-                await execFile("git", ["checkout", "--", filePath]);
-            }
-            catch {
-                // best-effort rollback
-            }
-            throw applyErr;
-        }
-    }
-    finally {
-        await unlink(patchFile).catch(() => undefined);
-    }
-    await execFile("git", ["add", "--", filePath]);
     const coAuthor = `Co-authored-by: ${thread.author} <${thread.author}@users.noreply.github.com>`;
     const commitBody = opts.description ? `${opts.description}\n\n${coAuthor}` : coAuthor;
-    await execFile("git", ["commit", "-m", opts.message, "-m", commitBody]);
-    const { stdout: shaOut } = await execFile("git", ["rev-parse", "HEAD"]);
-    const commitSha = shaOut.trim();
-    const resolveResult = await applyResolveOptions(prNumber, repo, {
-        resolveThreadIds: [opts.threadId],
-    });
-    const resolveErrors = resolveResult.errors;
+    const commitMessageArg = opts.message;
+    const commitBodyArg = commitBody;
+    const quotedPath = `'${filePath.replace(/'/g, "'\\''")}'`;
+    const range = startLine === endLine ? `line ${startLine}` : `lines ${startLine}–${endLine}`;
+    const sq = (s) => `'${s.replace(/'/g, "'\\''")}'`;
+    const commitCmd = [
+        "git commit",
+        `-m ${sq(commitMessageArg)}`,
+        ...commitBodyArg.split("\n\n").map((p) => `-m ${sq(p)}`),
+    ].join(" ");
+    const postActionInstructions = [
+        `Apply the patch to \`${filePath}\`: run \`git apply\` with the diff shown above, or edit the file directly using the line range (${range}).`,
+        `Stage the file: \`git add -- ${quotedPath}\``,
+        `Commit: \`${commitCmd}\``,
+        `Resolve the thread on GitHub: \`npx pr-shepherd resolve ${prNumber} --resolve-thread-ids ${opts.threadId}\``,
+        `Push when ready: \`git push\` (or \`git push --force-with-lease\` after rebasing).`,
+    ];
     return {
         pr: prNumber,
         repo: `${repo.owner}/${repo.name}`,
@@ -151,11 +106,10 @@ export async function runCommitSuggestion(opts) {
         startLine,
         endLine,
         author: thread.author,
-        applied: true,
-        commitSha,
         patch,
-        postActionInstruction: resolveErrors.length > 0
-            ? `Commit created (${commitSha}), but failed to resolve thread ${opts.threadId}: ${resolveErrors.join("; ")}. Run \`git push\` then resolve manually.`
-            : "Run `git push` (or `git push --force-with-lease` after rebasing) to publish the commit.",
+        commitMessage: commitMessageArg,
+        commitBody: commitBodyArg,
+        filesToStage: [filePath],
+        postActionInstructions,
     };
 }

package/bin/commands/iterate/classify.mjs

@@ -20,10 +20,11 @@ export function classifyReviewSummaries(summaries, approvals, minimizeApprovals)
         surfacedApprovals: approvals,
     };
 }
-export function buildResolveCommand(threads, allCommentIds, reviews, checks, prNumber) {
+export function buildResolveCommand(threads, resolutionOnlyThreads, allCommentIds, reviews, checks, prNumber) {
     const argv = ["npx", "pr-shepherd", "resolve", String(prNumber)];
-    if (threads.length > 0) {
-        argv.push("--resolve-thread-ids", threads.map((t) => t.id).join(","));
+    const threadIds = [...threads.map((t) => t.id), ...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(","));
@@ -41,6 +42,6 @@ export function buildResolveCommand(threads, allCommentIds, reviews, checks, prN
     // --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 = threads.length > 0 || allCommentIds.length > 0 || reviews.length > 0;
+    const hasMutations = threadIds.length > 0 || allCommentIds.length > 0 || reviews.length > 0;
     return { argv, requiresHeadSha, requiresDismissMessage: hasDismiss, hasMutations };
 }

package/bin/commands/iterate/escalate.mjs

@@ -1,5 +1,5 @@
 import { loadConfig } from "../../config/load.mjs";
-export function checkEscalateTriggers(actionableThreads, actionableComments, changesRequestedReviews, failingChecks, threadAttempts, hasConflicts) {
+export function checkEscalateTriggers(actionableThreads, resolutionOnlyThreads, actionableComments, changesRequestedReviews, failingChecks, threadAttempts, hasConflicts) {
     const triggers = [];
     const maxAttempts = loadConfig().iterate.fixAttemptsPerThread;
     // Trigger 1: fix thrash — same thread dispatched too many times without resolving.
@@ -11,6 +11,7 @@ export function checkEscalateTriggers(actionableThreads, actionableComments, cha
     // Skip when there are merge conflicts — fix_code handles conflict resolution, not escalation.
     if (changesRequestedReviews.length > 0 &&
         actionableThreads.length === 0 &&
+        resolutionOnlyThreads.length === 0 &&
         actionableComments.length === 0 &&
         failingChecks.length === 0 &&
         !hasConflicts) {