opencode-magi 0.4.0 → 0.6.0

package/README.md

@@ -61,26 +61,33 @@ Add the following content to the configuration file.
 ```json
 {
   "$schema": "https://raw.githubusercontent.com/magi-ai/opencode-magi/main/schema.json",
-  "review": {
-    "agents": [
-      {
-        "account": "your-account-1",
-        "model": "openai/gpt-5.5"
+  "agents": {
+    "refs": {
+      "account-1": {
+        "model": "openai/gpt-5.5",
+        "account": "account-1"
       },
-      {
-        "account": "your-account-2",
-        "model": "anthropic/claude-opus-4-7"
+      "account-2": {
+        "model": "anthropic/claude-opus-4-7",
+        "account": "account-2"
       },
-      {
-        "account": "your-account-3",
-        "model": "opencode/kimi-k2-6"
+      "account-3": {
+        "model": "opencode/kimi-k2-6",
+        "account": "account-3"
       }
+    }
+  },
+  "review": {
+    "agents": [
+      { "ref": "account-1" },
+      { "ref": "account-2" },
+      { "ref": "account-3" }
     ]
   }
 }
 ```
 
-`review.agents[].account` is the GitHub account used to post reviews and approvals. Must be authenticated with `gh auth token --user <account>` and must be unique.
+After refs are expanded, `review.agents[].account` is the GitHub account used to post reviews and approvals. Must be authenticated with `gh auth token --user <account>` and must be unique.
 
 #### Set project config
 
@@ -101,53 +108,54 @@ Add the following content to the configuration file.
     "owner": "your-owner",
     "repo": "your-repo"
   },
