dev-loops 0.1.0

package/scripts/github/reconcile-draft-gate.mjs

@@ -0,0 +1,328 @@
+#!/usr/bin/env node
+import { buildParseError, formatCliError, isDirectCliRun, parseJsonText } from "../_core-helpers.mjs";
+import { parsePrNumber, requireOptionValue, runChild } from "../_cli-primitives.mjs";
+import { loadDevLoopConfig, resolveGateConfig } from "@dev-loops/core/config";
+import { parseRepoSlug } from "@dev-loops/core/github/repo-slug";
+import { detectCheckpointEvidence } from "./detect-checkpoint-evidence.mjs";
+import { upsertCheckpointVerdict } from "./upsert-checkpoint-verdict.mjs";
+const USAGE = `Usage: reconcile-draft-gate.mjs --repo <owner/name> --pr <number>
+Optional/manual recovery tool for an already non-draft PR when you want to
+retroactively record clean \`draft_gate\` evidence.
+Converts the PR to draft, validates the head, posts a reconciling clean
+draft_gate comment, then marks the PR ready for review again.
+Fail-closed guards:
+  - Refuses to reconcile if any draft_gate evidence already exists on the PR.
+  - Requires CI to be green on the current head SHA before posting the
+    reconciling gate comment unless config disables \`gates.draft.requireCi\`.
+Required:
+  --repo <owner/name>   Repository slug (e.g. owner/repo)
+  --pr <number>         Pull request number
+Output (stdout, JSON):
+  {
+    "ok": true,
+    "action": "reconciled",
+    "repo": "owner/repo",
+    "pr": 17,
+    "headSha": "abc1234",
+    "currentHeadSha": "abc1234",
+    "commentId": 101,
+    "commentUrl": "https://github.com/owner/repo/pull/17#issuecomment-101"
+  }
+Error output (stderr, JSON):
+  { "ok": false, "error": "...", "usage": "..." }
+  { "ok": false, "error": "..." }
+Exit codes:
+  0  Success — PR was reconciled and gate evidence posted
+  1  Argument error, gh failure, or unrecoverable state`.trim();
+const parseError = buildParseError(USAGE);
+export function parseReconcileDraftGateCliArgs(argv) {
+  const args = [...argv];
+  const options = {
+    help: false,
+    repo: undefined,
+    pr: undefined,
+  };
+  while (args.length > 0) {
+    const token = args.shift();
+    if (token === "--help" || token === "-h") {
+      options.help = true;
+      return options;
+    }
+    if (token === "--repo") {
+      options.repo = requireOptionValue(args, "--repo", parseError).trim();
+      continue;
+    }
+    if (token === "--pr") {
+      options.pr = parsePrNumber(requireOptionValue(args, "--pr", parseError), parseError);
+      continue;
+    }
+    throw parseError(`Unknown argument: ${token}`);
+  }
+  const missing = ["repo", "pr"].filter((key) => options[key] === undefined);
+  if (missing.length > 0) {
+    throw parseError("reconcile-draft-gate requires --repo and --pr");
+  }
+  try {
+    parseRepoSlug(options.repo);
+  } catch (error) {
+    throw parseError(error instanceof Error ? error.message : String(error));
+  }
+  return options;
+}
+const CONVERT_TO_DRAFT_MUTATION = [
+  "mutation($pullRequestId:ID!) {",
+  "  convertPullRequestToDraft(input: {pullRequestId: $pullRequestId}) {",
+  "    pullRequest {",
+  "      id",
+  "      isDraft",
+  "    }",
+  "  }",
+  "}",
+].join("\n");
+const PR_ID_QUERY = [
+  "query($owner:String!, $name:String!, $number:Int!) {",
+  "  repository(owner: $owner, name: $name) {",
+  "    pullRequest(number: $number) {",
+  "      id",
+  "      isDraft",
+  "    }",
+  "  }",
+  "}",
+].join("\n");
+async function resolvePrNodeId({ repo, pr }, { env, ghCommand }) {
+  const [owner, name] = repo.split("/");
+  const result = await runChild(ghCommand, [
+    "api", "graphql",
+    "-f", "query=" + PR_ID_QUERY,
+    "-f", `owner=${owner}`,
+    "-f", `name=${name}`,
+    "-F", `number=${pr}`,
+  ], env);
+  if (result.code !== 0) {
+    throw new Error(
+      `Failed to resolve PR node ID for #${pr}: ${result.stderr.trim() || `exit code ${result.code}`}`
+    );
+  }
+  const payload = parseJsonText(result.stdout, {
+    label: `gh api graphql (resolvePrNodeId for #${pr})`,
+  });
+  const prData = payload?.data?.repository?.pullRequest;
+  if (!prData?.id) {
+    throw new Error(`Could not resolve PR node ID for #${pr}`);
+  }
+  return { id: prData.id, isDraft: prData.isDraft };
+}
+async function convertPrToDraft({ repo, pr }, { env, ghCommand }) {
+  const resolvedPr = await resolvePrNodeId({ repo, pr }, { env, ghCommand });
+  if (resolvedPr.isDraft === true) {
+    return {
+      ...resolvedPr,
+      alreadyDraft: true,
+    };
+  }
+  const result = await runChild(ghCommand, [
+    "api", "graphql",
+    "-f", "query=" + CONVERT_TO_DRAFT_MUTATION,
+    "-F", `pullRequestId=${resolvedPr.id}`,
+  ], env);
+  if (result.code !== 0) {
+    throw new Error(
+      `Failed to convert PR #${pr} to draft: ${result.stderr.trim() || `exit code ${result.code}`}`
+    );
+  }
+  const payload = parseJsonText(result.stdout, {
+    label: `gh api graphql (convertPullRequestToDraft #${pr})`,
+  });
+  const converted = payload?.data?.convertPullRequestToDraft?.pullRequest;
+  if (converted?.isDraft !== true) {
+    throw new Error(`PR #${pr} was not set to draft state after mutation`);
+  }
+  return {
+    ...converted,
+    alreadyDraft: false,
+  };
+}
+async function markPrReady({ repo, pr }, { env, ghCommand }) {
+  const result = await runChild(ghCommand, [
+    "pr", "ready", String(pr),
+    "--repo", repo,
+  ], env);
+  if (result.code !== 0) {
+    throw new Error(
+      `Failed to mark PR #${pr} ready: ${result.stderr.trim() || `exit code ${result.code}`}`
+    );
+  }
+  return true;
+}
+function normalizeCheckBucket(check = {}) {
+  const bucket = typeof check.bucket === "string" ? check.bucket.trim().toLowerCase() : "";
+  if (bucket) {
+    return bucket;
+  }
+  const state = typeof check.state === "string" ? check.state.trim().toLowerCase() : "";
+  if (["success", "passed", "pass"].includes(state)) {
+    return "pass";
+  }
+  if (["skipped", "skipping"].includes(state)) {
+    return "skipping";
+  }
+  if (["pending", "queued", "in_progress", "waiting", "requested", "expected", "action_required"].includes(state)) {
+    return "pending";
+  }
+  if (["failure", "failed", "fail", "error", "timed_out", "startup_failure"].includes(state)) {
+    return "fail";
+  }
+  if (["cancel", "cancelled", "canceled"].includes(state)) {
+    return "cancel";
+  }
+  return state || "unknown";
+}
+function summarizeBlockingChecks(blockingChecks) {
+  if (!Array.isArray(blockingChecks) || blockingChecks.length === 0) {
+    return "unknown blocking CI state";
+  }
+  return blockingChecks
+    .map((check) => `${check.name || "unnamed-check"}=${check.bucket}`)
+    .join(", ");
+}
+async function checkCiStatus({ repo, pr, headSha }, { env, ghCommand }) {
+  const result = await runChild(ghCommand, [
+    "pr", "checks", String(pr),
+    "--repo", repo,
+    "--json", "bucket,state,name,workflow",
+  ], env);
+  const stdout = result.stdout.trim();
+  if (result.code !== 0) {
+    if ((result.code !== 1 && result.code !== 8) || stdout.length === 0) {
+      throw new Error(
+        `Failed to check PR #${pr} CI status: ${result.stderr.trim() || `exit code ${result.code}`}`
+      );
+    }
+  }
+  const payload = parseJsonText(stdout || "[]", {
+    label: `gh pr checks #${pr}`,
+  });
+  if (!Array.isArray(payload)) {
+    throw new Error(`Invalid gh pr checks payload for PR #${pr}: expected an array`);
+  }
+  if (payload.length === 0) {
+    return {
+      status: "none",
+      checks: [],
+      blockingSummary: `No CI/check runs were reported for PR #${pr} head ${headSha.slice(0, 7)}.`,
+    };
+  }
+  const checks = payload.map((check) => ({
+    name: typeof check?.name === "string" && check.name.trim().length > 0 ? check.name.trim() : null,
+    workflow: typeof check?.workflow === "string" && check.workflow.trim().length > 0 ? check.workflow.trim() : null,
+    state: typeof check?.state === "string" && check.state.trim().length > 0 ? check.state.trim() : null,
+    bucket: normalizeCheckBucket(check),
+  }));
+  const blockingChecks = checks.filter((check) => !["pass", "skipping"].includes(check.bucket));
+  return {
+    status: blockingChecks.length === 0 ? "success" : "blocked",
+    checks,
+    blockingChecks,
+    blockingSummary: blockingChecks.length === 0
+      ? null
+      : `Blocking CI/check state on head ${headSha.slice(0, 7)}: ${summarizeBlockingChecks(blockingChecks)}.`,
+  };
+}
+export async function reconcileDraftGate(options, { env = process.env, ghCommand = "gh", repoRoot = process.cwd() } = {}) {
+  const { config } = await loadDevLoopConfig({ repoRoot });
+  const draftGateConfig = resolveGateConfig(config, "draft");
+  const initialEvidence = await detectCheckpointEvidence(
+    { repo: options.repo, pr: options.pr },
+    { env, ghCommand }
+  );
+  const headSha = initialEvidence.currentHeadSha;
+  if (!headSha) {
+    throw new Error(`Could not resolve current head SHA for PR #${options.pr}`);
+  }
+  if (initialEvidence.draftGate?.visible) {
+    throw new Error(
+      `PR #${options.pr} already has a visible draft_gate comment (verdict: ` +
+      `${initialEvidence.draftGate.verdict || "unknown"}). Refusing to overwrite existing ` +
+      `evidence. Reconcile manually or clear the existing comment first.`
+    );
+  }
+  if (initialEvidence.draftGateMarker?.visible) {
+    throw new Error(
+      `PR #${options.pr} already has a visible draft_gate marker. Refusing to overwrite ` +
+      `existing evidence. Reconcile manually or clear the existing marker first.`
+    );
+  }
+  if (draftGateConfig.requireCi) {
+    const ciStatus = await checkCiStatus(
+      { repo: options.repo, pr: options.pr, headSha },
+      { env, ghCommand }
+    );
+    if (ciStatus.status !== "success") {
+      throw new Error(
+        `PR #${options.pr} CI is not green. ${ciStatus.blockingSummary || "No successful check state was confirmed."} ` +
+        `Refusing to post a clean draft_gate comment. Fix CI first.`
+      );
+    }
+  }
+  const draftConversion = await convertPrToDraft({ repo: options.repo, pr: options.pr }, { env, ghCommand });
+  let gateResult;
+  try {
+    gateResult = await upsertCheckpointVerdict({
+      repo: options.repo,
+      pr: options.pr,
+      gate: "draft_gate",
+      headSha,
+      verdict: "clean",
+      findingsSeverityCounts: { "must-fix": 0, "worth-fixing-now": 0, "defer": 0 },
+      findingsSummary: draftGateConfig.requireCi
+        ? "Reconciled non-draft PR — draft gate auto-reconciled (CI green)."
+        : "Reconciled non-draft PR — draft gate auto-reconciled (CI optional by config).",
+      nextAction: "Mark ready for review (auto-reconciled).",
+    }, { env, ghCommand, repoRoot });
+  } catch (error) {
+    if (draftConversion.alreadyDraft !== true) {
+      try {
+        await markPrReady({ repo: options.repo, pr: options.pr }, { env, ghCommand });
+      } catch {
+      }
+    }
+    throw error;
+  }
+  await markPrReady({ repo: options.repo, pr: options.pr }, { env, ghCommand });
+  return {
+    ok: true,
+    action: "reconciled",
+    repo: options.repo,
+    pr: options.pr,
+    headSha: gateResult.headSha || headSha,
+    currentHeadSha: gateResult.currentHeadSha || headSha,
+    commentId: gateResult.commentId,
+    commentUrl: gateResult.commentUrl,
+  };
+}
+async function main() {
+  let options;
+  try {
+    options = parseReconcileDraftGateCliArgs(process.argv.slice(2));
+  } catch (error) {
+    process.stderr.write(`${formatCliError(error, { usage: USAGE })}\n`);
+    process.exitCode = 1;
+    return;
+  }
+  if (options.help) {
+    process.stdout.write(`${USAGE}\n`);
+    return;
+  }
+  try {
+    const result = await reconcileDraftGate(options);
+    process.stdout.write(`${JSON.stringify(result)}\n`);
+  } catch (error) {
+    process.stderr.write(
+      `${JSON.stringify({ ok: false, error: error instanceof Error ? error.message : String(error) })}\n`
+    );
+    process.exitCode = 1;
+  }
+}
+if (isDirectCliRun(import.meta.url)) {
+  await main();
+}

