opencode-magi 0.0.0-dev-20260520165420 → 0.0.0-dev-20260520171120

package/dist/github/commands.js

@@ -102,9 +102,24 @@ async function fetchPullRequestQueueInput(exec, repository, pr, token) {
     return { headRefOid: pullRequest.headRefOid, id: pullRequest.id };
 }
 export async function fetchPullRequest(exec, repository, pr) {
-    const json = await exec(`gh pr view ${pr} --repo ${shellQuote(repoSpecifier(repository))} --json number,title,url,isDraft,baseRefOid,headRefOid,baseRefName,headRefName,headRepository,headRepositoryOwner`);
+    const json = await exec(`gh pr view ${pr} --repo ${shellQuote(repoSpecifier(repository))} --json number,title,body,url,state,author,isDraft,baseRefOid,headRefOid,baseRefName,headRefName,headRepository,headRepositoryOwner,changedFiles`);
     return JSON.parse(json);
 }
+export async function fetchPullRequestClosingIssues(exec, repository, pr) {
+    const query = `query($owner: String!, $repo: String!, $pr: Int!) { repository(owner: $owner, name: $repo) { pullRequest(number: $pr) { closingIssuesReferences(first: 20) { nodes { number title body url state author { login } labels(first: 100) { nodes { name } } issueType { name } } } } } }`;
+    const raw = await exec(`gh api${ghHostOption(repository)} graphql -f query=${shellQuote(query)} -F owner=${shellQuote(repository.github.owner)} -F repo=${shellQuote(repository.github.repo)} -F pr=${pr}`);
+    const data = JSON.parse(raw);
+    return (data.data?.repository?.pullRequest?.closingIssuesReferences?.nodes?.map((issue) => ({
+        author: issue.author?.login ?? "",
+        body: issue.body ?? "",
+        labels: issue.labels?.nodes?.map((label) => label.name) ?? [],
+        number: issue.number,
+        state: issue.state,
+        title: issue.title,
+        type: issue.issueType?.name,
+        url: issue.url,
+    })) ?? []);
+}
 export async function fetchIssue(exec, repository, issue) {
     const query = `query($owner: String!, $repo: String!, $issue: Int!) { repository(owner: $owner, name: $repo) { issue(number: $issue) { number title body url state author { login } labels(first: 100) { nodes { name } } issueType { name } } } }`;
     try {
@@ -142,17 +157,47 @@ async function fetchIssueWithCli(exec, repository, issue) {
     };
 }
 export async function fetchIssueComments(exec, repository, issue, limit = 50) {
-    const query = `query($owner: String!, $repo: String!, $issue: Int!, $limit: Int!) { repository(owner: $owner, name: $repo) { issue(number: $issue) { comments(last: $limit) { nodes { databaseId author { login } authorAssociation body createdAt url } } } } }`;
+    return (await fetchIssueCommentPage(exec, repository, issue, limit)).comments;
+}
+export async function fetchIssueCommentPage(exec, repository, issue, limit = 50) {
+    const query = `query($owner: String!, $repo: String!, $issue: Int!, $limit: Int!) { repository(owner: $owner, name: $repo) { issue(number: $issue) { comments(last: $limit) { totalCount nodes { databaseId author { login } authorAssociation body createdAt url } } } } }`;
     const raw = await exec(`gh api${ghHostOption(repository)} graphql -f query=${shellQuote(query)} -F owner=${shellQuote(repository.github.owner)} -F repo=${shellQuote(repository.github.repo)} -F issue=${issue} -F limit=${limit}`);
     const data = JSON.parse(raw);
-    return (data.data?.repository?.issue?.comments?.nodes?.map((comment) => ({
+    const connection = data.data?.repository?.issue?.comments;
+    const comments = connection?.nodes?.map((comment) => ({
         author: comment.author?.login ?? "",
         authorAssociation: comment.authorAssociation,
         body: comment.body ?? "",
         createdAt: comment.createdAt,
         id: comment.databaseId,
         url: comment.url,
-    })) ?? []);
+    })) ?? [];
+    return {
+        comments,
+        omitted: Math.max(0, (connection?.totalCount ?? comments.length) - comments.length),
+    };
+}
+export async function fetchPullRequestComments(exec, repository, pr, limit = 50) {
+    return (await fetchPullRequestCommentPage(exec, repository, pr, limit))
+        .comments;
+}
+export async function fetchPullRequestCommentPage(exec, repository, pr, limit = 50) {
+    const query = `query($owner: String!, $repo: String!, $pr: Int!, $limit: Int!) { repository(owner: $owner, name: $repo) { pullRequest(number: $pr) { comments(last: $limit) { totalCount nodes { databaseId author { login } authorAssociation body createdAt url } } } } }`;
+    const raw = await exec(`gh api${ghHostOption(repository)} graphql -f query=${shellQuote(query)} -F owner=${shellQuote(repository.github.owner)} -F repo=${shellQuote(repository.github.repo)} -F pr=${pr} -F limit=${limit}`);
+    const data = JSON.parse(raw);
+    const connection = data.data?.repository?.pullRequest?.comments;
+    const comments = connection?.nodes?.map((comment) => ({
+        author: comment.author?.login ?? "",
+        authorAssociation: comment.authorAssociation,
+        body: comment.body ?? "",
+        createdAt: comment.createdAt,
+        id: comment.databaseId,
+        url: comment.url,
+    })) ?? [];
+    return {
+        comments,
+        omitted: Math.max(0, (connection?.totalCount ?? comments.length) - comments.length),
+    };
 }
 export async function fetchRelatedPullRequests(exec, repository, issue) {
     const query = `query($owner: String!, $repo: String!, $issue: Int!) { repository(owner: $owner, name: $repo) { issue(number: $issue) { timelineItems(first: 50, itemTypes: [CONNECTED_EVENT, CROSS_REFERENCED_EVENT]) { nodes { __typename ... on ConnectedEvent { subject { __typename ... on PullRequest { number title url state mergedAt body author { login } } } } ... on CrossReferencedEvent { source { __typename ... on PullRequest { number title url state mergedAt body author { login } } } } } } } } }`;
@@ -295,7 +340,7 @@ export async function fetchPullRequestCommits(exec, repository, pr) {
     }));
 }
 export async function fetchPullRequestSafetyMeta(exec, repository, pr) {
-    const query = `query($owner: String!, $repo: String!, $pr: Int!, $filesCursor: String) { repository(owner: $owner, name: $repo) { pullRequest(number: $pr) { author { login } changedFiles labels(first: 100) { nodes { name } } files(first: 100, after: $filesCursor) { nodes { path } pageInfo { hasNextPage endCursor } } } } } }`;
+    const query = `query($owner: String!, $repo: String!, $pr: Int!, $filesCursor: String) { repository(owner: $owner, name: $repo) { pullRequest(number: $pr) { author { login } changedFiles labels(first: 100) { nodes { name } } files(first: 100, after: $filesCursor) { nodes { path } pageInfo { hasNextPage endCursor } } } } }`;
     const files = [];
     let author = "";
     let changedFiles = 0;
@@ -467,11 +512,19 @@ function findingComment(finding) {
     }
     return comment;
 }
