pr-shepherd 0.8.1 → 0.10.0

package/bin/commands/resolve-instructions.mjs

@@ -4,13 +4,15 @@
  * `buildFixInstructions` in `commands/iterate/render.mts`).
  */
 export function buildFetchInstructions(prNumber, result) {
-    const { actionableThreads, actionableComments, changesRequestedReviews, reviewSummaries, commitSuggestionsEnabled, } = result;
+    const { actionableThreads, firstLookThreads, actionableComments, firstLookComments, changesRequestedReviews, reviewSummaries, commitSuggestionsEnabled, } = result;
+    const firstLookTotal = firstLookThreads.length + firstLookComments.length;
     const total = actionableThreads.length +
         actionableComments.length +
         changesRequestedReviews.length +
-        reviewSummaries.length;
+        reviewSummaries.length +
+        firstLookTotal;
     if (total === 0) {
-        return ["No actionable items — end this invocation."];
+        return ["No actionable items and no first-look items — end this invocation."];
     }
     const hasCodeItems = actionableThreads.length > 0 ||
         actionableComments.length > 0 ||
@@ -18,15 +20,21 @@ export function buildFetchInstructions(prNumber, result) {
     const hasSuggestions = commitSuggestionsEnabled && actionableThreads.some((t) => t.suggestion != null);
     const instructions = [];
     instructions.push(`Classify every item listed above into exactly one of: Fixed / Actionable / Not relevant / Outdated / Acknowledge. Do not silently skip any item. Bot-authored review summaries (authors whose name contains \`[bot]\` or matches \`copilot-pull-request-reviewer\`, \`gemini-code-assist\`) default to Acknowledge with reason "bot summary — no actionable content" unless the body calls out an unaddressed issue.`);
+    if (firstLookTotal > 0) {
+        instructions.push(`Items in \`## First-look items\` are for acknowledgement only — do not pass their IDs to \`--resolve-thread-ids\`, \`--minimize-comment-ids\`, or \`--dismiss-review-ids\`. Acknowledge each one with a one-line classification (e.g. "outdated — addressed by commit abc1234", "resolved — already fixed", "minimized — noise").`);
+    }
     if (hasSuggestions) {
         instructions.push(`For each Actionable thread marked \`[suggestion]\` in \`## Actionable Review Threads\` above: run \`npx pr-shepherd commit-suggestion ${prNumber} --thread-id <id> --message "<one-sentence headline>" --format=json\`, one thread at a time. On \`applied: true\` mark it Fixed — the CLI already resolved the thread, so exclude the ID from \`--resolve-thread-ids\`. On \`applied: false\` read \`reason\` and \`patch\`, then fall through to the manual fix step — do not retry the same command. Optionally pass \`--dry-run\` (omitting \`--message\`) if you want to inspect the unified diff before it mutates the working tree — the CLI validates with \`git apply --check\`, returns the patch and \`valid: true/false\`, and exits \`1\` on drift without committing or resolving the thread.`);
     }
     if (hasCodeItems) {
         instructions.push(`Read and edit each file referenced under \`## Actionable Review Threads\`, \`## Actionable PR Comments\`, and \`## Pending CHANGES_REQUESTED reviews\` above. Reclassify each fixed item as Fixed. If an item is too complex to address, leave it as Actionable for the final report.`);
-        instructions.push(`Commit changed files: \`git add <files>\` (not \`git add -A\`) \`&& git commit -m "<descriptive message>"\`. If the fixes alter the PR's scope or intent, run \`gh pr edit ${prNumber} --title "<new title>" --body "<new body>"\` to reflect them. Then rebase and push: \`BASE_BRANCH=$(gh pr view ${prNumber} --json baseRefName --jq .baseRefName) && git fetch origin && git rebase "origin/$BASE_BRANCH" && git push --force-with-lease\`. Cancel stale in-progress runs: \`BRANCH=$(git rev-parse --abbrev-ref HEAD) && gh run list --branch "$BRANCH" --status in_progress --json databaseId --jq '.[].databaseId' | xargs -I{} gh run cancel {}\`.`);
+        instructions.push(`Commit changed files: \`git add <files>\` (not \`git add -A\`) \`&& git commit -m "<descriptive message>"\`.`);
+        instructions.push(`Keep the PR title and description current: if the fixes 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.`);
+        instructions.push(`Rebase and push: \`BASE_BRANCH=$(gh pr view ${prNumber} --json baseRefName --jq .baseRefName) && git fetch origin && git rebase "origin/$BASE_BRANCH" && git push --force-with-lease\`.`);
+        instructions.push(`Cancel stale in-progress runs: \`BRANCH=$(git rev-parse --abbrev-ref HEAD) && CURRENT_SHA=$(git rev-parse HEAD) && gh run list --branch "$BRANCH" --status in_progress --json databaseId,headSha --jq ".[] | select(.headSha != \\"$CURRENT_SHA\\") | .databaseId" | xargs -I{} gh run cancel {}\`.`);
     }
     const requireShaHint = hasCodeItems
-        ? ` Include \`--require-sha $(git rev-parse HEAD)\` only when the commit-and-push step above ran.`
+        ? ` Include \`--require-sha $(git rev-parse HEAD)\` only when the rebase-and-push step above ran.`
         : "";
     const dismissNote = changesRequestedReviews.length > 0
         ? ` For \`--dismiss-review-ids\`: \`--message\` is required with one specific sentence describing the fix or the reason for not acting (no boilerplate like "address review comments"); omit \`--message\` when not dismissing. Review-summary IDs (\`PRR_…\` from \`## Review summaries\`) go into \`--minimize-comment-ids\`, never \`--dismiss-review-ids\`.`
@@ -34,6 +42,7 @@ export function buildFetchInstructions(prNumber, result) {
             ? ` Review-summary IDs (\`PRR_…\` from \`## Review summaries\`) go into \`--minimize-comment-ids\`.`
             : "";
     instructions.push(`Run \`npx pr-shepherd resolve ${prNumber} [--resolve-thread-ids <ids>] [--minimize-comment-ids <ids>] [--dismiss-review-ids <ids> --message "<reason>"]\` with only the non-empty flag subsets. Skip the command entirely if all three ID lists are empty.${requireShaHint}${dismissNote}`);
+    instructions.push(`For any large decisions or rejections you made this iteration, add or update a \`## Shepherd Journal\` section in the PR description (\`gh pr edit ${prNumber} --body …\`) summarizing each decision. For threads and comments, use the markdown link shown in each item's bullet above; for reviews, reference the review ID.`);
     instructions.push(`Report: echo the CLI's mutation output, then one line per Acknowledged item: \`Acknowledged <id> (@<author>): <reason>\`. If any fetched item was neither resolved nor acknowledged, stop and escalate: "<N> item(s) fetched but not acted on or acknowledged — need human direction before closing".`);
     return instructions;
 }

package/bin/commands/resolve.mjs

@@ -1,25 +1,11 @@
-/**
- * `shepherd resolve [PR] [flags]`
- *
- * Two modes:
- *
- *   Fetch mode (--fetch or no mutation flags):
- *     Auto-resolves outdated threads and returns all active threads,
- *     visible comments, and CHANGES_REQUESTED reviews for LLM triage.
- *     Sonnet reads this output, applies code fixes, pushes, then calls
- *     resolve in mutation mode to resolve/minimize/dismiss by ID.
- *
- *   Mutation mode (--resolve-thread-ids, --minimize-comment-ids, --dismiss-review-ids):
- *     Resolves/minimizes/dismisses by ID. Optionally verifies the push
- *     has landed on GitHub before mutating (--require-sha).
- */
 import { getRepoInfo, getCurrentPrNumber } from "../github/client.mjs";
 import { fetchPrBatch } from "../github/batch.mjs";
 import { getOutdatedThreads } from "../comments/outdated.mjs";
 import { autoResolveOutdated, applyResolveOptions } from "../comments/resolve.mjs";
 import { loadConfig } from "../config/load.mjs";
-import { parseSuggestion } from "../suggestions/parse.mjs";
+import { extractSuggestion } from "../suggestions/extract.mjs";
 import { buildFetchInstructions } from "./resolve-instructions.mjs";
+import { loadSeenSet, markSeen } from "../state/seen-comments.mjs";
 /**
  * Fetch mode: auto-resolve outdated threads and return all active items for LLM triage.
  */
@@ -31,12 +17,26 @@ export async function runResolveFetch(opts) {
     }
     // Always bypass cache for resolve — we need fresh data before mutating.
     const { data } = await fetchPrBatch(prNumber, repo);
+    const stateKey = { owner: repo.owner, repo: repo.name, pr: prNumber };
     const unresolvedThreads = data.reviewThreads.filter((t) => !t.isResolved && !t.isMinimized);
     const visibleComments = data.comments.filter((c) => !c.isMinimized);
-    // Auto-resolve outdated.
+    // First-look: collect items that would normally be hidden and check seen markers.
+    const outdatedCandidates = data.reviewThreads.filter((t) => t.isOutdated);
+    const resolvedCandidates = data.reviewThreads.filter((t) => t.isResolved && !t.isOutdated);
+    const minimizedThreadCandidates = data.reviewThreads.filter((t) => t.isMinimized && !t.isResolved && !t.isOutdated);
+    const minimizedCommentCandidates = data.comments.filter((c) => c.isMinimized);
+    const seenSet = await loadSeenSet(stateKey);
+    const unseenOutdated = outdatedCandidates.filter((t) => !seenSet.has(t.id));
+    const unseenResolved = resolvedCandidates.filter((t) => !seenSet.has(t.id));
+    const unseenMinimizedThreads = minimizedThreadCandidates.filter((t) => !seenSet.has(t.id));
+    const unseenMinimizedComments = minimizedCommentCandidates.filter((c) => !seenSet.has(c.id));
+    // Auto-resolve outdated (same as before — fires regardless of first-look status).
     const outdated = getOutdatedThreads(unresolvedThreads);
+    const autoResolvedIds = new Set();
     if (outdated.length > 0) {
-        const { errors } = await autoResolveOutdated(outdated.map((t) => t.id));
+        const { resolved: resolvedIds, errors } = await autoResolveOutdated(outdated.map((t) => t.id));
+        for (const id of resolvedIds)
+            autoResolvedIds.add(id);
         if (errors.length > 0) {
             process.stderr.write(`pr-shepherd: auto-resolve outdated threads failed (continuing): ${errors.join(", ")}\n`);
         }
@@ -50,35 +50,36 @@ export async function runResolveFetch(opts) {
             thread.suggestion = suggestion;
         return thread;
     });
+    const firstLookThreads = [
+        ...unseenOutdated.map((t) => ({
+            ...t,
+            firstLookStatus: "outdated",
+            autoResolved: autoResolvedIds.has(t.id),
+        })),
+        ...unseenResolved.map((t) => ({ ...t, firstLookStatus: "resolved" })),
+        ...unseenMinimizedThreads.map((t) => ({ ...t, firstLookStatus: "minimized" })),
+    ];
+    const firstLookComments = unseenMinimizedComments.map((c) => ({
+        ...c,
+        firstLookStatus: "minimized",
+    }));
+    // Mark first-look items as seen (best-effort — markSeen never throws).
+    await Promise.allSettled([
+        ...firstLookThreads.map((t) => markSeen(stateKey, t.id)),
+        ...firstLookComments.map((c) => markSeen(stateKey, c.id)),
+    ]);
     const result = {
         prNumber,
         actionableThreads,
+        firstLookThreads,
         actionableComments: visibleComments,
+        firstLookComments,
         changesRequestedReviews: data.changesRequestedReviews,
         reviewSummaries: cfg.resolve.fetchReviewSummaries ? data.reviewSummaries : [],
         commitSuggestionsEnabled: cfg.actions.commitSuggestions,
     };
     return { ...result, instructions: buildFetchInstructions(prNumber, result) };
 }
-/**
- * Attach a parsed suggestion block to a thread if the comment body contains one
- * and the thread has a resolvable line anchor. Threads without `path`/`line`
- * (rare — usually file-level comments) can't accept a suggestion commit.
- */
-function extractSuggestion(thread) {
-    if (!thread.path || thread.line === null)
-        return null;
-    const parsed = parseSuggestion(thread.body);
-    if (!parsed)
-        return null;
-    const startLine = thread.startLine ?? thread.line;
-    return {
-        startLine,
-        endLine: thread.line,
-        lines: parsed.lines,
-        author: thread.author,
-    };
-}
 /**
  * Mutation mode: resolve/minimize/dismiss by ID.
  */

package/bin/commands/status.mjs

@@ -2,35 +2,46 @@
  * `shepherd status PR1 [PR2 PR3 …]`
  *
  * Fetches readiness status for one or more PRs and prints a table.
- * Uses a separate lightweight GraphQL query (MULTI_PR_STATUS_QUERY) per PR
- * rather than the heavy batch query, since we only need summary data.
+ * Issues a single GraphQL request with one alias per PR number rather than
+ * N separate requests, so the round-trip count is always 1 (plus optional
+ * per-PR pagination calls when a PR has > 100 review threads).
  *
  * Exit code: 0 if all PRs are READY, non-zero otherwise.
  */
 import { graphql, getRepoInfo } from "../github/client.mjs";
-import { MULTI_PR_STATUS_QUERY, MULTI_PR_STATUS_QUERY_WITH_CURSOR } from "../github/queries.mjs";
+import { MULTI_PR_STATUS_QUERY_WITH_CURSOR } from "../github/queries.mjs";
 export async function runStatus(opts) {
+    if (opts.prNumbers.length === 0)
+        return [];
     const repo = await getRepoInfo();
-    const summaries = await Promise.all(opts.prNumbers.map((pr) => fetchSummary(pr, repo.owner, repo.name)));
+    const doc = buildBatchStatusQuery(opts.prNumbers);
+    const result = await graphql(doc, {
+        owner: repo.owner,
+        repo: repo.name,
+    });
+    const summaries = await Promise.all(opts.prNumbers.map((pr) => {
+        const rawPr = result.data.repository[`pr_${pr}`];
+        if (!rawPr) {
+            throw new Error(`PR #${pr} not found in ${repo.owner}/${repo.name}`);
+        }
+        return paginateAndBuild(pr, rawPr, repo.owner, repo.name);
+    }));
     return summaries;
 }
 // ---------------------------------------------------------------------------
 // Internal
 // ---------------------------------------------------------------------------
-async function fetchSummary(pr, owner, repo) {
-    const result = await graphql(MULTI_PR_STATUS_QUERY, {
-        owner,
-        repo,
-        pr,
-    });
-    const p = result.data.repository.pullRequest;
-    if (!p) {
-        throw new Error(`PR #${pr} not found in ${owner}/${repo}`);
-    }
+function buildBatchStatusQuery(prNumbers) {
+    const uniquePrs = [...new Set(prNumbers.filter((n) => n > 0))];
+    const f = "number title state isDraft mergeStateStatus reviewDecision " +
+        "reviewThreads(last:100){totalCount pageInfo{hasPreviousPage startCursor} nodes{isResolved}} " +
+        "commits(last:1){nodes{commit{statusCheckRollup{state}}}}";
+    const aliases = uniquePrs.map((n) => `pr_${n}:pullRequest(number:${n}){${f}}`).join(" ");
+    return `query MultiPrStatusBatch($owner:String!,$repo:String!){repository(owner:$owner,name:$repo){${aliases}}}`;
+}
+async function paginateAndBuild(pr, p, owner, repo) {
     let allNodes = p.reviewThreads.nodes;
-    // If the response was truncated, fetch additional pages to get the full count.
     if (p.reviewThreads.totalCount > p.reviewThreads.nodes.length) {
-        // Fetch additional pages backward until we have all threads.
         const MAX_THREAD_PAGES = 10;
         let pagesFetched = 0;
         const totalCount = p.reviewThreads.totalCount;
@@ -59,7 +70,6 @@ async function fetchSummary(pr, owner, repo) {
     }
     const unresolvedThreads = allNodes.filter((n) => !n.isResolved).length;
     const ciState = p.commits.nodes[0]?.commit.statusCheckRollup?.state ?? null;
-    // If we still have fewer nodes than totalCount, report truncation.
     const threadsTruncated = p.reviewThreads.totalCount > allNodes.length;
     return {
         number: p.number,
@@ -77,17 +87,19 @@ async function fetchSummary(pr, owner, repo) {
 // Output helpers
 // ---------------------------------------------------------------------------
 export function formatStatusTable(summaries, repoFull) {
-    const lines = [`\n# ${repoFull} — PR status (${summaries.length})\n`];
-    for (const s of summaries) {
-        const verdict = deriveVerdict(s);
-        const ciLabel = s.ciState ?? "—";
-        const title = s.title.slice(0, 50);
-        const truncNote = s.threadsTruncated
-            ? " (threads truncated — run shepherd check for full count)"
-            : "";
-        lines.push(`PR #${String(s.number).padEnd(5)} ${title.padEnd(52)} ${verdict.padEnd(12)} ${ciLabel}${truncNote}`);
-    }
-    return lines.join("\n");
+    const heading = `# ${repoFull} — PR status (${summaries.length})`;
+    if (summaries.length === 0)
+        return heading;
+    const rows = summaries.map((s) => {
+        const raw = s.title.length > 50 ? `${s.title.slice(0, 47)}...` : s.title;
+        const title = raw.replace(/\\/g, "\\\\").replace(/\|/g, "\\|").replace(/\n/g, " ");
+        return `| #${s.number} | ${title} | ${deriveVerdict(s)} | ${s.ciState ?? "—"} |`;
+    });
+    const table = ["| PR | Title | Verdict | CI |", "| --- | --- | --- | --- |", ...rows].join("\n");
+    const footnotes = summaries
+        .filter((s) => s.threadsTruncated)
+        .map((s) => `> Note: PR #${s.number} threads truncated — run \`pr-shepherd check ${s.number}\` for full count.`);
+    return [heading, table, ...footnotes].join("\n\n");
 }
 export function deriveVerdict(s) {
     if (s.state === "MERGED")
@@ -102,7 +114,7 @@ export function deriveVerdict(s) {
         s.reviewDecision !== "CHANGES_REQUESTED") {
         return "READY";
     }
-    if (s.mergeStateStatus === "BLOCKED")
+    if (s.mergeStateStatus === "BLOCKED" || s.mergeStateStatus === "HAS_HOOKS")
         return "BLOCKED";
     if (s.mergeStateStatus === "DIRTY")
         return "CONFLICTS";

package/bin/comments/resolve.mjs

@@ -1,32 +1,12 @@
-/**
- * Batched mutations for resolving threads, minimizing comments, and dismissing reviews.
- *
- * The three mutation types (resolve / minimize / dismiss) are run sequentially so total
- * in-flight mutations never exceed CONCURRENCY at once, keeping us well within GitHub's
- * secondary rate-limit window.
- *
- * Push-before-resolve safety:
- *   When `requireSha` is set, shepherd verifies that GitHub has received that
- *   commit before issuing any resolve/dismiss mutations. It polls up to 20 seconds.
- *   If the push hasn't landed, shepherd throws rather than resolving prematurely
- *   (which could allow auto-merge before reviewers see the fix).
- */
 import { graphql, getPrHeadSha } from "../github/client.mjs";
-import { RESOLVE_THREAD_MUTATION, MINIMIZE_COMMENT_MUTATION, DISMISS_REVIEW_MUTATION, } from "../github/queries.mjs";
 import { loadConfig } from "../config/load.mjs";
-/**
- * Execute all requested resolve/minimize/dismiss mutations.
- *
- * @throws Error if `requireSha` is set and GitHub hasn't received that commit
- *              within the polling window.
- */
 export async function applyResolveOptions(pr, repo, opts) {
-    // Require --message when dismissing reviews.
     if ((opts.dismissReviewIds?.length ?? 0) > 0 && !opts.dismissMessage) {
         throw new Error("--message is required when dismissing reviews");
     }
-    // Safety check: verify the push landed before resolving.
     if (opts.requireSha) {
+        // Verify GitHub received the commit before resolving — prevents auto-merge
+        // before reviewers see the fix.
         await waitForSha(pr, repo, opts.requireSha);
     }
     const result = {
@@ -35,55 +15,87 @@ export async function applyResolveOptions(pr, repo, opts) {
         dismissedReviews: [],
         errors: [],
     };
-    await runBatched(opts.resolveThreadIds ?? [], (id) => resolveThread(id), result.resolvedThreads, result.errors);
-    await runBatched(opts.minimizeCommentIds ?? [], (id) => minimizeComment(id, "RESOLVED"), result.minimizedComments, result.errors);
-    await runBatched(opts.dismissReviewIds ?? [], (id) => dismissReview(id, opts.dismissMessage ?? ""), result.dismissedReviews, result.errors);
+    await bulkApply(opts.resolveThreadIds ?? [], opts.minimizeCommentIds ?? [], opts.dismissReviewIds ?? [], opts.dismissMessage ?? "", result);
     return result;
 }
-/**
- * Auto-resolve a batch of outdated threads via the resolveReviewThread mutation.
- */
 export async function autoResolveOutdated(threadIds) {
-    const resolved = [];
-    const errors = [];
-    await runBatched(threadIds, (id) => resolveThread(id), resolved, errors);
-    return { resolved, errors };
-}
-// ---------------------------------------------------------------------------
-// Mutation helpers
-// ---------------------------------------------------------------------------
-async function resolveThread(threadId) {
-    await graphql(RESOLVE_THREAD_MUTATION, { threadId });
-}
-async function minimizeComment(commentId, classifier) {
-    await graphql(MINIMIZE_COMMENT_MUTATION, { commentId, classifier });
+    const result = {
+        resolvedThreads: [],
+        minimizedComments: [],
+        dismissedReviews: [],
+        errors: [],
+    };
+    await bulkApply(threadIds, [], [], "", result);
+    return { resolved: result.resolvedThreads, errors: result.errors };
 }
-async function dismissReview(reviewId, message) {
-    await graphql(DISMISS_REVIEW_MUTATION, { reviewId, message });
+// Chunk at 50 so a single oversized list never fails the entire call.
+const BULK_CHUNK_SIZE = 50;
+function buildBulkMutation(resolveIds, minimizeIds, dismissIds, dismissMessage) {
+    const ops = [];
+    for (let i = 0; i < resolveIds.length; i++) {
+        ops.push(`  r${i}: resolveReviewThread(input: { threadId: ${JSON.stringify(resolveIds[i])} }) { thread { isResolved } }`);
+    }
+    for (let i = 0; i < minimizeIds.length; i++) {
+        ops.push(`  m${i}: minimizeComment(input: { subjectId: ${JSON.stringify(minimizeIds[i])}, classifier: RESOLVED }) { minimizedComment { isMinimized } }`);
+    }
+    for (let i = 0; i < dismissIds.length; i++) {
+        ops.push(`  d${i}: dismissPullRequestReview(input: { pullRequestReviewId: ${JSON.stringify(dismissIds[i])}, message: ${JSON.stringify(dismissMessage)} }) { pullRequestReview { state } }`);
+    }
+    return `mutation BulkApply {\n${ops.join("\n")}\n}`;
 }
-// ---------------------------------------------------------------------------
-// Concurrency helper
-// ---------------------------------------------------------------------------
-async function runBatched(ids, fn, successList, errorList) {
-    const CONCURRENCY = loadConfig().resolve.concurrency;
-    // Process in chunks of CONCURRENCY.
-    for (let i = 0; i < ids.length; i += CONCURRENCY) {
-        const chunk = ids.slice(i, i + CONCURRENCY);
+async function bulkApply(resolveIds, minimizeIds, dismissIds, dismissMessage, result) {
+    const allOps = [
+        ...resolveIds.map((id) => ({ kind: "r", id })),
+        ...minimizeIds.map((id) => ({ kind: "m", id })),
+        ...dismissIds.map((id) => ({ kind: "d", id })),
+    ];
+    for (let i = 0; i < allOps.length; i += BULK_CHUNK_SIZE) {
+        const chunk = allOps.slice(i, i + BULK_CHUNK_SIZE);
         // eslint-disable-next-line no-await-in-loop
-        await Promise.all(chunk.map(async (id) => {
-            try {
-                await fn(id);
-                successList.push(id);
-            }
-            catch (err) {
-                errorList.push(`${id}: ${err instanceof Error ? err.message : String(err)}`);
-            }
-        }));
+        await bulkApplyChunk(chunk.filter((o) => o.kind === "r").map((o) => o.id), chunk.filter((o) => o.kind === "m").map((o) => o.id), chunk.filter((o) => o.kind === "d").map((o) => o.id), dismissMessage, result);
+    }
+}
+async function bulkApplyChunk(resolveIds, minimizeIds, dismissIds, dismissMessage, result) {
+    if (resolveIds.length === 0 && minimizeIds.length === 0 && dismissIds.length === 0)
+        return;
+    const doc = buildBulkMutation(resolveIds, minimizeIds, dismissIds, dismissMessage);
+    let data;
+    try {
+        const resp = await graphql(doc, {});
+        data = resp.data;
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        for (const id of resolveIds)
+            result.errors.push(`${id}: ${msg}`);
+        for (const id of minimizeIds)
+            result.errors.push(`${id}: ${msg}`);
+        for (const id of dismissIds)
+            result.errors.push(`${id}: ${msg}`);
+        return;
+    }
+    for (let i = 0; i < resolveIds.length; i++) {
+        const r = data[`r${i}`];
+        if (r?.thread?.isResolved === true)
+            result.resolvedThreads.push(resolveIds[i]);
+        else
+            result.errors.push(`${resolveIds[i]}: resolve returned null or thread not resolved`);
+    }
+    for (let i = 0; i < minimizeIds.length; i++) {
+        const m = data[`m${i}`];
+        if (m?.minimizedComment?.isMinimized === true)
+            result.minimizedComments.push(minimizeIds[i]);
+        else
+            result.errors.push(`${minimizeIds[i]}: minimize returned null or comment not minimized`);
+    }
+    for (let i = 0; i < dismissIds.length; i++) {
+        const d = data[`d${i}`];
+        if (d?.pullRequestReview != null)
+            result.dismissedReviews.push(dismissIds[i]);
+        else
+            result.errors.push(`${dismissIds[i]}: dismiss returned null`);
     }
 }
-// ---------------------------------------------------------------------------
-// SHA polling
-// ---------------------------------------------------------------------------
 async function waitForSha(pr, repo, expectedSha) {
     const { intervalMs: SHA_POLL_INTERVAL_MS, maxAttempts: SHA_POLL_MAX_ATTEMPTS } = loadConfig().resolve.shaPoll;
     for (let attempt = 0; attempt < SHA_POLL_MAX_ATTEMPTS; attempt++) {
@@ -94,7 +106,6 @@ async function waitForSha(pr, repo, expectedSha) {
                 return;
         }
         catch (err) {
-            // Transient network / 5xx error — keep polling unless this is the last attempt.
             if (attempt === SHA_POLL_MAX_ATTEMPTS - 1)
                 throw err;
         }
@@ -103,7 +114,6 @@ async function waitForSha(pr, repo, expectedSha) {
             await sleep(SHA_POLL_INTERVAL_MS);
         }
     }
-    // Total actual wait = (SHA_POLL_MAX_ATTEMPTS - 1) * SHA_POLL_INTERVAL_MS (no sleep after last poll).
     throw new Error(`Timeout: GitHub PR #${pr} head SHA has not updated to ${expectedSha} after ${((SHA_POLL_MAX_ATTEMPTS - 1) * SHA_POLL_INTERVAL_MS) / 1000}s. Push may still be in transit — retry shortly.`);
 }
 function sleep(ms) {

package/bin/config.json

@@ -3,11 +3,7 @@
     "cooldownSeconds": 30,
     "fixAttemptsPerThread": 3,
     "stallTimeoutMinutes": 30,
-    "minimizeReviewSummaries": {
-      "bots": true,
-      "humans": true,
-      "approvals": false
-    }
+    "minimizeApprovals": false
   },
   "watch": {
     "interval": "4m",
@@ -16,7 +12,6 @@
     "maxTurns": 50
   },
   "resolve": {
-    "concurrency": 4,
     "shaPoll": {
       "intervalMs": 2000,
       "maxAttempts": 10
@@ -24,7 +19,9 @@
     "fetchReviewSummaries": true
   },
   "checks": {
-    "ciTriggerEvents": ["pull_request", "pull_request_target"]
+    "ciTriggerEvents": ["pull_request", "pull_request_target"],
+    "logTailLines": 5,
+    "logTailChars": 200
   },
   "mergeStatus": {
     "blockingReviewerLogins": ["copilot"]

package/bin/github/batch-parsers.mjs

@@ -19,6 +19,7 @@ export function parseRawPr(raw, rawThreadPages, rawCommentNodes, rawReviewNodes,
             startLine: comment?.startLine ?? null,
             author: comment?.author?.login ?? "unknown",
             body: comment?.body ?? "",
+            url: comment?.url ?? "",
             createdAtUnix: comment ? parseCreatedAt(comment.createdAt) : 0,
         };
     });
@@ -27,6 +28,7 @@ export function parseRawPr(raw, rawThreadPages, rawCommentNodes, rawReviewNodes,
         isMinimized: c.isMinimized,
         author: c.author?.login ?? "unknown",
         body: c.body,
+        url: c.url,
         createdAtUnix: parseCreatedAt(c.createdAt),
     }));
     const changesRequestedReviews = rawReviewNodes.map((r) => ({
@@ -94,6 +96,8 @@ export function parseRawPr(raw, rawThreadPages, rawCommentNodes, rawReviewNodes,
         mergeStateStatus: raw.mergeStateStatus,
         reviewDecision: (raw.reviewDecision ?? null),
         headRefOid: raw.headRefOid,
+        headRefName: raw.headRefName,
+        headRepoWithOwner: raw.headRepository?.nameWithOwner ?? null,
         baseRefName: raw.baseRefName,
         reviewRequests,
         latestReviews,

package/bin/github/client.mjs

@@ -8,7 +8,7 @@
 import { execFile as execFileCb } from "node:child_process";
 import { promisify } from "node:util";
 import { graphql as httpGraphql, rest } from "./http.mjs";
-import { PR_NUMBER_BY_BRANCH_QUERY } from "./queries.mjs";
+import { PR_NUMBER_BY_BRANCH_QUERY, GET_PR_HEAD_SHA_QUERY } from "./queries.mjs";
 const execFile = promisify(execFileCb);
 // ---------------------------------------------------------------------------
 // GraphQL — thin re-exports so callers don't need to import http.mts directly
@@ -42,38 +42,17 @@ export async function getCurrentPrNumber() {
 }
 /** Returns the `headRefOid` (commit SHA) of the given PR as reported by GitHub. */
 export async function getPrHeadSha(pr, owner, name) {
-    const data = await rest("GET", `/repos/${owner}/${name}/pulls/${pr}`);
-    return data.head.sha;
-}
-/**
- * Full head info for a PR — sha, branch name, and the head repository's full name.
- * Needed by commit-suggestions to target the correct branch via `createCommitOnBranch`.
- */
-export async function getPrHead(pr, owner, name) {
-    const data = await rest("GET", `/repos/${owner}/${name}/pulls/${pr}`);
-    if (!data.head.repo) {
-        throw new Error(`PR #${pr} head repository is unavailable (fork may have been deleted).`);
-    }
-    return {
-        sha: data.head.sha,
-        ref: data.head.ref,
-        repoWithOwner: data.head.repo.full_name,
-    };
-}
-/**
- * Fetch a file's raw text content at a given ref. Uses the REST contents endpoint,
- * which returns base64 for files under 1MB. Throws for binary / oversize files.
- */
-export async function getFileContents(repoWithOwner, path, ref) {
-    const data = await rest("GET", `/repos/${repoWithOwner}/contents/${encodePathForApi(path)}?ref=${encodeURIComponent(ref)}`);
-    if (!data.content || data.encoding !== "base64") {
-        throw new Error(`File ${path} could not be read as text (encoding=${data.encoding ?? "n/a"}).`);
+    const result = await httpGraphql(GET_PR_HEAD_SHA_QUERY, { owner, repo: name, pr });
+    const sha = result.data.repository?.pullRequest?.headRefOid;
+    if (!sha) {
+        const detail = !result.data.repository
+            ? "repository not found or access denied"
+            : !result.data.repository.pullRequest
+                ? "PR not found or access denied"
+                : "headRefOid missing";
+        throw new Error(`Could not resolve head SHA for ${owner}/${name} PR #${pr}: ${detail}`);
     }
-    return Buffer.from(data.content, "base64").toString("utf8");
-}
-// Encode every path segment but preserve the slashes between them.
-function encodePathForApi(path) {
-    return path.split("/").map(encodeURIComponent).join("/");
+    return sha;
 }
 /**
  * Fetches `mergeable` and `mergeStateStatus` via the REST API.

package/bin/github/gql/batch-pr.gql

@@ -19,6 +19,10 @@ query BatchPr(
       mergeStateStatus
       reviewDecision
       headRefOid
+      headRefName
+      headRepository {
+        nameWithOwner
+      }
       baseRefName
       # Not paginated — capped at 50; PRs with more pending reviewers truncate silently.
       reviewRequests(last: 50) {
@@ -58,6 +62,7 @@ query BatchPr(
             nodes {
               id
               isMinimized
+              url
               author {
                 login
               }
@@ -78,6 +83,7 @@ query BatchPr(
         nodes {
           id
           isMinimized
+          url
           author {
             login
           }

package/bin/github/gql/get-pr-head-sha.gql

@@ -0,0 +1,7 @@
+query GetPrHeadSha($owner: String!, $repo: String!, $pr: Int!) {
+  repository(owner: $owner, name: $repo) {
+    pullRequest(number: $pr) {
+      headRefOid
+    }
+  }
+}