opencode-magi 0.1.0 → 0.3.0

package/dist/orchestrator/report.js

@@ -10,6 +10,11 @@ function reportUrl(value) {
 function linkOrText(text, url) {
     return url ? `[${text}](${url})` : text;
 }
+function pullRequestLine(input) {
+    const host = input.repository.github.host || "github.com";
+    const url = `https://${host}/${input.repository.github.owner}/${input.repository.github.repo}/pull/${input.pr}`;
+    return `- **Pull Request**: [#${input.pr}](${url})`;
+}
 function formatFinding(finding) {
     const line = finding.startLine == null
         ? `${finding.path}:${finding.line}`
@@ -22,6 +27,9 @@ function formatRereviewFinding(finding) {
         : `${finding.path}:${finding.startLine}-${finding.line}`;
     return `\`${line}\`: ${finding.body}`;
 }
+function formatRequirementFinding(finding) {
+    return `Issue #${finding.issueNumber}: ${finding.requirement}`;
+}
 function isReviewOutput(output) {
     return "findings" in output;
 }
@@ -73,7 +81,10 @@ function reviewerDetailLines(output) {
             return output.reason ? [output.reason] : [];
         if (output.verdict !== "CHANGES_REQUESTED")
             return [];
-        return output.findings.map(formatFinding);
+        return [
+            ...output.findings.map(formatFinding),
+            ...output.requirementFindings.map(formatRequirementFinding),
+        ];
     }
     if (output.verdict === "CLOSE")
         return output.reason ? [output.reason] : [];
@@ -81,6 +92,7 @@ function reviewerDetailLines(output) {
         return [];
     return [
         ...output.newFindings.map(formatRereviewFinding),
+        ...output.requirementFindings.map(formatRequirementFinding),
         ...output.followUps.map((item) => `Comment #${item.commentId}: ${item.body}`),
     ];
 }
@@ -150,6 +162,7 @@ function editorLines(outputs) {
 }
 export function formatReviewReport(input) {
     return [
+        pullRequestLine(input),
         ...dryRunLines(input.dryRun),
         ...safetyLines(input.safety),
         ...checkLines(input.ciReports),
@@ -158,6 +171,7 @@ export function formatReviewReport(input) {
 }
 export function formatMergeReport(input) {
     return [
+        pullRequestLine(input),
         ...mergeStatusLines(input.status),
         ...dryRunLines(input.dryRun),
         ...safetyLines(input.safety),

package/dist/orchestrator/review-context.js

@@ -0,0 +1,309 @@
+import { fetchIssue, fetchIssueCommentPage, fetchPullRequestClosingIssues, fetchPullRequestCommentPage, fetchPullRequestReviewThreadPage, fetchPullRequestSafetyMeta, } from "../github/commands";
+const LIMITS = {
+    closingIssueComments: 20,
+    commentBody: 4000,
+    prComments: 20,
+    referencedIssueComments: 10,
+    reviewThreadComments: 20,
+    reviewThreads: 50,
+};
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function truncateBody(body) {
+    if (body.length <= LIMITS.commentBody)
+        return { body };
+    return {
+        body: `${body.slice(0, LIMITS.commentBody)}\n[truncated after ${LIMITS.commentBody} characters]`,
+        truncated: true,
+    };
+}
+function boundedComments(comments, limit) {
+    return [...comments]
+        .sort((a, b) => a.createdAt.localeCompare(b.createdAt))
+        .slice(-limit)
+        .map((comment) => ({
+        author: comment.author,
+        createdAt: comment.createdAt,
+        id: comment.id,
+        url: comment.url,
+        ...truncateBody(comment.body),
+    }));
+}
+function omittedCommentCount(input) {
+    return input.omitted + Math.max(0, input.comments.length - input.limit);
+}
+function quoteEvidence(value) {
+    const compact = value.replaceAll(/\s+/g, " ").trim();
+    return compact.length > 120 ? `${compact.slice(0, 117)}...` : compact;
+}
+function issueReferencePattern(repository) {
+    const host = escapeRegExp(repository.github.host || "github.com");
+    const owner = escapeRegExp(repository.github.owner);
+    const repo = escapeRegExp(repository.github.repo);
+    return new RegExp(`(?:https?://${host}/${owner}/${repo}/issues/(\\d+)|#(\\d+))`, "gi");
+}
+function issueNumberFromMatch(match) {
+    return Number(match[1] ?? match[2]);
+}
+function addRelationship(relationships, number, relationship, source) {
+    const current = relationships.get(number);
+    const nextRelationship = current?.relationship === "closing" || relationship === "closing"
+        ? "closing"
+        : "referenced";
+    const sources = current?.sources ?? [];
+    relationships.set(number, {
+        number,
+        relationship: nextRelationship,
+        sources: sources.includes(source) ? sources : [...sources, source],
+    });
+}
+function scanRelationshipText(input) {
+    const referencePattern = issueReferencePattern(input.repository);
+    const closingPattern = new RegExp(`\\b(?:close|closes|closed|fix|fixes|fixed|resolve|resolves|resolved)\\b[\\s\\S]{0,80}?${referencePattern.source}`, "gi");
+    for (const match of input.text.matchAll(referencePattern)) {
+        const number = issueNumberFromMatch(match);
+        if (number === input.currentPr)
+            continue;
+        addRelationship(input.relationships, number, "referenced", `${input.label} "${quoteEvidence(match[0])}"`);
+    }
+    for (const match of input.text.matchAll(closingPattern)) {
+        const number = Number(match[1] ?? match[2]);
+        if (!number || number === input.currentPr)
+            continue;
+        addRelationship(input.relationships, number, "closing", `${input.label} "${quoteEvidence(match[0])}"`);
+    }
+}
+export function collectIssueRelationships(input) {
+    const relationships = new Map();
+    for (const issue of input.closingIssues) {
+        if (issue.number === input.pr.number)
+            continue;
+        addRelationship(relationships, issue.number, "closing", "GitHub closingIssuesReferences");
+    }
+    scanRelationshipText({
+        currentPr: input.pr.number,
+        label: "PR title",
+        relationships,
+        repository: input.repository,
+        text: input.pr.title,
+    });
+    scanRelationshipText({
+        currentPr: input.pr.number,
+        label: "PR body",
+        relationships,
+        repository: input.repository,
+        text: input.pr.body ?? "",
+    });
+    for (const comment of input.prComments) {
+        scanRelationshipText({
+            currentPr: input.pr.number,
+            label: `PR comment ${comment.id}`,
+            relationships,
+            repository: input.repository,
+            text: comment.body,
+        });
+    }
+    for (const thread of input.reviewThreads) {
+        for (const comment of thread.comments) {
+            scanRelationshipText({
+                currentPr: input.pr.number,
+                label: `review thread ${thread.threadId} comment ${comment.commentId}`,
+                relationships,
+                repository: input.repository,
+                text: comment.body,
+            });
+        }
+    }
+    return [...relationships.values()].sort((a, b) => a.number - b.number);
+}
+async function contextIssue(input) {
+    const issue = input.issue ??
+        (await fetchIssue(input.exec, input.repository, input.relationship.number));
+    const commentPage = await fetchIssueCommentPage(input.exec, input.repository, issue.number, input.limit);
+    return {
+        author: issue.author,
+        body: issue.body,
+        comments: boundedComments(commentPage.comments, input.limit),
+        commentsOmitted: omittedCommentCount({
+            comments: commentPage.comments,
+            limit: input.limit,
+            omitted: commentPage.omitted,
+        }),
+        number: issue.number,
+        relationship: input.relationship.relationship,
+        source: input.relationship.sources.join("; "),
+        state: issue.state,
+        title: issue.title,
+        url: issue.url,
+    };
+}
+function orderReviewThreads(threads) {
+    return [...threads]
+        .sort((a, b) => {
+        if (a.isResolved !== b.isResolved)
+            return a.isResolved ? 1 : -1;
+        const aLatest = a.comments.at(-1)?.createdAt ?? "";
+        const bLatest = b.comments.at(-1)?.createdAt ?? "";
+        return bLatest.localeCompare(aLatest);
+    })
+        .slice(0, LIMITS.reviewThreads)
+        .map((thread) => ({
+        ...thread,
+        comments: thread.comments
+            .slice(-LIMITS.reviewThreadComments)
+            .map((comment) => ({
+            ...comment,
+            ...truncateBody(comment.body),
+        })),
+    }));
+}
+export async function buildReviewContextSnapshot(input) {
+    const [prCommentPage, reviewThreadPage, safetyMeta, closingIssues] = await Promise.all([
+        fetchPullRequestCommentPage(input.exec, input.repository, input.pr.number, LIMITS.prComments),
+        fetchPullRequestReviewThreadPage(input.exec, input.repository, input.pr.number, LIMITS.reviewThreads, LIMITS.reviewThreadComments),
+        fetchPullRequestSafetyMeta(input.exec, input.repository, input.pr.number),
+        fetchPullRequestClosingIssues(input.exec, input.repository, input.pr.number).catch(() => []),
+    ]);
+    const prComments = prCommentPage.comments;
+    const orderedReviewThreads = orderReviewThreads(reviewThreadPage.threads);
+    const prCommentsOmitted = omittedCommentCount({
+        comments: prComments,
+        limit: LIMITS.prComments,
+        omitted: prCommentPage.omitted,
+    });
+    const relationships = collectIssueRelationships({
+        closingIssues,
+        pr: input.pr,
+        prComments,
+        repository: input.repository,
+        reviewThreads: orderedReviewThreads,
+    });
+    const closingIssueMap = new Map(closingIssues.map((issue) => [issue.number, issue]));
+    const closingRelationships = relationships.filter((relationship) => relationship.relationship === "closing");
+    const referencedRelationships = relationships.filter((relationship) => relationship.relationship === "referenced");
+    return {
+        closingIssues: await Promise.all(closingRelationships.map((relationship) => contextIssue({
+            exec: input.exec,
+            issue: closingIssueMap.get(relationship.number),
+            limit: LIMITS.closingIssueComments,
+            relationship,
+            repository: input.repository,
+        }))),
+        pullRequest: {
+            author: input.pr.author?.login ?? safetyMeta.author,
+            baseRef: input.pr.baseRefName,
+            baseSha: input.pr.baseRefOid,
+            body: input.pr.body ?? "",
+            changedFiles: safetyMeta.files,
+            comments: boundedComments(prComments, LIMITS.prComments),
+            commentsOmitted: prCommentsOmitted,
+            headRef: input.pr.headRefName,
+            headSha: input.pr.headRefOid,
+            number: input.pr.number,
+            relationship: "target",
+            source: "/magi:review input",
+            state: input.pr.state ?? "",
+            title: input.pr.title,
+            url: input.pr.url,
+        },
+        referencedIssues: await Promise.all(referencedRelationships.map((relationship) => contextIssue({
+            exec: input.exec,
+            limit: LIMITS.referencedIssueComments,
+            relationship,
+            repository: input.repository,
+        }))),
+        reviewDiscussion: {
+            prComments: boundedComments(prComments, LIMITS.prComments),
+            prCommentsOmitted,
+            reviewThreads: orderedReviewThreads,
+            reviewThreadsOmitted: reviewThreadPage.omitted,
+        },
+    };
+}
+function indented(value) {
+    return value.trim() ? value : "(empty)";
+}
+function renderOmissionNote(omitted, label, limit) {
+    return omitted > 0
+        ? `\n[omitted ${omitted} older ${label} due to limit ${limit}]`
+        : "";
+}
+function renderComments(comments, omitted = 0, limit = comments.length) {
+    if (!comments.length)
+        return `(none)${renderOmissionNote(omitted, "comments", limit)}`;
+    return (comments
+        .map((comment) => {
+        const suffix = comment.truncated ? " [truncated]" : "";
+        return `- ${comment.createdAt} @${comment.author} (${comment.id})${suffix}\n${indented(comment.body)}`;
+    })
+        .join("\n") + renderOmissionNote(omitted, "comments", limit));
+}
+function renderIssue(issue) {
+    return `<issue>
+number: ${issue.number}
+title: ${issue.title}
+url: ${issue.url}
+state: ${issue.state}
+author: ${issue.author}
+relationship: ${issue.relationship}
+source: ${issue.source}
+body:
+${indented(issue.body)}
+comments:
+${renderComments(issue.comments, issue.commentsOmitted, issue.relationship === "closing" ? LIMITS.closingIssueComments : LIMITS.referencedIssueComments)}
+</issue>`;
+}
+function renderThreads(threads, omitted = 0) {
+    if (!threads.length) {
+        return `(none)${renderOmissionNote(omitted, "review threads", LIMITS.reviewThreads)}`;
+    }
+    return (threads
+        .map((thread) => {
+        const comments = thread.comments
+            .map((comment) => {
+            const suffix = comment.truncated ? " [truncated]" : "";
+            return `  - ${comment.createdAt} @${comment.author} (${comment.commentId})${suffix}\n${indented(comment.body)}`;
+        })
+            .join("\n") +
+            renderOmissionNote(thread.omittedComments ?? 0, "thread comments", LIMITS.reviewThreadComments);
+        return `- threadId: ${thread.threadId}\n  resolved: ${Boolean(thread.isResolved)}\n  path: ${thread.path}:${thread.line}\n  comments:\n${comments}`;
+    })
+        .join("\n") +
+        renderOmissionNote(omitted, "review threads", LIMITS.reviewThreads));
+}
+export function renderReviewContext(snapshot) {
+    return [
+        `<pull_request_context>
+number: ${snapshot.pullRequest.number}
+title: ${snapshot.pullRequest.title}
+url: ${snapshot.pullRequest.url}
+state: ${snapshot.pullRequest.state}
+author: ${snapshot.pullRequest.author}
+relationship: ${snapshot.pullRequest.relationship}
+source: ${snapshot.pullRequest.source}
+baseRef: ${snapshot.pullRequest.baseRef}
+headRef: ${snapshot.pullRequest.headRef}
+baseSha: ${snapshot.pullRequest.baseSha}
+headSha: ${snapshot.pullRequest.headSha}
+body:
+${indented(snapshot.pullRequest.body)}
+comments:
+${renderComments(snapshot.pullRequest.comments, snapshot.pullRequest.commentsOmitted, LIMITS.prComments)}
+changedFiles:
+${snapshot.pullRequest.changedFiles.length ? snapshot.pullRequest.changedFiles.map((file) => `- ${file}`).join("\n") : "(none)"}
+</pull_request_context>`,
+        `<closing_issues>
+${snapshot.closingIssues.length ? snapshot.closingIssues.map(renderIssue).join("\n") : "(none)"}
+</closing_issues>`,
+        `<referenced_issues>
+${snapshot.referencedIssues.length ? snapshot.referencedIssues.map(renderIssue).join("\n") : "(none)"}
+</referenced_issues>`,
+        `<review_discussion>
+prComments:
+${renderComments(snapshot.reviewDiscussion.prComments, snapshot.reviewDiscussion.prCommentsOmitted, LIMITS.prComments)}
+reviewThreads:
+${renderThreads(snapshot.reviewDiscussion.reviewThreads, snapshot.reviewDiscussion.reviewThreadsOmitted)}
+</review_discussion>`,
+    ].join("\n\n");
+}

package/dist/orchestrator/review.js

@@ -1,16 +1,19 @@
 import { mkdir, writeFile } from "node:fs/promises";
 import { join } from "node:path";
-import { createWorktree, fetchPullRequest, fetchPullRequestCommits, fetchPullRequestReviews, fetchUnresolvedThreads, postApproval, postChangesRequested, postCloseComment, postReply, removeWorktree, resolveThread, } from "../github/commands";
+import { createWorktree, fetchPullRequest, fetchPullRequestCommits, fetchPullRequestReviews, fetchUnresolvedThreads, closePullRequest, mergePullRequest, postApproval, postChangesRequested, postCloseComment, postReply, removeWorktree, resolveThread, shellQuote, } from "../github/commands";
 import { composeFindingValidationPrompt, composeCloseReconsiderationPrompt, composeRereviewPrompt, composeReviewPrompt, } from "../prompts/compose";
 import { prRunOutputDir } from "../config/output";
+import { worktreeBaseDir } from "../config/worktree";
 import { parseCloseReconsiderationOutput, parseFindingValidationOutput, parseRereviewOutput, parseReviewOutput, } from "../prompts/output";
 import { throwIfAborted, withAbortSignal } from "./abort";
 import { waitForChecksWithClassification } from "./ci";
+import { parseRightSideDiffTargets, validateInlineCommentTargets, } from "./inline-comments";
 import { applyFindingValidation, reviewFindingTargets, validateFindingVotes, } from "./findings";
 import { closeMinorityReviewers, mergeVerdictForPolicy, } from "./majority";
 import { runModelWithRepair } from "./model";
 import { mapPool } from "./pool";
 import { formatReviewReport } from "./report";
+import { buildReviewContextSnapshot, renderReviewContext, } from "./review-context";
 import { checkSafetyGate, hasSafetyGate } from "./safety";
 function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
@@ -36,7 +39,7 @@ async function postReviewOutput(input, reviewerKey, output) {
         return postApproval(input.exec, input.repository, input.pr, reviewer.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 postChangesRequested(input.exec, input.repository, input.pr, reviewer.account, output.findings, output.requirementFindings);
 }
 function dryRunReviewPost(key, output) {
     if (output.verdict === "MERGE")
@@ -111,6 +114,9 @@ function reviewStateToVerdict(state) {
         return "CHANGES_REQUESTED";
     return "CLOSE";
 }
+function hasBlockingCiReports(reports) {
+    return reports.some((report) => report.scopeInside.length || report.scopeOutsideUnresolved.length);
+}
 function previousReviewText(review) {
     return JSON.stringify({
         body: review.body ?? "",
@@ -119,11 +125,26 @@ function previousReviewText(review) {
         submittedAt: review.submittedAt,
     }, null, 2);
 }
+function parseReviewOutputWithInlineTargets(text, targets) {
+    const output = parseReviewOutput(text);
+    validateInlineCommentTargets(output.findings, targets);
+    return output;
+}
+function parseRereviewOutputWithInlineTargets(text, targets) {
+    const output = parseRereviewOutput(text);
+    validateInlineCommentTargets(output.newFindings, targets, "newFindings");
+    return output;
+}
 function reviewOutputFromState(review) {
     const verdict = reviewStateToVerdict(review.state);
     return verdict === "CLOSE"
-        ? { findings: [], reason: review.body || "Close requested.", verdict }
-        : { findings: [], verdict };
+        ? {
+            findings: [],
+            reason: review.body || "Close requested.",
+            requirementFindings: [],
+            verdict,
+        }
+        : { findings: [], requirementFindings: [], verdict };
 }
 export function hasPendingThreadReply(threads, reviewerAccount) {
     return threads.some((thread) => {
@@ -147,7 +168,7 @@ async function postRereviewOutput(input, reviewerKey, output) {
         return postApproval(input.exec, input.repository, input.pr, reviewer.account);
     if (output.verdict === "CLOSE")
         return postCloseComment(input.exec, input.repository, input.pr, reviewer.account, output.reason ?? "Close requested.");
-    if (!output.newFindings.length)
+    if (!output.newFindings.length && !output.requirementFindings.length)
         return "";
     return postChangesRequested(input.exec, input.repository, input.pr, reviewer.account, output.newFindings.map((finding) => ({
         fix: "Please address this before merging.",
@@ -155,7 +176,7 @@ async function postRereviewOutput(input, reviewerKey, output) {
         line: finding.line,
         path: finding.path,
         startLine: finding.startLine,
-    })));
+    })), output.requirementFindings);
 }
 function isReviewOutput(output) {
     return "findings" in output;
@@ -187,6 +208,7 @@ async function runFindingValidation(input) {
             includeSessionContext: !hasReviewerSession,
             pr: input.reviewInput.pr,
             repository: input.reviewInput.repository,
+            reviewContext: input.reviewContext,
             reviewer,
             worktreePath: input.worktreePath,
         });
@@ -299,6 +321,7 @@ async function runCloseReconsideration(input) {
             includeSessionContext: !hasReviewerSession,
             pr: input.reviewInput.pr,
             repository: input.reviewInput.repository,
+            reviewContext: input.reviewContext,
             reviewer,
             worktreePath: input.worktreePath,
         });
@@ -332,7 +355,11 @@ async function runCloseReconsideration(input) {
                     }
                 },
                 options: reviewer.options,
-                parse: parseCloseReconsiderationOutput,
+                parse: (text) => {
+                    const output = parseCloseReconsiderationOutput(text);
+                    validateInlineCommentTargets(output.findings, input.inlineCommentTargets);
+                    return output;
+                },
                 permission: reviewer.permission,
                 prompt,
                 repairAttempts: input.reviewInput.config.output?.repairAttempts ?? 3,
@@ -393,6 +420,7 @@ export async function runReview(input) {
                 dryRun: input.dryRun,
                 outputs: {},
                 posted: {},
+                pr: input.pr,
                 repository: input.repository,
                 safety,
             });
@@ -444,6 +472,15 @@ export async function runReview(input) {
         pr: input.pr,
     }), ...(input.runId ? [input.runId] : []));
     await mkdir(outputDir, { recursive: true });
+    await input.onProgress?.({ phase: "fetching review context", type: "phase" });
+    const reviewContextSnapshot = await buildReviewContextSnapshot({
+        exec,
+        pr: meta,
+        repository: input.repository,
+    });
+    const reviewContext = renderReviewContext(reviewContextSnapshot);
+    await writeFile(join(outputDir, "review-context.json"), JSON.stringify(reviewContextSnapshot, null, 2));
+    await writeFile(join(outputDir, "review-context.md"), `${reviewContext}\n`);
     await input.onProgress?.({ phase: "waiting for checks", type: "phase" });
     const checkResult = await waitForChecksWithClassification({
         client: input.client,
@@ -497,7 +534,7 @@ export async function runReview(input) {
             checkResult.report.scopeInside.length)) {
         await input.onProgress?.({ report: checkResult.report, type: "ci_report" });
     }
-    const worktreeRoot = join(input.directory, input.config.worktree?.dir ?? ".magi/worktrees");
+    const worktreeRoot = worktreeBaseDir(input.directory, input.config, "pr");
     await input.onProgress?.({ phase: "creating worktree", type: "phase" });
     const worktree = await createWorktree(exec, input.repository, input.pr, worktreeRoot);
     const worktreePath = worktree.path;
@@ -514,6 +551,7 @@ export async function runReview(input) {
                 return [];
             return [{ assignment, reviewer }];
         });
+        const inlineCommentTargets = parseRightSideDiffTargets(await exec(`git diff --no-ext-diff --unified=3 ${shellQuote(meta.baseRefOid)} ${shellQuote(meta.headRefOid)}`, { cwd: worktreePath }));
         for (const reviewer of input.repository.agents.reviewers) {
             const assignment = mode.assignments.get(reviewer.account);
             if (assignment?.type !== "skip")
@@ -544,6 +582,7 @@ export async function runReview(input) {
                     previousReview: previousReviewText(previous),
                     previousHeadSha: previous.commit.oid,
                     repository: input.repository,
+                    reviewContext,
                     reviewer,
                     unresolvedThreads: JSON.stringify(unresolved, null, 2),
                     worktreePath,
@@ -578,7 +617,7 @@ export async function runReview(input) {
                             }
                         },
                         options: reviewer.options,
-                        parse: parseRereviewOutput,
+                        parse: (text) => parseRereviewOutputWithInlineTargets(text, inlineCommentTargets),
                         permission: reviewer.permission,
                         prompt,
                         repairAttempts: input.config.output?.repairAttempts ?? 3,
@@ -610,6 +649,7 @@ export async function runReview(input) {
                 headSha: meta.headRefOid,
                 pr: input.pr,
                 repository: input.repository,
+                reviewContext,
                 reviewer,
                 worktreePath,
             });
@@ -643,7 +683,7 @@ export async function runReview(input) {
                         }
                     },
                     options: reviewer.options,
-                    parse: parseReviewOutput,
+                    parse: (text) => parseReviewOutputWithInlineTargets(text, inlineCommentTargets),
                     permission: reviewer.permission,
                     prompt,
                     repairAttempts: input.config.output?.repairAttempts ?? 3,
@@ -703,8 +743,10 @@ export async function runReview(input) {
         });
         entries = await runCloseReconsideration({
             entries: [...entries, ...skippedCloseEntries],
+            inlineCommentTargets,
             meta,
             outputDir,
+            reviewContext,
             reviewInput: { ...input, exec },
             sessionIds,
             targets: closeTargets,
@@ -714,6 +756,7 @@ export async function runReview(input) {
             entries,
             meta,
             outputDir,
+            reviewContext,
             reviewInput: { ...input, exec },
             sessionIds,
             worktreePath,
@@ -752,6 +795,30 @@ export async function runReview(input) {
                         : await postReviewOutput({ ...input, exec }, key, output),
             ]))),
         };
+        const automationAccount = input.repository.agents.reviewers[0]?.account;
+        const enableReviewAutomation = input.enableReviewAutomation ?? true;
+        if (enableReviewAutomation &&
+            verdict === "MERGE" &&
+            input.repository.reviewAutomation?.merge) {
+            await input.onProgress?.({ phase: "merging PR", type: "phase" });
+            posted.automation = hasBlockingCiReports(ciReports)
+                ? "skipped: unresolved CI"
+                : input.dryRun
+                    ? "dry-run:would-merge"
+                    : automationAccount
+                        ? await mergePullRequest(input.exec, input.repository, input.pr, automationAccount)
+                        : "skipped: no review automation account";
+        }
+        if (enableReviewAutomation &&
+            verdict === "CLOSE" &&
+            input.repository.reviewAutomation?.close) {
+            await input.onProgress?.({ phase: "closing PR", type: "phase" });
+            posted.automation = input.dryRun
+                ? "dry-run:would-close"
+                : automationAccount
+                    ? await closePullRequest(input.exec, input.repository, input.pr, automationAccount)
+                    : "skipped: no review automation account";
+        }
         await writeFile(join(outputDir, "majority.json"), JSON.stringify({
             approvalPolicy: input.approvalPolicy ?? "majority",
             verdict,
@@ -765,6 +832,7 @@ export async function runReview(input) {
             dryRun: input.dryRun,
             outputs,
             posted,
+            pr: input.pr,
             repository: input.repository,
         });
         await writeFile(join(outputDir, "report.md"), `${report}\n`);