-export async function postChangesRequested(exec, repository, pr, account, findings) {
+function requirementFindingSummary(finding) {
+    return [
+        `- Missing issue #${finding.issueNumber} requirement: ${finding.requirement}`,
+        `  Evidence: ${finding.evidence}`,
+        `  Fix: ${finding.fix}`,
+    ].join("\n");
+}
+export async function postChangesRequested(exec, repository, pr, account, findings, requirementFindings = []) {
     const token = await ghToken(exec, repository, account);
     const payloadPath = join(tmpdir(), `magi-review-${process.pid}-${Date.now()}.json`);
     const body = findings
         .map((finding) => `- ${finding.issue.split("\n")[0]}`)
+        .concat(requirementFindings.map(requirementFindingSummary))
         .join("\n");
     await writeFile(payloadPath, JSON.stringify({
         body,
@@ -610,6 +663,45 @@ export async function fetchUnresolvedThreads(exec, repository, pr, author) {
         ];
     });
 }
+export async function fetchPullRequestReviewThreads(exec, repository, pr, threadLimit = 50, commentsPerThread = 20) {
+    return (await fetchPullRequestReviewThreadPage(exec, repository, pr, threadLimit, commentsPerThread)).threads;
+}
+export async function fetchPullRequestReviewThreadPage(exec, repository, pr, threadLimit = 50, commentsPerThread = 20) {
+    const query = `query($owner: String!, $repo: String!, $pr: Int!, $threadLimit: Int!, $commentsPerThread: Int!) { repository(owner: $owner, name: $repo) { pullRequest(number: $pr) { reviewThreads(last: $threadLimit) { totalCount nodes { id isResolved comments(last: $commentsPerThread) { totalCount nodes { databaseId author { login } path line body createdAt } } } } } } }`;
+    const raw = await exec(`gh api${ghHostOption(repository)} graphql -f query=${shellQuote(query)} -F owner=${shellQuote(repository.github.owner)} -F repo=${shellQuote(repository.github.repo)} -F pr=${pr} -F threadLimit=${threadLimit} -F commentsPerThread=${commentsPerThread}`);
+    const data = JSON.parse(raw);
+    const connection = data.data?.repository?.pullRequest?.reviewThreads;
+    const nodes = connection?.nodes ?? [];
+    const threads = nodes.flatMap((thread) => {
+        const comments = [...thread.comments.nodes]
+            .sort((a, b) => a.createdAt.localeCompare(b.createdAt))
+            .map((comment) => ({
+            author: comment.author?.login ?? "",
+            body: comment.body ?? "",
+            commentId: comment.databaseId,
+            createdAt: comment.createdAt,
+        }));
+        const first = thread.comments.nodes[0];
+        if (!first)
+            return [];
+        return [
+            {
+                body: first.body ?? "",
+                commentId: first.databaseId,
+                comments,
+                isResolved: thread.isResolved,
+                line: first.line,
+                omittedComments: Math.max(0, (thread.comments.totalCount ?? comments.length) - comments.length),
+                path: first.path,
+                threadId: thread.id,
+            },
+        ];
+    });
+    return {
+        omitted: Math.max(0, (connection?.totalCount ?? threads.length) - threads.length),
+        threads,
+    };
+}
 export async function postReply(exec, repository, pr, account, commentId, body) {
     const token = await ghToken(exec, repository, account);
     const payloadPath = join(tmpdir(), `magi-reply-${process.pid}-${Date.now()}-${commentId}.json`);

package/dist/index.js

@@ -118,6 +118,11 @@ function parseOptionalPr(value) {
         return undefined;
     return parsePrToken(value);
 }
+function parseOptionalPrs(value) {
+    if (!value?.trim())
+        return undefined;
+    return parsePrs(value);
+}
 function parseOptionalIssue(value) {
     if (!value?.trim())
         return undefined;
@@ -432,7 +437,7 @@ export const MagiPlugin = async ({ client, directory }) => {
                         block: args.block,
                         issue: parseOptionalIssue(args.issue),
                         outputDir: await configuredOutputDir(),
-                        pr: parseOptionalPr(args.pr),
+                        pr: parseOptionalPrs(args.pr),
                         runId: args.runId,
                         timeoutMs: args.timeoutSeconds == null
                             ? undefined

package/dist/orchestrator/findings.js

@@ -58,9 +58,10 @@ export function applyFindingValidation(input) {
             discarded.push(target);
             return false;
         });
-        next[reviewer] = findings.length
-            ? { ...output, findings }
-            : { findings: [], verdict: "MERGE" };
+        next[reviewer] =
+            findings.length || output.requirementFindings.length
+                ? { ...output, findings }
+                : { findings: [], requirementFindings: [], verdict: "MERGE" };
     }
     return { outputs: next, summary: { discarded, kept } };
 }

package/dist/orchestrator/report.js

@@ -27,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;
 }
@@ -78,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] : [];
@@ -86,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}`),
     ];
 }

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

@@ -13,6 +13,7 @@ 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);
@@ -38,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")
@@ -137,8 +138,13 @@ function parseRereviewOutputWithInlineTargets(text, targets) {
 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) => {
@@ -162,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.",
@@ -170,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;
@@ -202,6 +208,7 @@ async function runFindingValidation(input) {
             includeSessionContext: !hasReviewerSession,
             pr: input.reviewInput.pr,
             repository: input.reviewInput.repository,
+            reviewContext: input.reviewContext,
             reviewer,
             worktreePath: input.worktreePath,
         });
@@ -314,6 +321,7 @@ async function runCloseReconsideration(input) {
             includeSessionContext: !hasReviewerSession,
             pr: input.reviewInput.pr,
             repository: input.reviewInput.repository,
+            reviewContext: input.reviewContext,
             reviewer,
             worktreePath: input.worktreePath,
         });
@@ -464,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,
@@ -565,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,
@@ -631,6 +649,7 @@ export async function runReview(input) {
                 headSha: meta.headRefOid,
                 pr: input.pr,
                 repository: input.repository,
+                reviewContext,
                 reviewer,
                 worktreePath,
             });
@@ -727,6 +746,7 @@ export async function runReview(input) {
             inlineCommentTargets,
             meta,
             outputDir,
+            reviewContext,
             reviewInput: { ...input, exec },
             sessionIds,
             targets: closeTargets,
@@ -736,6 +756,7 @@ export async function runReview(input) {
             entries,
             meta,
             outputDir,
+            reviewContext,
             reviewInput: { ...input, exec },
             sessionIds,
             worktreePath,

package/dist/orchestrator/run-manager.js

@@ -35,6 +35,19 @@ function isActiveStatus(status) {
         status === "running" ||
         status === "posting");
 }
+function matchesNumberFilter(value, filter) {
+    if (filter == null)
+        return true;
+    return Array.isArray(filter)
+        ? value != null && filter.includes(value)
+        : value === filter;
+}
+function hasAllRequestedPrStates(states, pr) {
+    if (pr == null)
+        return true;
+    const prs = Array.isArray(pr) ? pr : [pr];
+    return prs.every((item) => states.some((state) => state.pr === item));
+}
 function isWithinDirectory(directory, path) {
     const relation = relative(directory, path);
     return (relation === "" || (!relation.startsWith("..") && !isAbsolute(relation)));
@@ -548,6 +561,7 @@ export class MagiRunManager {
         while (input.block) {
             const states = await this.filteredStates(input);
             if (states.length &&
+                hasAllRequestedPrStates(states, input.pr) &&
                 states.every((state) => !isActiveStatus(state.status)))
                 return states;
             if (Date.now() - startedAt >= timeoutMs)
@@ -1661,7 +1675,7 @@ export class MagiRunManager {
         return states
             .filter((state) => input.command == null || state.command === input.command)
             .filter((state) => input.issue == null || state.issue === input.issue)
-            .filter((state) => input.pr == null || state.pr === input.pr)
+            .filter((state) => matchesNumberFilter(state.pr, input.pr))
             .sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
     }
     async selectState(input) {

package/dist/prompts/compose.js

@@ -45,6 +45,7 @@ function reviewValues(input) {
         headSha: input.headSha,
         jsonEncodedWorktreePath: JSON.stringify(input.worktreePath),
         pr: String(input.pr),
+        reviewContext: input.reviewContext ?? "",
         worktreePath: input.worktreePath,
     };
 }
@@ -85,6 +86,9 @@ function previousReviewBlock(previousReview) {
         ? `<previous_review>\n${previousReview.trim()}\n</previous_review>`
         : "";
 }
+function reviewContextBlock(reviewContext) {
+    return reviewContext?.trim() ? reviewContext.trim() : "";
+}
 async function reviewGuidelinesBlock(input) {
     const body = (await readOptionalPrompt(input.directory, input.path, input.values)).trim();
     return body ? `<review_guidelines>\n${body}\n</review_guidelines>` : "";
@@ -95,6 +99,9 @@ async function editGuidelinesBlock(input) {
 }
 async function sessionContextBlocks(input) {
     return [
+        input.includeSessionContext
+            ? reviewContextBlock(input.values.reviewContext)
+            : "",
         input.includeSessionContext ? languageBlock(input.repository.language) : "",
         input.includeSessionContext ? personaBlock(input.reviewer.persona) : "",
         input.includeReviewGuidelines
@@ -116,6 +123,7 @@ export async function composeReviewPrompt(input) {
     });
     return [
         task,
+        reviewContextBlock(input.reviewContext),
         languageBlock(input.repository.language),
         personaBlock(input.reviewer.persona),
         await reviewGuidelinesBlock({
@@ -138,6 +146,7 @@ export async function composeRereviewPrompt(input) {
     });
     return [
         task,
+        reviewContextBlock(input.reviewContext),
         input.includeSessionContext === false
             ? ""
             : languageBlock(input.repository.language),

package/dist/prompts/contracts.js

@@ -15,16 +15,25 @@ The object must match this shape:
       "perspective": "Optional review perspective."
     }
   ],
+  "requirementFindings": [
+    {
+      "issueNumber": 47,
+      "requirement": "Required closing-issue behavior that is missing.",
+      "evidence": "Why the PR does not satisfy the requirement.",
+      "fix": "How to satisfy the requirement."
+    }
+  ],
   "reason": "Required only for CLOSE."
 }
 
 Rules:
-- MERGE requires an empty findings array.
-- CHANGES_REQUESTED requires at least one finding.
-- CLOSE requires a reason and an empty findings array.
+- MERGE requires empty findings and requirementFindings arrays.
+- CHANGES_REQUESTED requires at least one finding or requirementFinding.
+- CLOSE requires a reason and empty findings and requirementFindings arrays.
 - path must be repository-relative.
 - line and startLine must refer to lines inside the PR diff hunk.
 - Omit startLine for single-line findings.
+- Use requirementFindings for missing closing-issue requirements that do not map cleanly to a diff line.
 </output_contract>`.trim();
 export const rereviewOutputContract = `
 <output_contract>
@@ -36,15 +45,17 @@ The object must match this shape:
   "resolve": [{ "commentId": 123, "threadId": "..." }],
   "followUps": [{ "commentId": 123, "body": "..." }],
   "newFindings": [{ "path": "relative/path.ext", "line": 123, "startLine": 120, "body": "..." }],
+  "requirementFindings": [{ "issueNumber": 47, "requirement": "Missing requirement.", "evidence": "Why it is missing.", "fix": "How to fix it." }],
   "reason": "Required only for CLOSE."
 }
 
 Rules:
-- MERGE requires empty followUps and newFindings arrays.
-- CHANGES_REQUESTED requires at least one followUp or newFinding.
-- CLOSE requires a reason and empty followUps and newFindings arrays.
+- MERGE requires empty followUps, newFindings, and requirementFindings arrays.
+- CHANGES_REQUESTED requires at least one followUp, newFinding, or requirementFinding.
+- CLOSE requires a reason and empty followUps, newFindings, and requirementFindings arrays.
 - line and startLine must refer to lines inside the latest PR diff hunk.
 - Omit startLine for single-line findings.
+- Use requirementFindings for missing closing-issue requirements that do not map cleanly to a diff line.
 </output_contract>`.trim();
 export const findingValidationOutputContract = `
 <output_contract>
@@ -83,12 +94,13 @@ The object must match this shape:
       "issue": "What is wrong.",
       "fix": "How to fix it."
     }
-  ]
+  ],
+  "requirementFindings": [{ "issueNumber": 47, "requirement": "Missing requirement.", "evidence": "Why it is missing.", "fix": "How to fix it." }]
 }
 
 Rules:
-- MERGE requires an empty findings array.
-- CHANGES_REQUESTED requires at least one finding.
+- MERGE requires empty findings and requirementFindings arrays.
+- CHANGES_REQUESTED requires at least one finding or requirementFinding.
 - CLOSE is not allowed in this reconsideration step.
 - Omit startLine for single-line findings.
 </output_contract>`.trim();
