opencode-magi 0.7.0 → 0.8.0

package/dist/config/resolve.js

@@ -24,6 +24,31 @@ const DEFAULT_TRIAGE_CATEGORIES = [
         types: ["Feature"],
     },
 ];
+export const DEFAULT_TRIAGE_LABEL_RULES = [
+    { remove: ["triage"], when: { disposition: "accepted" } },
+    {
+        add: ["duplicate"],
+        remove: ["triage"],
+        when: { disposition: "duplicate" },
+    },
+    {
+        add: ["duplicate"],
+        remove: ["triage"],
+        when: { disposition: "already_handled" },
+    },
+    {
+        add: ["wontfix"],
+        remove: ["triage"],
+        when: { disposition: "rejected" },
+    },
+    {
+        add: ["invalid"],
+        remove: ["triage"],
+        when: { disposition: "invalid" },
+    },
+    { add: ["question"], when: { disposition: "needs_category" } },
+    { add: ["question"], when: { disposition: "needs_acceptance" } },
+];
 export function reviewerKey(reviewer, index) {
     return reviewer.id ?? `reviewer-${index + 1}`;
 }
@@ -138,6 +163,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: {
@@ -190,9 +216,9 @@ export function resolveRepository(config) {
         },
         triage: {
             automation: {
-                clear: config.triage?.automation?.clear ?? ["triage"],
                 close: config.triage?.automation?.close ?? false,
                 create: config.triage?.automation?.create ?? false,
+                label: config.triage?.automation?.label ?? DEFAULT_TRIAGE_LABEL_RULES,
                 merge: config.triage?.automation?.merge ?? false,
                 review: config.triage?.automation?.review ?? false,
             },
@@ -215,6 +241,7 @@ export function resolveRepository(config) {
                 blockedLabels: config.triage?.safety?.blockedLabels ?? [],
                 requiredLabels: config.triage?.safety?.requiredLabels ?? ["triage"],
             },
+            signals: config.triage?.signals ?? [],
             worktree: config.triage?.worktree,
         },
     };

package/dist/config/validate.js

@@ -80,6 +80,7 @@ const TRIAGE_KEYS = new Set([
     "prompts",
     "reporter",
     "safety",
+    "signals",
     "voters",
     "worktree",
 ]);
@@ -93,17 +94,24 @@ 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"]);
 const TRIAGE_AUTOMATION_KEYS = new Set([
-    "clear",
     "close",
     "create",
+    "label",
     "merge",
     "review",
 ]);
 const TRIAGE_CATEGORY_KEYS = new Set(["description", "id", "labels", "types"]);
