opencode-magi 0.7.0 → 0.9.0

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 === "multi" ? "multi" : "single";
+}
+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) {
@@ -163,6 +295,90 @@ export async function inlineCommentTargetsForDiff(input) {
         cwd: input.worktreePath,
     }));
 }
+function firstTargetLine(targets, path) {
+    const lines = targets.get(path);
+    if (!lines?.size)
+        return undefined;
+    return [...lines].sort((a, b) => a - b)[0];
+}
+function mergeInlineCommentTargets(left, right) {
+    const merged = new Map();
+    for (const [path, lines] of [...left, ...right]) {
+        const targetLines = merged.get(path) ?? new Set();
+        for (const line of lines)
+            targetLines.add(line);
+        merged.set(path, targetLines);
+    }
+    return merged;
+}
+function targetLineSummary(targets, path) {
+    const lines = targets.get(path);
+    if (!lines?.size)
+        return "(none)";
+    const sorted = [...lines].sort((a, b) => a - b);
+    const shown = sorted.slice(0, 12).join(", ");
+    return sorted.length > 12 ? `${shown}, ...` : shown;
+}
+function indentedExcerpt(lines) {
+    return lines
+        .slice(0, 24)
+        .map((line) => `  ${line}`)
+        .join("\n");
+}
+function parseMergeConflictSections(output) {
+    const conflictHeaders = new Set([
+        "added in both",
+        "changed in both",
+        "removed in local",
+        "removed in remote",
+    ]);
+    const sections = [];
+    let current;
+    for (const line of output.split("\n")) {
+        if (!line.trim())
+            continue;
+        if (!line.startsWith(" ") &&
+            !line.startsWith("+") &&
+            !line.startsWith("-") &&
+            !line.startsWith("@")) {
+            current = conflictHeaders.has(line)
+                ? { lines: [line], paths: new Set() }
+                : undefined;
+            if (current)
+                sections.push(current);
+            continue;
+        }
+        if (!current)
+            continue;
+        current.lines.push(line);
+        const path = /^  (?:base|our|their)\s+\d+\s+[0-9a-f]+\s+(.+)$/.exec(line)?.[1];
+        if (path)
+            current.paths.add(path);
+    }
+    return sections.flatMap((section) => [...section.paths].map((path) => ({
+        excerpt: indentedExcerpt(section.lines),
+        path,
+    })));
+}
+export async function mergeConflictContextForDiff(input) {
+    const mergeBase = (await input.exec(`git merge-base ${shellQuote(input.baseSha)} ${shellQuote(input.headSha)}`, { cwd: input.worktreePath })).trim();
+    const output = await input.exec(`git merge-tree ${shellQuote(mergeBase)} ${shellQuote(input.headSha)} ${shellQuote(input.baseSha)}`, { cwd: input.worktreePath });
+    const conflicts = parseMergeConflictSections(output);
+    if (!conflicts.length)
+        return "";
+    return [
+        "The PR currently has unresolved merge conflicts with the base branch.",
+        "Treat unresolved conflicts as review findings and request changes when they make the PR unsafe or impossible to merge.",
+        "Use suggestedLine when it is present; it is a valid right-side PR diff line for an inline finding.",
+        ...conflicts.map((conflict) => {
+            const suggestedLine = firstTargetLine(input.inlineCommentTargets, conflict.path);
+            const suggestedLineText = suggestedLine
+                ? `suggestedLine: ${suggestedLine}`
+                : "suggestedLine: (no right-side PR diff line found)";
+            return `<conflict_file>\npath: ${conflict.path}\n${suggestedLineText}\nrightSideDiffLines: ${targetLineSummary(input.inlineCommentTargets, conflict.path)}\nmergeTreeExcerpt:\n${conflict.excerpt}\n</conflict_file>`;
+        }),
+    ].join("\n");
+}
 function parsePostedFindingLocation(location) {
     const range = /^(.*):(\d+)-(\d+)$/.exec(location);
     if (range) {
@@ -211,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 {
@@ -266,19 +485,136 @@ 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 outputs = Object.entries(input.outputs).sort(([a], [b]) => a.localeCompare(b));
+    const closeReasons = outputs.flatMap(([reviewer, output]) => output.verdict === "CLOSE"
+        ? [`- ${reviewer}: ${output.reason ?? "Close requested."}`]
+        : []);
+    const acceptedFindings = outputs.flatMap(([reviewer, output]) => outputFindings(reviewer, output).map(({ finding, index }) => {
+        const line = finding.startLine == null || finding.startLine === finding.line
+            ? String(finding.line)
+            : `${finding.startLine}-${finding.line}`;
+        return `- ${reviewer} #${index + 1} ${finding.path}:${line}: ${finding.issue} Fix: ${finding.fix}`;
+    }));
+    const lines = [
+        `Magi single-account review result: ${input.verdict}.`,
+        "",
+        "Logical reviewer verdicts:",
+        ...outputs.map(([reviewer, output]) => `- ${reviewer}: ${output.verdict}`),
+        ...(input.verdict === "CLOSE" && closeReasons.length
+            ? ["", "Close reasons:", ...closeReasons]
+            : []),
+        ...(input.verdict === "CHANGES_REQUESTED" && acceptedFindings.length
+            ? ["", "Accepted change requests:", ...acceptedFindings]
+            : []),
+        "",
+        ...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,
@@ -586,23 +922,68 @@ 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) {
+        const account = input.repository.review?.account ?? "";
+        const threads = await fetchUnresolvedThreads(exec, input.repository, input.pr, account);
+        const assigned = assignThreadsByReviewFindingMarker({
+            fallbackReviewerKeys: reviewerKeys,
+            pr: input.pr,
+            reviewerKeys,
+            threads,
+        });
+        for (const reviewer of input.repository.agents.reviewers) {
+            const reviewerThreads = assigned[reviewer.key] ?? [];
+            unresolvedThreadsByReviewer.set(reviewer.key, reviewerThreads);
+            if (preliminaryMode.assignments.get(reviewer.key)?.type !== "skip") {
+                continue;
+            }
+            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)}`;
@@ -692,7 +1073,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 }];
@@ -709,8 +1090,15 @@ export async function runReview(input) {
             toSha: meta.headRefOid,
             worktreePath,
         });
+        const mergeConflictContext = await mergeConflictContextForDiff({
+            baseSha: meta.baseRefOid,
+            exec,
+            headSha: meta.headRefOid,
+            inlineCommentTargets: initialInlineCommentTargets,
+            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?.({
@@ -740,13 +1128,18 @@ export async function runReview(input) {
                     toSha: meta.headRefOid,
                     worktreePath,
                 });
-                const unresolved = unresolvedThreadsByAccount.get(reviewer.account) ??
-                    (await fetchUnresolvedThreads(exec, input.repository, input.pr, reviewer.account));
+                const rereviewInlineCommentTargets = mergeConflictContext
+                    ? mergeInlineCommentTargets(inlineCommentTargets, initialInlineCommentTargets)
+                    : inlineCommentTargets;
+                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,
                     directory: input.directory,
                     headSha: meta.headRefOid,
+                    mergeConflictContext,
                     pr: input.pr,
                     previousReview: previousReviewText(previous),
                     previousHeadSha: previous.commit.oid,
@@ -787,7 +1180,7 @@ export async function runReview(input) {
                         },
                         options: reviewer.options,
                         parentSessionId: input.parentSessionId,
-                        parse: (text) => parseRereviewOutputWithInlineTargets(text, inlineCommentTargets),
+                        parse: (text) => parseRereviewOutputWithInlineTargets(text, rereviewInlineCommentTargets),
                         permission: reviewer.permission,
                         prompt,
                         repairAttempts: input.config.output?.repairAttempts ?? 3,
@@ -819,6 +1212,7 @@ export async function runReview(input) {
                 ciFailureContext,
                 directory: input.directory,
                 headSha: meta.headRefOid,
+                mergeConflictContext,
                 pr: input.pr,
                 repository: input.repository,
                 reviewContext,
@@ -885,7 +1279,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 [
@@ -903,7 +1297,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 [
@@ -937,14 +1331,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 [
@@ -960,23 +1354,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" &&