@@ -101,12 +113,13 @@ The object must match this shape:
   "verdict": "MERGE" | "CHANGES_REQUESTED",
   "resolve": [{ "commentId": 123, "threadId": "..." }],
   "followUps": [{ "commentId": 123, "body": "..." }],
-  "newFindings": [{ "path": "relative/path.ext", "line": 123, "startLine": 120, "body": "..." }]
+  "newFindings": [{ "path": "relative/path.ext", "line": 123, "startLine": 120, "body": "..." }],
+  "requirementFindings": [{ "issueNumber": 47, "requirement": "Missing requirement.", "evidence": "Why it is missing.", "fix": "How to fix it." }]
 }
 
 Rules:
-- MERGE requires empty followUps and newFindings arrays.
-- CHANGES_REQUESTED requires at least one followUp or newFinding.
+- MERGE requires empty followUps, newFindings, and requirementFindings arrays.
+- CHANGES_REQUESTED requires at least one followUp, newFinding, or requirementFinding.
 - CLOSE is not allowed in this reconsideration step.
 - Omit startLine for single-line findings.
 </output_contract>`.trim();

package/dist/prompts/output.js

@@ -71,6 +71,17 @@ function requireNumber(value, path) {
         throw new Error(`${path} must be an integer`);
     return value;
 }
+function parseRequirementFindings(value) {
+    return (value == null ? [] : requireArray(value, "requirementFindings")).map((finding, index) => {
+        const item = finding;
+        return {
+            evidence: requireString(item.evidence, `requirementFindings[${index}].evidence`),
+            fix: requireString(item.fix, `requirementFindings[${index}].fix`),
+            issueNumber: requireNumber(item.issueNumber, `requirementFindings[${index}].issueNumber`),
+            requirement: requireString(item.requirement, `requirementFindings[${index}].requirement`),
+        };
+    });
+}
 function requireOneOf(value, path, values) {
     const text = requireString(value, path);
     if (!values.includes(text)) {
@@ -185,12 +196,17 @@ export function parseReviewOutput(text) {
                 : requireNumber(item.startLine, `findings[${index}].startLine`),
         };
     });
-    if (data.verdict === "MERGE" && findings.length)
-        throw new Error("MERGE requires no findings");
-    if (data.verdict === "CHANGES_REQUESTED" && !findings.length)
-        throw new Error("CHANGES_REQUESTED requires findings");
-    if (data.verdict === "CLOSE" && findings.length)
-        throw new Error("CLOSE requires no findings");
+    const requirementFindings = parseRequirementFindings(data.requirementFindings);
+    if (data.verdict === "MERGE" &&
+        (findings.length || requirementFindings.length))
+        throw new Error("MERGE requires no findings or requirementFindings");
+    if (data.verdict === "CHANGES_REQUESTED" &&
+        !findings.length &&
+        !requirementFindings.length)
+        throw new Error("CHANGES_REQUESTED requires findings or requirementFindings");
+    if (data.verdict === "CLOSE" &&
+        (findings.length || requirementFindings.length))
+        throw new Error("CLOSE requires no findings or requirementFindings");
     const reason = typeof data.reason === "string" && data.reason.trim()
         ? data.reason
         : undefined;
@@ -199,6 +215,7 @@ export function parseReviewOutput(text) {
     return {
         findings,
         reason,
+        requirementFindings,
         verdict: data.verdict,
     };
 }
@@ -231,24 +248,29 @@ export function parseRereviewOutput(text) {
                 : requireNumber(value.startLine, `newFindings[${index}].startLine`),
         };
     });
-    if (data.verdict === "MERGE" && (followUps.length || newFindings.length)) {
-        throw new Error("MERGE requires no followUps or newFindings");
+    const requirementFindings = parseRequirementFindings(data.requirementFindings);
+    if (data.verdict === "MERGE" &&
+        (followUps.length || newFindings.length || requirementFindings.length)) {
+        throw new Error("MERGE requires no followUps, newFindings, or requirementFindings");
     }
-    if (data.verdict === "CLOSE" && (followUps.length || newFindings.length)) {
-        throw new Error("CLOSE requires no followUps or newFindings");
+    if (data.verdict === "CLOSE" &&
+        (followUps.length || newFindings.length || requirementFindings.length)) {
+        throw new Error("CLOSE requires no followUps, newFindings, or requirementFindings");
     }
     if (data.verdict === "CLOSE" && !data.reason) {
         throw new Error("CLOSE requires reason");
     }
     if (data.verdict === "CHANGES_REQUESTED" &&
         !followUps.length &&
-        !newFindings.length) {
-        throw new Error("CHANGES_REQUESTED requires followUps or newFindings");
+        !newFindings.length &&
+        !requirementFindings.length) {
+        throw new Error("CHANGES_REQUESTED requires followUps, newFindings, or requirementFindings");
     }
     return {
         followUps,
         newFindings,
         reason: data.reason == null ? undefined : requireString(data.reason, "reason"),
+        requirementFindings,
         resolve,
         verdict: data.verdict,
     };

package/dist/prompts/templates/review/review.md

@@ -4,4 +4,10 @@ Review only the diff from {baseSha} to {headSha}.
 Use: git -C {jsonEncodedWorktreePath} diff {baseSha}...{headSha}
 Do not edit files or perform write operations.
 
+This PR may include closing issue references.
+For each closing issue, review whether the PR fully satisfies the issue body, acceptance criteria, required behavior, required tests, required documentation, and bounded issue comments.
+Request changes if a closing issue requirement is missing, only documented, only schema-exposed, or not wired into runtime behavior.
+Do not approve solely because the PR improves the codebase if it claims to close an issue that remains incomplete.
+For referenced non-closing issues, use them as context only unless the PR body explicitly claims to complete them.
+
 {ciFailureContextBlock}

package/package.json

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