-  "review": {
-    "agents": [
-      {
-        "account": "your-account-1",
-        "model": "openai/gpt-5.5"
+  "agents": {
+    "refs": {
+      "account-1": {
+        "model": "openai/gpt-5.5",
+        "account": "account-1"
       },
-      {
-        "account": "your-account-2",
-        "model": "anthropic/claude-opus-4-7"
+      "account-2": {
+        "model": "anthropic/claude-opus-4-7",
+        "account": "account-2"
       },
-      {
-        "account": "your-account-3",
-        "model": "opencode/kimi-k2-6"
+      "account-3": {
+        "model": "opencode/kimi-k2-6",
+        "account": "account-3"
+      },
+      "account-4": {
+        "model": "openai/gpt-5.5",
+        "account": "account-4",
+        "author": {
+          "name": "account-4",
+          "email": "your-email@example.com"
+        }
       }
+    }
+  },
+  "review": {
+    "agents": [
+      { "ref": "account-1" },
+      { "ref": "account-2" },
+      { "ref": "account-3" }
     ]
   },
   "merge": {
-    "editor": {
-      "account": "your-editor-account",
-      "model": "openai/gpt-5.5",
-      "author": {
-        "name": "your-account",
-        "email": "your-email@example.com"
-      }
-    }
+    "editor": { "ref": "account-4" }
   },
   "triage": {
-    "account": "your-triage-account",
+    "account": "account-5",
     "agents": [
-      {
-        "id": "general",
-        "model": "openai/gpt-5.5"
-      },
-      {
-        "id": "maintenance",
-        "model": "anthropic/claude-opus-4-7"
-      },
-      {
-        "id": "product",
-        "model": "opencode/kimi-k2-6"
-      }
+      { "ref": "account-1" },
+      { "ref": "account-2" },
+      { "ref": "account-3" }
     ]
   }
 }
 ```
 
-`review.agents[].account` is the GitHub account used to post reviews and approvals. Must be authenticated with `gh auth token --user <account>` and must be unique. `merge.editor.account` is used by `/magi:merge` to push fixes, close PRs, and merge PRs.
+Entries with `ref` are expanded from `agents.refs`. Fields set alongside `ref` override fields from the preset.
+
+After refs are expanded, `review.agents[].account` is the GitHub account used to post reviews and approvals. Must be authenticated with `gh auth token --user <account>` and must be unique. `merge.editor.account` is used by `/magi:merge` to push fixes, close PRs, and merge PRs.
 
 #### Validate config
 

package/dist/config/resolve.js

@@ -28,7 +28,7 @@ export function reviewerKey(reviewer, index) {
     return reviewer.id ?? `reviewer-${index + 1}`;
 }
 export function triageAgentKey(agent, index) {
-    return agent.id ?? `triage-${index + 1}`;
+    return agent.id ?? `voter-${index + 1}`;
 }
 export function validateReviewerId(id) {
     return ID_PATTERN.test(id);
@@ -104,7 +104,7 @@ export function resolveAgents(config) {
         triageCreator: creator
             ? {
                 ...creator,
-                account: creator.account ?? config.triage?.account ?? "",
+                account: creator.account ?? "",
                 permission: resolveTriageCreatorPermission(agents, creator),
             }
             : undefined,
@@ -179,7 +179,6 @@ export function resolveRepository(config) {
             requiredLabels: config.review?.safety?.requiredLabels ?? [],
         },
         triage: {
-            account: config.triage?.account,
             automation: {
                 clear: config.triage?.automation?.clear ?? ["triage"],
                 close: config.triage?.automation?.close ?? false,
@@ -193,6 +192,7 @@ export function resolveRepository(config) {
             },
             output: config.triage?.output,
             prompts: config.triage?.prompts ?? {},
+            reporter: config.triage?.reporter,
             safety: {
                 allowAuthors: config.triage?.safety?.allowAuthors ?? [],
                 allowMentionActors: config.triage?.safety?.allowMentionActors ?? [],

package/dist/config/validate.js

@@ -40,6 +40,7 @@ const EDITOR_KEYS = new Set([
     "persona",
 ]);
 const TRIAGE_AGENT_KEYS = new Set([
+    "account",
     "id",
     "model",
     "options",
@@ -75,7 +76,6 @@ const MERGE_KEYS = new Set([
     "prompts",
 ]);
 const TRIAGE_KEYS = new Set([
-    "account",
     "agents",
     "automation",
     "categories",
@@ -83,6 +83,7 @@ const TRIAGE_KEYS = new Set([
     "creator",
     "output",
     "prompts",
+    "reporter",
     "safety",
     "worktree",
 ]);
@@ -135,7 +136,6 @@ const MERGE_PROMPT_KEYS = new Set([
     "editGuidelines",
 ]);
 const TRIAGE_PROMPT_KEYS = new Set([
-    "action",
     "acceptance",
     "category",
     "comment",
@@ -357,6 +357,9 @@ function validateTriageAgentList(agents, path, errors, catalog) {
             errors.push(`${path}[${index}].model is required`);
         validateString(agent.model, `${path}[${index}].model`, errors);
         validateModel(agent.model, `${path}[${index}].model`, errors, catalog);
+        if (!agent.account)
+            errors.push(`${path}[${index}].account is required`);
+        validateString(agent.account, `${path}[${index}].account`, errors);
         validateString(agent.persona, `${path}[${index}].persona`, errors);
         if (agent.options != null && !isPlainObject(agent.options))
             errors.push(`${path}[${index}].options must be an object`);
@@ -383,12 +386,16 @@ function validateResolvedReviewers(reviewers, path, errors) {
         accounts.add(reviewer.account);
     }
 }
-function validateResolvedAgentKeys(agents, path, errors) {
+function validateResolvedTriageAgents(agents, path, errors) {
     const keys = new Set();
+    const accounts = new Set();
     for (const agent of agents) {
         if (keys.has(agent.key))
             errors.push(`${path} has duplicate agent key: ${agent.key}`);
         keys.add(agent.key);
+        if (accounts.has(agent.account))
+            errors.push(`${path} has duplicate agent account: ${agent.account}`);
+        accounts.add(agent.account);
     }
 }
 function validateEditor(editor, path, errors, catalog) {
@@ -672,19 +679,26 @@ function validateTriage(config, errors, options) {
     validateKnownKeys(triage, "triage", TRIAGE_KEYS, errors);
     const automation = triage.automation;
     const concurrency = triage.concurrency;
+    const creator = triage.creator;
+    const reporter = typeof triage.reporter === "string" ? triage.reporter : undefined;
     const safety = triage.safety;
-    if (!triage.account)
-        errors.push("triage.account is required");
-    validateString(triage.account, "triage.account", errors);
     if (!triage.agents)
         errors.push("triage.agents is required");
     validateTriageAgentList(triage.agents, "triage.agents", errors, options.modelCatalog);
     if (Array.isArray(triage.agents)) {
-        validateResolvedAgentKeys(resolveAgents(config).triage ?? [], "triage.resolvedAgents", errors);
+        const resolvedTriageAgents = resolveAgents(config).triage ?? [];
+        validateResolvedTriageAgents(resolvedTriageAgents, "triage.resolvedAgents", errors);
+        if (reporter != null &&
+            !resolvedTriageAgents.some((agent) => agent.key === reporter)) {
+            errors.push(`triage.reporter must match a triage agent key: ${reporter}`);
+        }
     }
-    validateTriageCreator(triage.creator, "triage.creator", errors, options.modelCatalog);
-    if (automation?.create && !triage.creator)
+    validateString(triage.reporter, "triage.reporter", errors);
+    validateTriageCreator(creator, "triage.creator", errors, options.modelCatalog);
+    if (automation?.create && !creator)
         errors.push("triage.creator is required when triage.automation.create is true");
+    if (automation?.create && creator && !creator.account)
+        errors.push("triage.creator.account is required when triage.automation.create is true");
     if (automation != null && !isPlainObject(automation)) {
         errors.push("triage.automation must be an object");
     }
@@ -745,10 +759,10 @@ async function validateAuth(config, exec, errors) {
     const agents = resolveAgents(config);
     for (const reviewer of agents.reviewers)
         accounts.add(reviewer.account);
+    for (const agent of agents.triage ?? [])
+        accounts.add(agent.account);
     if (agents.editor)
         accounts.add(agents.editor.account);
-    if (config.triage?.account)
-        accounts.add(config.triage.account);
     if (agents.triageCreator?.account)
         accounts.add(agents.triageCreator.account);
     await Promise.all([...accounts].filter(Boolean).map(async (account) => {
@@ -802,19 +816,18 @@ async function validateRepositoryPermissions(config, exec, errors, warnings) {
             warnings.push(`Could not validate repository permissions for GitHub account: ${reviewer.account} (${error.message})`);
         }
     }));
-    if (config.triage?.account) {
+    await Promise.all((agents.triage ?? []).map(async (agent) => {
         try {
-            const permissions = await fetchPermissions(config, exec, config.triage.account);
+            const permissions = await fetchPermissions(config, exec, agent.account);
             if (!permissions.pull) {
-                errors.push(`GitHub account cannot read repository for issue triage: ${config.triage.account}`);
+                errors.push(`GitHub account cannot read repository for issue triage: ${agent.account}`);
             }
         }
         catch (error) {
-            warnings.push(`Could not validate repository permissions for GitHub account: ${config.triage.account} (${error.message})`);
+            warnings.push(`Could not validate repository permissions for GitHub account: ${agent.account} (${error.message})`);
         }
-    }
-    if (agents.triageCreator?.account &&
-        agents.triageCreator.account !== config.triage?.account) {
+    }));
+    if (agents.triageCreator?.account) {
         try {
             const permissions = await fetchPermissions(config, exec, agents.triageCreator.account);
             if (!permissions.push) {

package/dist/config/worktree.js

@@ -17,3 +17,9 @@ export function worktreeBaseDirs(directory, config = {}) {
         worktreeBaseDir(directory, config, "issue"),
     ];
 }
+export function prRunWorktreeDir(input) {
+    return join(worktreeBaseDir(input.directory, input.config, "pr"), String(input.pr), input.runId);
+}
+export function issueRunWorktreeDir(input) {
+    return join(worktreeBaseDir(input.directory, input.config, "issue"), String(input.issue), input.runId);
+}

package/dist/github/commands.js

@@ -20,6 +20,68 @@ function errorText(error) {
         .filter((item) => typeof item === "string")
         .join("\n");
 }
+async function localCommitExists(exec, worktreePath, sha) {
+    try {
+        await exec(`git cat-file -e ${shellQuote(`${sha}^{commit}`)}`, {
+            cwd: worktreePath,
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function pullRequestCommitSource(input) {
+    if (input.source === "base") {
+        return {
+            owner: input.repository.github.owner,
+            refName: input.meta.baseRefName,
+            repo: input.repository.github.repo,
+        };
+    }
+    return {
+        owner: input.meta.headRepositoryOwner?.login ?? input.repository.github.owner,
+        refName: input.meta.headRefName,
+        repo: input.meta.headRepository?.name ?? input.repository.github.repo,
+    };
+}
+async function fetchPullRequestCommitSource(input) {
+    const commitSource = pullRequestCommitSource(input);
+    try {
+        await input.exec(`git fetch --no-tags ${shellQuote(repositoryGitUrl(input.repository, commitSource.owner, commitSource.repo))} ${shellQuote(`refs/heads/${commitSource.refName}`)}`, { cwd: input.worktreePath });
+    }
+    catch (error) {
+        throw new Error(`Could not fetch ${input.source} ref ${commitSource.refName} for #${input.meta.number}: ${errorText(error)}`);
+    }
+}
+export async function ensurePullRequestCommits(input) {
+    const missing = [];
+    for (const commit of input.commits) {
+        if (!(await localCommitExists(input.exec, input.worktreePath, commit.sha))) {
+            missing.push(commit);
+        }
+    }
+    for (const source of new Set(missing.map((commit) => commit.source))) {
+        await fetchPullRequestCommitSource({
+            exec: input.exec,
+            meta: input.meta,
+            repository: input.repository,
+            source,
+            worktreePath: input.worktreePath,
+        });
+    }
+    for (const commit of missing) {
+        if (await localCommitExists(input.exec, input.worktreePath, commit.sha)) {
+            continue;
+        }
+        const source = pullRequestCommitSource({
+            meta: input.meta,
+            repository: input.repository,
+            source: commit.source,
+        });
+        throw new Error(`${commit.label} commit ${commit.sha} is unavailable after fetching ${commit.source} ref ${source.refName}`);
+    }
+}
 function isCheckoutConfigLockError(error) {
     const text = errorText(error);
     return (/could not lock config file/i.test(text) ||
@@ -246,6 +308,12 @@ function duplicateReferences(text) {
         refs.add(Number(match[1]));
     return [...refs];
 }
+function issueTitleSearchQuery(title, fallback) {
+    return (title
+        .replaceAll(/[^\p{L}\p{N}_]+/gu, " ")
+        .replaceAll(/\s+/g, " ")
+        .trim() || fallback);
+}
 async function fetchIssueCandidate(exec, repository, number, whyCandidate) {
     const raw = await exec(`gh issue view ${number} --repo ${shellQuote(repoSpecifier(repository))} --json number,title,url,state,body,createdAt`).catch(() => undefined);
     if (!raw)
@@ -254,7 +322,7 @@ async function fetchIssueCandidate(exec, repository, number, whyCandidate) {
     return { ...data, whyCandidate };
 }
 export async function searchDuplicateIssues(exec, repository, issue, limit = 5) {
-    const query = issue.title;
+    const query = issueTitleSearchQuery(issue.title, String(issue.number));
     const explicitCandidates = await Promise.all(duplicateReferences(issue.body)
         .filter((number) => number !== issue.number)
         .map((number) => fetchIssueCandidate(exec, repository, number, "Issue body explicitly references a duplicate target.")));
@@ -324,16 +392,43 @@ export async function removeIssueLabels(exec, repository, issue, labels, account
     return removed;
 }
 export async function fetchPullRequestReviews(exec, repository, pr) {
-    const query = `query($owner: String!, $repo: String!, $pr: Int!) { repository(owner: $owner, name: $repo) { pullRequest(number: $pr) { reviews(first: 100) { nodes { author { login } submittedAt state body commit { oid } } } } } }`;
-    const raw = await exec(`gh api${ghHostOption(repository)} graphql -f query=${shellQuote(query)} -F owner=${shellQuote(repository.github.owner)} -F repo=${shellQuote(repository.github.repo)} -F pr=${pr}`);
-    const data = JSON.parse(raw);
-    return data.data.repository.pullRequest.reviews.nodes;
+    const query = `query($owner: String!, $repo: String!, $pr: Int!, $cursor: String) { repository(owner: $owner, name: $repo) { pullRequest(number: $pr) { reviews(first: 100, after: $cursor) { nodes { author { login } submittedAt state body commit { oid } comments(first: 100) { nodes { body path line startLine } } } pageInfo { hasNextPage endCursor } } } } }`;
+    const reviews = [];
+    let cursor;
+    for (;;) {
+        const cursorFlag = cursor ? ` -F cursor=${shellQuote(cursor)}` : "";
+        const raw = await exec(`gh api${ghHostOption(repository)} graphql -f query=${shellQuote(query)} -F owner=${shellQuote(repository.github.owner)} -F repo=${shellQuote(repository.github.repo)} -F pr=${pr}${cursorFlag}`);
+        const data = JSON.parse(raw);
+        const connection = data.data.repository.pullRequest.reviews;
+        reviews.push(...connection.nodes);
+        if (!connection.pageInfo?.hasNextPage)
+            break;
+        cursor = connection.pageInfo.endCursor;
+        if (!cursor)
+            throw new Error("GitHub reviews page was truncated");
+    }
+    return reviews.map((review) => ({
+        ...review,
+        comments: review.comments?.nodes ?? [],
+    }));
 }
 export async function fetchPullRequestCommits(exec, repository, pr) {
-    const query = `query($owner: String!, $repo: String!, $pr: Int!) { repository(owner: $owner, name: $repo) { pullRequest(number: $pr) { commits(first: 100) { nodes { commit { oid committedDate parents { totalCount } } } } } } }`;
-    const raw = await exec(`gh api${ghHostOption(repository)} graphql -f query=${shellQuote(query)} -F owner=${shellQuote(repository.github.owner)} -F repo=${shellQuote(repository.github.repo)} -F pr=${pr}`);
-    const data = JSON.parse(raw);
-    return data.data.repository.pullRequest.commits.nodes.map(({ commit }) => ({
+    const query = `query($owner: String!, $repo: String!, $pr: Int!, $cursor: String) { repository(owner: $owner, name: $repo) { pullRequest(number: $pr) { commits(first: 100, after: $cursor) { nodes { commit { oid committedDate parents { totalCount } } } pageInfo { hasNextPage endCursor } } } } }`;
+    const commits = [];
+    let cursor;
+    for (;;) {
+        const cursorFlag = cursor ? ` -F cursor=${shellQuote(cursor)}` : "";
+        const raw = await exec(`gh api${ghHostOption(repository)} graphql -f query=${shellQuote(query)} -F owner=${shellQuote(repository.github.owner)} -F repo=${shellQuote(repository.github.repo)} -F pr=${pr}${cursorFlag}`);
+        const data = JSON.parse(raw);
+        const connection = data.data.repository.pullRequest.commits;
+        commits.push(...connection.nodes);
+        if (!connection.pageInfo?.hasNextPage)
+            break;
+        cursor = connection.pageInfo.endCursor;
+        if (!cursor)
+            throw new Error("GitHub commits page was truncated");
+    }
+    return commits.map(({ commit }) => ({
         committedDate: commit.committedDate,
         oid: commit.oid,
         parentCount: commit.parents.totalCount,
@@ -363,38 +458,9 @@ export async function fetchPullRequestSafetyMeta(exec, repository, pr) {
     }
     return { author, changedFiles, files, labels };
 }
-export async function waitForChecks(exec, repository, pr, enabled = repository.checks.waitBeforeReview) {
-    if (!enabled)
-        return undefined;
-    const report = {
-        attempts: 0,
-        excluded: [],
-        failed: [],
-        rerun: [],
-        scopeInside: [],
-        scopeOutsideRecovered: [],
-        scopeOutsideUnresolved: [],
-    };
-    try {
-        await watchChecks(exec, repository, pr);
-        return report;
-    }
-    catch {
-        report.failed = applyCheckExclusions({
-            checks: await fetchFailedChecks(exec, repository, pr),
-            excluded: report.excluded,
-            patterns: repository.checks.exclude,
-        });
-        return report;
-    }
-}
 export async function watchChecks(exec, repository, pr) {
     await exec(`gh pr checks ${pr} --repo ${shellQuote(repoSpecifier(repository))} --watch`);
 }
-export async function fetchFailedChecks(exec, repository, pr) {
-    const checks = await fetchPullRequestChecks(exec, repository, pr);
-    return checks.filter((check) => isFailedCheck(check) || isCancelledCheck(check));
-}
 export function isCancelledCheck(check) {
     return check.bucket === "cancel" || check.state === "CANCELLED";
 }
@@ -466,9 +532,8 @@ export async function fetchMergeQueueRequirement(exec, repository, branch) {
     const rules = JSON.parse(raw);
     return rules.some((rule) => rule.type === "merge_queue");
 }
-export async function createWorktree(exec, repository, pr, root) {
-    const worktreePath = join(root, `pr-${pr}`);
-    const lockKey = `${repoSpecifier(repository)}:${root}`;
+export async function createWorktree(exec, repository, pr, worktreePath) {
+    const lockKey = `${repoSpecifier(repository)}:${dirname(dirname(worktreePath))}`;
     return withWorktreeCreateLock(lockKey, async () => {
         let worktreeAdded = false;
         try {
@@ -509,9 +574,6 @@ export async function postCloseComment(exec, repository, pr, account, body) {
         await rm(payloadPath, { force: true });
     }
 }
-function isInlineFinding(finding) {
-    return finding.line != null;
-}
 function findingComment(finding) {
     const comment = {
         body: `**Issue:** ${finding.issue}\n\n**Fix:** ${finding.fix}`,
@@ -525,54 +587,18 @@ function findingComment(finding) {
     }
     return comment;
 }
-function requirementFindingSummary(finding) {
-    return [
-        `- Missing issue #${finding.issueNumber} requirement: ${finding.requirement}`,
-        `  Evidence: ${finding.evidence}`,
-        `  Fix: ${finding.fix}`,
-    ].join("\n");
-}
-function findingLocation(finding) {
-    if (finding.line == null)
-        return finding.path;
-    if (finding.startLine == null)
-        return `${finding.path}:${finding.line}`;
-    return `${finding.path}:${finding.startLine}-${finding.line}`;
-}
-function findingSummary(finding) {
-    return [
-        `- ${findingLocation(finding)}: ${finding.issue}`,
-        `  Fix: ${finding.fix}`,
-    ]
-        .filter(Boolean)
-        .join("\n");
-}
-function changesRequestedBody(findings, requirementFindings) {
-    const inlineFindings = findings.filter(isInlineFinding);
-    const fileLevelFindings = findings.filter((finding) => !isInlineFinding(finding));
-    const sections = [];
-    if (inlineFindings.length) {
-        sections.push(["Inline findings:", ...inlineFindings.map(findingSummary)].join("\n"));
-    }
-    if (fileLevelFindings.length) {
-        sections.push(["File-level findings:", ...fileLevelFindings.map(findingSummary)].join("\n"));
-    }
-    if (requirementFindings.length) {
-        sections.push([
-            "Requirement findings:",
-            ...requirementFindings.map(requirementFindingSummary),
-        ].join("\n"));
-    }
-    return sections.join("\n\n");
+function changesRequestedBody(findings) {
+    return findings.length === 1
+        ? "Changes requested: 1 inline comment."
+        : `Changes requested: ${findings.length} inline comments.`;
 }
-export async function postChangesRequested(exec, repository, pr, account, findings, requirementFindings = []) {
+export async function postChangesRequested(exec, repository, pr, account, findings) {
     const token = await ghToken(exec, repository, account);
     const payloadPath = join(tmpdir(), `magi-review-${process.pid}-${Date.now()}.json`);
-    const inlineFindings = findings.filter(isInlineFinding);
-    const body = changesRequestedBody(findings, requirementFindings);
+    const body = changesRequestedBody(findings);
     await writeFile(payloadPath, JSON.stringify({
         body,
-        comments: inlineFindings.map(findingComment),
+        comments: findings.map(findingComment),
         event: "REQUEST_CHANGES",
     }));
     try {
@@ -624,6 +650,17 @@ export async function waitForMergeQueue(exec, repository, pr, intervalMs = 30_00
         await new Promise((resolve) => setTimeout(resolve, intervalMs));
     }
 }
+export async function waitForAutoMerge(exec, repository, pr, intervalMs = 30_000) {
+    for (;;) {
+        const status = await fetchPullRequestMergeStatus(exec, repository, pr);
+        if (status.state === "MERGED")
+            return "merged";
+        if (status.state !== "OPEN" || status.autoMergeRequest == null) {
+            return "dequeued";
+        }
+        await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    }
+}
 export async function closePullRequest(exec, repository, pr, account) {
     const token = await ghToken(exec, repository, account);
     return exec(`gh pr close ${pr} --repo ${shellQuote(repoSpecifier(repository))}`, ghTokenEnv(token));
@@ -662,11 +699,49 @@ export async function configureGitIdentity(exec, worktreePath, identity) {
     }
 }
 export async function fetchUnresolvedThreads(exec, repository, pr, author) {
-    const query = `query($owner: String!, $repo: String!, $pr: Int!) { repository(owner: $owner, name: $repo) { pullRequest(number: $pr) { reviewThreads(first: 100) { nodes { id isResolved comments(first: 50) { nodes { databaseId author { login } path line body createdAt } } } } } } }`;
-    const raw = await exec(`gh api${ghHostOption(repository)} graphql -f query=${shellQuote(query)} -F owner=${shellQuote(repository.github.owner)} -F repo=${shellQuote(repository.github.repo)} -F pr=${pr}`);
-    const data = JSON.parse(raw);
-    const threads = data.data.repository.pullRequest.reviewThreads
-        .nodes;
+    const threadQuery = `query($owner: String!, $repo: String!, $pr: Int!, $cursor: String) { repository(owner: $owner, name: $repo) { pullRequest(number: $pr) { reviewThreads(first: 100, after: $cursor) { nodes { id isResolved comments(first: 100) { nodes { databaseId author { login } path line body createdAt } pageInfo { hasNextPage endCursor } } } pageInfo { hasNextPage endCursor } } } } }`;
+    const commentQuery = `query($threadId: ID!, $cursor: String) { node(id: $threadId) { ... on PullRequestReviewThread { comments(first: 100, after: $cursor) { nodes { databaseId author { login } path line body createdAt } pageInfo { hasNextPage endCursor } } } } }`;
+    const threads = [];
+    let cursor;
+    async function fetchRemainingComments(threadId, initialCursor) {
+        const comments = [];
+        let commentsCursor = initialCursor;
+        for (;;) {
+            const raw = await exec(`gh api${ghHostOption(repository)} graphql -f query=${shellQuote(commentQuery)} -F threadId=${shellQuote(threadId)} -F cursor=${shellQuote(commentsCursor)}`);
+            const data = JSON.parse(raw);
+            const connection = data.data.node?.comments;
+            if (!connection)
+                throw new Error("GitHub review thread comments were missing");
+            comments.push(...connection.nodes);
+            if (!connection.pageInfo?.hasNextPage)
+                break;
+            const nextCursor = connection.pageInfo.endCursor;
+            if (!nextCursor)
+                throw new Error("GitHub review thread comments page was truncated");
+            commentsCursor = nextCursor;
+        }
+        return comments;
+    }
+    for (;;) {
+        const cursorFlag = cursor ? ` -F cursor=${shellQuote(cursor)}` : "";
+        const raw = await exec(`gh api${ghHostOption(repository)} graphql -f query=${shellQuote(threadQuery)} -F owner=${shellQuote(repository.github.owner)} -F repo=${shellQuote(repository.github.repo)} -F pr=${pr}${cursorFlag}`);
+        const data = JSON.parse(raw);
+        const connection = data.data.repository.pullRequest.reviewThreads;
+        for (const thread of connection.nodes) {
+            const commentsCursor = thread.comments.pageInfo?.endCursor;
+            if (thread.comments.pageInfo?.hasNextPage) {
+                if (!commentsCursor)
+                    throw new Error("GitHub review thread comments page was truncated");
+                thread.comments.nodes.push(...(await fetchRemainingComments(thread.id, commentsCursor)));
+            }
+        }
+        threads.push(...connection.nodes);
+        if (!connection.pageInfo?.hasNextPage)
+            break;
+        cursor = connection.pageInfo.endCursor;
+        if (!cursor)
+            throw new Error("GitHub review threads page was truncated");
+    }
     return threads.flatMap((thread) => {
         if (thread.isResolved || !thread.comments.nodes.length)
             return [];