+const TRIAGE_LABEL_RULE_KEYS = new Set(["add", "remove", "when"]);
+const TRIAGE_LABEL_RULE_WHEN_KEYS = new Set([
+    "category",
+    "disposition",
+    "signals",
+]);
 const TRIAGE_CONCURRENCY_KEYS = new Set(["runs"]);
 const TRIAGE_SAFETY_KEYS = new Set([
     "allowAuthors",
@@ -112,6 +120,18 @@ const TRIAGE_SAFETY_KEYS = new Set([
     "blockedLabels",
     "requiredLabels",
 ]);
+const TRIAGE_SIGNAL_KEYS = new Set(["description", "id"]);
+const TRIAGE_DISPOSITIONS = new Set([
+    "accepted",
+    "rejected",
+    "invalid",
+    "duplicate",
+    "already_handled",
+    "needs_category",
+    "needs_acceptance",
+    "blocked",
+    "failed",
+]);
 const SAFETY_KEYS = new Set([
     "allowAuthors",
     "blockedPaths",
@@ -552,7 +572,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);
@@ -691,6 +711,79 @@ function validateTriageCategories(categories, path, errors) {
         validateString(category.description, `${itemPath}.description`, errors);
     });
 }
+function validateTriageSignals(signals, path, errors) {
+    if (signals == null)
+        return;
+    if (!Array.isArray(signals)) {
+        errors.push(`${path} must be an array`);
+        return;
+    }
+    const ids = new Set();
+    signals.forEach((item, index) => {
+        const itemPath = `${path}[${index}]`;
+        if (!isPlainObject(item)) {
+            errors.push(`${itemPath} must be an object`);
+            return;
+        }
+        const signal = item;
+        validateKnownKeys(signal, itemPath, TRIAGE_SIGNAL_KEYS, errors);
+        if (!signal.id) {
+            errors.push(`${itemPath}.id is required`);
+        }
+        else if (typeof signal.id !== "string") {
+            errors.push(`${itemPath}.id must be a string`);
+        }
+        else if (!TRIAGE_CATEGORY_ID_PATTERN.test(signal.id)) {
+            errors.push(`${itemPath}.id must match /^[A-Za-z0-9_-]+$/`);
+        }
+        else if (ids.has(signal.id)) {
+            errors.push(`${itemPath}.id must be unique`);
+        }
+        else {
+            ids.add(signal.id);
+        }
+        if (!signal.description) {
+            errors.push(`${itemPath}.description is required`);
+        }
+        else {
+            validateString(signal.description, `${itemPath}.description`, errors);
+        }
+    });
+}
+function validateTriageLabelRules(rules, path, errors) {
+    if (rules == null)
+        return;
+    if (!Array.isArray(rules)) {
+        errors.push(`${path} must be an array`);
+        return;
+    }
+    rules.forEach((item, index) => {
+        const itemPath = `${path}[${index}]`;
+        if (!isPlainObject(item)) {
+            errors.push(`${itemPath} must be an object`);
+            return;
+        }
+        const rule = item;
+        validateKnownKeys(rule, itemPath, TRIAGE_LABEL_RULE_KEYS, errors);
+        validateStringArray(rule.add, `${itemPath}.add`, errors);
+        validateStringArray(rule.remove, `${itemPath}.remove`, errors);
+        if (!isPlainObject(rule.when)) {
+            errors.push(`${itemPath}.when must be an object`);
+            return;
+        }
+        validateKnownKeys(rule.when, `${itemPath}.when`, TRIAGE_LABEL_RULE_WHEN_KEYS, errors);
+        if (!Object.keys(rule.when).length) {
+            errors.push(`${itemPath}.when must not be empty`);
+        }
+        if (rule.when.disposition != null &&
+            (typeof rule.when.disposition !== "string" ||
+                !TRIAGE_DISPOSITIONS.has(rule.when.disposition))) {
+            errors.push(`${itemPath}.when.disposition must be a triage disposition`);
+        }
+        validateString(rule.when.category, `${itemPath}.when.category`, errors);
+        validateStringArray(rule.when.signals, `${itemPath}.when.signals`, errors);
+    });
+}
 function validateSafety(config, errors) {
     const safety = config.review?.safety;
     if (safety != null && !isPlainObject(safety)) {
@@ -764,7 +857,7 @@ function validateTriage(config, errors, options) {
     validateBoolean(automation?.create, "triage.automation.create", errors);
     validateBoolean(automation?.merge, "triage.automation.merge", errors);
     validateBoolean(automation?.review, "triage.automation.review", errors);
-    validateStringArray(automation?.clear, "triage.automation.clear", errors);
+    validateTriageLabelRules(automation?.label, "triage.automation.label", errors);
     if (automation?.review && !automation.create) {
         errors.push("triage.automation.review requires triage.automation.create to be true");
     }
@@ -779,6 +872,7 @@ function validateTriage(config, errors, options) {
         errors.push("triage.concurrency.runs must be a positive integer");
     }
     validateTriageCategories(triage.categories, "triage.categories", errors);
+    validateTriageSignals(triage.signals, "triage.signals", errors);
     validateKnownKeys(safety, "triage.safety", TRIAGE_SAFETY_KEYS, errors);
     validateStringArray(safety?.allowAuthors, "triage.safety.allowAuthors", errors);
     validateStringArray(safety?.allowMentionActors, "triage.safety.allowMentionActors", errors);

package/dist/github/commands.js

@@ -404,6 +404,15 @@ export async function assignIssue(exec, repository, issue, account) {
     const token = await ghToken(exec, repository, account);
     return exec(`gh issue edit ${issue} --repo ${shellQuote(repoSpecifier(repository))} --add-assignee ${shellQuote(account)}`, ghTokenEnv(token));
 }
+export async function addIssueLabels(exec, repository, issue, labels, account) {
+    const token = await ghToken(exec, repository, account);
+    const added = [];
+    for (const label of labels) {
+        await exec(`gh issue edit ${issue} --repo ${shellQuote(repoSpecifier(repository))} --add-label ${shellQuote(label)}`, ghTokenEnv(token));
+        added.push(label);
+    }
+    return added;
+}
 export async function removeIssueLabels(exec, repository, issue, labels, account) {
     const token = await ghToken(exec, repository, account);
     const removed = [];
@@ -685,6 +694,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`,