package/scripts/github/reply-resolve-review-thread.mjs

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+import { readFile } from "node:fs/promises";
+import { defineSubcommand, isDirectCliRun } from "@dev-loops/core/cli/subcommand-runner";
+import { parseRepoSlug } from "@dev-loops/core/github/repo-slug";
+import {
+  replyAndMaybeResolve,
+  validateResolutionMessage,
+} from "./_review-thread-mutations.mjs";
+
+export { hasCommitShaReference } from "./_review-thread-mutations.mjs";
+
+const { runAsScript } = defineSubcommand({
+  name: "reply-resolve-review-thread --repo <owner/name> --pr <n> --comment-id <n> --thread-id <id> --body-file <path>",
+  description: "Reply to a review thread comment and resolve the thread.",
+  options: [
+    { flag: "--repo", type: "string", required: true, description: "GitHub repository slug" },
+    { flag: "--pr", type: "pr", required: true, description: "Pull request number" },
+    { flag: "--comment-id", type: "positiveInt", required: true, description: "GraphQL databaseId of the comment to reply to" },
+    { flag: "--thread-id", type: "string", required: true, description: "GraphQL node ID of the review thread" },
+    { flag: "--body-file", type: "string", required: true, description: "Path to file containing the reply body text" },
+  ],
+  async run({ repo, pr, commentId, threadId, bodyFile }) {
+    parseRepoSlug(repo);
+
+    const rawBody = await readFile(bodyFile, "utf8");
+    if (rawBody.trim().length === 0) throw new Error("--body-file must contain non-empty text");
+    validateResolutionMessage(rawBody);
+
+    const result = await replyAndMaybeResolve(
+      { repo, pr, commentId, threadId, body: rawBody, resolve: true },
+      { env: process.env, ghCommand: "gh" },
+    );
+
+    process.stdout.write(JSON.stringify({
+      ok: true, repo, pr, commentId, threadId,
+      replyId: result.replyId, replyUrl: result.replyUrl, resolved: true,
+    }) + "\n");
+    return 0;
+  },
+});
+
+if (isDirectCliRun(import.meta.url)) { runAsScript(); }

