opencode-magi 0.4.0 → 0.6.0

package/dist/orchestrator/triage.js

@@ -1,12 +1,12 @@
 import { mkdir, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { issueRunOutputDir } from "../config/output";
-import { worktreeBaseDir } from "../config/worktree";
+import { issueRunWorktreeDir } from "../config/worktree";
 import { assignIssue, closeIssue, closePullRequest, configureGitIdentity, createPullRequest, fetchIssue, fetchIssueComments, fetchRelatedPullRequests, postIssueComment, pushHead, removeIssueLabels, removeWorktree, searchDuplicateIssues, shellQuote, updateIssueComment, } from "../github/commands";
-import { composeTriageAcceptancePrompt, composeTriageActionPrompt, composeTriageCategoryPrompt, composeTriageCommentClassificationPrompt, composeTriageCommentPrompt, composeTriageCreatePrPrompt, composeTriageDuplicatePrompt, composeTriageExistingPrPrompt, composeTriageQuestionPrompt, composeTriageReconsiderPrompt, } from "../prompts/compose";
-import { parseTriageActionOutput, parseTriageBinaryOutput, parseTriageCategoryOutput, parseTriageCommentClassificationOutput, parseTriageCreatePrOutput, parseTriageDuplicateOutput, parseTriageExistingPrOutput, } from "../prompts/output";
+import { composeTriageAcceptancePrompt, composeTriageCategoryPrompt, composeTriageCommentClassificationPrompt, composeTriageCreatePrPrompt, composeTriageDuplicatePrompt, composeTriageExistingPrPrompt, composeTriageReconsiderPrompt, } from "../prompts/compose";
+import { parseTriageBinaryOutput, parseTriageCategoryOutput, parseTriageCommentClassificationOutput, parseTriageCreatePrOutput, parseTriageDuplicateOutput, parseTriageExistingPrOutput, } from "../prompts/output";
 import { aggregateStringMajority, majorityThreshold } from "./majority";
-import { runModelText, runModelWithRepair, } from "./model";
+import { runModelWithRepair, } from "./model";
 const MARKER_PREFIX = "opencode-magi:triage";
 const BINARY_VOTES = ["ASK", "NO", "YES"];
 const DUPLICATE_VOTES = ["DUPLICATE", "NOT_DUPLICATE"];
@@ -106,24 +106,24 @@ async function emitTriageModelProgress(input) {
         await emitProgress(input.run, {
             options: input.progress.options,
             phase: input.phase,
-            reviewer: input.reviewer,
             sessionId: input.progress.sessionId,
             type: "triage_agent_session",
+            voter: input.voter,
         });
     }
     if (input.progress.type === "repair") {
         await emitProgress(input.run, {
             phase: input.phase,
-            reviewer: input.reviewer,
             type: "triage_agent_repair",
+            voter: input.voter,
         });
     }
     if (input.progress.type === "response") {
         await emitProgress(input.run, {
             phase: input.phase,
-            reviewer: input.reviewer,
             sessionId: input.progress.sessionId,
             type: "triage_agent_response",
+            voter: input.voter,
         });
     }
 }
