opencode-magi 0.5.0 → 0.6.0

package/dist/orchestrator/findings.js

@@ -1,9 +1,20 @@
 import { majorityThreshold } from "./majority";
+function validationFindings(output) {
+    if ("findings" in output)
+        return output.findings;
+    return output.newFindings.map((finding) => ({
+        fix: "Please address this before merging.",
+        issue: finding.body,
+        line: finding.line,
+        path: finding.path,
+        startLine: finding.startLine,
+    }));
+}
 export function reviewFindingTargets(outputs) {
     return Object.entries(outputs).flatMap(([reviewer, output]) => {
         if (output.verdict !== "CHANGES_REQUESTED")
             return [];
-        return output.findings.map((finding, findingIndex) => ({
+        return validationFindings(output).map((finding, findingIndex) => ({
             finding,
             findingIndex,
             reviewer,
@@ -41,7 +52,9 @@ export function applyFindingValidation(input) {
             next[reviewer] = output;
             continue;
         }
-        const findings = output.findings.filter((finding, findingIndex) => {
+        const keptIndexes = new Set();
+        const findings = validationFindings(output);
+        findings.forEach((finding, findingIndex) => {
             let agrees = 1;
             for (const validator of input.reviewerKeys) {
                 if (validator === reviewer)
@@ -53,14 +66,23 @@ export function applyFindingValidation(input) {
             const target = { finding, findingIndex, reviewer };
             if (agrees >= threshold) {
                 kept.push(target);
-                return true;
+                keptIndexes.add(findingIndex);
+                return;
             }
             discarded.push(target);
-            return false;
         });
-        next[reviewer] = findings.length
-            ? { ...output, findings }
-            : { findings: [], verdict: "MERGE" };
+        if ("findings" in output) {
+            const keptFindings = output.findings.filter((_finding, index) => keptIndexes.has(index));
+            next[reviewer] = keptFindings.length
+                ? { ...output, findings: keptFindings }
+                : { findings: [], verdict: "MERGE" };
+            continue;
+        }
+        const newFindings = output.newFindings.filter((_finding, index) => keptIndexes.has(index));
+        next[reviewer] =
+            newFindings.length || output.followUps.length
+                ? { ...output, newFindings }
+                : { ...output, newFindings, verdict: "MERGE" };
     }
     return { outputs: next, summary: { discarded, kept } };
 }

package/dist/orchestrator/majority.js

@@ -10,7 +10,7 @@ export function aggregateStringMajority(results, votes) {
     const voters = Object.fromEntries(votes.map((vote) => [vote, []]));
     for (const result of results) {
         counts[result.vote] += 1;
-        voters[result.vote].push(result.reviewer);
+        voters[result.vote].push(result.voter);
     }
     const threshold = majorityThreshold(results.length);
     const vote = votes.find((item) => counts[item] >= threshold);

package/dist/orchestrator/merge.js

@@ -1,17 +1,17 @@
 import { mkdir, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { prRunOutputDir } from "../config/output";
-import { closePullRequest, configureGitIdentity, fetchMergeQueueRequirement, fetchPullRequest, fetchUnresolvedThreads, mergePullRequest, postApproval, postChangesRequested, postCloseComment, postReply, pushHead, removeWorktree, resolveThread, shellQuote, waitForMergeQueue, } from "../github/commands";
+import { closePullRequest, configureGitIdentity, fetchMergeQueueRequirement, fetchPullRequest, fetchUnresolvedThreads, mergePullRequest, postApproval, postChangesRequested, postCloseComment, postReply, pushHead, removeWorktree, resolveThread, waitForAutoMerge, waitForMergeQueue, } from "../github/commands";
 import { composeEditPrompt, composeRereviewCloseReconsiderationPrompt, composeRereviewPrompt, } from "../prompts/compose";
 import { parseEditOutput, parseRereviewCloseReconsiderationOutput, parseRereviewOutput, } from "../prompts/output";
 import { throwIfAborted, withAbortSignal } from "./abort";
 import { waitForChecksWithClassification } from "./ci";
-import { parseRightSideDiffTargets, validateInlineCommentTargets, } from "./inline-comments";
+import { validateInlineCommentTargets, } from "./inline-comments";
 import { closeMinorityReviewers, mergeVerdictForPolicy } from "./majority";
 import { runModelWithRepair } from "./model";
 import { mapPool } from "./pool";
 import { formatMergeReport } from "./report";
-import { runReview } from "./review";
+import { inlineCommentTargetsForDiff, runReview, } from "./review";
 import { checkSafetyGate, hasSafetyGate } from "./safety";
 function outputDir(input) {
     return prRunOutputDir({
@@ -53,7 +53,7 @@ async function withReviewerFailureProgress(input) {
 async function runEditor(input, worktreePath, cycle, reviewFindings, unresolvedThreads) {
     const editor = input.repository.agents.editor;
     if (!editor)
-        throw new Error("agents.editor is required for magi_merge");
+        throw new Error("merge.editor is required for magi_merge");
     throwIfAborted(input.signal);
     await configureGitIdentity(input.exec, worktreePath, {
         email: editor.author?.email,
@@ -96,6 +96,7 @@ async function runEditor(input, worktreePath, cycle, reviewFindings, unresolvedT
                 }
             },
             options: editor.options,
+            parentSessionId: input.parentSessionId,
             parse: parseEditOutput,
             permission: editor.permission,
             prompt,
@@ -195,7 +196,21 @@ async function runRereview(input, worktreePath, previousHeadSha, cycle, sessionI
     throwIfAborted(input.signal);
     const meta = await fetchPullRequest(input.exec, input.repository, input.pr);
     const headSha = options.dryRunHeadSha ?? meta.headRefOid;
-    const inlineCommentTargets = parseRightSideDiffTargets(await input.exec(`git diff --no-ext-diff --unified=3 ${shellQuote(meta.baseRefOid)} ${shellQuote(headSha)}`, { cwd: worktreePath }));
+    const inlineCommentTargets = await inlineCommentTargetsForDiff({
+        ensure: options.dryRunHeadSha
+            ? undefined
+            : {
+                fromSource: "base",
+                meta,
+                repository: input.repository,
+                toSource: "head",
+            },
+        exec: input.exec,
+        fromSha: meta.baseRefOid,
+        range: "direct",
+        toSha: headSha,
+        worktreePath,
+    });
     const artifactDir = outputDir(input);
     let entries = await mapPool(input.repository.agents.reviewers, input.repository.concurrency.reviewers, async (reviewer) => {
         throwIfAborted(input.signal);
@@ -250,6 +265,7 @@ async function runRereview(input, worktreePath, previousHeadSha, cycle, sessionI
                     }
                 },
                 options: reviewer.options,
+                parentSessionId: input.parentSessionId,
                 parse: (text) => parseRereviewOutputWithInlineTargets(text, inlineCommentTargets),
                 permission: reviewer.permission,
                 prompt,
@@ -294,7 +310,7 @@ async function runRereview(input, worktreePath, previousHeadSha, cycle, sessionI
                 baseSha: meta.baseRefOid,
                 closeReason: entry.output.reason,
                 directory: input.directory,
-                headSha: meta.headRefOid,
+                headSha,
                 includeReviewGuidelines: !hasReviewerSession,
                 includeSessionContext: !hasReviewerSession,
                 pr: input.pr,
@@ -333,6 +349,7 @@ async function runRereview(input, worktreePath, previousHeadSha, cycle, sessionI
                         }
                     },
                     options: reviewer.options,
+                    parentSessionId: input.parentSessionId,
                     parse: (text) => {
                         const output = parseRereviewCloseReconsiderationOutput(text);
                         validateInlineCommentTargets(output.newFindings, inlineCommentTargets, "newFindings");
@@ -409,8 +426,11 @@ async function finishMergeRun(input, result, reportInput) {
 }
 async function mergeWithQueue(input, exec, editorAccount) {
     await mergePullRequest(exec, input.repository, input.pr, editorAccount);
-    if (!input.repository.merge.mergeQueue)
-        return "merged";
+    if (!input.repository.merge.mergeQueue) {
+        if (!input.repository.merge.auto)
+            return "merged";
+        return waitForAutoMerge(exec, input.repository, input.pr);
+    }
     return waitForMergeQueue(exec, input.repository, input.pr);
 }
 export function hasBlockingCiReports(reports) {
@@ -570,7 +590,7 @@ export async function runMerge(input) {
     const abortableInput = { ...input, exec };
     const editor = input.repository.agents.editor;
     if (!editor)
-        throw new Error("agents.editor is required for magi_merge");
+        throw new Error("merge.editor is required for magi_merge");
     throwIfAborted(input.signal);
     const artifactDir = outputDir(input);
     await mkdir(artifactDir, { recursive: true });
@@ -701,7 +721,7 @@ export async function runMerge(input) {
                 threads: unresolvedThreads,
             });
             const editorFindings = blockingReviewFindings(reportOutputs);
-            const editableFindings = editableThreads.length ? editorFindings : [];
+            const editableFindings = editorFindings;
             const findingAttemptsExhausted = input.repository.merge.maxThreadResolutionCycles !== 0 &&
                 cycle > input.repository.merge.maxThreadResolutionCycles;
             if (!editableThreads.length &&
@@ -781,6 +801,7 @@ export async function runMerge(input) {
                         exec,
                         headSha: editedHeadSha,
                         onProgress: (phase) => input.onProgress?.({ phase, type: "phase" }),
+                        parentSessionId: input.parentSessionId,
                         pr: input.pr,
                         repairAttempts: input.config.output?.repairAttempts ?? 3,
                         repository: input.repository,

package/dist/orchestrator/model.js

@@ -89,6 +89,7 @@ function extractText(result, allowEmpty = false) {
 export async function createModelSession(input) {
     return extractSessionId(await input.client.session.create({
         body: {
+            parentID: input.parentSessionId,
             permission: toOpenCodePermissionRules(input.permission),
             title: input.title,
         },
@@ -96,15 +97,26 @@ export async function createModelSession(input) {
 }
 export async function promptModelText(input) {
     throwIfAborted(input.signal);
-    const result = await input.client.session.prompt({
-        body: {
-            model: modelBody(input.model),
-            parts: [{ type: "text", text: input.prompt }],
-        },
-        path: { id: input.sessionId },
-    });
-    throwIfAborted(input.signal);
-    return extractText(result, input.allowEmpty);
+    const abort = () => {
+        void input.client.session
+            .abort?.({ path: { id: input.sessionId } })
+            .catch(() => undefined);
+    };
+    input.signal?.addEventListener("abort", abort, { once: true });
+    try {
+        const result = await input.client.session.prompt({
+            body: {
+                model: modelBody(input.model),
+                parts: [{ type: "text", text: input.prompt }],
+            },
+            path: { id: input.sessionId },
+        });
+        throwIfAborted(input.signal);
+        return extractText(result, input.allowEmpty);
+    }
+    finally {
+        input.signal?.removeEventListener("abort", abort);
+    }
 }
 async function sendPrompt(client, sessionId, model, prompt, signal) {
     return promptModelText({ client, model, prompt, sessionId, signal });
@@ -113,6 +125,7 @@ export async function runModelText(input) {
     throwIfAborted(input.signal);
     const sessionId = await createModelSession({
         client: input.client,
+        parentSessionId: input.parentSessionId,
         permission: input.permission,
         title: input.title,
     });
@@ -152,6 +165,7 @@ export async function runModelWithRepair(input) {
             ? input.sessionId
             : extractSessionId(await input.client.session.create({
                 body: {
+                    parentID: input.parentSessionId,
                     permission: toOpenCodePermissionRules(input.permission),
                     title: input.title,
                 },

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";
@@ -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) {
@@ -182,10 +210,42 @@ function reviewFindingsFromBody(body) {
     }
     return { findings };
 }
+function parsePostedFindingComment(body) {
+    const match = /^\*\*Issue:\*\*\s*([\s\S]*?)\s*\r?\n\r?\n\*\*Fix:\*\*\s*([\s\S]+?)\s*$/.exec(body);
+    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: [],
@@ -230,8 +290,8 @@ 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])),
@@ -290,6 +350,7 @@ async function runFindingValidation(input) {
                     }
                 },
                 options: reviewer.options,
+                parentSessionId: input.reviewInput.parentSessionId,
                 parse: (text) => {
                     const output = parseFindingValidationOutput(text);
                     validateFindingVotes({
@@ -315,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,
     });
@@ -323,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");
@@ -352,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,
@@ -403,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}`,
@@ -434,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,
@@ -514,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({
@@ -567,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,
@@ -582,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",
@@ -599,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")
@@ -619,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({
@@ -665,6 +786,7 @@ export async function runReview(input) {
                             }
                         },
                         options: reviewer.options,
+                        parentSessionId: input.parentSessionId,
                         parse: (text) => parseRereviewOutputWithInlineTargets(text, inlineCommentTargets),
                         permission: reviewer.permission,
                         prompt,
@@ -684,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,
@@ -731,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,
@@ -750,6 +875,7 @@ export async function runReview(input) {
                 verdict: result.value.verdict,
             });
             return {
+                inlineCommentTargets: initialInlineCommentTargets,
                 key: reviewer.key,
                 raw: result.raw,
                 sessionId: result.sessionId,
@@ -783,6 +909,7 @@ export async function runReview(input) {
             return [
                 {
                     key: reviewer.key,
+                    inlineCommentTargets: initialInlineCommentTargets,
                     raw: assignment.review.body ?? "",
                     sessionId: "",
                     value: reviewOutputFromState(assignment.review),
@@ -791,7 +918,6 @@ export async function runReview(input) {
         });
         entries = await runCloseReconsideration({
             entries: [...entries, ...skippedCloseEntries],
-            inlineCommentTargets,
             meta,
             outputDir,
             reviewContext,