opencode-magi 0.0.0-dev-20260525101932 → 0.0.0-dev-20260525141349

package/README.md

@@ -17,7 +17,7 @@ OpenCode Magi recreates the review cycle humans already run on GitHub: multiple
 - Multi-agent reviews with an odd-number majority of 3 or more reviewers.
 - Optional unanimous approval policy for merge automation when every reviewer must approve before a PR is merged.
 - Finding-level voting before posting change requests, so only findings accepted by reviewer majority are submitted.
-- Each reviewer acts through its configured GitHub account, posting real reviews, approvals, change requests, and follow-up comments.
+- Multi-account review mode where each reviewer posts through its configured GitHub account, plus single-account review mode where one GitHub account posts the consensus result for multiple logical reviewers.
 - Re-review support for edited PRs: fixed threads are resolved, satisfied reviewers approve, and remaining issues are posted as additional comments.
 - Optional merge and close automation where an editor agent responds on behalf of the author, fixes changes it agrees with, pushes commits when needed, and repeats the reviewer/editor cycle until the PR can be approved, queued, merged, or closed.
 - Per-agent OpenCode permissions for reviewer, CI classifier, and editor child sessions.
@@ -87,7 +87,23 @@ Add the following content to the configuration file.
 }
 ```
 
-After `refs` are expanded, `review.reviewers[].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.reviewers[].account` is the GitHub account used to post reviews and approvals in the default `review.mode: "multi"`. Must be authenticated with `gh auth token --user <account>` and must be unique.
+
+For individual setups, use `review.mode: "single"` with one `review.account`. Magi still runs an odd number of at least 3 logical reviewer agents and keeps majority voting, finding validation, and close reconsideration, but GitHub branch protection sees only the one configured review account.
+
+```json
+{
+  "review": {
+    "mode": "single",
+    "account": "your-account",
+    "reviewers": [
+      { "id": "general", "model": "openai/gpt-5.5" },
+      { "id": "security", "model": "anthropic/claude-opus-4-7" },
+      { "id": "compat", "model": "opencode/kimi-k2-6" }
+    ]
+  }
+}
+```
 
 #### Set project config
 
@@ -165,7 +181,7 @@ Entries with `ref` are expanded from `agents.refs`. Fields set alongside `ref` o
 }
 ```
 
