opencode-magi 0.0.0-dev-20260525165911 → 0.0.0-dev-20260525211234

package/dist/config/resolve.js

@@ -113,9 +113,8 @@ export function resolveAgents(config) {
     const agents = config.agents ?? {};
     const editor = config.merge?.editor;
     const creator = config.triage?.creator;
-    const singleReviewAccount = config.review && config.review.mode !== "multi"
-        ? config.review.account
-        : undefined;
+    const singleReviewAccount = config.review && config.mode !== "multi" ? config.account : undefined;
+    const singleTriageAccount = config.triage && config.mode !== "multi" ? config.account : undefined;
     return {
         editor: editor
             ? {
@@ -134,6 +133,7 @@ export function resolveAgents(config) {
         })),
         triage: (config.triage?.voters ?? []).map((agent, index) => ({
             ...agent,
+            account: singleTriageAccount ?? agent.account ?? "",
             key: triageAgentKey(agent, index),
             index,
             model: normalizedModel(agent.model),
@@ -142,7 +142,7 @@ export function resolveAgents(config) {
         triageCreator: creator
             ? {
                 ...creator,
-                account: creator.account ?? "",
+                account: singleTriageAccount ?? creator.account ?? "",
                 model: normalizedModel(creator.model),
                 permission: resolveTriageCreatorPermission(agents, creator),
             }
@@ -188,6 +188,8 @@ export function resolveRepository(config) {
             repo: config.github.repo,
         },
         language: config.language,
+        account: config.account,
+        mode: config.mode ?? "single",
         merge: {
             approvalPolicy: config.review?.merge?.approvalPolicy ?? "majority",
             method: config.review?.merge?.method ?? "squash",
@@ -208,10 +210,6 @@ export function resolveRepository(config) {
             review: config.review?.prompts?.review,
             reviewGuidelines: config.review?.prompts?.reviewGuidelines,
         },
-        review: {
-            account: config.review?.account,
-            mode: config.review?.mode ?? "single",
-        },
         reviewAutomation: {
             close: config.review?.automation?.close ?? false,
             merge: config.review?.automation?.merge ?? true,

package/dist/config/validate.js

@@ -13,11 +13,13 @@ const TRIAGE_CATEGORY_ID_PATTERN = /^[A-Za-z0-9_-]+$/;
 const RESERVED_TRIAGE_CATEGORY_IDS = new Set(["ASK", "none"]);
 const CONFIG_KEYS = new Set([
     "$schema",
+    "account",
     "agents",
     "clear",
     "github",
     "language",
     "merge",
+    "mode",
     "output",
     "review",
     "triage",
@@ -54,12 +56,10 @@ const TRIAGE_CREATOR_KEYS = new Set([
 const AUTHOR_KEYS = new Set(["email", "name"]);
 const GITHUB_KEYS = new Set(["apiRetryAttempts", "host", "owner", "repo"]);
 const REVIEW_KEYS = new Set([
-    "account",
     "automation",
     "checks",
     "concurrency",
     "merge",
-    "mode",
     "output",
     "prompts",
     "reviewers",
@@ -421,7 +421,7 @@ function validateReviewerList(reviewers, path, errors, catalog, mode = "single")
         }
     });
 }
-function validateTriageAgentList(voters, path, errors, catalog) {
+function validateTriageAgentList(voters, path, errors, catalog, mode = "single") {
     if (voters == null)
         return;
     if (!Array.isArray(voters)) {
@@ -441,8 +441,10 @@ function validateTriageAgentList(voters, path, errors, catalog) {
         if (!agent.model)
             errors.push(`${path}[${index}].model is required`);
         validateAndNormalizeModel(agent, `${path}[${index}].model`, errors, catalog);
-        if (!agent.account)
+        if (mode === "multi" && !agent.account)
             errors.push(`${path}[${index}].account is required`);
+        if (mode === "single" && agent.account)
+            errors.push(`${path}[${index}].account is not supported in single mode`);
         validateString(agent.account, `${path}[${index}].account`, errors);
         validateString(agent.persona, `${path}[${index}].persona`, errors);
         validatePermissionConfig(agent.permissions, `${path}[${index}].permissions`, errors);
@@ -469,26 +471,25 @@ function validateResolvedReviewers(reviewers, path, errors, mode = "single") {
     }
 }
 function reviewMode(config) {
-    return config.review?.mode === "multi" ? "multi" : "single";
+    return config.mode === "multi" ? "multi" : "single";
 }
 function validateReviewIdentity(config, errors) {
-    const mode = config.review?.mode;
+    const mode = config.mode;
     if (mode != null && mode !== "multi" && mode !== "single") {
-        errors.push("review.mode must be multi or single");
+        errors.push("mode must be multi or single");
     }
-    validateString(config.review?.account, "review.account", errors);
-    if ((mode == null || mode === "single") && !config.review?.account) {
-        errors.push("review.account is required when review.mode is single");
+    if ((mode == null || mode === "single") && !config.account) {
+        errors.push("account is required when mode is single");
     }
 }
-function validateResolvedTriageAgents(agents, path, errors) {
+function validateResolvedTriageAgents(agents, path, errors, mode = "single") {
     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))
+        if (mode === "multi" && accounts.has(agent.account))
             errors.push(`${path} has duplicate agent account: ${agent.account}`);
         accounts.add(agent.account);
     }
@@ -532,7 +533,7 @@ function validateEditor(editor, path, errors, catalog) {
         }
     }
 }
-function validateTriageCreator(creator, path, errors, catalog) {
+function validateTriageCreator(creator, path, errors, catalog, mode = "single") {
     if (!creator)
         return;
     if (!isPlainObject(creator)) {
@@ -542,6 +543,8 @@ function validateTriageCreator(creator, path, errors, catalog) {
     validateKnownKeys(creator, path, TRIAGE_CREATOR_KEYS, errors);
     if (!creator.model)
         errors.push(`${path}.model is required`);
+    if (mode === "single" && creator.account)
+        errors.push(`${path}.account is not supported in single mode`);
     validateString(creator.account, `${path}.account`, errors);
     validateAndNormalizeModel(creator, `${path}.model`, errors, catalog);
     validateString(creator.persona, `${path}.persona`, errors);
@@ -830,6 +833,7 @@ function validatePromptObject(prompts, path, keys, errors) {
 }
 function validateTriage(config, errors, options) {
     const triage = config.triage;
+    const mode = reviewMode(config);
     if (!triage)
         return;
     if (!isPlainObject(triage)) {
@@ -844,7 +848,7 @@ function validateTriage(config, errors, options) {
     const safety = triage.safety;
     if (!triage.voters)
         errors.push("triage.voters is required");
-    validateTriageAgentList(triage.voters, "triage.voters", errors, options.modelCatalog);
+    validateTriageAgentList(triage.voters, "triage.voters", errors, options.modelCatalog, mode);
     if (Array.isArray(triage.voters)) {
         const resolvedTriageAgents = triage.voters.map((agent, index) => ({
             account: agent && typeof agent === "object" && typeof agent.account === "string"
@@ -852,17 +856,21 @@ function validateTriage(config, errors, options) {
                 : "",
             key: agent && typeof agent === "object" ? triageAgentKey(agent, index) : "",
         }));
-        validateResolvedTriageAgents(resolvedTriageAgents, "triage.resolvedAgents", errors);
-        if (reporter != null &&
+        validateResolvedTriageAgents(resolvedTriageAgents, "triage.resolvedAgents", errors, mode);
+        if (mode === "multi" &&
+            reporter != null &&
             !resolvedTriageAgents.some((agent) => agent.key === reporter)) {
             errors.push(`triage.reporter must match a triage voter key: ${reporter}`);
         }
     }
+    if (mode === "single" && reporter != null) {
+        errors.push("triage.reporter is not supported in single mode");
+    }
     validateString(triage.reporter, "triage.reporter", errors);
-    validateTriageCreator(creator, "triage.creator", errors, options.modelCatalog);
+    validateTriageCreator(creator, "triage.creator", errors, options.modelCatalog, mode);
     if (automation?.create && !creator)
         errors.push("triage.creator is required when triage.automation.create is true");
-    if (automation?.create && creator && !creator.account)
+    if (mode === "multi" && 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");
@@ -924,8 +932,8 @@ async function validateAuth(config, exec, errors) {
     const accounts = new Set();
     const agents = resolveAgents(config);
     if (reviewMode(config) === "single") {
-        if (config.review?.account)
-            accounts.add(config.review.account);
+        if (config.account)
+            accounts.add(config.account);
     }
     else {
         for (const reviewer of agents.reviewers)
@@ -978,8 +986,8 @@ async function validateRepositoryPermissions(config, exec, errors, warnings) {
         return;
     const agents = resolveAgents(config);
     const reviewAccounts = reviewMode(config) === "single"
-        ? config.review?.account
-            ? [config.review.account]
+        ? config.account
+            ? [config.account]
             : []
         : agents.reviewers.map((reviewer) => reviewer.account);
     await Promise.all(reviewAccounts.map(async (account) => {
@@ -1040,7 +1048,10 @@ export async function validateConfig(config, options = {}) {
         validateJsonSchema(config, errors);
     validateKnownKeys(config, "config", CONFIG_KEYS, errors);
     validateString(config.$schema, "$schema", errors);
+    validateString(config.account, "account", errors);
     validateString(config.language, "language", errors);
+    if (config.review || config.triage)
+        validateReviewIdentity(config, errors);
     if (config.agents != null && !isPlainObject(config.agents)) {
         errors.push("agents must be an object");
     }
@@ -1059,7 +1070,6 @@ export async function validateConfig(config, options = {}) {
         else {
             validateKnownKeys(config.review, "review", REVIEW_KEYS, errors);
         }
-        validateReviewIdentity(config, errors);
         if (!config.review.reviewers)
             errors.push("review.reviewers is required");
         validateReviewerList(config.review.reviewers, "review.reviewers", errors, options.modelCatalog, mode);

package/dist/orchestrator/merge.js

@@ -213,7 +213,7 @@ async function runRereview(input, worktreePath, previousHeadSha, cycle, sessionI
         worktreePath,
     });
     const artifactDir = outputDir(input);
-    const singleReviewMode = input.repository.review?.mode !== "multi";
+    const singleReviewMode = input.repository.mode !== "multi";
     const reviewerKeys = input.repository.agents.reviewers.map((reviewer) => reviewer.key);
     const singleModeThreads = singleReviewMode
         ? assignThreadsByReviewFindingMarker({
@@ -221,7 +221,7 @@ async function runRereview(input, worktreePath, previousHeadSha, cycle, sessionI
             pr: input.pr,
             reviewerKeys,
             threads: options.dryRunThreads == null
-                ? await fetchUnresolvedThreads(input.exec, input.repository, input.pr, input.repository.review?.account ?? "")
+                ? await fetchUnresolvedThreads(input.exec, input.repository, input.pr, input.repository.account ?? "")
                 : Object.values(options.dryRunThreads).flat(),
         })
         : undefined;
@@ -412,7 +412,7 @@ async function runRereview(input, worktreePath, previousHeadSha, cycle, sessionI
             ? { consensus: `dry-run:would-post-single-review:${verdict}` }
             : {
                 consensus: await (async () => {
-                    const account = input.repository.review?.account ?? "";
+                    const account = input.repository.account ?? "";
                     await Promise.all(entries.flatMap((entry) => entry.output.resolve.map((item) => resolveThread(input.exec, input.repository, account, item.threadId))));
                     await Promise.all(entries.flatMap((entry) => entry.output.followUps.map((item) => postReply(input.exec, input.repository, input.pr, account, item.commentId, [
                         `**Reviewer:** ${entry.reviewer}`,

package/dist/orchestrator/review.js

@@ -16,12 +16,14 @@ import { formatReviewReport } from "./report";
 import { buildReviewContextSnapshot, renderReviewContext, } from "./review-context";
 import { checkSafetyGate, hasSafetyGate } from "./safety";
 function resolvedReviewMode(repository) {
-    return repository.review?.mode === "multi" ? "multi" : "single";
+    return repository.mode === "multi" ? "multi" : "single";
 }
 export function reviewPostingAccount(repository, reviewer) {
-    return resolvedReviewMode(repository) === "single"
-        ? (repository.review?.account ?? reviewer.account)
-        : reviewer.account;
+    if (resolvedReviewMode(repository) !== "single")
+        return reviewer.account;
+    if (repository.account)
+        return repository.account;
+    throw new Error("account is required for single review mode");
 }
 function reviewAssignmentKey(repository, reviewer) {
     return resolvedReviewMode(repository) === "single"
@@ -579,9 +581,9 @@ function singleFindingBody(input) {
     ].join("\n");
 }
 export async function postSingleConsensusReview(input) {
-    const account = input.repository.review?.account;
+    const account = input.repository.account;
     if (!account)
-        throw new Error("review.account is required for single review mode");
+        throw new Error("account is required for single review mode");
     const body = singleReviewBody(input);
     if (input.verdict === "MERGE") {
         return postApproval(input.exec, input.repository, input.pr, account, body);
@@ -927,7 +929,7 @@ export async function runReview(input) {
     const reviewerAccounts = input.repository.agents.reviewers.map((reviewer) => reviewer.account);
     const preliminaryMode = singleReviewMode
         ? resolveSingleAccountReviewMode({
-            account: input.repository.review?.account ?? "",
+            account: input.repository.account ?? "",
             current: freshnessTarget,
             pr: input.pr,
             reviewerKeys,
@@ -942,7 +944,7 @@ export async function runReview(input) {
         return (preliminaryMode.assignments.get(reviewAssignmentKey(input.repository, reviewer))?.type === "skip");
     });
     if (singleReviewMode) {
-        const account = input.repository.review?.account ?? "";
+        const account = input.repository.account ?? "";
         const threads = await fetchUnresolvedThreads(exec, input.repository, input.pr, account);
         const assigned = assignThreadsByReviewFindingMarker({
             fallbackReviewerKeys: reviewerKeys,
@@ -973,7 +975,7 @@ export async function runReview(input) {
     const mode = singleReviewMode
         ? pendingThreadReplyReviewers.size
             ? resolveSingleAccountReviewMode({
-                account: input.repository.review?.account ?? "",
+                account: input.repository.account ?? "",
                 current: freshnessTarget,
                 pendingReviewers: pendingThreadReplyReviewers,
                 pr: input.pr,
@@ -1368,7 +1370,7 @@ export async function runReview(input) {
                         consensus: input.dryRun
                             ? `dry-run:would-post-single-review:${verdict}`
                             : await (async () => {
-                                const account = input.repository.review?.account ?? "";
+                                const account = input.repository.account ?? "";
                                 await Promise.all(Object.values(activeOutputs).flatMap((output) => {
                                     if (!("resolve" in output))
                                         return [];
@@ -1414,7 +1416,7 @@ export async function runReview(input) {
                 ]))),
             };
         const automationAccount = singleReviewMode
-            ? input.repository.review?.account
+            ? input.repository.account
             : input.repository.agents.reviewers[0]?.account;
         const enableReviewAutomation = input.enableReviewAutomation ?? true;
         if (enableReviewAutomation &&

package/package.json

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

package/schema.json

@@ -5,6 +5,7 @@
   "additionalProperties": false,
   "properties": {
     "$schema": { "type": "string" },
+    "account": { "type": "string", "minLength": 1 },
     "agents": {
       "type": "object",
       "additionalProperties": false,
@@ -44,6 +45,7 @@
     },
     "language": { "type": "string" },
     "merge": { "$ref": "#/$defs/merge" },
+    "mode": { "enum": ["multi", "single"], "default": "single" },
     "output": {
       "type": "object",
       "additionalProperties": false,
@@ -113,7 +115,7 @@
     "triageAgent": {
       "type": "object",
       "if": { "not": { "required": ["ref"] } },
-      "then": { "required": ["model", "account"] },
+      "then": { "required": ["model"] },
       "additionalProperties": false,
       "properties": {
         "ref": { "type": "string", "minLength": 1 },
@@ -366,8 +368,6 @@
       "type": "object",
       "additionalProperties": false,
       "properties": {
-        "mode": { "enum": ["multi", "single"], "default": "single" },
-        "account": { "type": "string", "minLength": 1 },
         "reviewers": {
           "type": "array",
           "minItems": 3,