opencode-magi 0.0.0-dev-20260525031145 → 0.0.0-dev-20260525064434

package/dist/config/resolve.js

@@ -138,6 +138,7 @@ export function resolveRepository(config) {
         agents: resolveAgents(config),
         automation: {
             close: config.merge?.automation?.close ?? false,
+            conflict: config.merge?.automation?.conflict ?? false,
             merge: config.merge?.automation?.merge ?? true,
         },
         checks: {

package/dist/config/validate.js

@@ -93,6 +93,7 @@ const REVIEW_MERGE_KEYS = new Set([
 const REVIEW_CHECKS_KEYS = new Set(["exclude", "retryFailedJobs", "wait"]);
 const MERGE_CHECKS_KEYS = new Set(["wait"]);
 const AUTOMATION_KEYS = new Set(["close", "merge"]);
+const MERGE_AUTOMATION_KEYS = new Set(["close", "conflict", "merge"]);
 const CLEAR_KEYS = new Set(["branch", "output", "session", "worktree"]);
 const CONCURRENCY_KEYS = new Set(["reviewers", "runs"]);
 const OUTPUT_KEYS = new Set(["repairAttempts"]);
@@ -552,7 +553,7 @@ function validateMerge(config, errors, options) {
         errors.push("merge must be an object");
     }
     validateKnownKeys(merge, "merge", MERGE_KEYS, errors);
-    validateBooleanObject(merge?.automation, "merge.automation", AUTOMATION_KEYS, errors);
+    validateBooleanObject(merge?.automation, "merge.automation", MERGE_AUTOMATION_KEYS, errors);
     const checks = merge?.checks;
     validateKnownKeys(checks, "merge.checks", MERGE_CHECKS_KEYS, errors);
     validateBoolean(checks?.wait, "merge.checks.wait", errors);

package/dist/github/commands.js

@@ -685,6 +685,29 @@ export async function waitForAutoMerge(exec, repository, pr, intervalMs = 30_000
         await new Promise((resolve) => setTimeout(resolve, intervalMs));
     }
 }
+export async function fetchBaseBranch(exec, repository, meta, worktreePath) {
+    await exec(`git fetch --no-tags ${shellQuote(repositoryGitUrl(repository, repository.github.owner, repository.github.repo))} ${shellQuote(`refs/heads/${meta.baseRefName}`)}`, { cwd: worktreePath });
+}
+export async function mergeBaseNoCommit(exec, baseSha, worktreePath) {
+    await exec(`git merge --no-commit --no-ff ${shellQuote(baseSha)}`, {
+        cwd: worktreePath,
+    }).catch(() => undefined);
+}
+export async function listUnmergedFiles(exec, worktreePath) {
+    const output = await exec("git diff --name-only --diff-filter=U", {
+        cwd: worktreePath,
+    });
+    return output
+        .split("\n")
+        .map((line) => line.trim())
+        .filter(Boolean);
+}
+export async function abortMerge(exec, worktreePath) {
+    await exec("git merge --abort", { cwd: worktreePath }).catch(() => undefined);
+}
+export async function currentHeadSha(exec, worktreePath) {
+    return (await exec("git rev-parse HEAD", { cwd: worktreePath })).trim();
+}
 export async function closePullRequest(exec, repository, pr, account) {
     const token = await ghToken(exec, repository, account);
     return exec(`gh pr close ${pr} --repo ${shellQuote(repoSpecifier(repository))}`, ghTokenEnv(token));

package/dist/orchestrator/merge.js

@@ -1,8 +1,8 @@
 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, waitForAutoMerge, waitForMergeQueue, } from "../github/commands";
-import { composeEditPrompt, composeRereviewCloseReconsiderationPrompt, composeRereviewPrompt, } from "../prompts/compose";
+import { abortMerge, closePullRequest, configureGitIdentity, currentHeadSha, fetchBaseBranch, fetchMergeQueueRequirement, fetchPullRequest, fetchUnresolvedThreads, listUnmergedFiles, mergePullRequest, mergeBaseNoCommit, postApproval, postChangesRequested, postCloseComment, postReply, pushHead, removeWorktree, resolveThread, waitForAutoMerge, waitForMergeQueue, } from "../github/commands";
+import { composeEditPrompt, composeMergeConflictPrompt, composeRereviewCloseReconsiderationPrompt, composeRereviewPrompt, } from "../prompts/compose";
 import { parseEditOutput, parseRereviewCloseReconsiderationOutput, parseRereviewOutput, } from "../prompts/output";
 import { throwIfAborted, withAbortSignal } from "./abort";
 import { waitForChecksWithClassification } from "./ci";
@@ -433,6 +433,224 @@ async function mergeWithQueue(input, exec, editorAccount) {
     }
     return waitForMergeQueue(exec, input.repository, input.pr);
 }
+async function runConflictEditor(input) {
+    const editor = input.run.repository.agents.editor;
+    if (!editor)
+        throw new Error("merge.editor is required for magi_merge");
+    await configureGitIdentity(input.run.exec, input.worktreePath, {
+        email: editor.author?.email,
+        name: editor.author?.name,
+    });
+    const artifactDir = outputDir(input.run);
+    const prompt = await composeMergeConflictPrompt({
+        baseBranch: input.baseBranch,
+        baseSha: input.baseSha,
+        conflictedFiles: JSON.stringify(input.conflictedFiles, null, 2),
+        directory: input.run.directory,
+        headSha: input.headSha,
+        pr: input.run.pr,
+        repository: input.run.repository,
+        worktreePath: input.worktreePath,
+    });
+    await input.run.onProgress?.({ cycle: input.cycle, type: "editor_started" });
+    const result = await withEditorFailureProgress({
+        cycle: input.cycle,
+        onProgress: input.run.onProgress,
+        run: () => runModelWithRepair({
+            client: input.run.client,
+            model: editor.model,
+            onProgress: async (progress) => {
+                if (progress.type === "session_created") {
+                    await input.run.onProgress?.({
+                        cycle: input.cycle,
+                        options: progress.options,
+                        sessionId: progress.sessionId,
+                        type: "editor_session",
+                    });
+                }
+                if (progress.type === "repair") {
+                    await input.run.onProgress?.({
+                        cycle: input.cycle,
+                        type: "editor_repair",
+                    });
+                }
+                if (progress.type === "response") {
+                    await input.run.onProgress?.({
+                        cycle: input.cycle,
+                        sessionId: progress.sessionId,
+                        type: "editor_response",
+                    });
+                }
+            },
+            options: editor.options,
+            parentSessionId: input.run.parentSessionId,
+            parse: parseEditOutput,
+            permission: editor.permission,
+            prompt,
+            repairAttempts: input.run.config.output?.repairAttempts ?? 3,
+            schemaName: "edit",
+            signal: input.run.signal,
+            title: `magi resolve conflict ${input.run.repository.alias}#${input.run.pr}`,
+        }),
+    });
+    await writeFile(join(artifactDir, "editor.conflict.prompt.txt"), prompt);
+    await writeFile(join(artifactDir, "editor.conflict.raw.txt"), result.raw);
+    await writeFile(join(artifactDir, "editor.conflict.json"), JSON.stringify(result.value, null, 2));
+    await input.run.onProgress?.({ cycle: input.cycle, type: "editor_completed" });
+    return result.value;
+}
+async function recoverMergeQueueConflict(input) {
+    await input.run.onProgress?.({
+        phase: "checking merge queue conflict",
+        type: "phase",
+    });
+    const meta = await fetchPullRequest(input.exec, input.run.repository, input.run.pr);
+    if (meta.state && meta.state.toUpperCase() !== "OPEN")
+        return undefined;
+    await fetchBaseBranch(input.exec, input.run.repository, meta, input.worktreePath);
+    await mergeBaseNoCommit(input.exec, meta.baseRefOid, input.worktreePath);
+    const conflictedFiles = await listUnmergedFiles(input.exec, input.worktreePath);
+    if (!conflictedFiles.length) {
+        await abortMerge(input.exec, input.worktreePath);
+        return undefined;
+    }
+    await input.run.onProgress?.({
+        phase: "resolving merge conflict",
+        type: "phase",
+    });
+    const editorOutput = await runConflictEditor({
+        baseBranch: meta.baseRefName,
+        baseSha: meta.baseRefOid,
+        conflictedFiles,
+        cycle: input.cycle,
+        headSha: input.previousHeadSha,
+        run: input.run,
+        worktreePath: input.worktreePath,
+    });
+    if (editorOutput.mode !== "EDITED") {
+        return {
+            ciReports: input.ciReports,
+            editorOutput,
+            headSha: input.previousHeadSha,
+            outputs: {},
+            posted: {},
+            status: "changes_unresolved",
+        };
+    }
+    const remainingConflicts = await listUnmergedFiles(input.exec, input.worktreePath);
+    const editedHeadSha = await currentHeadSha(input.exec, input.worktreePath);
+    if (remainingConflicts.length || editedHeadSha === input.previousHeadSha) {
+        return {
+            ciReports: input.ciReports,
+            editorOutput,
+            headSha: input.previousHeadSha,
+            outputs: {},
+            posted: {},
+            status: "changes_unresolved",
+        };
+    }
+    const editor = input.run.repository.agents.editor;
+    if (!editor)
+        throw new Error("merge.editor is required for magi_merge");
+    const headOwner = meta.headRepositoryOwner?.login;
+    const headRepo = meta.headRepository?.name;
+    if (!headOwner || !headRepo) {
+        throw new Error("Pull request head repository is missing");
+    }
+    await pushHead(input.exec, input.run.repository, input.worktreePath, editor.account, { owner: headOwner, ref: meta.headRefName, repo: headRepo });
+    const ciReports = [...input.ciReports];
+    let ciFailureContext = "";
+    await input.run.onProgress?.({
+        phase: "waiting for checks after conflict resolution",
+        type: "phase",
+    });
+    const checkResult = await waitForChecksWithClassification({
+        afterEdit: {
+            cycle: input.cycle,
+            headSha: editedHeadSha,
+            previousHeadSha: input.previousHeadSha,
+            worktreePath: input.worktreePath,
+        },
+        client: input.run.client,
+        directory: input.run.directory,
+        exec: input.exec,
+        headSha: editedHeadSha,
+        onProgress: (phase) => input.run.onProgress?.({ phase, type: "phase" }),
+        parentSessionId: input.run.parentSessionId,
+        pr: input.run.pr,
+        repairAttempts: input.run.config.output?.repairAttempts ?? 3,
+        repository: input.run.repository,
+        signal: input.run.signal,
+        wait: input.run.repository.checks.waitAfterEdit,
+    });
+    ciFailureContext = checkResult?.ciFailureContext ?? "";
+    if (checkResult &&
+        (checkResult.report.scopeOutsideRecovered.length ||
+            checkResult.report.scopeOutsideUnresolved.length ||
+            checkResult.report.scopeInside.length)) {
+        ciReports.push(checkResult.report);
+        await input.run.onProgress?.({
+            report: checkResult.report,
+            type: "ci_report",
+        });
+    }
+    await input.run.onProgress?.({
+        phase: "rereview after conflict resolution",
+        type: "phase",
+    });
+    const rereview = await runRereview(input.run, input.worktreePath, input.previousHeadSha, input.cycle, input.sessionIds, ciFailureContext);
+    if (rereview.verdict === "CLOSE") {
+        if (!input.run.repository.automation.close) {
+            return {
+                ciReports,
+                editorOutput,
+                headSha: editedHeadSha,
+                outputs: rereview.outputs,
+                posted: rereview.posted,
+                status: "close_requested",
+            };
+        }
+        await input.run.onProgress?.({ phase: "closing PR", type: "phase" });
+        await closePullRequest(input.exec, input.run.repository, input.run.pr, editor.account);
+        return {
+            ciReports,
+            editorOutput,
+            headSha: editedHeadSha,
+            outputs: rereview.outputs,
+            posted: rereview.posted,
+            status: "closed",
+        };
+    }
+    if (rereview.verdict === "MERGE") {
+        if (hasBlockingCiReports(ciReports)) {
+            return {
+                ciReports,
+                editorOutput,
+                headSha: editedHeadSha,
+                outputs: rereview.outputs,
+                posted: rereview.posted,
+                status: "ci_unresolved",
+            };
+        }
+        await input.run.onProgress?.({ phase: "re-enqueueing PR", type: "phase" });
+        const status = await mergeWithQueue(input.run, input.exec, editor.account);
+        return {
+            ciReports,
+            editorOutput,
+            headSha: editedHeadSha,
+            outputs: rereview.outputs,
+            posted: rereview.posted,
+            status,
+        };
+    }
+    return {
+        ciReports,
+        editorOutput,
+        headSha: editedHeadSha,
+        outputs: rereview.outputs,
+        posted: rereview.posted,
+    };
+}
 export function hasBlockingCiReports(reports) {
     return reports.some((report) => report.scopeInside.length || report.scopeOutsideUnresolved.length);
 }
@@ -656,6 +874,28 @@ export async function runMerge(input) {
             outputs: reportOutputs,
             posted: reportPosted,
         });
+        let previousHeadSha = review.headSha;
+        const ciReports = [...review.ciReports];
+        const threadAttempts = {};
+        let dryRunThreads = input.dryRun
+            ? syntheticReviewThreads(reportOutputs)
+            : undefined;
+        let conflictRecoveryAttempted = false;
+        const applyConflictRecovery = (recovery) => {
+            editorOutputs.push({
+                ...recovery.editorOutput,
+                label: "Conflict recovery",
+            });
+            ciReports.length = 0;
+            ciReports.push(...recovery.ciReports);
+            reportCiReports = [...recovery.ciReports];
+            if (Object.keys(recovery.outputs).length)
+                reportOutputs = recovery.outputs;
+            if (Object.keys(recovery.posted).length)
+                reportPosted = recovery.posted;
+            previousHeadSha = recovery.headSha;
+            dryRunThreads = undefined;
+        };
         if (review.verdict === "SAFETY_BLOCKED") {
             await input.onProgress?.({
                 status: "safety_blocked",
@@ -693,15 +933,45 @@ export async function runMerge(input) {
             }
             await input.onProgress?.({ phase: "merging PR", type: "phase" });
             const status = await mergeWithQueue(input, exec, editor.account);
-            await input.onProgress?.({ status, type: "merge_completed" });
-            return complete({ cycles: 0, pr: input.pr, status });
+            if (status === "dequeued" &&
+                input.repository.automation.conflict &&
+                input.repository.merge.mergeQueue) {
+                if (!review.worktreePath)
+                    throw new Error("Review worktree is missing");
+                conflictRecoveryAttempted = true;
+                const recovery = await recoverMergeQueueConflict({
+                    ciReports,
+                    cycle: 1,
+                    exec,
+                    previousHeadSha,
+                    run: abortableInput,
+                    sessionIds: review.sessionIds,
+                    worktreePath: review.worktreePath,
+                });
+                if (recovery) {
+                    applyConflictRecovery(recovery);
+                    if (recovery.status) {
+                        await input.onProgress?.({
+                            status: recovery.status,
+                            type: "merge_completed",
+                        });
+                        return complete({
+                            cycles: 1,
+                            pr: input.pr,
+                            status: recovery.status,
+                        });
+                    }
+                }
+                else {
+                    await input.onProgress?.({ status, type: "merge_completed" });
+                    return complete({ cycles: 0, pr: input.pr, status });
+                }
+            }
+            else {
+                await input.onProgress?.({ status, type: "merge_completed" });
+                return complete({ cycles: 0, pr: input.pr, status });
+            }
         }
-        let previousHeadSha = review.headSha;
-        const ciReports = [...review.ciReports];
-        const threadAttempts = {};
-        let dryRunThreads = input.dryRun
-            ? syntheticReviewThreads(reportOutputs)
-            : undefined;
         for (let cycle = 1;; cycle += 1) {
             const unresolvedThreads = input.dryRun
                 ? flattenSyntheticThreads(dryRunThreads ?? {})
@@ -886,6 +1156,36 @@ export async function runMerge(input) {
                 }
                 await input.onProgress?.({ phase: "merging PR", type: "phase" });
                 const status = await mergeWithQueue(input, exec, editor.account);
+                if (status === "dequeued" &&
+                    input.repository.automation.conflict &&
+                    input.repository.merge.mergeQueue &&
+                    !conflictRecoveryAttempted) {
+                    conflictRecoveryAttempted = true;
+                    const recovery = await recoverMergeQueueConflict({
+                        ciReports,
+                        cycle: cycle + 1,
+                        exec,
+                        previousHeadSha,
+                        run: abortableInput,
+                        sessionIds: review.sessionIds,
+                        worktreePath: review.worktreePath,
+                    });
+                    if (recovery) {
+                        applyConflictRecovery(recovery);
+                        if (recovery.status) {
+                            await input.onProgress?.({
+                                status: recovery.status,
+                                type: "merge_completed",
+                            });
+                            return complete({
+                                cycles: cycle + 1,
+                                pr: input.pr,
+                                status: recovery.status,
+                            });
+                        }
+                        continue;
+                    }
+                }
                 await input.onProgress?.({ status, type: "merge_completed" });
                 return complete({ cycles: cycle, pr: input.pr, status });
             }

package/dist/orchestrator/report.js

@@ -138,7 +138,7 @@ function editorLines(outputs) {
     return [
         "- **Editor**:",
         ...outputs.flatMap((output, index) => {
-            const label = `  - Cycle ${index + 1}`;
+            const label = `  - ${output.label ?? `Cycle ${index + 1}`}`;
             if (output.mode === "REPLIED") {
                 return [
                     `${label}: replied without code changes`,

package/dist/orchestrator/review.js

@@ -163,6 +163,90 @@ export async function inlineCommentTargetsForDiff(input) {
         cwd: input.worktreePath,
     }));
 }
+function firstTargetLine(targets, path) {
+    const lines = targets.get(path);
+    if (!lines?.size)
+        return undefined;
+    return [...lines].sort((a, b) => a - b)[0];
+}
+function mergeInlineCommentTargets(left, right) {
+    const merged = new Map();
+    for (const [path, lines] of [...left, ...right]) {
+        const targetLines = merged.get(path) ?? new Set();
+        for (const line of lines)
+            targetLines.add(line);
+        merged.set(path, targetLines);
+    }
+    return merged;
+}
+function targetLineSummary(targets, path) {
+    const lines = targets.get(path);
+    if (!lines?.size)
+        return "(none)";
+    const sorted = [...lines].sort((a, b) => a - b);
+    const shown = sorted.slice(0, 12).join(", ");
+    return sorted.length > 12 ? `${shown}, ...` : shown;
+}
+function indentedExcerpt(lines) {
+    return lines
+        .slice(0, 24)
+        .map((line) => `  ${line}`)
+        .join("\n");
+}
+function parseMergeConflictSections(output) {
+    const conflictHeaders = new Set([
+        "added in both",
+        "changed in both",
+        "removed in local",
+        "removed in remote",
+    ]);
+    const sections = [];
+    let current;
+    for (const line of output.split("\n")) {
+        if (!line.trim())
+            continue;
+        if (!line.startsWith(" ") &&
+            !line.startsWith("+") &&
+            !line.startsWith("-") &&
+            !line.startsWith("@")) {
+            current = conflictHeaders.has(line)
+                ? { lines: [line], paths: new Set() }
+                : undefined;
+            if (current)
+                sections.push(current);
+            continue;
+        }
+        if (!current)
+            continue;
+        current.lines.push(line);
+        const path = /^  (?:base|our|their)\s+\d+\s+[0-9a-f]+\s+(.+)$/.exec(line)?.[1];
+        if (path)
+            current.paths.add(path);
+    }
+    return sections.flatMap((section) => [...section.paths].map((path) => ({
+        excerpt: indentedExcerpt(section.lines),
+        path,
+    })));
+}
+export async function mergeConflictContextForDiff(input) {
+    const mergeBase = (await input.exec(`git merge-base ${shellQuote(input.baseSha)} ${shellQuote(input.headSha)}`, { cwd: input.worktreePath })).trim();
+    const output = await input.exec(`git merge-tree ${shellQuote(mergeBase)} ${shellQuote(input.headSha)} ${shellQuote(input.baseSha)}`, { cwd: input.worktreePath });
+    const conflicts = parseMergeConflictSections(output);
+    if (!conflicts.length)
+        return "";
+    return [
+        "The PR currently has unresolved merge conflicts with the base branch.",
+        "Treat unresolved conflicts as review findings and request changes when they make the PR unsafe or impossible to merge.",
+        "Use suggestedLine when it is present; it is a valid right-side PR diff line for an inline finding.",
+        ...conflicts.map((conflict) => {
+            const suggestedLine = firstTargetLine(input.inlineCommentTargets, conflict.path);
+            const suggestedLineText = suggestedLine
+                ? `suggestedLine: ${suggestedLine}`
+                : "suggestedLine: (no right-side PR diff line found)";
+            return `<conflict_file>\npath: ${conflict.path}\n${suggestedLineText}\nrightSideDiffLines: ${targetLineSummary(input.inlineCommentTargets, conflict.path)}\nmergeTreeExcerpt:\n${conflict.excerpt}\n</conflict_file>`;
+        }),
+    ].join("\n");
+}
 function parsePostedFindingLocation(location) {
     const range = /^(.*):(\d+)-(\d+)$/.exec(location);
     if (range) {
@@ -709,6 +793,13 @@ export async function runReview(input) {
             toSha: meta.headRefOid,
             worktreePath,
         });
+        const mergeConflictContext = await mergeConflictContextForDiff({
+            baseSha: meta.baseRefOid,
+            exec,
+            headSha: meta.headRefOid,
+            inlineCommentTargets: initialInlineCommentTargets,
+            worktreePath,
+        });
         for (const reviewer of input.repository.agents.reviewers) {
             const assignment = mode.assignments.get(reviewer.account);
             if (assignment?.type !== "skip")
@@ -740,6 +831,9 @@ export async function runReview(input) {
                     toSha: meta.headRefOid,
                     worktreePath,
                 });
+                const rereviewInlineCommentTargets = mergeConflictContext
+                    ? mergeInlineCommentTargets(inlineCommentTargets, initialInlineCommentTargets)
+                    : inlineCommentTargets;
                 const unresolved = unresolvedThreadsByAccount.get(reviewer.account) ??
                     (await fetchUnresolvedThreads(exec, input.repository, input.pr, reviewer.account));
                 const prompt = await composeRereviewPrompt({
@@ -747,6 +841,7 @@ export async function runReview(input) {
                     ciFailureContext,
                     directory: input.directory,
                     headSha: meta.headRefOid,
+                    mergeConflictContext,
                     pr: input.pr,
                     previousReview: previousReviewText(previous),
                     previousHeadSha: previous.commit.oid,
@@ -787,7 +882,7 @@ export async function runReview(input) {
                         },
                         options: reviewer.options,
                         parentSessionId: input.parentSessionId,
-                        parse: (text) => parseRereviewOutputWithInlineTargets(text, inlineCommentTargets),
+                        parse: (text) => parseRereviewOutputWithInlineTargets(text, rereviewInlineCommentTargets),
                         permission: reviewer.permission,
                         prompt,
                         repairAttempts: input.config.output?.repairAttempts ?? 3,
@@ -819,6 +914,7 @@ export async function runReview(input) {
                 ciFailureContext,
                 directory: input.directory,
                 headSha: meta.headRefOid,
+                mergeConflictContext,
                 pr: input.pr,
                 repository: input.repository,
                 reviewContext,

package/dist/prompts/compose.js

@@ -35,6 +35,7 @@ function repositoryValues(repository) {
 }
 function reviewValues(input) {
     const ciFailureContext = input.ciFailureContext?.trim() ?? "";
+    const mergeConflictContext = input.mergeConflictContext?.trim() ?? "";
     return {
         ...repositoryValues(input.repository),
         baseSha: input.baseSha,
@@ -44,6 +45,10 @@ function reviewValues(input) {
             : "",
         headSha: input.headSha,
         jsonEncodedWorktreePath: JSON.stringify(input.worktreePath),
+        mergeConflictContext,
+        mergeConflictContextBlock: mergeConflictContext
+            ? `<merge_conflict_context>\n${mergeConflictContext}\n</merge_conflict_context>`
+            : "",
         pr: String(input.pr),
         reviewContext: input.reviewContext ?? "",
         worktreePath: input.worktreePath,
@@ -67,6 +72,17 @@ function editValues(input) {
         worktreePath: input.worktreePath,
     };
 }
+function mergeConflictValues(input) {
+    return {
+        ...repositoryValues(input.repository),
+        baseBranch: input.baseBranch,
+        baseSha: input.baseSha,
+        conflictedFiles: input.conflictedFiles,
+        headSha: input.headSha,
+        pr: String(input.pr),
+        worktreePath: input.worktreePath,
+    };
+}
 function triageValues(input) {
     const categories = input.repository.triage?.categories ?? [];
     const categoryOptions = categories
@@ -97,6 +113,12 @@ function previousReviewBlock(previousReview) {
 function reviewContextBlock(reviewContext) {
     return reviewContext?.trim() ? reviewContext.trim() : "";
 }
+function mergeConflictContextBlock(mergeConflictContext) {
+    const body = mergeConflictContext?.trim();
+    return body
+        ? `<merge_conflict_context>\n${body}\n</merge_conflict_context>`
+        : "";
+}
 async function reviewGuidelinesBlock(input) {
     const body = (await readOptionalPrompt(input.directory, input.path, input.values)).trim();
     return body ? `<review_guidelines>\n${body}\n</review_guidelines>` : "";
@@ -136,6 +158,7 @@ export async function composeReviewPrompt(input) {
     return [
         task,
         reviewContextBlock(input.reviewContext),
+        mergeConflictContextBlock(input.mergeConflictContext),
         languageBlock(input.repository.language),
         personaBlock(input.reviewer.persona),
         await reviewGuidelinesBlock({
@@ -159,6 +182,7 @@ export async function composeRereviewPrompt(input) {
     return [
         task,
         reviewContextBlock(input.reviewContext),
+        mergeConflictContextBlock(input.mergeConflictContext),
         input.includeSessionContext === false
             ? ""
             : languageBlock(input.repository.language),
@@ -200,6 +224,28 @@ export async function composeEditPrompt(input) {
         .filter(Boolean)
         .join("\n\n");
 }
+export async function composeMergeConflictPrompt(input) {
+    const values = mergeConflictValues(input);
+    const task = await taskBlock({
+        builtin: "merge/conflict",
+        directory: input.directory,
+        values,
+    });
+    const persona = input.repository.agents.editor?.persona;
+    return [
+        task,
+        languageBlock(input.repository.language),
+        personaBlock(persona),
+        await editGuidelinesBlock({
+            directory: input.directory,
+            path: input.repository.prompts.editGuidelines,
+            values,
+        }),
+        editOutputContract,
+    ]
+        .filter(Boolean)
+        .join("\n\n");
+}
 export async function composeFindingValidationPrompt(input) {
     const values = { ...reviewValues(input), findings: input.findings };
     const task = await taskBlock({

package/dist/prompts/templates/merge/conflict.md

@@ -0,0 +1,10 @@
+Resolve merge conflicts for pull request #{pr} in {owner}/{repo}.
+The PR worktree is {worktreePath}.
+
+The latest base branch is {baseBranch} at {baseSha}.
+The PR head before conflict recovery was {headSha}.
+
+Conflicted files:
+{conflictedFiles}
+
+Resolve every merge conflict in the worktree. Preserve the intended PR behavior while incorporating the latest base branch changes. Stage all resolved files and create a commit. Do not push.

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

@@ -13,6 +13,8 @@ Every newFinding must target a valid right-side line in the PR diff.
 If the problem itself does not have an exact changed line, choose the nearest changed line that represents the cause, responsibility, missing implementation, or affected behavior. This includes but is not limited to missing validation, missing wiring, missing requirements, missing tests, missing documentation, affected configuration, or relevant call sites.
 Do not omit line. Do not create file-level or body-only newFindings.
 
+If `<merge_conflict_context>` is present, treat unresolved merge conflicts as review findings. Request changes when a conflict makes the PR unsafe or impossible to merge, and prefer the provided `suggestedLine` when it is present.
+
 {ciFailureContextBlock}
 Do not edit files or perform write operations.
 

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

@@ -14,4 +14,6 @@ Every finding must target a valid right-side line in the PR diff.
 If the problem itself does not have an exact changed line, choose the nearest changed line that represents the cause, responsibility, missing implementation, or affected behavior. This includes but is not limited to missing validation, missing wiring, missing requirements, missing tests, missing documentation, affected configuration, or relevant call sites.
 Do not omit line. Do not create file-level or body-only findings.
 
+If `<merge_conflict_context>` is present, treat unresolved merge conflicts as review findings. Request changes when a conflict makes the PR unsafe or impossible to merge, and prefer the provided `suggestedLine` when it is present.
+
 {ciFailureContextBlock}

package/package.json

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

package/schema.json

@@ -179,6 +179,15 @@
         "close": { "type": "boolean" }
       }
     },
+    "mergeAutomation": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "merge": { "type": "boolean", "default": true },
+        "close": { "type": "boolean", "default": false },
+        "conflict": { "type": "boolean", "default": false }
+      }
+    },
     "reviewChecks": {
       "type": "object",
       "additionalProperties": false,
@@ -339,7 +348,7 @@
         "editor": { "$ref": "#/$defs/editor" },
         "checks": { "$ref": "#/$defs/mergeChecks" },
         "prompts": { "$ref": "#/$defs/mergePrompts" },
-        "automation": { "$ref": "#/$defs/automation" },
+        "automation": { "$ref": "#/$defs/mergeAutomation" },
         "maxThreadResolutionCycles": {
           "type": "integer",
           "minimum": 0,