opencode-magi 0.4.0 → 0.6.0

package/dist/orchestrator/report.js

@@ -16,24 +16,17 @@ function pullRequestLine(input) {
     return `- **Pull Request**: [#${input.pr}](${url})`;
 }
 function formatFinding(finding) {
-    const line = finding.line == null
-        ? finding.path
-        : finding.startLine == null
-            ? `${finding.path}:${finding.line}`
-            : `${finding.path}:${finding.startLine}-${finding.line}`;
+    const line = finding.startLine == null
+        ? `${finding.path}:${finding.line}`
+        : `${finding.path}:${finding.startLine}-${finding.line}`;
     return `\`${line}\`: ${finding.issue}`;
 }
 function formatRereviewFinding(finding) {
-    const line = finding.line == null
-        ? finding.path
-        : finding.startLine == null
-            ? `${finding.path}:${finding.line}`
-            : `${finding.path}:${finding.startLine}-${finding.line}`;
+    const line = finding.startLine == null
+        ? `${finding.path}:${finding.line}`
+        : `${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;
 }
@@ -85,10 +78,7 @@ function reviewerDetailLines(output) {
             return output.reason ? [output.reason] : [];
         if (output.verdict !== "CHANGES_REQUESTED")
             return [];
-        return [
-            ...output.findings.map(formatFinding),
-            ...output.requirementFindings.map(formatRequirementFinding),
-        ];
+        return output.findings.map(formatFinding);
     }
     if (output.verdict === "CLOSE")
         return output.reason ? [output.reason] : [];
@@ -96,7 +86,6 @@ 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

@@ -37,6 +37,23 @@ function quoteEvidence(value) {
     const compact = value.replaceAll(/\s+/g, " ").trim();
     return compact.length > 120 ? `${compact.slice(0, 117)}...` : compact;
 }
+function errorText(error) {
+    if (!error || typeof error !== "object")
+        return String(error);
+    const value = error;
+    return [value.message, value.stderr, value.stdout]
+        .filter((item) => typeof item === "string")
+        .join("\n");
+}
+function isIssueLookupFailure(error) {
+    const text = errorText(error);
+    return (/could not resolve to an issue/i.test(text) ||
+        /could not fetch issue #\d+/i.test(text) ||
+        /not an issue/i.test(text));
+}
+function isIssueUrl(url) {
+    return /\/issues\/\d+(?:$|[/?#])/i.test(url);
+}
 function issueReferencePattern(repository) {
     const host = escapeRegExp(repository.github.host || "github.com");
     const owner = escapeRegExp(repository.github.owner);
@@ -120,6 +137,9 @@ export function collectIssueRelationships(input) {
 async function contextIssue(input) {
     const issue = input.issue ??
         (await fetchIssue(input.exec, input.repository, input.relationship.number));
+    if (!isIssueUrl(issue.url)) {
+        throw new Error(`Reference #${issue.number} resolved to ${issue.url}, not an Issue`);
+    }
     const commentPage = await fetchIssueCommentPage(input.exec, input.repository, issue.number, input.limit);
     return {
         author: issue.author,
@@ -138,6 +158,19 @@ async function contextIssue(input) {
         url: issue.url,
     };
 }