@@ -133,12 +133,12 @@ async function runVote(input) {
         directory: input.directory,
         issue: input.issue,
         repository: input.repository,
-        reviewer: input.agent,
+        voter: input.agent,
     });
     await emitProgress(input.run, {
         phase: input.phase,
-        reviewer: input.agent.key,
         type: "triage_agent_started",
+        voter: input.agent.key,
     });
     let result;
     try {
@@ -148,10 +148,11 @@ async function runVote(input) {
             onProgress: (progress) => emitTriageModelProgress({
                 phase: input.phase,
                 progress,
-                reviewer: input.agent.key,
                 run: input.run,
+                voter: input.agent.key,
             }),
             options: input.agent.options,
+            parentSessionId: input.run.parentSessionId,
             parse: input.parse,
             permission: input.agent.permission,
             prompt,
@@ -165,16 +166,16 @@ async function runVote(input) {
         await emitProgress(input.run, {
             error: error instanceof Error ? error.message : String(error),
             phase: input.phase,
-            reviewer: input.agent.key,
             type: "triage_agent_failed",
+            voter: input.agent.key,
         });
         throw error;
     }
     await emitProgress(input.run, {
         phase: input.phase,
-        reviewer: input.agent.key,
         sessionId: result.sessionId,
         type: "triage_agent_completed",
+        voter: input.agent.key,
         vote: result.value.vote,
     });
     return {
@@ -182,13 +183,15 @@ async function runVote(input) {
         promptText: prompt,
         raw: result.raw,
         sessionId: result.sessionId,
+        voter: input.agent.key,
     };
 }
 async function writeVoteArtifacts(input) {
-    const base = join(input.outputDir, `${input.reviewer}.${input.phase}`);
+    const base = join(input.outputDir, `${input.voter}.${input.phase}`);
     await writeFile(`${base}.prompt.txt`, `${input.output.promptText}\n`);
     await writeFile(`${base}.raw.txt`, `${input.output.raw}\n`);
     await writeJson(`${base}.json`, {
+        body: input.output.body,
         reason: input.output.reason,
         vote: input.output.vote,
     });
@@ -230,14 +233,14 @@ async function runDuplicateVote(input) {
         signal: input.input.signal,
     })));
     const majority = aggregateStringMajority(outputs.map((output, index) => ({
-        reviewer: agents[index].key,
+        voter: agents[index].key,
         vote: output.vote,
     })), DUPLICATE_VOTES);
     await Promise.all(outputs.map((output, index) => writeVoteArtifacts({
         output,
         outputDir: input.outputDir,
         phase: "duplicate",
-        reviewer: agents[index].key,
+        voter: agents[index].key,
     })));
     await Promise.all(outputs.map((output, index) => writeJson(join(input.outputDir, `${agents[index].key}.duplicate.json`), {
         duplicateOf: output.duplicateOf,
@@ -272,17 +275,17 @@ async function runPhaseVote(input) {
         signal: input.input.signal,
     })));
     const majority = aggregateStringMajority(outputs.map((output, index) => ({
-        reviewer: agents[index].key,
+        voter: agents[index].key,
         vote: output.vote,
     })), input.votes);
     await Promise.all(outputs.map((output, index) => writeVoteArtifacts({
         output,
         outputDir: input.outputDir,
         phase: input.phase,
-        reviewer: agents[index].key,
+        voter: agents[index].key,
     })));
     await writeJson(join(input.outputDir, `${input.phase}-majority.json`), majority);
-    return majority.vote;
+    return { outputs, vote: majority.vote };
 }
 async function relationshipScan(input, issue) {
     const [comments, relatedPullRequests, duplicateCandidates] = await Promise.all([
@@ -290,17 +293,20 @@ async function relationshipScan(input, issue) {
         fetchRelatedPullRequests(input.exec, input.repository, input.issue),
         searchDuplicateIssues(input.exec, input.repository, issue),
     ]);
+    const triageAccounts = new Set((input.repository.agents.triage ?? []).map((agent) => agent.account));
     const markers = comments
-        .filter((comment) => comment.author === input.repository.triage?.account)
+        .filter((comment) => triageAccounts.has(comment.author))
         .map((comment) => {
         const parsed = parseTriageMarker(comment.body);
-        return parsed ? { ...parsed, commentId: comment.id } : undefined;
+        return parsed
+            ? { ...parsed, account: comment.author, commentId: comment.id }
+            : undefined;
     })
         .filter(Boolean);
     const previousMarker = markers.at(-1);
     const mentionReplies = previousMarker
         ? eligibleMentionReplies({
-            account: input.repository.triage?.account ?? "",
+            account: previousMarker.account ?? "",
             comments,
             marker: previousMarker,
             processed: previousMarker.processed,
@@ -450,63 +456,38 @@ function previousAutomationPlan(input) {
         postComment: false,
     };
 }
-async function runActionPrompt(input) {
-    const agent = input.input.repository.agents.triage?.[0];
-    if (!agent)
-        throw new Error("triage.agents is required");
-    const context = JSON.stringify({
-        allowedActions: input.plan.allowedActions,
-        deterministicPlan: input.plan,
-        result: input.result,
-        triageContext: input.context,
-    }, null, 2);
-    const prompt = await composeTriageActionPrompt({
-        context,
-        directory: input.input.directory,
-        issue: input.input.issue,
-        repository: input.input.repository,
-        reviewer: agent,
-    });
-    const result = await runModelWithRepair({
-        client: input.input.client,
-        model: agent.model,
-        options: agent.options,
-        parse: parseTriageActionOutput,
-        permission: agent.permission,
-        prompt,
-        repairAttempts: 3,
-        schemaName: "triage action",
-        signal: input.input.signal,
-        title: `Magi triage action #${input.input.issue}`,
-    });
-    await writeJson(join(input.outputDir, "action.json"), {
-        model: result.value,
-        plan: input.plan,
-    });
-    return result.value;
-}
 async function classifyMentionReplies(input) {
-    const agent = input.input.repository.agents.triage?.[0];
-    if (!agent)
-        throw new Error("triage.agents is required");
+    const agent = triageReporter(input.input.repository, input.input.issue);
     const prompt = await composeTriageCommentClassificationPrompt({
         context: JSON.stringify({ context: input.context, mentionReplies: input.replies }, null, 2),
         directory: input.input.directory,
         issue: input.input.issue,
         repository: input.input.repository,
-        reviewer: agent,
+        voter: agent,
     });
     const result = await runModelWithRepair({
         client: input.input.client,
         model: agent.model,
+        onProgress: async (progress) => {
+            if (progress.type !== "session_created")
+                return;
+            await emitProgress(input.input, {
+                agent: agent.key,
+                key: `triage:comment-classification:${agent.key}:${progress.sessionId}`,
+                options: progress.options,
+                sessionId: progress.sessionId,
+                type: "triage_session",
+            });
+        },
         options: agent.options,
+        parentSessionId: input.input.parentSessionId,
         parse: parseTriageCommentClassificationOutput,
         permission: agent.permission,
         prompt,
         repairAttempts: 3,
         schemaName: "triage comment classification",
         signal: input.input.signal,
-        title: `Magi triage comment classification #${input.input.issue}`,
+        title: `Magi triage comment classification #${input.input.issue} (${agent.key})`,
     });
     await writeJson(join(input.outputDir, "comment-classification.json"), result.value);
     return result.value;
@@ -523,54 +504,40 @@ async function runReconsiderationVote(input) {
         votes: BINARY_VOTES,
     });
 }
-async function composeResultComment(input) {
-    const agents = input.input.repository.agents.triage;
-    if (!agents?.length)
+function triageReporter(repository, issue) {
+    const agents = repository.agents.triage ?? [];
+    if (!agents.length)
         throw new Error("triage.agents is required");
-    if (input.result.disposition === "ask" &&
-        input.result.askReason === "category_unclear") {
-        const language = input.input.repository.language?.toLowerCase() ?? "";
-        const body = language.includes("ja") || language.includes("japanese")
-            ? `@${input.issue.author} 現在の説明だけでは、何をすべきか判断できません。\n\n期待する動作、実際の動作、必要な理由、関連する例・ログ・スクリーンショットなどを追記してください。`
-            : `@${input.issue.author} I can't determine what should be done from the current description.\n\nPlease add more detail, such as the expected behavior, the actual behavior, the reason this is needed, or any relevant examples, logs, or screenshots.`;
-        const comment = `${body}\n\n${marker({
-            action: input.action,
-            checkpoint: "pending",
-            decision: input.result,
-            issue: input.issue.number,
-            processed: input.processed,
-        })}`;
-        await writeFile(join(input.outputDir, "comment.md"), `${comment}\n`);
-        return comment;
-    }
-    const prompt = await (input.result.disposition === "ask"
-        ? composeTriageQuestionPrompt
-        : composeTriageCommentPrompt)({
-        author: input.issue.author,
-        context: input.context,
-        directory: input.input.directory,
-        issue: input.issue.number,
-        repository: input.input.repository,
-    });
-    const comment = (await runModelText({
-        allowEmpty: false,
-        client: input.input.client,
-        model: agents[0].model,
-        options: agents[0].options,
-        permission: agents[0].permission,
-        prompt,
-        signal: input.input.signal,
-        title: `Magi triage comment #${input.issue.number}`,
-    })).raw +
-        `\n\n${marker({
-            action: input.action,
-            checkpoint: "pending",
-            decision: input.result,
-            issue: input.issue.number,
-            processed: input.processed,
-        })}`;
-    await writeFile(join(input.outputDir, "comment.md"), `${comment}\n`);
-    return comment;
+    const configured = repository.triage?.reporter;
+    const reporter = configured
+        ? agents.find((agent) => agent.key === configured)
+        : agents[Math.abs(issue) % agents.length];
+    if (!reporter)
+        throw new Error(`Unknown triage reporter: ${configured}`);
+    return reporter;
+}
+function decisionCommentBody(input) {
+    const reason = input.reason?.trim();
+    const result = JSON.stringify(input.result);
+    return reason
+        ? `Magi triage decision: ${result}\n\nReason: ${reason}`
+        : `Magi triage decision: ${result}\n\nAction: ${input.action}`;
+}
+function agentForKey(repository, key) {
+    const agent = repository.agents.triage?.find((item) => item.key === key);
+    if (!agent)
+        throw new Error(`Unknown triage agent: ${key}`);
+    return agent;
+}
+function askOutputs(outputs) {
+    return (outputs ?? []).filter((output) => output.vote === "ASK");
+}
+function chooseDecisionReason(input) {
+    return (input.outputs?.find((output) => output.voter === input.reporter.key &&
+        output.vote === input.vote &&
+        output.reason)?.reason ??
+        input.outputs?.find((output) => output.vote === input.vote)?.reason ??
+        input.outputs?.find((output) => output.voter === input.reporter.key)?.reason);
 }
 async function postMarkedIssueComment(input) {
     const posted = await postIssueComment(input.exec, input.repository, input.issue, input.account, input.body);
@@ -578,9 +545,20 @@ async function postMarkedIssueComment(input) {
     const updated = body === input.body
         ? posted
         : await updateIssueComment(input.exec, input.repository, posted.id, input.account, body);
-    await writeJson(join(input.outputDir, "posted.json"), updated);
+    await writeJson(join(input.outputDir, `posted-${updated.id}.json`), {
+        account: input.account,
+        ...updated,
+    });
     return updated;
 }
+async function postPlainIssueComment(input) {
+    const posted = await postIssueComment(input.exec, input.repository, input.issue, input.account, input.body);
+    await writeJson(join(input.outputDir, `posted-${posted.id}.json`), {
+        account: input.account,
+        ...posted,
+    });
+    return posted;
+}
 async function persistProcessedMarker(input) {
     if (!input.marker.commentId)
         return;
@@ -604,6 +582,49 @@ async function persistProcessedMarker(input) {
         updated,
     });
 }
+async function postAskComments(input) {
+    const urls = [];
+    for (const output of askOutputs(input.outputs)) {
+        const agent = agentForKey(input.repository, output.voter);
+        const body = input.mark
+            ? `${output.body}\n\n${marker({
+                action: input.action,
+                checkpoint: "pending",
+                decision: input.result,
+                issue: input.issue.number,
+                processed: input.processed,
+            })}`
+            : output.body;
+        if (!body?.trim())
+            continue;
+        await writeFile(join(input.outputDir, `${agent.key}.ask-comment.md`), `${body}\n`);
+        if (input.dryRun) {
+            urls.push(`dry-run:would-comment:${agent.key}`);
+            continue;
+        }
+        await emitProgress(input.run, { type: "comment_posting" });
+        const posted = input.mark
+            ? await postMarkedIssueComment({
+                account: agent.account,
+                body,
+                exec: input.exec,
+                issue: input.issue.number,
+                outputDir: input.outputDir,
+                repository: input.repository,
+            })
+            : await postPlainIssueComment({
+                account: agent.account,
+                body,
+                exec: input.exec,
+                issue: input.issue.number,
+                outputDir: input.outputDir,
+                repository: input.repository,
+            });
+        urls.push(posted.url);
+        await emitProgress(input.run, { type: "comment_posted", url: posted.url });
+    }
+    return urls;
+}
 async function finishWithResult(input) {
     const triage = input.input.repository.triage;
     if (!triage)
@@ -614,30 +635,44 @@ async function finishWithResult(input) {
         result: input.result,
         type: "decision",
     });
-    await runActionPrompt({
-        context: input.context,
-        input: input.input,
-        outputDir: input.outputDir,
-        plan,
-        result: input.result,
-    });
     let prUrl;
-    const comment = plan.postComment
-        ? await composeResultComment({
+    const reporter = triageReporter(input.input.repository, input.issue.number);
+    const comment = plan.postComment && input.result.disposition !== "ask"
+        ? `${decisionCommentBody({
+            action: plan.action,
+            reason: input.commentReason,
+            result: input.result,
+        })}\n\n${marker({
             action: plan.action,
-            context: `Result: ${decisionText(input.result)}\nAction: ${plan.action}\n\n${input.context}`,
-            input: input.input,
+            checkpoint: "pending",
+            decision: input.result,
+            issue: input.issue.number,
+            processed: input.processed,
+        })}`
+        : undefined;
+    if (comment) {
+        await writeFile(join(input.outputDir, "comment.md"), `${comment}\n`);
+    }
+    if (input.result.disposition === "ask" && input.askOutputs) {
+        await postAskComments({
+            action: plan.action,
+            dryRun: input.input.dryRun,
+            exec: input.input.exec,
             issue: input.issue,
+            mark: input.markAskComments ?? false,
+            outputs: input.askOutputs,
             outputDir: input.outputDir,
             processed: input.processed,
+            repository: input.input.repository,
             result: input.result,
-        })
-        : undefined;
+            run: input.input,
+        });
+    }
     if (!input.input.dryRun) {
         if (comment) {
             await emitProgress(input.input, { type: "comment_posting" });
             const posted = await postMarkedIssueComment({
-                account: triage.account ?? "",
+                account: reporter.account,
                 body: comment,
                 exec: input.input.exec,
                 issue: input.issue.number,
@@ -652,18 +687,18 @@ async function finishWithResult(input) {
         if (plan.clearLabels) {
             const clearLabels = existingClearLabels(input.issue, triage.automation.clear);
             if (clearLabels.length) {
-                await removeIssueLabels(input.input.exec, input.input.repository, input.issue.number, clearLabels, triage.account ?? "");
+                await removeIssueLabels(input.input.exec, input.input.repository, input.issue.number, clearLabels, reporter.account);
             }
         }
         if (plan.closeIssue) {
             const closedPrs = [];
             for (const pr of input.relationship.relatedPullRequests.filter((pr) => pr.state === "OPEN")) {
-                await closePullRequest(input.input.exec, input.input.repository, pr.number, triage.account ?? "");
+                await closePullRequest(input.input.exec, input.input.repository, pr.number, reporter.account);
                 closedPrs.push(pr.number);
             }
             if (closedPrs.length)
                 await writeJson(join(input.outputDir, "closed-prs.json"), closedPrs);
-            await closeIssue(input.input.exec, input.input.repository, input.issue.number, triage.account ?? "");
+            await closeIssue(input.input.exec, input.input.repository, input.issue.number, reporter.account);
         }
         if (plan.createPr) {
             prUrl = await createImplementationPr({
@@ -671,6 +706,7 @@ async function finishWithResult(input) {
                 input: input.input,
                 issue: input.issue,
                 outputDir: input.outputDir,
+                runId: input.runId,
             });
             if (prUrl) {
                 await writeJson(join(input.outputDir, "pr.json"), { url: prUrl });
@@ -679,7 +715,7 @@ async function finishWithResult(input) {
         }
         if (input.previousMarker && prUrl) {
             await persistProcessedMarker({
-                account: triage.account ?? "",
+                account: input.previousMarker.account ?? reporter.account,
                 comments: input.relationship.comments,
                 exec: input.input.exec,
                 issue: input.issue,
@@ -734,15 +770,17 @@ async function createImplementationPr(input) {
     const creator = input.input.repository.agents.triageCreator;
     if (!creator)
         return undefined;
-    const triage = input.input.repository.triage;
-    if (!triage?.account)
-        throw new Error("triage.account is required");
     await emitProgress(input.input, { type: "pr_creation_started" });
     await emitProgress(input.input, { type: "triage_creator_started" });
     try {
-        await assignIssue(input.input.exec, input.input.repository, input.issue.number, triage.account);
+        await assignIssue(input.input.exec, input.input.repository, input.issue.number, creator.account);
         const branch = `magi/issue-${input.issue.number}-${Date.now().toString(36)}`;
-        const worktreePath = join(worktreeBaseDir(input.input.directory, input.input.config, "issue"), `issue-${input.issue.number}`);
+        const worktreePath = issueRunWorktreeDir({
+            config: input.input.config,
+            directory: input.input.directory,
+            issue: input.issue.number,
+            runId: input.runId,
+        });
         await mkdir(dirname(worktreePath), { recursive: true });
         await input.input.exec(`git worktree add -b ${shellQuote(branch)} ${shellQuote(worktreePath)}`);
         await emitProgress(input.input, {
@@ -781,6 +819,7 @@ async function createImplementationPr(input) {
                     }
                 },
                 options: creator.options,
+                parentSessionId: input.input.parentSessionId,
                 parse: parseTriageCreatePrOutput,
                 permission: creator.permission,
                 prompt,
@@ -824,8 +863,8 @@ async function createImplementationPr(input) {
 }
 export async function runTriage(input) {
     const triage = input.repository.triage;
-    if (!triage?.account)
-        throw new Error("triage.account is required");
+    if (!triage)
+        throw new Error("triage configuration is required");
     const agents = input.repository.agents.triage;
     if (!agents?.length)
         throw new Error("triage.agents is required");
@@ -865,6 +904,9 @@ export async function runTriage(input) {
     await emitProgress(input, { phase: "triaging", type: "phase" });
     let processed = relationship.previousMarker?.processed ?? [];
     let result;
+    let askCommentOutputs;
+    let commentReason;
+    let markAskComments = false;
     if (relationship.previousMarker) {
         if (!relationship.mentionReplies.length) {
             const result = finalResultFromMarker(relationship.previousMarker);
@@ -886,6 +928,7 @@ export async function runTriage(input) {
                     processed,
                     relationship,
                     result,
+                    runId,
                 });
             }
             const report = `Magi triage skipped #${issue.number} because no eligible mention replies were found for reconsideration.`;
@@ -909,7 +952,7 @@ export async function runTriage(input) {
         if (!triggeringComments.length) {
             if (!input.dryRun) {
                 await persistProcessedMarker({
-                    account: triage.account,
+                    account: relationship.previousMarker.account ?? "",
                     comments: relationship.comments,
                     exec: input.exec,
                     issue,
@@ -934,21 +977,38 @@ export async function runTriage(input) {
             },
         });
         await writeFile(join(outputDir, "context.md"), `${context}\n`);
-        const vote = await runReconsiderationVote({ context, input, outputDir });
         const previous = finalResultFromMarker(relationship.previousMarker);
-        result =
-            vote === "YES"
-                ? { category: previous.category, disposition: "accepted" }
-                : vote === "NO"
-                    ? { category: previous.category, disposition: "rejected" }
-                    : {
-                        askReason: "acceptance_unclear",
-                        category: previous.category,
-                        disposition: "ask",
-                    };
+        if (previous.disposition !== "ask" ||
+            previous.askReason !== "acceptance_unclear") {
+            const reconsideration = await runReconsiderationVote({
+                context,
+                input,
+                outputDir,
+            });
+            const reporter = triageReporter(input.repository, issue.number);
+            commentReason = chooseDecisionReason({
+                outputs: reconsideration.outputs,
+                reporter,
+                vote: reconsideration.vote ?? "ASK",
+            });
+            result =
+                reconsideration.vote === "YES"
+                    ? { category: previous.category, disposition: "accepted" }
+                    : reconsideration.vote === "NO"
+                        ? { category: previous.category, disposition: "rejected" }
+                        : {
+                            askReason: "acceptance_unclear",
+                            category: previous.category,
+                            disposition: "ask",
+                        };
+            if (result.disposition === "ask") {
+                askCommentOutputs = askOutputs(reconsideration.outputs);
+                markAskComments = true;
+            }
+        }
     }
     if (!result && relationship.relatedPullRequests.length) {
-        const vote = await runPhaseVote({
+        const existingPr = await runPhaseVote({
             context,
             input,
             outputDir,
@@ -958,7 +1018,7 @@ export async function runTriage(input) {
             schemaName: "triage existing PR",
             votes: EXISTING_PR_VOTES,
         });
-        if (vote === "RELATED_PR_HANDLES_ISSUE") {
+        if (existingPr.vote === "RELATED_PR_HANDLES_ISSUE") {
             const merged = relationship.relatedPullRequests.some((pr) => pr.state === "MERGED");
             if (merged && triage.automation.close) {
                 const relatedPrDecision = {
@@ -973,59 +1033,22 @@ export async function runTriage(input) {
                     createPr: false,
                     postComment: true,
                 };
-                await emitProgress(input, {
-                    action: plan.action,
-                    result: relatedPrDecision,
-                    type: "decision",
-                });
-                await runActionPrompt({
+                return finishWithResult({
+                    commentReason: chooseDecisionReason({
+                        outputs: existingPr.outputs,
+                        reporter: triageReporter(input.repository, issue.number),
+                        vote: "RELATED_PR_HANDLES_ISSUE",
+                    }),
                     context,
                     input,
-                    outputDir,
-                    plan,
-                    result: relatedPrDecision,
-                });
-                const body = await composeResultComment({
-                    action: "CLOSE",
-                    context: `Result: ${decisionText(relatedPrDecision)}\nAction: CLOSE\n\n${context}`,
-                    input,
                     issue,
                     outputDir,
+                    plan,
                     processed,
+                    relationship,
                     result: relatedPrDecision,
+                    runId,
                 });
-                if (!input.dryRun) {
-                    await emitProgress(input, { type: "comment_posting" });
-                    const posted = await postMarkedIssueComment({
-                        account: triage.account,
-                        body,
-                        exec: input.exec,
-                        issue: issue.number,
-                        outputDir,
-                        repository: input.repository,
-                    });
-                    await emitProgress(input, { type: "comment_posted", url: posted.url });
-                    const clearLabels = existingClearLabels(issue, triage.automation.clear);
-                    if (clearLabels.length) {
-                        await removeIssueLabels(input.exec, input.repository, issue.number, clearLabels, triage.account);
-                    }
-                    const closedPrs = [];
-                    for (const pr of relationship.relatedPullRequests.filter((pr) => pr.state === "OPEN")) {
-                        await closePullRequest(input.exec, input.repository, pr.number, triage.account);
-                        closedPrs.push(pr.number);
-                    }
-                    if (closedPrs.length)
-                        await writeJson(join(outputDir, "closed-prs.json"), closedPrs);
-                    await closeIssue(input.exec, input.repository, issue.number, triage.account);
-                }
-                const report = `Magi triage closed #${issue.number} because a related PR was merged.`;
-                await writeFile(join(outputDir, "report.md"), `${report}\n`);
-                return {
-                    issue: issue.number,
-                    outputDir,
-                    report,
-                    result: relatedPrDecision,
-                };
             }
             return finishWithResult({
                 context,
@@ -1035,6 +1058,7 @@ export async function runTriage(input) {
                 processed,
                 relationship,
                 result: { category: null, disposition: "clear_only" },
+                runId,
             });
         }
     }
@@ -1047,6 +1071,7 @@ export async function runTriage(input) {
         });
         if (duplicate) {
             context = `${context}\n\nDuplicate decision: ${JSON.stringify(duplicate)}`;
+            commentReason = duplicate.reason;
             result = { category: null, disposition: "duplicate" };
         }
     }
@@ -1056,8 +1081,9 @@ export async function runTriage(input) {
             category: resolvedCategory,
             source: resolvedCategory ? "config" : "vote",
         });
-        const category = resolvedCategory ??
-            (await runPhaseVote({
+        const categoryVote = resolvedCategory
+            ? undefined
+            : await runPhaseVote({
                 context,
                 input,
                 outputDir,
@@ -1066,14 +1092,16 @@ export async function runTriage(input) {
                 prompt: composeTriageCategoryPrompt,
                 schemaName: "triage category",
                 votes: ["ASK", ...triage.categories.map((item) => item.id)],
-            })) ??
-            "ASK";
+            });
+        const category = resolvedCategory ?? categoryVote?.vote ?? "ASK";
         if (category === "ASK") {
             result = {
                 askReason: "category_unclear",
                 category: null,
                 disposition: "ask",
             };
+            askCommentOutputs = askOutputs(categoryVote?.outputs);
+            markAskComments = false;
         }
         else {
             const categoryConfig = triage.categories.find((item) => item.id === category);
@@ -1081,7 +1109,7 @@ export async function runTriage(input) {
                 category: categoryConfig,
                 triageContext: context,
             }, null, 2);
-            const vote = await runPhaseVote({
+            const acceptance = await runPhaseVote({
                 context: voteContext,
                 input,
                 outputDir,
@@ -1091,22 +1119,35 @@ export async function runTriage(input) {
                 schemaName: "triage acceptance",
                 votes: BINARY_VOTES,
             });
+            const reporter = triageReporter(input.repository, issue.number);
+            commentReason = chooseDecisionReason({
+                outputs: acceptance.outputs,
+                reporter,
+                vote: acceptance.vote ?? "ASK",
+            });
             result =
-                vote === "YES"
+                acceptance.vote === "YES"
                     ? { category, disposition: "accepted" }
-                    : vote === "NO"
+                    : acceptance.vote === "NO"
                         ? { category, disposition: "rejected" }
                         : {
                             askReason: "acceptance_unclear",
                             category,
                             disposition: "ask",
                         };
+            if (result.disposition === "ask") {
+                askCommentOutputs = askOutputs(acceptance.outputs);
+                markAskComments = true;
+            }
         }
     }
     return finishWithResult({
+        askOutputs: askCommentOutputs,
+        commentReason,
         context,
         input,
         issue,
+        markAskComments,
         outputDir,
         processed,
         relationship,
@@ -1115,5 +1156,6 @@ export async function runTriage(input) {
             category: null,
             disposition: "ask",
         },
+        runId,
     });
 }