opencode-magi 0.0.0-dev-20260522033138 → 0.0.0-dev-20260522071924

package/dist/config/resolve.js

@@ -104,7 +104,7 @@ export function resolveAgents(config) {
         triageCreator: creator
             ? {
                 ...creator,
-                account: creator.account ?? config.triage?.account ?? "",
+                account: creator.account ?? "",
                 permission: resolveTriageCreatorPermission(agents, creator),
             }
             : undefined,
@@ -179,7 +179,6 @@ export function resolveRepository(config) {
             requiredLabels: config.review?.safety?.requiredLabels ?? [],
         },
         triage: {
-            account: config.triage?.account,
             automation: {
                 clear: config.triage?.automation?.clear ?? ["triage"],
                 close: config.triage?.automation?.close ?? false,
@@ -193,6 +192,7 @@ export function resolveRepository(config) {
             },
             output: config.triage?.output,
             prompts: config.triage?.prompts ?? {},
+            reporter: config.triage?.reporter,
             safety: {
                 allowAuthors: config.triage?.safety?.allowAuthors ?? [],
                 allowMentionActors: config.triage?.safety?.allowMentionActors ?? [],

package/dist/config/validate.js

@@ -40,6 +40,7 @@ const EDITOR_KEYS = new Set([
     "persona",
 ]);
 const TRIAGE_AGENT_KEYS = new Set([
+    "account",
     "id",
     "model",
     "options",
@@ -75,7 +76,6 @@ const MERGE_KEYS = new Set([
     "prompts",
 ]);
 const TRIAGE_KEYS = new Set([
-    "account",
     "agents",
     "automation",
     "categories",
@@ -83,6 +83,7 @@ const TRIAGE_KEYS = new Set([
     "creator",
     "output",
     "prompts",
+    "reporter",
     "safety",
     "worktree",
 ]);
@@ -357,6 +358,9 @@ function validateTriageAgentList(agents, path, errors, catalog) {
             errors.push(`${path}[${index}].model is required`);
         validateString(agent.model, `${path}[${index}].model`, errors);
         validateModel(agent.model, `${path}[${index}].model`, errors, catalog);
+        if (!agent.account)
+            errors.push(`${path}[${index}].account is required`);
+        validateString(agent.account, `${path}[${index}].account`, errors);
         validateString(agent.persona, `${path}[${index}].persona`, errors);
         if (agent.options != null && !isPlainObject(agent.options))
             errors.push(`${path}[${index}].options must be an object`);
@@ -383,12 +387,16 @@ function validateResolvedReviewers(reviewers, path, errors) {
         accounts.add(reviewer.account);
     }
 }
-function validateResolvedAgentKeys(agents, path, errors) {
+function validateResolvedTriageAgents(agents, path, errors) {
     const keys = new Set();
+    const accounts = new Set();
     for (const agent of agents) {
         if (keys.has(agent.key))
             errors.push(`${path} has duplicate agent key: ${agent.key}`);
         keys.add(agent.key);
+        if (accounts.has(agent.account))
+            errors.push(`${path} has duplicate agent account: ${agent.account}`);
+        accounts.add(agent.account);
     }
 }
 function validateEditor(editor, path, errors, catalog) {
@@ -672,19 +680,26 @@ function validateTriage(config, errors, options) {
     validateKnownKeys(triage, "triage", TRIAGE_KEYS, errors);
     const automation = triage.automation;
     const concurrency = triage.concurrency;
+    const creator = triage.creator;
+    const reporter = typeof triage.reporter === "string" ? triage.reporter : undefined;
     const safety = triage.safety;
-    if (!triage.account)
-        errors.push("triage.account is required");
-    validateString(triage.account, "triage.account", errors);
     if (!triage.agents)
         errors.push("triage.agents is required");
     validateTriageAgentList(triage.agents, "triage.agents", errors, options.modelCatalog);
     if (Array.isArray(triage.agents)) {
-        validateResolvedAgentKeys(resolveAgents(config).triage ?? [], "triage.resolvedAgents", errors);
+        const resolvedTriageAgents = resolveAgents(config).triage ?? [];
+        validateResolvedTriageAgents(resolvedTriageAgents, "triage.resolvedAgents", errors);
+        if (reporter != null &&
+            !resolvedTriageAgents.some((agent) => agent.key === reporter)) {
+            errors.push(`triage.reporter must match a triage agent key: ${reporter}`);
+        }
     }
-    validateTriageCreator(triage.creator, "triage.creator", errors, options.modelCatalog);
-    if (automation?.create && !triage.creator)
+    validateString(triage.reporter, "triage.reporter", errors);
+    validateTriageCreator(creator, "triage.creator", errors, options.modelCatalog);
+    if (automation?.create && !creator)
         errors.push("triage.creator is required when triage.automation.create is true");
+    if (automation?.create && creator && !creator.account)
+        errors.push("triage.creator.account is required when triage.automation.create is true");
     if (automation != null && !isPlainObject(automation)) {
         errors.push("triage.automation must be an object");
     }
@@ -745,10 +760,10 @@ async function validateAuth(config, exec, errors) {
     const agents = resolveAgents(config);
     for (const reviewer of agents.reviewers)
         accounts.add(reviewer.account);
+    for (const agent of agents.triage ?? [])
+        accounts.add(agent.account);
     if (agents.editor)
         accounts.add(agents.editor.account);
-    if (config.triage?.account)
-        accounts.add(config.triage.account);
     if (agents.triageCreator?.account)
         accounts.add(agents.triageCreator.account);
     await Promise.all([...accounts].filter(Boolean).map(async (account) => {
@@ -802,19 +817,18 @@ async function validateRepositoryPermissions(config, exec, errors, warnings) {
             warnings.push(`Could not validate repository permissions for GitHub account: ${reviewer.account} (${error.message})`);
         }
     }));
-    if (config.triage?.account) {
+    await Promise.all((agents.triage ?? []).map(async (agent) => {
         try {
-            const permissions = await fetchPermissions(config, exec, config.triage.account);
+            const permissions = await fetchPermissions(config, exec, agent.account);
             if (!permissions.pull) {
-                errors.push(`GitHub account cannot read repository for issue triage: ${config.triage.account}`);
+                errors.push(`GitHub account cannot read repository for issue triage: ${agent.account}`);
             }
         }
         catch (error) {
-            warnings.push(`Could not validate repository permissions for GitHub account: ${config.triage.account} (${error.message})`);
+            warnings.push(`Could not validate repository permissions for GitHub account: ${agent.account} (${error.message})`);
         }
-    }
-    if (agents.triageCreator?.account &&
-        agents.triageCreator.account !== config.triage?.account) {
+    }));
+    if (agents.triageCreator?.account) {
         try {
             const permissions = await fetchPermissions(config, exec, agents.triageCreator.account);
             if (!permissions.push) {

package/dist/orchestrator/triage.js

@@ -3,10 +3,10 @@ import { dirname, join } from "node:path";
 import { issueRunOutputDir } from "../config/output";
 import { worktreeBaseDir } 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 { composeTriageAcceptancePrompt, composeTriageActionPrompt, composeTriageCategoryPrompt, composeTriageCommentClassificationPrompt, composeTriageCreatePrPrompt, composeTriageDuplicatePrompt, composeTriageExistingPrPrompt, composeTriageReconsiderPrompt, } from "../prompts/compose";
 import { parseTriageActionOutput, 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"];
@@ -181,6 +181,7 @@ async function runVote(input) {
         ...result.value,
         promptText: prompt,
         raw: result.raw,
+        reviewer: input.agent.key,
         sessionId: result.sessionId,
     };
 }
@@ -189,6 +190,7 @@ async function writeVoteArtifacts(input) {
     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,
     });
@@ -282,7 +284,7 @@ async function runPhaseVote(input) {
         reviewer: 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 +292,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,
@@ -523,54 +528,41 @@ 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.reviewer === input.reporter.key &&
+        output.vote === input.vote &&
+        output.reason)?.reason ??
+        input.outputs?.find((output) => output.vote === input.vote)?.reason ??
+        input.outputs?.find((output) => output.reviewer === input.reporter.key)
+            ?.reason);
 }
 async function postMarkedIssueComment(input) {
     const posted = await postIssueComment(input.exec, input.repository, input.issue, input.account, input.body);
@@ -578,9 +570,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 +607,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.reviewer);
+        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)
@@ -622,22 +668,43 @@ async function finishWithResult(input) {
         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 +719,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({
@@ -679,7 +746,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,13 +801,10 @@ 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}`);
         await mkdir(dirname(worktreePath), { recursive: true });
@@ -824,8 +888,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 +929,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);
@@ -909,7 +976,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 +1001,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 +1042,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 +1057,21 @@ 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,
                 });
-                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,
@@ -1047,6 +1093,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 +1103,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 +1114,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 +1131,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 +1141,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,

package/dist/prompts/contracts.js

@@ -217,8 +217,13 @@ Return exactly one JSON object and nothing else. Do not wrap it in markdown.
 The object must match this shape:
 {
   "vote": ${votes},
-  "reason": "Short rationale."
+  "reason": "Short rationale.",
+  "body": "Required only when vote is ASK. Public issue comment body asking for the missing information."
 }
+
+Rules:
+- body is required when vote is ASK and must be written for the issue author.
+- Omit body when vote is not ASK.
 </output_contract>`.trim();
 }
 export const triageDuplicateOutputContract = `

package/dist/prompts/output.js

@@ -92,9 +92,14 @@ function parseTriageVote(text, votes) {
     const data = extractJson(text);
     if (!data || typeof data !== "object")
         throw new Error("triage vote output must be an object");
+    const vote = requireOneOf(data.vote, "vote", votes);
+    const body = data.body == null ? undefined : requireString(data.body, "body");
+    if (vote === "ASK" && !body?.trim())
+        throw new Error("ASK requires body");
     return {
+        body,
         reason: requireString(data.reason, "reason"),
-        vote: requireOneOf(data.vote, "vote", votes),
+        vote,
     };
 }
 export function parseTriageExistingPrOutput(text) {

package/package.json

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

package/schema.json

@@ -116,12 +116,13 @@
     "triageAgent": {
       "type": "object",
       "if": { "not": { "required": ["ref"] } },
-      "then": { "required": ["model"] },
+      "then": { "required": ["model", "account"] },
       "additionalProperties": false,
       "properties": {
         "ref": { "type": "string", "minLength": 1 },
         "id": { "type": "string", "pattern": "^[A-Za-z0-9_-]+$" },
         "model": { "type": "string", "minLength": 1 },
+        "account": { "type": "string", "minLength": 1 },
         "options": { "type": "object", "additionalProperties": true },
         "permissions": { "$ref": "#/$defs/permissions" },
         "persona": { "type": "string" }
@@ -334,7 +335,6 @@
       "type": "object",
       "additionalProperties": false,
       "properties": {
-        "account": { "type": "string", "minLength": 1 },
         "agents": {
           "type": "array",
           "minItems": 3,
@@ -349,6 +349,7 @@
         "safety": { "$ref": "#/$defs/triageSafety" },
         "concurrency": { "$ref": "#/$defs/triageConcurrency" },
         "prompts": { "$ref": "#/$defs/triagePrompts" },
+        "reporter": { "type": "string", "minLength": 1 },
         "output": { "type": "string" },
         "worktree": { "type": "string" }
       }