+async function contextIssueIfIssue(input) {
+    try {
+        return await contextIssue(input);
+    }
+    catch (error) {
+        if (isIssueLookupFailure(error))
+            return undefined;
+        throw error;
+    }
+}
+function presentIssue(issue) {
+    return Boolean(issue);
+}
 function orderReviewThreads(threads) {
     return [...threads]
         .sort((a, b) => {
@@ -183,13 +216,13 @@ export async function buildReviewContextSnapshot(input) {
     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({
+        closingIssues: (await Promise.all(closingRelationships.map((relationship) => contextIssueIfIssue({
             exec: input.exec,
             issue: closingIssueMap.get(relationship.number),
             limit: LIMITS.closingIssueComments,
             relationship,
             repository: input.repository,
-        }))),
+        })))).filter(presentIssue),
         pullRequest: {
             author: input.pr.author?.login ?? safetyMeta.author,
             baseRef: input.pr.baseRefName,
@@ -207,12 +240,12 @@ export async function buildReviewContextSnapshot(input) {
             title: input.pr.title,
             url: input.pr.url,
         },
-        referencedIssues: await Promise.all(referencedRelationships.map((relationship) => contextIssue({
+        referencedIssues: (await Promise.all(referencedRelationships.map((relationship) => contextIssueIfIssue({
             exec: input.exec,
             limit: LIMITS.referencedIssueComments,
             relationship,
             repository: input.repository,
-        }))),
+        })))).filter(presentIssue),
         reviewDiscussion: {
             prComments: boundedComments(prComments, LIMITS.prComments),
             prCommentsOmitted,

package/dist/orchestrator/review.js

@@ -1,10 +1,10 @@
 import { mkdir, writeFile } from "node:fs/promises";
 import { join } from "node:path";
-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 { createWorktree, fetchPullRequest, fetchPullRequestCommits, fetchPullRequestReviews, fetchUnresolvedThreads, closePullRequest, mergePullRequest, ensurePullRequestCommits, postApproval, postChangesRequested, postCloseComment, postReply, removeWorktree, resolveThread, shellQuote, } from "../github/commands";
+import { composeFindingValidationPrompt, composeCloseReconsiderationPrompt, composeRereviewCloseReconsiderationPrompt, composeRereviewPrompt, composeReviewPrompt, } from "../prompts/compose";
 import { prRunOutputDir } from "../config/output";
-import { worktreeBaseDir } from "../config/worktree";
-import { parseCloseReconsiderationOutput, parseFindingValidationOutput, parseRereviewOutput, parseReviewOutput, } from "../prompts/output";
+import { prRunWorktreeDir } from "../config/worktree";
+import { parseCloseReconsiderationOutput, parseFindingValidationOutput, parseRereviewCloseReconsiderationOutput, parseRereviewOutput, parseReviewOutput, } from "../prompts/output";
 import { throwIfAborted, withAbortSignal } from "./abort";
 import { waitForChecksWithClassification } from "./ci";
 import { parseRightSideDiffTargets, validateInlineCommentTargets, } from "./inline-comments";
@@ -39,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, output.requirementFindings);
+    return postChangesRequested(input.exec, input.repository, input.pr, reviewer.account, output.findings);
 }
 function dryRunReviewPost(key, output) {
     if (output.verdict === "MERGE")
@@ -112,7 +112,7 @@ function reviewStateToVerdict(state) {
         return "MERGE";
     if (state === "CHANGES_REQUESTED")
         return "CHANGES_REQUESTED";
-    return "CLOSE";
+    throw new Error(`Unsupported GitHub review state: ${state}`);
 }
 function hasBlockingCiReports(reports) {
     return reports.some((report) => report.scopeInside.length || report.scopeOutsideUnresolved.length);
@@ -135,6 +135,34 @@ function parseRereviewOutputWithInlineTargets(text, targets) {
     validateInlineCommentTargets(output.newFindings, targets, "newFindings");
     return output;
 }
+export async function inlineCommentTargetsForDiff(input) {
+    if (input.ensure) {
+        await ensurePullRequestCommits({
+            commits: [
+                {
+                    label: "base",
+                    sha: input.fromSha,
+                    source: input.ensure.fromSource,
+                },
+                {
+                    label: "head",
+                    sha: input.toSha,
+                    source: input.ensure.toSource,
+                },
+            ],
+            exec: input.exec,
+            meta: input.ensure.meta,
+            repository: input.ensure.repository,
+            worktreePath: input.worktreePath,
+        });
+    }
+    const diffRange = input.range === "direct"
+        ? `${shellQuote(input.fromSha)} ${shellQuote(input.toSha)}`
+        : `${shellQuote(input.fromSha)}...${shellQuote(input.toSha)}`;
+    return parseRightSideDiffTargets(await input.exec(`git diff --no-ext-diff --unified=3 ${diffRange}`, {
+        cwd: input.worktreePath,
+    }));
+}
 function parsePostedFindingLocation(location) {
     const range = /^(.*):(\d+)-(\d+)$/.exec(location);
     if (range) {
@@ -147,11 +175,10 @@ function parsePostedFindingLocation(location) {
     const line = /^(.*):(\d+)$/.exec(location);
     if (line)
         return { line: Number(line[2]), path: line[1] ?? location };
-    return { path: location };
+    return undefined;
 }
 function reviewFindingsFromBody(body) {
     const findings = [];
-    const requirementFindings = [];
     const lines = (body ?? "").split(/\r?\n/);
     let section;
     for (let index = 0; index < lines.length; index += 1) {
@@ -161,7 +188,7 @@ function reviewFindingsFromBody(body) {
             continue;
         }
         if (line === "Requirement findings:") {
-            section = "requirement";
+            section = undefined;
             continue;
         }
         if (section === "finding") {
@@ -169,43 +196,63 @@ function reviewFindingsFromBody(body) {
             const fix = /^\s+Fix: (.+)$/.exec(lines[index + 1] ?? "");
             if (!match || !fix)
                 continue;
+            const location = parsePostedFindingLocation(match[1] ?? "");
+            if (!location)
+                continue;
             findings.push({
-                ...parsePostedFindingLocation(match[1] ?? ""),
+                ...location,
                 fix: fix[1] ?? "Please address this before merging.",
                 issue: match[2] ?? "Review finding.",
             });
             index += 1;
             continue;
         }
-        if (section !== "requirement")
-            continue;
-        const match = /^- Missing issue #(\d+) requirement: (.+)$/.exec(line ?? "");
-        const evidence = /^\s+Evidence: (.+)$/.exec(lines[index + 1] ?? "");
-        const fix = /^\s+Fix: (.+)$/.exec(lines[index + 2] ?? "");
-        if (!match || !evidence || !fix)
-            continue;
-        requirementFindings.push({
-            evidence: evidence[1] ?? "See review body.",
-            fix: fix[1] ?? "Please address this before merging.",
-            issueNumber: Number(match[1]),
-            requirement: match[2] ?? "Review requirement.",
-        });
-        index += 2;
     }
-    return { findings, requirementFindings };
+    return { findings };
+}
+function parsePostedFindingComment(body) {
+    const match = /^\*\*Issue:\*\*\s*([\s\S]*?)\s*\r?\n\r?\n\*\*Fix:\*\*\s*([\s\S]+?)\s*$/.exec(body);
+    if (!match)
+        return undefined;
+    return {
+        fix: match[2]?.trim() || "Please address this before merging.",
+        issue: match[1]?.trim() || "Review finding.",
+    };
+}
+function reviewFindingsFromComments(comments) {
+    return {
+        findings: (comments ?? []).flatMap((comment) => {
+            if (comment.line == null)
+                return [];
+            const parsed = parsePostedFindingComment(comment.body);
+            if (!parsed)
+                return [];
+            return [
+                {
+                    ...parsed,
+                    line: comment.line,
+                    path: comment.path,
+                    startLine: comment.startLine ?? undefined,
+                },
+            ];
+        }),
+    };
 }
 export function reviewOutputFromState(review) {
     const verdict = reviewStateToVerdict(review.state);
-    if (verdict === "CHANGES_REQUESTED")
+    if (verdict === "CHANGES_REQUESTED") {
+        const fromComments = reviewFindingsFromComments(review.comments);
+        if (fromComments.findings.length)
+            return { ...fromComments, verdict };
         return { ...reviewFindingsFromBody(review.body), verdict };
+    }
     return verdict === "CLOSE"
         ? {
             findings: [],
             reason: review.body || "Close requested.",
-            requirementFindings: [],
             verdict,
         }
-        : { findings: [], requirementFindings: [], verdict };
+        : { findings: [], verdict };
 }
 export function hasPendingThreadReply(threads, reviewerAccount) {
     return threads.some((thread) => {
@@ -229,22 +276,22 @@ 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 && !output.requirementFindings.length)
+    if (!output.newFindings.length)
         return "";
     return postChangesRequested(input.exec, input.repository, input.pr, reviewer.account, output.newFindings.map((finding) => ({
         fix: "Please address this before merging.",
         issue: finding.body,
         path: finding.path,
-        ...(finding.line == null ? {} : { line: finding.line }),
+        line: finding.line,
         startLine: finding.startLine,
-    })), output.requirementFindings);
+    })));
 }
 function isReviewOutput(output) {
     return "findings" in output;
 }
 async function runFindingValidation(input) {
-    const reviewOutputs = Object.fromEntries(input.entries.flatMap((entry) => isReviewOutput(entry.value) ? [[entry.key, entry.value]] : []));
-    const targets = reviewFindingTargets(reviewOutputs);
+    const outputs = Object.fromEntries(input.entries.map((entry) => [entry.key, entry.value]));
+    const targets = reviewFindingTargets(outputs);
     if (!targets.length) {
         return {
             outputs: Object.fromEntries(input.entries.map((entry) => [entry.key, entry.value])),
@@ -303,6 +350,7 @@ async function runFindingValidation(input) {
                     }
                 },
                 options: reviewer.options,
+                parentSessionId: input.reviewInput.parentSessionId,
                 parse: (text) => {
                     const output = parseFindingValidationOutput(text);
                     validateFindingVotes({
@@ -328,7 +376,7 @@ async function runFindingValidation(input) {
         return [reviewer.key, result.value];
     }, { signal: input.reviewInput.signal }));
     const filtered = applyFindingValidation({
-        outputs: reviewOutputs,
+        outputs,
         reviewerKeys: input.reviewInput.repository.agents.reviewers.map((reviewer) => reviewer.key),
         validations,
     });
@@ -336,7 +384,7 @@ async function runFindingValidation(input) {
     await input.reviewInput.onProgress?.({
         discarded: filtered.summary.discarded.length,
         kept: filtered.summary.kept.length,
-        reviewersChangedToMerge: Object.entries(reviewOutputs)
+        reviewersChangedToMerge: Object.entries(outputs)
             .filter(([reviewer, output]) => {
             return (output.verdict === "CHANGES_REQUESTED" &&
                 filtered.outputs[reviewer]?.verdict === "MERGE");
@@ -365,27 +413,49 @@ async function runCloseReconsideration(input) {
         type: "phase",
     });
     return Promise.all(input.entries.map(async (entry) => {
-        if (!targets.includes(entry.key) || !isReviewOutput(entry.value)) {
+        if (!targets.includes(entry.key)) {
             return entry;
         }
         const reviewer = input.reviewInput.repository.agents.reviewers.find((item) => item.key === entry.key);
         if (!reviewer)
             return entry;
         const hasReviewerSession = Boolean(input.sessionIds[reviewer.key]);
-        const prompt = await composeCloseReconsiderationPrompt({
-            baseSha: input.meta.baseRefOid,
-            ciFailureContext: undefined,
-            closeReason: entry.value.reason,
-            directory: input.reviewInput.directory,
-            headSha: input.meta.headRefOid,
-            includeReviewGuidelines: !hasReviewerSession,
-            includeSessionContext: !hasReviewerSession,
-            pr: input.reviewInput.pr,
-            repository: input.reviewInput.repository,
-            reviewContext: input.reviewContext,
-            reviewer,
-            worktreePath: input.worktreePath,
-        });
+        const isReviewEntry = isReviewOutput(entry.value);
+        let prompt;
+        if (isReviewEntry) {
+            prompt = await composeCloseReconsiderationPrompt({
+                baseSha: input.meta.baseRefOid,
+                ciFailureContext: undefined,
+                closeReason: entry.value.reason,
+                directory: input.reviewInput.directory,
+                headSha: input.meta.headRefOid,
+                includeReviewGuidelines: !hasReviewerSession,
+                includeSessionContext: !hasReviewerSession,
+                pr: input.reviewInput.pr,
+                repository: input.reviewInput.repository,
+                reviewContext: input.reviewContext,
+                reviewer,
+                worktreePath: input.worktreePath,
+            });
+        }
+        else {
+            if (!entry.previousHeadSha) {
+                throw new Error(`Missing previous review commit for ${reviewer.account}`);
+            }
+            prompt = await composeRereviewCloseReconsiderationPrompt({
+                baseSha: input.meta.baseRefOid,
+                closeReason: entry.value.reason,
+                directory: input.reviewInput.directory,
+                headSha: input.meta.headRefOid,
+                includeReviewGuidelines: !hasReviewerSession,
+                includeSessionContext: !hasReviewerSession,
+                pr: input.reviewInput.pr,
+                previousHeadSha: entry.previousHeadSha,
+                repository: input.reviewInput.repository,
+                reviewer,
+                worktreePath: input.worktreePath,
+            });
+        }
         const result = await withReviewerFailureProgress({
             onProgress: input.reviewInput.onProgress,
             reviewer: reviewer.key,
@@ -416,15 +486,21 @@ async function runCloseReconsideration(input) {
                     }
                 },
                 options: reviewer.options,
+                parentSessionId: input.reviewInput.parentSessionId,
                 parse: (text) => {
-                    const output = parseCloseReconsiderationOutput(text);
-                    validateInlineCommentTargets(output.findings, input.inlineCommentTargets);
+                    const output = isReviewEntry
+                        ? parseCloseReconsiderationOutput(text)
+                        : parseRereviewCloseReconsiderationOutput(text);
+                    const findings = "newFindings" in output ? output.newFindings : output.findings;
+                    validateInlineCommentTargets(findings, entry.inlineCommentTargets, "newFindings" in output ? "newFindings" : "findings");
                     return output;
                 },
                 permission: reviewer.permission,
                 prompt,
                 repairAttempts: input.reviewInput.config.output?.repairAttempts ?? 3,
-                schemaName: "close reconsideration",
+                schemaName: isReviewEntry
+                    ? "close reconsideration"
+                    : "rereview close reconsideration",
                 sessionId: input.sessionIds[reviewer.key],
                 signal: input.reviewInput.signal,
                 title: `magi reconsider close ${input.reviewInput.repository.alias}#${input.reviewInput.pr} ${reviewer.key}`,
@@ -447,7 +523,9 @@ async function runCloseReconsideration(input) {
         });
         input.sessionIds[reviewer.key] = result.sessionId;
         return {
+            inlineCommentTargets: entry.inlineCommentTargets,
             key: entry.key,
+            previousHeadSha: entry.previousHeadSha,
             raw: result.raw,
             sessionId: result.sessionId,
             value: result.value,
@@ -527,11 +605,13 @@ export async function runReview(input) {
         : preliminaryMode;
     if (mode.type === "already_reviewed" && !input.allowAlreadyReviewed)
         throw new Error("PR has already been reviewed by all configured accounts");
-    const outputDir = join(prRunOutputDir({
+    const runId = input.runId ?? `run-${Date.now().toString(36)}`;
+    const outputDir = prRunOutputDir({
         config: input.config,
         directory: input.directory,
         pr: input.pr,
-    }), ...(input.runId ? [input.runId] : []));
+        runId,
+    });
     await mkdir(outputDir, { recursive: true });
     await input.onProgress?.({ phase: "fetching review context", type: "phase" });
     const reviewContextSnapshot = await buildReviewContextSnapshot({
@@ -580,6 +660,7 @@ export async function runReview(input) {
         },
         onProgress: (phase) => input.onProgress?.({ phase, type: "phase" }),
         outputDir,
+        parentSessionId: input.parentSessionId,
         pr: input.pr,
         repairAttempts: input.config.output?.repairAttempts ?? 3,
         repository: input.repository,
@@ -595,10 +676,14 @@ export async function runReview(input) {
             checkResult.report.scopeInside.length)) {
         await input.onProgress?.({ report: checkResult.report, type: "ci_report" });
     }
-    const worktreeRoot = worktreeBaseDir(input.directory, input.config, "pr");
+    const worktreePath = prRunWorktreeDir({
+        config: input.config,
+        directory: input.directory,
+        pr: input.pr,
+        runId,
+    });
     await input.onProgress?.({ phase: "creating worktree", type: "phase" });
-    const worktree = await createWorktree(exec, input.repository, input.pr, worktreeRoot);
-    const worktreePath = worktree.path;
+    const worktree = await createWorktree(exec, input.repository, input.pr, worktreePath);
     await input.onProgress?.({
         branch: worktree.branch,
         type: "worktree_created",
@@ -612,7 +697,18 @@ 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 }));
+        const initialInlineCommentTargets = await inlineCommentTargetsForDiff({
+            ensure: {
+                fromSource: "base",
+                meta,
+                repository: input.repository,
+                toSource: "head",
+            },
+            exec,
+            fromSha: meta.baseRefOid,
+            toSha: meta.headRefOid,
+            worktreePath,
+        });
         for (const reviewer of input.repository.agents.reviewers) {
             const assignment = mode.assignments.get(reviewer.account);
             if (assignment?.type !== "skip")
@@ -632,6 +728,18 @@ export async function runReview(input) {
                 const previous = assignment.review;
                 if (!previous.commit?.oid)
                     throw new Error(`Missing previous review commit for ${reviewer.account}`);
+                const inlineCommentTargets = await inlineCommentTargetsForDiff({
+                    ensure: {
+                        fromSource: "head",
+                        meta,
+                        repository: input.repository,
+                        toSource: "head",
+                    },
+                    exec,
+                    fromSha: previous.commit.oid,
+                    toSha: meta.headRefOid,
+                    worktreePath,
+                });
                 const unresolved = unresolvedThreadsByAccount.get(reviewer.account) ??
                     (await fetchUnresolvedThreads(exec, input.repository, input.pr, reviewer.account));
                 const prompt = await composeRereviewPrompt({
@@ -678,6 +786,7 @@ export async function runReview(input) {
                             }
                         },
                         options: reviewer.options,
+                        parentSessionId: input.parentSessionId,
                         parse: (text) => parseRereviewOutputWithInlineTargets(text, inlineCommentTargets),
                         permission: reviewer.permission,
                         prompt,
@@ -697,7 +806,9 @@ export async function runReview(input) {
                     verdict: result.value.verdict,
                 });
                 return {
+                    inlineCommentTargets,
                     key: reviewer.key,
+                    previousHeadSha: previous.commit.oid,
                     raw: result.raw,
                     sessionId: result.sessionId,
                     value: result.value,
@@ -744,7 +855,8 @@ export async function runReview(input) {
                         }
                     },
                     options: reviewer.options,
-                    parse: (text) => parseReviewOutputWithInlineTargets(text, inlineCommentTargets),
+                    parentSessionId: input.parentSessionId,
+                    parse: (text) => parseReviewOutputWithInlineTargets(text, initialInlineCommentTargets),
                     permission: reviewer.permission,
                     prompt,
                     repairAttempts: input.config.output?.repairAttempts ?? 3,
@@ -763,6 +875,7 @@ export async function runReview(input) {
                 verdict: result.value.verdict,
             });
             return {
+                inlineCommentTargets: initialInlineCommentTargets,
                 key: reviewer.key,
                 raw: result.raw,
                 sessionId: result.sessionId,
@@ -796,6 +909,7 @@ export async function runReview(input) {
             return [
                 {
                     key: reviewer.key,
+                    inlineCommentTargets: initialInlineCommentTargets,
                     raw: assignment.review.body ?? "",
                     sessionId: "",
                     value: reviewOutputFromState(assignment.review),
@@ -804,7 +918,6 @@ export async function runReview(input) {
         });
         entries = await runCloseReconsideration({
             entries: [...entries, ...skippedCloseEntries],
-            inlineCommentTargets,
             meta,
             outputDir,
             reviewContext,