package/scripts/github/reply-resolve-review-threads.mjs

@@ -0,0 +1,329 @@
+#!/usr/bin/env node
+import { buildParseError, formatCliError, isDirectCliRun } from "../_core-helpers.mjs";
+import {
+  parsePrNumber,
+  requireOptionValue,
+} from "../_cli-primitives.mjs";
+import { parseRepoSlug } from "@dev-loops/core/github/repo-slug";
+import {
+  authorMatchesFilter,
+  captureParsedReviewThreads,
+  replyAndMaybeResolve,
+  validateResolutionMessage,
+} from "./_review-thread-mutations.mjs";
+const USAGE = `Usage: reply-resolve-review-threads.mjs --repo <owner/name> --pr <number> [--author <login>] [--message <text>] [--resolve]
+Reply to all matching unresolved review threads on one PR and optionally resolve them.
+Required:
+  --repo <owner/name>   Repository slug (e.g. owner/repo)
+  --pr <number>         Pull request number
+Optional:
+  --author <login>      Match threads containing a comment from this author (default: Copilot)
+  --message <text>      Reply body text; provide exactly one message source via --message or stdin
+  --resolve             Resolve each matched thread after the reply succeeds
+Output (stdout, JSON):
+  { "ok": true, "repo": "owner/name", "pr": 17, "author": "Copilot", "resolve": true,
+    "matchedThreadCount": 2, "repliedThreadCount": 2, "resolvedThreadCount": 2,
+    "skippedThreadCount": 1, "results": [{ ... }] }
+Error output (stderr, JSON):
+  Argument/usage errors:
+    { "ok": false, "error": "...", "usage": "..." }
+  Runtime/gh failures:
+    { "ok": false, "error": "...", "partialProgress"?: { ... } }
+Exit codes:
+  0  Success
+  1  Argument error or gh/runtime failure`.trim();
+const parseError = buildParseError(USAGE);
+export function parseReplyResolveThreadsCliArgs(argv) {
+  const args = [...argv];
+  const options = {
+    help: false,
+    repo: undefined,
+    pr: undefined,
+    author: "Copilot",
+    message: undefined,
+    resolve: false,
+  };
+  while (args.length > 0) {
+    const token = args.shift();
+    if (token === "--help" || token === "-h") {
+      options.help = true;
+      return options;
+    }
+    if (token === "--repo") {
+      options.repo = requireOptionValue(args, "--repo", parseError).trim();
+      continue;
+    }
+    if (token === "--pr") {
+      options.pr = parsePrNumber(requireOptionValue(args, "--pr", parseError), parseError);
+      continue;
+    }
+    if (token === "--author") {
+      options.author = requireOptionValue(args, "--author", parseError).trim();
+      continue;
+    }
+    if (token === "--message") {
+      options.message = requireOptionValue(args, "--message", parseError);
+      continue;
+    }
+    if (token === "--resolve") {
+      options.resolve = true;
+      continue;
+    }
+    throw parseError(`Unknown argument: ${token}`);
+  }
+  if (options.repo === undefined || options.pr === undefined) {
+    throw parseError("Replying and resolving review threads requires both --repo <owner/name> and --pr <number>");
+  }
+  if (options.author.length === 0) {
+    throw parseError("--author must contain non-empty text");
+  }
+  try {
+    parseRepoSlug(options.repo);
+  } catch (error) {
+    throw parseError(error instanceof Error ? error.message : String(error));
+  }
+  return options;
+}
+async function readStdinText(stdin) {
+  let text = "";
+  stdin.setEncoding?.("utf8");
+  for await (const chunk of stdin) {
+    text += chunk;
+  }
+  return text;
+}
+async function resolveMessageInput(options, { stdin = process.stdin } = {}) {
+  if (typeof options.message === "string") {
+    if (stdin.isTTY) {
+      if (options.message.trim().length === 0) {
+        throw parseError("Reply message must contain non-empty text");
+      }
+      return options.message;
+    }
+    const stdinText = await readStdinText(stdin);
+    if (stdinText.trim().length > 0) {
+      throw parseError("Choose exactly one message source: --message <text> or stdin");
+    }
+    if (options.message.trim().length === 0) {
+      throw parseError("Reply message must contain non-empty text");
+    }
+    return options.message;
+  }
+  if (stdin.isTTY) {
+    throw parseError("Choose exactly one message source: --message <text> or stdin");
+  }
+  const stdinText = await readStdinText(stdin);
+  if (stdinText.trim().length === 0) {
+    throw parseError("Reply message must contain non-empty text");
+  }
+  return stdinText;
+}
+function commentRecencyValue(comment) {
+  if (typeof comment?.databaseId === "string" && /^\d+$/.test(comment.databaseId)) {
+    return Number(comment.databaseId);
+  }
+  return Number.NaN;
+}
+function selectNewestMatchingComment(parsed, threadId, author) {
+  const candidates = parsed.comments.filter((comment) => (
+    comment.threadId === threadId
+    && authorMatchesFilter(comment.author?.login, author)
+  ));
+  if (candidates.length === 0) {
+    return null;
+  }
+  return candidates.reduce((latest, comment) => {
+    if (latest === null) {
+      return comment;
+    }
+    const latestRecency = commentRecencyValue(latest);
+    const commentRecency = commentRecencyValue(comment);
+    if (Number.isFinite(latestRecency) && Number.isFinite(commentRecency) && commentRecency !== latestRecency) {
+      return commentRecency > latestRecency ? comment : latest;
+    }
+    if (!Number.isFinite(latestRecency) && Number.isFinite(commentRecency)) {
+      return comment;
+    }
+    if (comment.id.localeCompare(latest.id, undefined, { numeric: true }) > 0) {
+      return comment;
+    }
+    return latest;
+  }, null);
+}
+export function planBatchReplyTargets(parsed, author) {
+  const unresolvedThreads = parsed.threads.filter((thread) => !thread.isResolved);
+  const matchedTargets = [];
+  let skippedThreadCount = 0;
+  for (const thread of unresolvedThreads) {
+    const comment = selectNewestMatchingComment(parsed, thread.id, author);
+    if (comment === null) {
+      skippedThreadCount += 1;
+      continue;
+    }
+    if (typeof comment.databaseId !== "string" || !/^\d+$/.test(comment.databaseId)) {
+      throw new Error(`Matched review thread ${thread.id} did not include a REST-safe numeric comment id for the newest ${author} comment`);
+    }
+    matchedTargets.push({
+      threadId: thread.id,
+      commentId: Number(comment.databaseId),
+    });
+  }
+  return {
+    matchedTargets,
+    skippedThreadCount,
+  };
+}
+function createSuccessPayload({ repo, pr, author, resolve, matchedThreadCount, repliedThreadCount, resolvedThreadCount, skippedThreadCount, results }) {
+  return {
+    ok: true,
+    repo,
+    pr,
+    author,
+    resolve,
+    matchedThreadCount,
+    repliedThreadCount,
+    resolvedThreadCount,
+    skippedThreadCount,
+    results,
+  };
+}
+function buildPartialProgress({ repo, pr, author, resolve, matchedThreadCount, skippedThreadCount, results }) {
+  const resolvedThreadCount = results.filter((entry) => entry.resolved).length;
+  return {
+    repo,
+    pr,
+    author,
+    resolve,
+    matchedThreadCount,
+    repliedThreadCount: results.length,
+    resolvedThreadCount,
+    skippedThreadCount,
+    results,
+  };
+}
+function toCliFailurePayload(error) {
+  const payload = JSON.parse(formatCliError(error));
+  if (error instanceof Error && error.partialProgress) {
+    payload.partialProgress = error.partialProgress;
+  }
+  return payload;
+}
+function attachPartialProgress(error, partialProgress) {
+  if (error instanceof Error) {
+    error.partialProgress = partialProgress;
+    return error;
+  }
+  const wrapped = new Error(String(error));
+  wrapped.partialProgress = partialProgress;
+  return wrapped;
+}
+export async function runCli(
+  argv = process.argv.slice(2),
+  {
+    stdin = process.stdin,
+    stdout = process.stdout,
+    env = process.env,
+    ghCommand = "gh",
+  } = {},
+) {
+  const options = parseReplyResolveThreadsCliArgs(argv);
+  if (options.help) {
+    stdout.write(`${USAGE}\n`);
+    return;
+  }
+  const message = await resolveMessageInput(options, { stdin });
+  validateResolutionMessage(message);
+  const parsed = await captureParsedReviewThreads(
+    { repo: options.repo, pr: options.pr },
+    { env, ghCommand },
+  );
+  const { matchedTargets, skippedThreadCount } = planBatchReplyTargets(parsed, options.author);
+  if (matchedTargets.length === 0) {
+    stdout.write(`${JSON.stringify(createSuccessPayload({
+      repo: options.repo,
+      pr: options.pr,
+      author: options.author,
+      resolve: options.resolve,
+      matchedThreadCount: 0,
+      repliedThreadCount: 0,
+      resolvedThreadCount: 0,
+      skippedThreadCount,
+      results: [],
+    }))}\n`);
+    return;
+  }
+  const results = [];
+  const partialBase = {
+    repo: options.repo,
+    pr: options.pr,
+    author: options.author,
+    resolve: options.resolve,
+    matchedThreadCount: matchedTargets.length,
+    skippedThreadCount,
+  };
+  try {
+    for (const target of matchedTargets) {
+      const result = await replyAndMaybeResolve(
+        {
+          repo: options.repo,
+          pr: options.pr,
+          commentId: target.commentId,
+          threadId: target.threadId,
+          body: message,
+          resolve: options.resolve,
+          validatedSnapshot: parsed,
+        },
+        { env, ghCommand },
+      );
+      results.push({
+        threadId: target.threadId,
+        commentId: target.commentId,
+        replyId: result.replyId,
+        replyUrl: result.replyUrl,
+        resolved: result.resolved,
+      });
+    }
+    if (options.resolve) {
+      const refreshed = await captureParsedReviewThreads(
+        { repo: options.repo, pr: options.pr },
+        { env, ghCommand },
+      );
+      const stillUnresolvedThreadIds = matchedTargets
+        .map((target) => target.threadId)
+        .filter((threadId) => refreshed.threads.some((thread) => thread.id === threadId && !thread.isResolved));
+      if (stillUnresolvedThreadIds.length > 0) {
+        throw attachPartialProgress(
+          new Error(`Post-resolve verification failed; targeted thread(s) remain unresolved: ${stillUnresolvedThreadIds.join(", ")}`),
+          {
+            ...buildPartialProgress({ ...partialBase, results }),
+            stillUnresolvedThreadIds,
+          },
+        );
+      }
+    }
+  } catch (error) {
+    if (error instanceof Error && error.partialProgress) {
+      throw error;
+    }
+    throw attachPartialProgress(error, buildPartialProgress({ ...partialBase, results }));
+  }
+  const repliedThreadCount = results.length;
+  const resolvedThreadCount = results.filter((entry) => entry.resolved).length;
+  stdout.write(`${JSON.stringify(createSuccessPayload({
+    repo: options.repo,
+    pr: options.pr,
+    author: options.author,
+    resolve: options.resolve,
+    matchedThreadCount: matchedTargets.length,
+    repliedThreadCount,
+    resolvedThreadCount,
+    skippedThreadCount,
+    results,
+  }))}\n`);
+}
+if (isDirectCliRun(import.meta.url)) {
+  runCli().catch((error) => {
+    process.stderr.write(`${JSON.stringify(toCliFailurePayload(error))}\n`);
+    process.exitCode = 1;
+  });
+}