-After `refs` are expanded, `review.reviewers[].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.
+After `refs` are expanded, `review.reviewers[].account` is the GitHub account used to post reviews and approvals in `multi` mode. Must be authenticated with `gh auth token --user <account>` and must be unique. In `single` mode, `review.account` is used for reviewer-originated review posts, approvals, change requests, close comments, reviewer replies, and reviewer thread resolutions. `merge.editor.account` is still used by `/magi:merge` to push fixes, close PRs, and merge PRs.
 
 #### Validate config
 

package/dist/config/resolve.js

@@ -113,6 +113,7 @@ export function resolveAgents(config) {
     const agents = config.agents ?? {};
     const editor = config.merge?.editor;
     const creator = config.triage?.creator;
+    const singleReviewAccount = config.review?.mode === "single" ? config.review.account : undefined;
     return {
         editor: editor
             ? {
@@ -123,6 +124,7 @@ export function resolveAgents(config) {
             : undefined,
         reviewers: (config.review?.reviewers ?? []).map((reviewer, index) => ({
             ...reviewer,
+            account: singleReviewAccount ?? reviewer.account ?? "",
             key: reviewerKey(reviewer, index),
             index,
             model: normalizedModel(reviewer.model),
@@ -204,6 +206,10 @@ export function resolveRepository(config) {
             review: config.review?.prompts?.review,
             reviewGuidelines: config.review?.prompts?.reviewGuidelines,
         },
+        review: {
+            account: config.review?.account,
+            mode: config.review?.mode ?? "multi",
+        },
         reviewAutomation: {
             close: config.review?.automation?.close ?? false,
             merge: config.review?.automation?.merge ?? true,

package/dist/config/validate.js

@@ -54,10 +54,12 @@ const TRIAGE_CREATOR_KEYS = new Set([
 const AUTHOR_KEYS = new Set(["email", "name"]);
 const GITHUB_KEYS = new Set(["apiRetryAttempts", "host", "owner", "repo"]);
 const REVIEW_KEYS = new Set([
+    "account",
     "automation",
     "checks",
     "concurrency",
     "merge",
+    "mode",
     "output",
     "prompts",
     "reviewers",
@@ -384,7 +386,7 @@ function validateAndNormalizeModel(target, path, errors, catalog) {
     }
     errors.push(`${path} must contain at least one usable OpenCode model candidate${candidateErrors.length ? ` (${candidateErrors.join("; ")})` : ""}`);
 }
-function validateReviewerList(reviewers, path, errors, catalog) {
+function validateReviewerList(reviewers, path, errors, catalog, mode = "multi") {
     if (reviewers == null)
         return;
     if (!Array.isArray(reviewers)) {
@@ -404,7 +406,7 @@ function validateReviewerList(reviewers, path, errors, catalog) {
         if (!reviewer.model)
             errors.push(`${path}[${index}].model is required`);
         validateAndNormalizeModel(reviewer, `${path}[${index}].model`, errors, catalog);
-        if (!reviewer.account)
+        if (mode === "multi" && !reviewer.account)
             errors.push(`${path}[${index}].account is required`);
         validateString(reviewer.account, `${path}[${index}].account`, errors);
         validateString(reviewer.persona, `${path}[${index}].persona`, errors);
@@ -454,18 +456,31 @@ function validateTriageAgentList(voters, path, errors, catalog) {
         }
     });
 }
-function validateResolvedReviewers(reviewers, path, errors) {
+function validateResolvedReviewers(reviewers, path, errors, mode = "multi") {
     const keys = new Set();
     const accounts = new Set();
     for (const reviewer of reviewers) {
         if (keys.has(reviewer.key))
             errors.push(`${path} has duplicate reviewer key: ${reviewer.key}`);
         keys.add(reviewer.key);
-        if (accounts.has(reviewer.account))
+        if (mode === "multi" && accounts.has(reviewer.account))
             errors.push(`${path} has duplicate reviewer account: ${reviewer.account}`);
         accounts.add(reviewer.account);
     }
 }
+function reviewMode(config) {
+    return config.review?.mode === "single" ? "single" : "multi";
+}
+function validateReviewIdentity(config, errors) {
+    const mode = config.review?.mode;
+    if (mode != null && mode !== "multi" && mode !== "single") {
+        errors.push("review.mode must be multi or single");
+    }
+    validateString(config.review?.account, "review.account", errors);
+    if (mode === "single" && !config.review?.account) {
+        errors.push("review.account is required when review.mode is single");
+    }
+}
 function validateResolvedTriageAgents(agents, path, errors) {
     const keys = new Set();
     const accounts = new Set();
@@ -908,8 +923,14 @@ async function validatePrompts(config, errors, directory) {
 async function validateAuth(config, exec, errors) {
     const accounts = new Set();
     const agents = resolveAgents(config);
-    for (const reviewer of agents.reviewers)
-        accounts.add(reviewer.account);
+    if (reviewMode(config) === "single") {
+        if (config.review?.account)
+            accounts.add(config.review.account);
+    }
+    else {
+        for (const reviewer of agents.reviewers)
+            accounts.add(reviewer.account);
+    }
     for (const agent of agents.triage ?? [])
         accounts.add(agent.account);
     if (agents.editor)
@@ -956,15 +977,20 @@ async function validateRepositoryPermissions(config, exec, errors, warnings) {
     if (!config.github?.owner || !config.github.repo)
         return;
     const agents = resolveAgents(config);
-    await Promise.all(agents.reviewers.map(async (reviewer) => {
+    const reviewAccounts = reviewMode(config) === "single"
+        ? config.review?.account
+            ? [config.review.account]
+            : []
+        : agents.reviewers.map((reviewer) => reviewer.account);
+    await Promise.all(reviewAccounts.map(async (account) => {
         try {
-            const permissions = await fetchPermissions(config, exec, reviewer.account);
+            const permissions = await fetchPermissions(config, exec, account);
             if (!permissions.pull) {
-                errors.push(`GitHub account cannot read repository for PR review: ${reviewer.account}`);
+                errors.push(`GitHub account cannot read repository for PR review: ${account}`);
             }
         }
         catch (error) {
-            warnings.push(`Could not validate repository permissions for GitHub account: ${reviewer.account} (${error.message})`);
+            warnings.push(`Could not validate repository permissions for GitHub account: ${account} (${error.message})`);
         }
     }));
     await Promise.all((agents.triage ?? []).map(async (agent) => {
@@ -1026,15 +1052,17 @@ export async function validateConfig(config, options = {}) {
         errors.push("review is required");
     }
     else if (config.review) {
+        const mode = reviewMode(config);
         if (!isPlainObject(config.review)) {
             errors.push("review must be an object");
         }
         else {
             validateKnownKeys(config.review, "review", REVIEW_KEYS, errors);
         }
+        validateReviewIdentity(config, errors);
         if (!config.review.reviewers)
             errors.push("review.reviewers is required");
-        validateReviewerList(config.review.reviewers, "review.reviewers", errors, options.modelCatalog);
+        validateReviewerList(config.review.reviewers, "review.reviewers", errors, options.modelCatalog, mode);
         if (Array.isArray(config.review.reviewers)) {
             validateResolvedReviewers(config.review.reviewers.map((reviewer, index) => ({
                 account: reviewer &&
@@ -1045,7 +1073,7 @@ export async function validateConfig(config, options = {}) {
                 key: reviewer && typeof reviewer === "object"
                     ? reviewerKey(reviewer, index)
                     : "",
-            })), "review.resolvedReviewers", errors);
+            })), "review.resolvedReviewers", errors, mode);
         }
     }
     if (options.requireTriage && !config.triage) {

package/dist/github/commands.js

@@ -592,8 +592,18 @@ export async function removeWorktree(exec, worktreePath) {
 export async function removeBranch(exec, branch) {
     await exec(`git branch -D ${shellQuote(branch)}`);
 }
-export async function postApproval(exec, repository, pr, account) {
+export async function postApproval(exec, repository, pr, account, body) {
     const token = await ghToken(exec, repository, account);
+    if (body != null) {
+        const payloadPath = join(tmpdir(), `magi-approve-${process.pid}-${Date.now()}.json`);
+        await writeFile(payloadPath, JSON.stringify({ body, event: "APPROVE" }));
+        try {
+            return await exec(`gh api${ghHostOption(repository)} repos/${repository.github.owner}/${repository.github.repo}/pulls/${pr}/reviews --method POST --input ${shellQuote(payloadPath)} --jq .html_url`, ghTokenEnv(token));
+        }
+        finally {
+            await rm(payloadPath, { force: true });
+        }
+    }
     return exec(`gh pr review ${pr} --repo ${shellQuote(repoSpecifier(repository))} --approve`, ghTokenEnv(token));
 }
 export async function postCloseComment(exec, repository, pr, account, body) {
@@ -607,9 +617,9 @@ export async function postCloseComment(exec, repository, pr, account, body) {
         await rm(payloadPath, { force: true });
     }
 }
-function findingComment(finding) {
+function findingComment(finding, body) {
     const comment = {
-        body: `**Issue:** ${finding.issue}\n\n**Fix:** ${finding.fix}`,
+        body: body ?? `**Issue:** ${finding.issue}\n\n**Fix:** ${finding.fix}`,
         line: finding.line,
         path: finding.path,
         side: "RIGHT",
@@ -625,13 +635,13 @@ function changesRequestedBody(findings) {
         ? "Changes requested: 1 inline comment."
         : `Changes requested: ${findings.length} inline comments.`;
 }
-export async function postChangesRequested(exec, repository, pr, account, findings) {
+export async function postChangesRequested(exec, repository, pr, account, findings, options = {}) {
     const token = await ghToken(exec, repository, account);
     const payloadPath = join(tmpdir(), `magi-review-${process.pid}-${Date.now()}.json`);
-    const body = changesRequestedBody(findings);
+    const body = options.body ?? changesRequestedBody(findings);
     await writeFile(payloadPath, JSON.stringify({
         body,
-        comments: findings.map(findingComment),
+        comments: findings.map((finding, index) => findingComment(finding, options.commentBodies?.[index])),
         event: "REQUEST_CHANGES",
     }));
     try {

package/dist/orchestrator/merge.js

@@ -11,7 +11,7 @@ import { closeMinorityReviewers, mergeVerdictForPolicy } from "./majority";
 import { runModelWithRepair } from "./model";
 import { mapPool } from "./pool";
 import { formatMergeReport } from "./report";
-import { inlineCommentTargetsForDiff, runReview, } from "./review";
+import { inlineCommentTargetsForDiff, assignThreadsByReviewFindingMarker, formatReviewMarker, postSingleConsensusReview, runReview, reviewPostingAccount, } from "./review";
 import { checkSafetyGate, hasSafetyGate } from "./safety";
 function outputDir(input) {
     return prRunOutputDir({
@@ -131,6 +131,7 @@ async function postRereviewOutput(input, reviewerKey, output) {
     const reviewer = input.repository.agents.reviewers.find((item) => item.key === reviewerKey);
     if (!reviewer)
         throw new Error(`Unknown reviewer: ${reviewerKey}`);
+    const account = reviewPostingAccount(input.repository, reviewer);
     if (input.dryRun) {
         if (output.verdict === "MERGE")
             return `dry-run:would-approve:${reviewerKey}`;
@@ -139,16 +140,16 @@ async function postRereviewOutput(input, reviewerKey, output) {
         }
         return `dry-run:would-request-changes:${reviewerKey}`;
     }
-    await Promise.all(output.resolve.map((item) => resolveThread(input.exec, input.repository, reviewer.account, item.threadId)));
-    const replies = await Promise.all(output.followUps.map((item) => postReply(input.exec, input.repository, input.pr, reviewer.account, item.commentId, item.body)));
+    await Promise.all(output.resolve.map((item) => resolveThread(input.exec, input.repository, account, item.threadId)));
+    const replies = await Promise.all(output.followUps.map((item) => postReply(input.exec, input.repository, input.pr, account, item.commentId, item.body)));
     if (output.verdict === "MERGE") {
-        return postApproval(input.exec, input.repository, input.pr, reviewer.account);
+        return postApproval(input.exec, input.repository, input.pr, account);
     }
     if (output.verdict === "CLOSE") {
-        return postCloseComment(input.exec, input.repository, input.pr, reviewer.account, output.reason ?? "Close requested.");
+        return postCloseComment(input.exec, input.repository, input.pr, account, output.reason ?? "Close requested.");
     }
     if (output.newFindings.length) {
-        return postChangesRequested(input.exec, input.repository, input.pr, reviewer.account, output.newFindings.map((finding) => ({
+        return postChangesRequested(input.exec, input.repository, input.pr, account, output.newFindings.map((finding) => ({
             fix: "Please address this before merging.",
             issue: finding.body,
             path: finding.path,
@@ -212,10 +213,24 @@ async function runRereview(input, worktreePath, previousHeadSha, cycle, sessionI
         worktreePath,
     });
     const artifactDir = outputDir(input);
+    const singleReviewMode = input.repository.review?.mode === "single";
+    const reviewerKeys = input.repository.agents.reviewers.map((reviewer) => reviewer.key);
+    const singleModeThreads = singleReviewMode
+        ? assignThreadsByReviewFindingMarker({
+            fallbackReviewerKeys: reviewerKeys,
+            headSha,
+            pr: input.pr,
+            reviewerKeys,
+            threads: options.dryRunThreads == null
+                ? await fetchUnresolvedThreads(input.exec, input.repository, input.pr, input.repository.review?.account ?? "")
+                : Object.values(options.dryRunThreads).flat(),
+        })
+        : undefined;
     let entries = await mapPool(input.repository.agents.reviewers, input.repository.concurrency.reviewers, async (reviewer) => {
         throwIfAborted(input.signal);
-        const unresolved = options.dryRunThreads?.[reviewer.key] ??
-            (await fetchUnresolvedThreads(input.exec, input.repository, input.pr, reviewer.account));
+        const unresolved = singleModeThreads?.[reviewer.key] ??
+            options.dryRunThreads?.[reviewer.key] ??
+            (await fetchUnresolvedThreads(input.exec, input.repository, input.pr, reviewPostingAccount(input.repository, reviewer)));
         const hasReviewerSession = Boolean(sessionIds[reviewer.key]);
         const prompt = await composeRereviewPrompt({
             baseSha: meta.baseRefOid,
@@ -388,14 +403,44 @@ async function runRereview(input, worktreePath, previousHeadSha, cycle, sessionI
             };
         }));
     }
-    const posted = Object.fromEntries(await Promise.all(entries.map(async (entry) => [
-        entry.reviewer,
-        await postRereviewOutput(input, entry.reviewer, entry.output),
-    ])));
     const verdict = mergeVerdictForPolicy(entries.map((entry) => ({
         reviewer: entry.reviewer,
         verdict: entry.verdict,
     })), input.repository.merge.approvalPolicy);
+    const outputs = Object.fromEntries(entries.map((entry) => [entry.reviewer, entry.output]));
+    const posted = singleReviewMode
+        ? input.dryRun
+            ? { consensus: `dry-run:would-post-single-review:${verdict}` }
+            : {
+                consensus: await (async () => {
+                    const account = input.repository.review?.account ?? "";
+                    await Promise.all(entries.flatMap((entry) => entry.output.resolve.map((item) => resolveThread(input.exec, input.repository, account, item.threadId))));
+                    await Promise.all(entries.flatMap((entry) => entry.output.followUps.map((item) => postReply(input.exec, input.repository, input.pr, account, item.commentId, [
+                        `**Reviewer:** ${entry.reviewer}`,
+                        "",
+                        item.body,
+                        "",
+                        formatReviewMarker({
+                            head: headSha,
+                            pr: input.pr,
+                            reviewer: entry.reviewer,
+                            verdict: entry.output.verdict,
+                        }),
+                    ].join("\n")))));
+                    return postSingleConsensusReview({
+                        exec: input.exec,
+                        headSha,
+                        outputs,
+                        pr: input.pr,
+                        repository: input.repository,
+                        verdict,
+                    });
+                })(),
+            }
+        : Object.fromEntries(await Promise.all(entries.map(async (entry) => [
+            entry.reviewer,
+            await postRereviewOutput(input, entry.reviewer, entry.output),
+        ])));
     await writeFile(join(artifactDir, `rereview-majority.cycle-${cycle}.json`), JSON.stringify({
         approvalPolicy: input.repository.merge.approvalPolicy,
         verdict,
@@ -405,7 +450,7 @@ async function runRereview(input, worktreePath, previousHeadSha, cycle, sessionI
         })),
     }, null, 2));
     return {
-        outputs: Object.fromEntries(entries.map((entry) => [entry.reviewer, entry.output])),
+        outputs,
         posted,
         verdict,
     };

package/dist/orchestrator/review.js

@@ -15,6 +15,85 @@ import { mapPool } from "./pool";
 import { formatReviewReport } from "./report";
 import { buildReviewContextSnapshot, renderReviewContext, } from "./review-context";
 import { checkSafetyGate, hasSafetyGate } from "./safety";
+function resolvedReviewMode(repository) {
+    return repository.review?.mode === "single" ? "single" : "multi";
+}
+export function reviewPostingAccount(repository, reviewer) {
+    return resolvedReviewMode(repository) === "single"
+        ? (repository.review?.account ?? reviewer.account)
+        : reviewer.account;
+}
+function reviewAssignmentKey(repository, reviewer) {
+    return resolvedReviewMode(repository) === "single"
+        ? reviewer.key
+        : reviewer.account;
+}
+function parseMarkerFields(text) {
+    const fields = Object.fromEntries(text
+        .trim()
+        .split(/\s+/)
+        .flatMap((part) => {
+        const index = part.indexOf("=");
+        return index > 0 ? [[part.slice(0, index), part.slice(index + 1)]] : [];
+    }));
+    return fields.v === "1" && fields.mode === "single" ? fields : undefined;
+}
+function isMarkerVerdict(value) {
+    return value === "CHANGES_REQUESTED" || value === "CLOSE" || value === "MERGE";
+}
+export function formatReviewMarker(marker) {
+    return `<!-- opencode-magi:review v=1 mode=single pr=${marker.pr} reviewer=${marker.reviewer} verdict=${marker.verdict} head=${marker.head} -->`;
+}
+export function parseReviewMarkers(body) {
+    const markers = [];
+    const regex = /<!--\s*opencode-magi:review\s+([^>]*)-->/g;
+    for (const match of body?.matchAll(regex) ?? []) {
+        const fields = parseMarkerFields(match[1] ?? "");
+        const pr = Number(fields?.pr);
+        if (!fields ||
+            !Number.isInteger(pr) ||
+            !fields.reviewer ||
+            !fields.head ||
+            !isMarkerVerdict(fields.verdict)) {
+            continue;
+        }
+        markers.push({
+            head: fields.head,
+            pr,
+            reviewer: fields.reviewer,
+            verdict: fields.verdict,
+        });
+    }
+    return markers;
+}
+export function formatReviewFindingMarker(marker) {
+    return `<!-- opencode-magi:review-finding v=1 mode=single pr=${marker.pr} reviewer=${marker.reviewer} finding=${marker.finding} head=${marker.head} -->`;
+}
+export function parseReviewFindingMarkers(body) {
+    const markers = [];
+    const regex = /<!--\s*opencode-magi:review-finding\s+([^>]*)-->/g;
+    for (const match of body?.matchAll(regex) ?? []) {
+        const fields = parseMarkerFields(match[1] ?? "");
+        const pr = Number(fields?.pr);
+        const finding = Number(fields?.finding);
+        if (!fields ||
+            !Number.isInteger(pr) ||
+            !Number.isInteger(finding) ||
+            !fields.reviewer ||
+            !fields.head) {
+            continue;
+        }
+        markers.push({ finding, head: fields.head, pr, reviewer: fields.reviewer });
+    }
+    return markers;
+}
+function markerReviewState(verdict) {
+    if (verdict === "MERGE")
+        return "APPROVED";
+    if (verdict === "CHANGES_REQUESTED")
+        return "CHANGES_REQUESTED";
+    return "CLOSE";
+}
 function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
@@ -35,11 +114,12 @@ async function postReviewOutput(input, reviewerKey, output) {
     const reviewer = input.repository.agents.reviewers.find((item) => item.key === reviewerKey);
     if (!reviewer)
         throw new Error(`Unknown reviewer: ${reviewerKey}`);
+    const account = reviewPostingAccount(input.repository, reviewer);
     if (output.verdict === "MERGE")
-        return postApproval(input.exec, input.repository, input.pr, reviewer.account);
+        return postApproval(input.exec, input.repository, input.pr, account);
     if (output.verdict === "CLOSE")
-        return postCloseComment(input.exec, input.repository, input.pr, reviewer.account, output.reason ?? "Close requested.");
-    return postChangesRequested(input.exec, input.repository, input.pr, reviewer.account, output.findings);
+        return postCloseComment(input.exec, input.repository, input.pr, account, output.reason ?? "Close requested.");
+    return postChangesRequested(input.exec, input.repository, input.pr, account, output.findings);
 }
 function dryRunReviewPost(key, output) {
     if (output.verdict === "MERGE")
@@ -86,6 +166,56 @@ export function resolveReviewMode(reviews, accounts, current, accountsWithPendin
         return { assignments, type: "already_reviewed" };
     return { assignments, type: "active" };
 }
+export function resolveSingleAccountReviewMode(input) {
+    const reviewerKeySet = new Set(input.reviewerKeys);
+    const pendingReviewers = input.pendingReviewers ?? new Set();
+    const latest = new Map();
+    for (const review of input.reviews) {
+        if (review.author.login !== input.account)
+            continue;
+        if (review.state === "DISMISSED")
+            continue;
+        for (const marker of parseReviewMarkers(review.body)) {
+            if (marker.pr !== input.pr || !reviewerKeySet.has(marker.reviewer)) {
+                continue;
+            }
+            const synthetic = {
+                ...review,
+                commit: { oid: marker.head },
+                comments: (review.comments ?? []).filter((comment) => parseReviewFindingMarkers(comment.body).some((findingMarker) => findingMarker.pr === input.pr &&
+                    findingMarker.reviewer === marker.reviewer &&
+                    findingMarker.head === marker.head)),
+                state: markerReviewState(marker.verdict),
+            };
+            const current = latest.get(marker.reviewer);
+            if (!current ||
+                current.submittedAt.localeCompare(review.submittedAt) < 0) {
+                latest.set(marker.reviewer, synthetic);
+            }
+        }
+    }
+    const reviewedHead = input.reviewerKeys.every((reviewer) => {
+        return (isReviewCurrent(latest.get(reviewer), input.current) &&
+            !pendingReviewers.has(reviewer));
+    });
+    const assignments = new Map();
+    for (const reviewer of input.reviewerKeys) {
+        const review = latest.get(reviewer);
+        if (!review) {
+            assignments.set(reviewer, { type: "initial" });
+            continue;
+        }
+        if (isReviewCurrent(review, input.current) &&
+            !pendingReviewers.has(reviewer)) {
+            assignments.set(reviewer, { review, type: "skip" });
+            continue;
+        }
+        assignments.set(reviewer, { review, type: "rereview" });
+    }
+    if (latest.size && reviewedHead)
+        return { assignments, type: "already_reviewed" };
+    return { assignments, type: "active" };
+}
 export function reviewFreshnessTarget(commits, headSha) {
     const latestNonMerge = [...commits]
         .reverse()
@@ -112,6 +242,8 @@ function reviewStateToVerdict(state) {
         return "MERGE";
     if (state === "CHANGES_REQUESTED")
         return "CHANGES_REQUESTED";
+    if (state === "CLOSE")
+        return "CLOSE";
     throw new Error(`Unsupported GitHub review state: ${state}`);
 }
 function hasBlockingCiReports(reports) {
@@ -295,7 +427,10 @@ function reviewFindingsFromBody(body) {
     return { findings };
 }
 function parsePostedFindingComment(body) {
-    const match = /^\*\*Issue:\*\*\s*([\s\S]*?)\s*\r?\n\r?\n\*\*Fix:\*\*\s*([\s\S]+?)\s*$/.exec(body);
+    const visibleBody = body
+        .replace(/<!--\s*opencode-magi:review-finding\s+[^>]*-->/g, "")
+        .trim();
+    const match = /^\*\*Issue:\*\*\s*([\s\S]*?)\s*\r?\n\r?\n\*\*Fix:\*\*\s*([\s\S]*?)(?:\s*\r?\n\r?\n\*\*Reviewer:\*\*[\s\S]*)?\s*$/.exec(visibleBody);
     if (!match)
         return undefined;
     return {
@@ -350,19 +485,120 @@ export function hasPendingThreadReply(threads, reviewerAccount) {
             comment.createdAt.localeCompare(latestReviewerComment.createdAt) > 0);
     });
 }
+export function assignThreadsByReviewFindingMarker(input) {
+    const reviewerKeys = new Set(input.reviewerKeys);
+    const assigned = Object.fromEntries(input.reviewerKeys.map((reviewer) => [reviewer, []]));
+    for (const thread of input.threads) {
+        const markers = [
+            thread.body,
+            thread.latestBody,
+            ...thread.comments.map((comment) => comment.body),
+        ]
+            .flatMap(parseReviewFindingMarkers)
+            .filter((marker) => {
+            return (marker.pr === input.pr &&
+                reviewerKeys.has(marker.reviewer) &&
+                (!input.headSha || marker.head === input.headSha));
+        });
+        const reviewers = markers.length
+            ? [...new Set(markers.map((marker) => marker.reviewer))]
+            : input.fallbackReviewerKeys;
+        for (const reviewer of reviewers)
+            assigned[reviewer]?.push(thread);
+    }
+    return assigned;
+}
+function outputFindings(reviewer, output) {
+    if (output.verdict !== "CHANGES_REQUESTED")
+        return [];
+    if ("findings" in output) {
+        return output.findings.map((finding, index) => ({
+            finding,
+            index,
+            reviewer,
+        }));
+    }
+    return output.newFindings.map((finding, index) => ({
+        finding: {
+            fix: "Please address this before merging.",
+            issue: finding.body,
+            line: finding.line,
+            path: finding.path,
+            startLine: finding.startLine,
+        },
+        index,
+        reviewer,
+    }));
+}
+function singleReviewBody(input) {
+    const lines = [
+        `Magi single-account review result: ${input.verdict}.`,
+        "",
+        "Logical reviewer verdicts:",
+        ...Object.entries(input.outputs).map(([reviewer, output]) => `- ${reviewer}: ${output.verdict}`),
+        "",
+        ...Object.entries(input.outputs).map(([reviewer, output]) => formatReviewMarker({
+            head: input.headSha,
+            pr: input.pr,
+            reviewer,
+            verdict: output.verdict,
+        })),
+    ];
+    return lines.join("\n");
+}
+function singleFindingBody(input) {
+    return [
+        `**Issue:** ${input.finding.issue}`,
+        "",
+        `**Fix:** ${input.finding.fix}`,
+        "",
+        `**Reviewer:** ${input.reviewer}`,
+        "",
+        formatReviewFindingMarker({
+            finding: input.index,
+            head: input.headSha,
+            pr: input.pr,
+            reviewer: input.reviewer,
+        }),
+    ].join("\n");
+}
+export async function postSingleConsensusReview(input) {
+    const account = input.repository.review?.account;
+    if (!account)
+        throw new Error("review.account is required for single review mode");
+    const body = singleReviewBody(input);
+    if (input.verdict === "MERGE") {
+        return postApproval(input.exec, input.repository, input.pr, account, body);
+    }
+    if (input.verdict === "CLOSE") {
+        return postCloseComment(input.exec, input.repository, input.pr, account, body);
+    }
+    const findings = Object.entries(input.outputs).flatMap(([reviewer, output]) => outputFindings(reviewer, output));
+    return postChangesRequested(input.exec, input.repository, input.pr, account, findings.map((item) => item.finding), {
+        body,
+        commentBodies: findings.map((item) => singleFindingBody({
+            finding: item.finding,
+            headSha: input.headSha,
+            index: item.index,
+            pr: input.pr,
+            reviewer: item.reviewer,
+        })),
+    });
+}
 async function postRereviewOutput(input, reviewerKey, output) {
     const reviewer = input.repository.agents.reviewers.find((item) => item.key === reviewerKey);
     if (!reviewer)
         throw new Error(`Unknown reviewer: ${reviewerKey}`);
-    await Promise.all(output.resolve.map((item) => resolveThread(input.exec, input.repository, reviewer.account, item.threadId)));
-    await Promise.all(output.followUps.map((item) => postReply(input.exec, input.repository, input.pr, reviewer.account, item.commentId, item.body)));
+    const account = reviewPostingAccount(input.repository, reviewer);
+    await Promise.all(output.resolve.map((item) => resolveThread(input.exec, input.repository, account, item.threadId)));
+    await Promise.all(output.followUps.map((item) => postReply(input.exec, input.repository, input.pr, account, item.commentId, item.body)));
     if (output.verdict === "MERGE")
-        return postApproval(input.exec, input.repository, input.pr, reviewer.account);
+        return postApproval(input.exec, input.repository, input.pr, account);
     if (output.verdict === "CLOSE")
-        return postCloseComment(input.exec, input.repository, input.pr, reviewer.account, output.reason ?? "Close requested.");
+        return postCloseComment(input.exec, input.repository, input.pr, account, output.reason ?? "Close requested.");
     if (!output.newFindings.length)
         return "";
-    return postChangesRequested(input.exec, input.repository, input.pr, reviewer.account, output.newFindings.map((finding) => ({
+    return postChangesRequested(input.exec, input.repository, input.pr, account, output.newFindings.map((finding) => ({
         fix: "Please address this before merging.",
         issue: finding.body,
         path: finding.path,
@@ -670,23 +906,66 @@ export async function runReview(input) {
     const reviews = await fetchPullRequestReviews(exec, input.repository, input.pr);
     const commits = await fetchPullRequestCommits(exec, input.repository, input.pr);
     const freshnessTarget = reviewFreshnessTarget(commits, meta.headRefOid);
+    const singleReviewMode = resolvedReviewMode(input.repository) === "single";
+    const reviewerKeys = input.repository.agents.reviewers.map((reviewer) => reviewer.key);
     const reviewerAccounts = input.repository.agents.reviewers.map((reviewer) => reviewer.account);
-    const preliminaryMode = resolveReviewMode(reviews, reviewerAccounts, freshnessTarget);
+    const preliminaryMode = singleReviewMode
+        ? resolveSingleAccountReviewMode({
+            account: input.repository.review?.account ?? "",
+            current: freshnessTarget,
+            pr: input.pr,
+            reviewerKeys,
+            reviews,
+        })
+        : resolveReviewMode(reviews, reviewerAccounts, freshnessTarget);
     const unresolvedThreadsByAccount = new Map();
+    const unresolvedThreadsByReviewer = new Map();
     const pendingThreadReplyAccounts = new Set();
+    const pendingThreadReplyReviewers = new Set();
     const skippedReviewers = input.repository.agents.reviewers.filter((reviewer) => {
-        return preliminaryMode.assignments.get(reviewer.account)?.type === "skip";
+        return (preliminaryMode.assignments.get(reviewAssignmentKey(input.repository, reviewer))?.type === "skip");
     });
-    await mapPool(skippedReviewers, input.repository.concurrency.reviewers, async (reviewer) => {
-        const threads = await fetchUnresolvedThreads(exec, input.repository, input.pr, reviewer.account);
-        unresolvedThreadsByAccount.set(reviewer.account, threads);
-        if (hasPendingThreadReply(threads, reviewer.account)) {
-            pendingThreadReplyAccounts.add(reviewer.account);
+    if (singleReviewMode && skippedReviewers.length) {
+        const account = input.repository.review?.account ?? "";
+        const threads = await fetchUnresolvedThreads(exec, input.repository, input.pr, account);
+        const assigned = assignThreadsByReviewFindingMarker({
+            fallbackReviewerKeys: reviewerKeys,
+            headSha: meta.headRefOid,
+            pr: input.pr,
+            reviewerKeys,
+            threads,
+        });
+        for (const reviewer of skippedReviewers) {
+            const reviewerThreads = assigned[reviewer.key] ?? [];
+            unresolvedThreadsByReviewer.set(reviewer.key, reviewerThreads);
+            if (hasPendingThreadReply(reviewerThreads, account)) {
+                pendingThreadReplyReviewers.add(reviewer.key);
+            }
         }
-    }, { signal: input.signal });
-    const mode = pendingThreadReplyAccounts.size
-        ? resolveReviewMode(reviews, reviewerAccounts, freshnessTarget, pendingThreadReplyAccounts)
-        : preliminaryMode;
+    }
+    else {
+        await mapPool(skippedReviewers, input.repository.concurrency.reviewers, async (reviewer) => {
+            const threads = await fetchUnresolvedThreads(exec, input.repository, input.pr, reviewer.account);
+            unresolvedThreadsByAccount.set(reviewer.account, threads);
+            if (hasPendingThreadReply(threads, reviewer.account)) {
+                pendingThreadReplyAccounts.add(reviewer.account);
+            }
+        }, { signal: input.signal });
+    }
+    const mode = singleReviewMode
+        ? pendingThreadReplyReviewers.size
+            ? resolveSingleAccountReviewMode({
+                account: input.repository.review?.account ?? "",
+                current: freshnessTarget,
+                pendingReviewers: pendingThreadReplyReviewers,
+                pr: input.pr,
+                reviewerKeys,
+                reviews,
+            })
+            : preliminaryMode
+        : pendingThreadReplyAccounts.size
+            ? resolveReviewMode(reviews, reviewerAccounts, freshnessTarget, pendingThreadReplyAccounts)
+            : preliminaryMode;
     if (mode.type === "already_reviewed" && !input.allowAlreadyReviewed)
         throw new Error("PR has already been reviewed by all configured accounts");
     const runId = input.runId ?? `run-${Date.now().toString(36)}`;
@@ -776,7 +1055,7 @@ export async function runReview(input) {
     try {
         throwIfAborted(input.signal);
         const activeReviewers = input.repository.agents.reviewers.flatMap((reviewer) => {
-            const assignment = mode.assignments.get(reviewer.account);
+            const assignment = mode.assignments.get(reviewAssignmentKey(input.repository, reviewer));
             if (!assignment || assignment.type === "skip")
                 return [];
             return [{ assignment, reviewer }];
@@ -801,7 +1080,7 @@ export async function runReview(input) {
             worktreePath,
         });
         for (const reviewer of input.repository.agents.reviewers) {
-            const assignment = mode.assignments.get(reviewer.account);
+            const assignment = mode.assignments.get(reviewAssignmentKey(input.repository, reviewer));
             if (assignment?.type !== "skip")
                 continue;
             await input.onProgress?.({
@@ -834,8 +1113,9 @@ export async function runReview(input) {
                 const rereviewInlineCommentTargets = mergeConflictContext
                     ? mergeInlineCommentTargets(inlineCommentTargets, initialInlineCommentTargets)
                     : inlineCommentTargets;
-                const unresolved = unresolvedThreadsByAccount.get(reviewer.account) ??
-                    (await fetchUnresolvedThreads(exec, input.repository, input.pr, reviewer.account));
+                const unresolved = unresolvedThreadsByReviewer.get(reviewer.key) ??
+                    unresolvedThreadsByAccount.get(reviewer.account) ??
+                    (await fetchUnresolvedThreads(exec, input.repository, input.pr, reviewPostingAccount(input.repository, reviewer)));
                 const prompt = await composeRereviewPrompt({
                     baseSha: meta.baseRefOid,
                     ciFailureContext,
@@ -981,7 +1261,7 @@ export async function runReview(input) {
         throwIfAborted(input.signal);
         const sessionIds = Object.fromEntries(entries.map((entry) => [entry.key, entry.sessionId]));
         const skippedVerdicts = input.repository.agents.reviewers.flatMap((reviewer) => {
-            const assignment = mode.assignments.get(reviewer.account);
+            const assignment = mode.assignments.get(reviewAssignmentKey(input.repository, reviewer));
             if (assignment?.type !== "skip")
                 return [];
             return [
@@ -999,7 +1279,7 @@ export async function runReview(input) {
             })),
         ]);
         const skippedCloseEntries = input.repository.agents.reviewers.flatMap((reviewer) => {
-            const assignment = mode.assignments.get(reviewer.account);
+            const assignment = mode.assignments.get(reviewAssignmentKey(input.repository, reviewer));
             if (assignment?.type !== "skip" || !closeTargets.includes(reviewer.key))
                 return [];
             return [
@@ -1033,14 +1313,14 @@ export async function runReview(input) {
         });
         const activeOutputs = validation.outputs;
         const skippedOutputs = Object.fromEntries(input.repository.agents.reviewers.flatMap((reviewer) => {
-            const assignment = mode.assignments.get(reviewer.account);
+            const assignment = mode.assignments.get(reviewAssignmentKey(input.repository, reviewer));
             return assignment?.type === "skip"
                 ? [[reviewer.key, reviewOutputFromState(assignment.review)]]
                 : [];
         }));
         const outputs = { ...skippedOutputs, ...activeOutputs };
         const remainingSkippedVerdicts = input.repository.agents.reviewers.flatMap((reviewer) => {
-            const assignment = mode.assignments.get(reviewer.account);
+            const assignment = mode.assignments.get(reviewAssignmentKey(input.repository, reviewer));
             if (assignment?.type !== "skip" || closeTargets.includes(reviewer.key))
                 return [];
             return [
@@ -1056,23 +1336,68 @@ export async function runReview(input) {
         }));
         const verdict = mergeVerdictForPolicy([...remainingSkippedVerdicts, ...activeVerdicts], input.approvalPolicy ?? "majority");
         await input.onProgress?.({ phase: "posting reviews", type: "phase" });
-        const posted = {
-            ...Object.fromEntries(input.repository.agents.reviewers.flatMap((reviewer) => {
-                const assignment = mode.assignments.get(reviewer.account);
-                return assignment?.type === "skip"
-                    ? [[reviewer.key, "skipped: already reviewed current head"]]
-                    : [];
-            })),
-            ...Object.fromEntries(await Promise.all(Object.entries(activeOutputs).map(async ([key, output]) => [
-                key,
-                input.dryRun
-                    ? dryRunReviewPost(key, output)
-                    : "resolve" in output
-                        ? await postRereviewOutput({ ...input, exec }, key, output)
-                        : await postReviewOutput({ ...input, exec }, key, output),
-            ]))),
-        };
-        const automationAccount = input.repository.agents.reviewers[0]?.account;
+        const skippedPosted = Object.fromEntries(input.repository.agents.reviewers.flatMap((reviewer) => {
+            const assignment = mode.assignments.get(reviewAssignmentKey(input.repository, reviewer));
+            return assignment?.type === "skip"
+                ? [[reviewer.key, "skipped: already reviewed current head"]]
+                : [];
+        }));
+        const posted = singleReviewMode
+            ? {
+                ...skippedPosted,
+                ...(Object.keys(activeOutputs).length
+                    ? {
+                        consensus: input.dryRun
+                            ? `dry-run:would-post-single-review:${verdict}`
+                            : await (async () => {
+                                const account = input.repository.review?.account ?? "";
+                                await Promise.all(Object.values(activeOutputs).flatMap((output) => {
+                                    if (!("resolve" in output))
+                                        return [];
+                                    return output.resolve.map((item) => resolveThread(exec, input.repository, account, item.threadId));
+                                }));
+                                await Promise.all(Object.entries(activeOutputs).flatMap(([key, output]) => {
+                                    if (!("followUps" in output))
+                                        return [];
+                                    return output.followUps.map((item) => postReply(exec, input.repository, input.pr, account, item.commentId, [
+                                        `**Reviewer:** ${key}`,
+                                        "",
+                                        item.body,
+                                        "",
+                                        formatReviewMarker({
+                                            head: meta.headRefOid,
+                                            pr: input.pr,
+                                            reviewer: key,
+                                            verdict: output.verdict,
+                                        }),
+                                    ].join("\n")));
+                                }));
+                                return postSingleConsensusReview({
+                                    exec,
+                                    headSha: meta.headRefOid,
+                                    outputs,
+                                    pr: input.pr,
+                                    repository: input.repository,
+                                    verdict,
+                                });
+                            })(),
+                    }
+                    : {}),
+            }
+            : {
+                ...skippedPosted,
+                ...Object.fromEntries(await Promise.all(Object.entries(activeOutputs).map(async ([key, output]) => [
+                    key,
+                    input.dryRun
+                        ? dryRunReviewPost(key, output)
+                        : "resolve" in output
+                            ? await postRereviewOutput({ ...input, exec }, key, output)
+                            : await postReviewOutput({ ...input, exec }, key, output),
+                ]))),
+            };
+        const automationAccount = singleReviewMode
+            ? input.repository.review?.account
+            : input.repository.agents.reviewers[0]?.account;
         const enableReviewAutomation = input.enableReviewAutomation ?? true;
         if (enableReviewAutomation &&
             verdict === "MERGE" &&

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-magi",
-  "version": "0.0.0-dev-20260525101932",
+  "version": "0.0.0-dev-20260525141349",
   "description": "Multi-agent PR review and merge orchestration plugin for OpenCode.",
   "license": "MIT",
   "author": "Hirotomo Yamada <hirotomo.yamada@avap.co.jp>",

package/schema.json

@@ -77,7 +77,7 @@
     "reviewer": {
       "type": "object",
       "if": { "not": { "required": ["ref"] } },
-      "then": { "required": ["model", "account"] },
+      "then": { "required": ["model"] },
       "additionalProperties": false,
       "properties": {
         "ref": { "type": "string", "minLength": 1 },
@@ -366,6 +366,8 @@
       "type": "object",
       "additionalProperties": false,
       "properties": {
+        "mode": { "enum": ["multi", "single"], "default": "multi" },
+        "account": { "type": "string", "minLength": 1 },
         "reviewers": {
           "type": "array",
           "minItems": 3,