opencode-magi 0.0.0-dev-20260519013159 → 0.0.0-dev-20260519070815

package/README.md

@@ -61,8 +61,8 @@ Add the following content to the configuration file.
 ```json
 {
   "$schema": "https://raw.githubusercontent.com/magi-ai/opencode-magi/main/schema.json",
-  "agents": {
-    "reviewers": [
+  "review": {
+    "agents": [
       {
         "account": "your-account-1",
         "model": "openai/gpt-5.5"
@@ -80,7 +80,7 @@ Add the following content to the configuration file.
 }
 ```
 
-`agents.reviewers[].account` is the GitHub account used to post reviews and approvals. Must be authenticated with `gh auth token --user <account>` and must be unique.
+`review.agents[].account` is the GitHub account used to post reviews and approvals. Must be authenticated with `gh auth token --user <account>` and must be unique.
 
 #### Set project config
 
@@ -101,8 +101,8 @@ Add the following content to the configuration file.
     "owner": "your-owner",
     "repo": "your-repo"
   },
-  "agents": {
-    "reviewers": [
+  "review": {
+    "agents": [
       {
         "account": "your-account-1",
         "model": "openai/gpt-5.5"
@@ -115,7 +115,9 @@ Add the following content to the configuration file.
         "account": "your-account-3",
         "model": "opencode/kimi-k2-6"
       }
-    ],
+    ]
+  },
+  "merge": {
     "editor": {
       "account": "your-editor-account",
       "model": "openai/gpt-5.5",
@@ -128,7 +130,7 @@ Add the following content to the configuration file.
 }
 ```
 
-`agents.reviewers[].account` is the GitHub account used to post reviews and approvals. Must be authenticated with `gh auth token --user <account>` and must be unique.
+`review.agents[].account` is the GitHub account used to post reviews and approvals. Must be authenticated with `gh auth token --user <account>` and must be unique. `merge.editor.account` is used by `/magi:merge` to push fixes, close PRs, and merge PRs.
 
 #### Validate config
 

package/dist/config/output.js

@@ -6,7 +6,7 @@ function resolvePath(directory, path) {
     return isAbsolute(path) ? path : join(directory, path);
 }
 export function outputBaseDir(directory, config, kind) {
-    return resolvePath(directory, config.output?.dirs?.[kind] ?? DEFAULT_OUTPUT_DIRS[kind]);
+    return resolvePath(directory, config.review?.output ?? DEFAULT_OUTPUT_DIRS[kind]);
 }
 export function outputBaseDirs(directory, config) {
     return [outputBaseDir(directory, config, "pr")];

package/dist/config/resolve.js

@@ -44,20 +44,22 @@ export function mergePermissions(base, override) {
     return merged;
 }
 export function resolveReviewerPermission(agents, reviewer) {
-    return mergePermissions(mergePermissions(DEFAULT_REVIEWER_PERMISSION, agents.permissions), reviewer.permission);
+    return mergePermissions(mergePermissions(DEFAULT_REVIEWER_PERMISSION, agents.permissions), reviewer.permissions);
 }
 export function resolveEditorPermission(agents, editor) {
-    return mergePermissions(mergePermissions(DEFAULT_EDITOR_PERMISSION, agents.permissions), editor.permission);
+    return mergePermissions(mergePermissions(DEFAULT_EDITOR_PERMISSION, agents.permissions), editor.permissions);
 }
-export function resolveAgents(agents) {
+export function resolveAgents(config) {
+    const agents = config.agents ?? {};
+    const editor = config.merge?.editor;
     return {
-        editor: agents.editor
+        editor: editor
             ? {
-                ...agents.editor,
-                permission: resolveEditorPermission(agents, agents.editor),
+                ...editor,
+                permission: resolveEditorPermission(agents, editor),
             }
             : undefined,
-        reviewers: (agents.reviewers ?? []).map((reviewer, index) => ({
+        reviewers: (config.review?.agents ?? []).map((reviewer, index) => ({
             ...reviewer,
             key: reviewerKey(reviewer, index),
             index,
@@ -72,20 +74,21 @@ export function resolveRepository(config) {
         throw new Error("github.repo is required");
     return {
         alias: config.github.repo,
-        agents: resolveAgents(config.agents),
+        agents: resolveAgents(config),
         automation: {
-            close: config.automation?.close ?? true,
-            merge: config.automation?.merge ?? true,
+            close: config.merge?.automation?.close ?? false,
+            merge: config.merge?.automation?.merge ?? true,
         },
         checks: {
-            exclude: config.checks?.exclude ?? [],
-            waitAfterEdit: config.checks?.waitAfterEdit ?? true,
-            waitBeforeReview: config.checks?.waitBeforeReview ?? true,
-            retryFailedJobs: config.checks?.retryFailedJobs ?? 3,
+            exclude: config.review?.checks?.exclude ?? [],
+            retryFailedJobs: config.review?.checks?.retryFailedJobs ?? 3,
+            wait: config.review?.checks?.wait ?? true,
+            waitAfterEdit: config.merge?.checks?.wait ?? true,
+            waitBeforeReview: config.review?.checks?.wait ?? true,
         },
         concurrency: {
-            runs: config.concurrency?.runs ?? 3,
-            reviewers: config.concurrency?.reviewers ?? 3,
+            runs: config.review?.concurrency?.runs ?? 3,
+            reviewers: config.review?.concurrency?.reviewers ?? 3,
         },
         github: {
             apiRetryAttempts: config.github.apiRetryAttempts ?? 3,
@@ -95,19 +98,35 @@ export function resolveRepository(config) {
         },
         language: config.language,
         merge: {
-            approvalPolicy: config.merge?.approvalPolicy ?? "majority",
-            method: config.merge?.method ?? "squash",
-            auto: config.merge?.auto ?? true,
-            deleteBranch: config.merge?.deleteBranch ?? true,
-            mergeQueue: config.merge?.mergeQueue ?? false,
+            approvalPolicy: config.review?.merge?.approvalPolicy ?? "majority",
+            method: config.review?.merge?.method ?? "squash",
+            auto: config.review?.merge?.auto ?? true,
+            deleteBranch: config.review?.merge?.deleteBranch ?? true,
+            queue: config.review?.merge?.queue ?? false,
+            mergeQueue: config.review?.merge?.queue ?? false,
             maxThreadResolutionCycles: config.merge?.maxThreadResolutionCycles ?? 5,
         },
-        prompts: config.prompts ?? {},
+        prompts: {
+            ciClassification: config.review?.prompts?.ciClassification,
+            ciClassificationAfterEdit: config.merge?.prompts?.ciClassification,
+            closeReconsideration: config.review?.prompts?.closeReconsideration,
+            edit: config.merge?.prompts?.edit,
+            editGuidelines: config.merge?.prompts?.editGuidelines,
+            findingValidation: config.review?.prompts?.findingValidation,
+            rereview: config.review?.prompts?.rereview,
+            rereviewCloseReconsideration: config.review?.prompts?.closeReconsideration,
+            review: config.review?.prompts?.review,
+            reviewGuidelines: config.review?.prompts?.reviewGuidelines,
+        },
+        reviewAutomation: {
+            close: config.review?.automation?.close ?? false,
+            merge: config.review?.automation?.merge ?? false,
+        },
         safety: {
-            allowAuthors: config.safety?.allowAuthors ?? [],
-            blockedPaths: config.safety?.blockedPaths ?? [],
-            maxChangedFiles: config.safety?.maxChangedFiles,
-            requiredLabels: config.safety?.requiredLabels ?? [],
+            allowAuthors: config.review?.safety?.allowAuthors ?? [],
+            blockedPaths: config.review?.safety?.blockedPaths ?? [],
+            maxChangedFiles: config.review?.safety?.maxChangedFiles,
+            requiredLabels: config.review?.safety?.requiredLabels ?? [],
         },
     };
 }

package/dist/config/validate.js

@@ -12,25 +12,20 @@ const validateSchema = AJV.compile(schema);
 const CONFIG_KEYS = new Set([
     "$schema",
     "agents",
-    "automation",
     "clear",
-    "checks",
-    "concurrency",
     "github",
     "language",
     "merge",
     "output",
-    "prompts",
-    "safety",
-    "worktree",
+    "review",
 ]);
-const AGENTS_KEYS = new Set(["editor", "permissions", "reviewers"]);
+const AGENTS_KEYS = new Set(["permissions"]);
 const REVIEWER_KEYS = new Set([
     "account",
     "id",
     "model",
     "options",
-    "permission",
+    "permissions",
     "persona",
 ]);
 const EDITOR_KEYS = new Set([
@@ -38,51 +33,61 @@ const EDITOR_KEYS = new Set([
     "author",
     "model",
     "options",
-    "permission",
+    "permissions",
     "persona",
 ]);
 const AUTHOR_KEYS = new Set(["email", "name"]);
 const GITHUB_KEYS = new Set(["apiRetryAttempts", "host", "owner", "repo"]);
+const REVIEW_KEYS = new Set([
+    "agents",
+    "automation",
+    "checks",
+    "concurrency",
+    "merge",
+    "output",
+    "prompts",
+    "safety",
+    "worktree",
+]);
 const MERGE_KEYS = new Set([
+    "automation",
+    "checks",
+    "editor",
+    "maxThreadResolutionCycles",
+    "prompts",
+]);
+const REVIEW_MERGE_KEYS = new Set([
     "approvalPolicy",
     "auto",
     "deleteBranch",
-    "maxThreadResolutionCycles",
-    "mergeQueue",
     "method",
+    "queue",
 ]);
-const CHECKS_KEYS = new Set([
-    "exclude",
-    "retryFailedJobs",
-    "waitAfterEdit",
-    "waitBeforeReview",
-]);
+const REVIEW_CHECKS_KEYS = new Set(["exclude", "retryFailedJobs", "wait"]);
+const MERGE_CHECKS_KEYS = new Set(["wait"]);
 const AUTOMATION_KEYS = new Set(["close", "merge"]);
 const CLEAR_KEYS = new Set(["branch", "output", "session", "worktree"]);
 const CONCURRENCY_KEYS = new Set(["reviewers", "runs"]);
-const OUTPUT_KEYS = new Set(["dirs", "repairAttempts"]);
-const OUTPUT_DIR_KEYS = new Set(["pr"]);
-const WORKTREE_KEYS = new Set(["dirs"]);
-const WORKTREE_DIR_KEYS = new Set(["pr"]);
+const OUTPUT_KEYS = new Set(["repairAttempts"]);
 const SAFETY_KEYS = new Set([
     "allowAuthors",
     "blockedPaths",
     "maxChangedFiles",
     "requiredLabels",
 ]);
-const PROMPT_KEYS = new Set([
+const REVIEW_PROMPT_KEYS = new Set([
     "ciClassification",
-    "ciClassificationAfterEdit",
     "closeReconsideration",
-    "edit",
-    "editGuidelines",
     "findingValidation",
-    "report",
     "rereview",
-    "rereviewCloseReconsideration",
     "review",
     "reviewGuidelines",
 ]);
+const MERGE_PROMPT_KEYS = new Set([
+    "ciClassification",
+    "edit",
+    "editGuidelines",
+]);
 function githubHost(config) {
     return config.github?.host ?? "github.com";
 }
@@ -211,7 +216,7 @@ function validateReviewerList(reviewers, path, errors, catalog) {
         validateString(reviewer.persona, `${path}[${index}].persona`, errors);
         if (reviewer.options != null && !isPlainObject(reviewer.options))
             errors.push(`${path}[${index}].options must be an object`);
-        validatePermissionConfig(reviewer.permission, `${path}[${index}].permission`, errors);
+        validatePermissionConfig(reviewer.permissions, `${path}[${index}].permissions`, errors);
         if (reviewer.id) {
             if (!validateReviewerId(reviewer.id)) {
                 errors.push(`${path}[${index}].id may contain only letters, numbers, underscores, and hyphens`);
@@ -234,7 +239,51 @@ function validateResolvedReviewers(reviewers, path, errors) {
         accounts.add(reviewer.account);
     }
 }
+function validateEditor(editor, path, errors, catalog) {
+    if (!editor)
+        return;
+    if (!isPlainObject(editor)) {
+        errors.push(`${path} must be an object`);
+        return;
+    }
+    if (!editor.model)
+        errors.push(`${path}.model is required`);
+    validateKnownKeys(editor, path, EDITOR_KEYS, errors);
+    validateString(editor.model, `${path}.model`, errors);
+    validateString(editor.account, `${path}.account`, errors);
+    validateString(editor.persona, `${path}.persona`, errors);
+    validateModel(editor.model, `${path}.model`, errors, catalog);
+    if (!editor.account)
+        errors.push(`${path}.account is required`);
+    if (editor.options != null && !isPlainObject(editor.options)) {
+        errors.push(`${path}.options must be an object`);
+    }
+    validatePermissionConfig(editor.permissions, `${path}.permissions`, errors);
+    const author = editor.author;
+    if (!author || !isPlainObject(author)) {
+        if (author != null)
+            errors.push(`${path}.author must be an object`);
+        errors.push(`${path}.author.name is required`);
+        errors.push(`${path}.author.email is required`);
+    }
+    else {
+        validateKnownKeys(author, `${path}.author`, AUTHOR_KEYS, errors);
+        if (!author.name) {
+            errors.push(`${path}.author.name is required`);
+        }
+        else if (typeof author.name !== "string") {
+            errors.push(`${path}.author.name must be a string`);
+        }
+        if (!author.email) {
+            errors.push(`${path}.author.email is required`);
+        }
+        else if (typeof author.email !== "string") {
+            errors.push(`${path}.author.email must be a string`);
+        }
+    }
+}
 function validateMerge(config, errors, options) {
+    const merge = config.merge;
     if (options.requireGithub ?? true) {
         if (!config.github?.owner)
             errors.push("github.owner is required");
@@ -248,102 +297,102 @@ function validateMerge(config, errors, options) {
     if (config.github != null && !isPlainObject(config.github)) {
         errors.push("github must be an object");
     }
-    if (config.merge != null && !isPlainObject(config.merge)) {
-        errors.push("merge must be an object");
-    }
-    validateKnownKeys(config.merge, "merge", MERGE_KEYS, errors);
-    validateBoolean(config.merge?.auto, "merge.auto", errors);
-    validateBoolean(config.merge?.deleteBranch, "merge.deleteBranch", errors);
-    validateBoolean(config.merge?.mergeQueue, "merge.mergeQueue", errors);
     if (config.github?.apiRetryAttempts != null &&
         (typeof config.github.apiRetryAttempts !== "number" ||
             !Number.isInteger(config.github.apiRetryAttempts) ||
             config.github.apiRetryAttempts < 0)) {
         errors.push("github.apiRetryAttempts must be a non-negative integer");
     }
-    if (config.merge?.method != null &&
-        (typeof config.merge.method !== "string" ||
-            !["merge", "rebase", "squash"].includes(config.merge.method))) {
-        errors.push("merge.method must be merge, squash, or rebase");
-    }
-    if (config.merge?.approvalPolicy != null &&
-        (typeof config.merge.approvalPolicy !== "string" ||
-            !["majority", "unanimous"].includes(config.merge.approvalPolicy))) {
-        errors.push("merge.approvalPolicy must be majority or unanimous");
+    if (merge != null && !isPlainObject(merge)) {
+        errors.push("merge must be an object");
     }
-    if (config.merge?.maxThreadResolutionCycles != null &&
-        (typeof config.merge.maxThreadResolutionCycles !== "number" ||
-            !Number.isInteger(config.merge.maxThreadResolutionCycles) ||
-            config.merge.maxThreadResolutionCycles < 0)) {
+    validateKnownKeys(merge, "merge", MERGE_KEYS, errors);
+    validateBooleanObject(merge?.automation, "merge.automation", AUTOMATION_KEYS, errors);
+    const checks = merge?.checks;
+    validateKnownKeys(checks, "merge.checks", MERGE_CHECKS_KEYS, errors);
+    validateBoolean(checks?.wait, "merge.checks.wait", errors);
+    validateEditor(merge?.editor, "merge.editor", errors, options.modelCatalog);
+    if (merge?.maxThreadResolutionCycles != null &&
+        (typeof merge.maxThreadResolutionCycles !== "number" ||
+            !Number.isInteger(merge.maxThreadResolutionCycles) ||
+            merge.maxThreadResolutionCycles < 0)) {
         errors.push("merge.maxThreadResolutionCycles must be a non-negative integer");
     }
+    if (options.requireEditor && !merge?.editor)
+        errors.push("merge.editor is required");
+}
+function validateReviewMerge(config, errors) {
+    const merge = config.review?.merge;
+    if (merge != null && !isPlainObject(merge)) {
+        errors.push("review.merge must be an object");
+    }
+    validateKnownKeys(merge, "review.merge", REVIEW_MERGE_KEYS, errors);
+    validateBoolean(merge?.auto, "review.merge.auto", errors);
+    validateBoolean(merge?.deleteBranch, "review.merge.deleteBranch", errors);
+    validateBoolean(merge?.queue, "review.merge.queue", errors);
+    if (merge?.method != null &&
+        (typeof merge.method !== "string" ||
+            !["merge", "rebase", "squash"].includes(merge.method))) {
+        errors.push("review.merge.method must be merge, squash, or rebase");
+    }
+    if (merge?.approvalPolicy != null &&
+        (typeof merge.approvalPolicy !== "string" ||
+            !["majority", "unanimous"].includes(merge.approvalPolicy))) {
+        errors.push("review.merge.approvalPolicy must be majority or unanimous");
+    }
 }
 function validateConcurrency(config, errors) {
-    if (config.concurrency != null && !isPlainObject(config.concurrency)) {
-        errors.push("concurrency must be an object");
-    }
-    validateKnownKeys(config.concurrency, "concurrency", CONCURRENCY_KEYS, errors);
-    if (config.concurrency?.runs != null) {
-        if (typeof config.concurrency.runs !== "number" ||
-            !Number.isInteger(config.concurrency.runs) ||
-            config.concurrency.runs < 1) {
-            errors.push("concurrency.runs must be a positive integer");
+    const concurrency = config.review?.concurrency;
+    if (concurrency != null && !isPlainObject(concurrency)) {
+        errors.push("review.concurrency must be an object");
+    }
+    validateKnownKeys(concurrency, "review.concurrency", CONCURRENCY_KEYS, errors);
+    if (concurrency?.runs != null) {
+        if (typeof concurrency.runs !== "number" ||
+            !Number.isInteger(concurrency.runs) ||
+            concurrency.runs < 1) {
+            errors.push("review.concurrency.runs must be a positive integer");
         }
     }
-    if (config.concurrency?.reviewers != null) {
-        if (typeof config.concurrency.reviewers !== "number" ||
-            !Number.isInteger(config.concurrency.reviewers) ||
-            config.concurrency.reviewers < 1) {
-            errors.push("concurrency.reviewers must be a positive integer");
+    if (concurrency?.reviewers != null) {
+        if (typeof concurrency.reviewers !== "number" ||
+            !Number.isInteger(concurrency.reviewers) ||
+            concurrency.reviewers < 1) {
+            errors.push("review.concurrency.reviewers must be a positive integer");
         }
     }
 }
 function validateAutomation(config, errors) {
-    if (config.automation != null && !isPlainObject(config.automation)) {
-        errors.push("automation must be an object");
-    }
-    validateKnownKeys(config.automation, "automation", AUTOMATION_KEYS, errors);
-    if (config.automation?.merge != null &&
-        typeof config.automation.merge !== "boolean") {
-        errors.push("automation.merge must be a boolean");
-    }
-    if (config.automation?.close != null &&
-        typeof config.automation.close !== "boolean") {
-        errors.push("automation.close must be a boolean");
-    }
+    validateBooleanObject(config.review?.automation, "review.automation", AUTOMATION_KEYS, errors);
 }
 function validateClear(config, errors) {
     validateBooleanObject(config.clear, "clear", CLEAR_KEYS, errors);
 }
 function validateChecks(config, errors) {
-    if (config.checks != null && !isPlainObject(config.checks)) {
-        errors.push("checks must be an object");
-    }
-    validateKnownKeys(config.checks, "checks", CHECKS_KEYS, errors);
-    if (config.checks?.exclude != null) {
-        if (!Array.isArray(config.checks.exclude)) {
-            errors.push("checks.exclude must be an array");
+    const checks = config.review?.checks;
+    if (checks != null && !isPlainObject(checks)) {
+        errors.push("review.checks must be an object");
+    }
+    validateKnownKeys(checks, "review.checks", REVIEW_CHECKS_KEYS, errors);
+    if (checks?.exclude != null) {
+        if (!Array.isArray(checks.exclude)) {
+            errors.push("review.checks.exclude must be an array");
         }
         else {
-            config.checks.exclude.forEach((item, index) => {
+            checks.exclude.forEach((item, index) => {
                 if (typeof item !== "string")
-                    errors.push(`checks.exclude[${index}] must be a string`);
+                    errors.push(`review.checks.exclude[${index}] must be a string`);
             });
         }
     }
-    if (config.checks?.waitBeforeReview != null &&
-        typeof config.checks.waitBeforeReview !== "boolean") {
-        errors.push("checks.waitBeforeReview must be a boolean");
+    if (checks?.wait != null && typeof checks.wait !== "boolean") {
+        errors.push("review.checks.wait must be a boolean");
     }
-    if (config.checks?.waitAfterEdit != null &&
-        typeof config.checks.waitAfterEdit !== "boolean") {
-        errors.push("checks.waitAfterEdit must be a boolean");
-    }
-    if (config.checks?.retryFailedJobs != null &&
-        (typeof config.checks.retryFailedJobs !== "number" ||
-            !Number.isInteger(config.checks.retryFailedJobs) ||
-            config.checks.retryFailedJobs < 0)) {
-        errors.push("checks.retryFailedJobs must be a non-negative integer");
+    if (checks?.retryFailedJobs != null &&
+        (typeof checks.retryFailedJobs !== "number" ||
+            !Number.isInteger(checks.retryFailedJobs) ||
+            checks.retryFailedJobs < 0)) {
+        errors.push("review.checks.retryFailedJobs must be a non-negative integer");
     }
 }
 function validateStringArray(value, path, errors) {
@@ -359,33 +408,44 @@ function validateStringArray(value, path, errors) {
     });
 }
 function validateSafety(config, errors) {
-    if (config.safety != null && !isPlainObject(config.safety)) {
-        errors.push("safety must be an object");
-    }
-    validateKnownKeys(config.safety, "safety", SAFETY_KEYS, errors);
-    validateStringArray(config.safety?.allowAuthors, "safety.allowAuthors", errors);
-    validateStringArray(config.safety?.blockedPaths, "safety.blockedPaths", errors);
-    validateStringArray(config.safety?.requiredLabels, "safety.requiredLabels", errors);
-    if (config.safety?.maxChangedFiles != null &&
-        (typeof config.safety.maxChangedFiles !== "number" ||
-            !Number.isInteger(config.safety.maxChangedFiles) ||
-            config.safety.maxChangedFiles < 0)) {
-        errors.push("safety.maxChangedFiles must be a non-negative integer");
+    const safety = config.review?.safety;
+    if (safety != null && !isPlainObject(safety)) {
+        errors.push("review.safety must be an object");
+    }
+    validateKnownKeys(safety, "review.safety", SAFETY_KEYS, errors);
+    validateStringArray(safety?.allowAuthors, "review.safety.allowAuthors", errors);
+    validateStringArray(safety?.blockedPaths, "review.safety.blockedPaths", errors);
+    validateStringArray(safety?.requiredLabels, "review.safety.requiredLabels", errors);
+    if (safety?.maxChangedFiles != null &&
+        (typeof safety.maxChangedFiles !== "number" ||
+            !Number.isInteger(safety.maxChangedFiles) ||
+            safety.maxChangedFiles < 0)) {
+        errors.push("review.safety.maxChangedFiles must be a non-negative integer");
     }
 }
-async function validatePrompts(config, errors, directory) {
-    if (config.prompts == null)
+function validatePromptObject(prompts, path, keys, errors) {
+    if (prompts == null)
         return;
-    if (!isPlainObject(config.prompts)) {
-        errors.push("prompts must be an object");
+    if (!isPlainObject(prompts)) {
+        errors.push(`${path} must be an object`);
         return;
     }
-    validateKnownKeys(config.prompts, "prompts", PROMPT_KEYS, errors);
-    await Promise.all(Object.entries(config.prompts).map(async ([key, value]) => {
-        if (typeof value !== "string") {
-            errors.push(`prompts.${key} must be a string`);
+    validateKnownKeys(prompts, path, keys, errors);
+    for (const [key, value] of Object.entries(prompts)) {
+        if (typeof value !== "string")
+            errors.push(`${path}.${key} must be a string`);
+    }
+}
+async function validatePrompts(config, errors, directory) {
+    validatePromptObject(config.review?.prompts, "review.prompts", REVIEW_PROMPT_KEYS, errors);
+    validatePromptObject(config.merge?.prompts, "merge.prompts", MERGE_PROMPT_KEYS, errors);
+    const promptEntries = [
+        ...Object.entries(config.review?.prompts ?? {}).map(([key, value]) => [`review.prompts.${key}`, value]),
+        ...Object.entries(config.merge?.prompts ?? {}).map(([key, value]) => [`merge.prompts.${key}`, value]),
+    ];
+    await Promise.all(promptEntries.map(async ([path, value]) => {
+        if (typeof value !== "string")
             return;
-        }
         if (!directory)
             return;
         const fullPath = promptPath(directory, value);
@@ -393,13 +453,13 @@ async function validatePrompts(config, errors, directory) {
             await access(fullPath, constants.R_OK);
         }
         catch {
-            errors.push(`prompts.${key} file is not readable: ${value}`);
+            errors.push(`${path} file is not readable: ${value}`);
         }
     }));
 }
 async function validateAuth(config, exec, errors) {
     const accounts = new Set();
-    const agents = resolveAgents(config.agents);
+    const agents = resolveAgents(config);
     for (const reviewer of agents.reviewers)
         accounts.add(reviewer.account);
     if (agents.editor)
@@ -421,7 +481,7 @@ async function fetchPermissions(config, exec, account) {
 async function validateRepositoryPermissions(config, exec, errors, warnings) {
     if (!config.github?.owner || !config.github.repo)
         return;
-    const agents = resolveAgents(config.agents);
+    const agents = resolveAgents(config);
     await Promise.all(agents.reviewers.map(async (reviewer) => {
         try {
             const permissions = await fetchPermissions(config, exec, reviewer.account);
@@ -455,65 +515,32 @@ export async function validateConfig(config, options = {}) {
     validateKnownKeys(config, "config", CONFIG_KEYS, errors);
     validateString(config.$schema, "$schema", errors);
     validateString(config.language, "language", errors);
-    if (!config.agents) {
-        errors.push("agents is required");
+    if (config.agents != null && !isPlainObject(config.agents)) {
+        errors.push("agents must be an object");
     }
     else {
-        if (!isPlainObject(config.agents)) {
-            errors.push("agents must be an object");
+        validateKnownKeys(config.agents, "agents", AGENTS_KEYS, errors);
+        validatePermissionConfig(config.agents?.permissions, "agents.permissions", errors);
+    }
+    if (!config.review) {
+        errors.push("review is required");
+    }
+    else {
+        if (!isPlainObject(config.review)) {
+            errors.push("review must be an object");
         }
         else {
-            validateKnownKeys(config.agents, "agents", AGENTS_KEYS, errors);
-        }
-        validatePermissionConfig(config.agents.permissions, "agents.permissions", errors);
-        if (!config.agents.reviewers)
-            errors.push("agents.reviewers is required");
-        validateReviewerList(config.agents.reviewers, "agents.reviewers", errors, options.modelCatalog);
-        if (options.requireEditor && !config.agents.editor)
-            errors.push("agents.editor is required");
-        if (config.agents.editor) {
-            if (!config.agents.editor.model)
-                errors.push("agents.editor.model is required");
-            validateKnownKeys(config.agents.editor, "agents.editor", EDITOR_KEYS, errors);
-            validateString(config.agents.editor.model, "agents.editor.model", errors);
-            validateString(config.agents.editor.account, "agents.editor.account", errors);
-            validateString(config.agents.editor.persona, "agents.editor.persona", errors);
-            validateModel(config.agents.editor.model, "agents.editor.model", errors, options.modelCatalog);
-            if (!config.agents.editor.account)
-                errors.push("agents.editor.account is required");
-            if (config.agents.editor.options != null &&
-                !isPlainObject(config.agents.editor.options)) {
-                errors.push("agents.editor.options must be an object");
-            }
-            validatePermissionConfig(config.agents.editor.permission, "agents.editor.permission", errors);
-            const author = config.agents.editor.author;
-            if (!author || !isPlainObject(author)) {
-                if (author != null)
-                    errors.push("agents.editor.author must be an object");
-                errors.push("agents.editor.author.name is required");
-                errors.push("agents.editor.author.email is required");
-            }
-            else {
-                validateKnownKeys(author, "agents.editor.author", AUTHOR_KEYS, errors);
-                if (!author.name) {
-                    errors.push("agents.editor.author.name is required");
-                }
-                else if (typeof author.name !== "string") {
-                    errors.push("agents.editor.author.name must be a string");
-                }
-                if (!author.email) {
-                    errors.push("agents.editor.author.email is required");
-                }
-                else if (typeof author.email !== "string") {
-                    errors.push("agents.editor.author.email must be a string");
-                }
-            }
+            validateKnownKeys(config.review, "review", REVIEW_KEYS, errors);
         }
-        if (Array.isArray(config.agents.reviewers)) {
-            validateResolvedReviewers(resolveAgents(config.agents).reviewers, "agents.resolvedReviewers", errors);
+        if (!config.review.agents)
+            errors.push("review.agents is required");
+        validateReviewerList(config.review.agents, "review.agents", errors, options.modelCatalog);
+        if (Array.isArray(config.review.agents)) {
+            validateResolvedReviewers(resolveAgents(config).reviewers, "review.resolvedAgents", errors);
         }
     }
     validateMerge(config, errors, options);
+    validateReviewMerge(config, errors);
     validateAutomation(config, errors);
     validateClear(config, errors);
     validateChecks(config, errors);
@@ -531,40 +558,8 @@ export async function validateConfig(config, options = {}) {
             errors.push("output.repairAttempts must be a non-negative integer");
         }
     }
-    if (config.output?.dirs != null) {
-        if (!isPlainObject(config.output.dirs)) {
-            errors.push("output.dirs must be an object");
-        }
-        else {
-            validateKnownKeys(config.output.dirs, "output.dirs", OUTPUT_DIR_KEYS, errors);
-            const dirs = config.output.dirs;
-            for (const key of OUTPUT_DIR_KEYS) {
-                const value = dirs[key];
-                if (value != null && typeof value !== "string") {
-                    errors.push(`output.dirs.${key} must be a string`);
-                }
-            }
-        }
-    }
-    if (config.worktree != null && !isPlainObject(config.worktree)) {
-        errors.push("worktree must be an object");
-    }
-    validateKnownKeys(config.worktree, "worktree", WORKTREE_KEYS, errors);
-    if (config.worktree?.dirs != null) {
-        if (!isPlainObject(config.worktree.dirs)) {
-            errors.push("worktree.dirs must be an object");
-        }
-        else {
-            validateKnownKeys(config.worktree.dirs, "worktree.dirs", WORKTREE_DIR_KEYS, errors);
-            const dirs = config.worktree.dirs;
-            for (const key of WORKTREE_DIR_KEYS) {
-                const value = dirs[key];
-                if (value != null && typeof value !== "string") {
-                    errors.push(`worktree.dirs.${key} must be a string`);
-                }
-            }
-        }
-    }
+    validateString(config.review?.output, "review.output", errors);
+    validateString(config.review?.worktree, "review.worktree", errors);
     if (options.checkAuth && !errors.length) {
         if (!options.exec) {
             errors.push("validateConfig requires exec when checkAuth is true");

package/dist/config/worktree.js

@@ -6,7 +6,7 @@ function resolvePath(directory, path) {
     return isAbsolute(path) ? path : join(directory, path);
 }
 export function worktreeBaseDir(directory, config, kind) {
-    return resolvePath(directory, config.worktree?.dirs?.[kind] ?? DEFAULT_WORKTREE_DIRS[kind]);
+    return resolvePath(directory, config.review?.worktree ?? DEFAULT_WORKTREE_DIRS[kind]);
 }
 export function worktreeBaseDirs(directory, config = {}) {
     return [worktreeBaseDir(directory, config, "pr")];

package/dist/index.js

@@ -190,7 +190,7 @@ export async function validateMagiConfigFiles(directory, options = {}) {
                 ? withGitHubApiRetry(options.exec, mergedConfig.github?.apiRetryAttempts ?? 3)
                 : undefined,
             modelCatalog: options.modelCatalog,
-            requireGithub: hasProjectConfig && Boolean(mergedConfig.agents?.reviewers),
+            requireGithub: hasProjectConfig && Boolean(mergedConfig.review?.agents),
         });
         loadedFrom = existing.map((status) => status.path).join(", ");
         errors.push(...validation.errors);

package/dist/orchestrator/merge.js

@@ -571,6 +571,7 @@ export async function runMerge(input) {
         ...abortableInput,
         allowAlreadyReviewed: true,
         approvalPolicy: input.repository.merge.approvalPolicy,
+        enableReviewAutomation: false,
         onProgress: (progress) => input.onProgress?.(progress),
         runId: input.runId,
         dryRun: input.dryRun,

package/dist/orchestrator/review.js

@@ -1,6 +1,6 @@
 import { mkdir, writeFile } from "node:fs/promises";
 import { join } from "node:path";
-import { createWorktree, fetchPullRequest, fetchPullRequestCommits, fetchPullRequestReviews, fetchUnresolvedThreads, postApproval, postChangesRequested, postCloseComment, postReply, removeWorktree, resolveThread, } from "../github/commands";
+import { createWorktree, fetchPullRequest, fetchPullRequestCommits, fetchPullRequestReviews, fetchUnresolvedThreads, closePullRequest, mergePullRequest, postApproval, postChangesRequested, postCloseComment, postReply, removeWorktree, resolveThread, } from "../github/commands";
 import { composeFindingValidationPrompt, composeCloseReconsiderationPrompt, composeRereviewPrompt, composeReviewPrompt, } from "../prompts/compose";
 import { prRunOutputDir } from "../config/output";
 import { worktreeBaseDir } from "../config/worktree";
@@ -112,6 +112,9 @@ function reviewStateToVerdict(state) {
         return "CHANGES_REQUESTED";
     return "CLOSE";
 }
+function hasBlockingCiReports(reports) {
+    return reports.some((report) => report.scopeInside.length || report.scopeOutsideUnresolved.length);
+}
 function previousReviewText(review) {
     return JSON.stringify({
         body: review.body ?? "",
@@ -753,6 +756,30 @@ export async function runReview(input) {
                         : await postReviewOutput({ ...input, exec }, key, output),
             ]))),
         };
+        const automationAccount = input.repository.agents.reviewers[0]?.account;
+        const enableReviewAutomation = input.enableReviewAutomation ?? true;
+        if (enableReviewAutomation &&
+            verdict === "MERGE" &&
+            input.repository.reviewAutomation?.merge) {
+            await input.onProgress?.({ phase: "merging PR", type: "phase" });
+            posted.automation = hasBlockingCiReports(ciReports)
+                ? "skipped: unresolved CI"
+                : input.dryRun
+                    ? "dry-run:would-merge"
+                    : automationAccount
+                        ? await mergePullRequest(input.exec, input.repository, input.pr, automationAccount)
+                        : "skipped: no review automation account";
+        }
+        if (enableReviewAutomation &&
+            verdict === "CLOSE" &&
+            input.repository.reviewAutomation?.close) {
+            await input.onProgress?.({ phase: "closing PR", type: "phase" });
+            posted.automation = input.dryRun
+                ? "dry-run:would-close"
+                : automationAccount
+                    ? await closePullRequest(input.exec, input.repository, input.pr, automationAccount)
+                    : "skipped: no review automation account";
+        }
         await writeFile(join(outputDir, "majority.json"), JSON.stringify({
             approvalPolicy: input.approvalPolicy ?? "majority",
             verdict,

package/dist/prompts/compose.js

@@ -34,7 +34,7 @@ function repositoryValues(repository) {
     };
 }
 function reviewValues(input) {
-    const ciFailureContext = input.ciFailureContext?.trim() ?? input.ciFailureLogs?.trim() ?? "";
+    const ciFailureContext = input.ciFailureContext?.trim() ?? "";
     return {
         ...repositoryValues(input.repository),
         baseSha: input.baseSha,
@@ -42,10 +42,6 @@ function reviewValues(input) {
         ciFailureContextBlock: ciFailureContext
             ? `<ci_failure_context>\n${ciFailureContext}\n</ci_failure_context>`
             : "",
-        ciFailureLogs: ciFailureContext,
-        ciFailureLogsBlock: ciFailureContext
-            ? `<ci_failure_context>\n${ciFailureContext}\n</ci_failure_context>`
-            : "",
         headSha: input.headSha,
         jsonEncodedWorktreePath: JSON.stringify(input.worktreePath),
         pr: String(input.pr),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-magi",
-  "version": "0.0.0-dev-20260519013159",
+  "version": "0.0.0-dev-20260519070815",
   "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,13 +5,11 @@
   "additionalProperties": false,
   "properties": {
     "$schema": { "type": "string" },
-    "agents": { "$ref": "#/$defs/agents" },
-    "automation": {
+    "agents": {
       "type": "object",
       "additionalProperties": false,
       "properties": {
-        "merge": { "type": "boolean", "default": true },
-        "close": { "type": "boolean", "default": true }
+        "permissions": { "$ref": "#/$defs/permissions" }
       }
     },
     "clear": {
@@ -24,24 +22,6 @@
         "branch": { "type": "boolean", "default": true }
       }
     },
-    "checks": {
-      "type": "object",
-      "additionalProperties": false,
-      "properties": {
-        "exclude": { "type": "array", "items": { "type": "string" } },
-        "waitAfterEdit": { "type": "boolean" },
-        "waitBeforeReview": { "type": "boolean" },
-        "retryFailedJobs": { "type": "integer", "minimum": 0, "default": 3 }
-      }
-    },
-    "concurrency": {
-      "type": "object",
-      "additionalProperties": false,
-      "properties": {
-        "runs": { "type": "integer", "minimum": 1, "default": 3 },
-        "reviewers": { "type": "integer", "minimum": 1, "default": 3 }
-      }
-    },
     "github": {
       "type": "object",
       "required": ["owner", "repo"],
@@ -59,64 +39,15 @@
       }
     },
     "language": { "type": "string" },
-    "merge": {
-      "type": "object",
-      "additionalProperties": false,
-      "properties": {
-        "approvalPolicy": {
-          "enum": ["majority", "unanimous"],
-          "default": "majority"
-        },
-        "method": { "enum": ["merge", "squash", "rebase"] },
-        "auto": { "type": "boolean" },
-        "deleteBranch": { "type": "boolean" },
-        "mergeQueue": { "type": "boolean", "default": false },
-        "maxThreadResolutionCycles": {
-          "type": "integer",
-          "minimum": 0,
-          "default": 5,
-          "description": "Maximum resolution attempts per unresolved review thread. Set 0 for unlimited attempts."
-        }
-      }
-    },
+    "merge": { "$ref": "#/$defs/merge" },
     "output": {
       "type": "object",
       "additionalProperties": false,
       "properties": {
-        "dirs": {
-          "type": "object",
-          "additionalProperties": false,
-          "properties": {
-            "pr": { "type": "string" }
-          }
-        },
         "repairAttempts": { "type": "integer", "minimum": 0, "default": 3 }
       }
     },
-    "prompts": { "$ref": "#/$defs/prompts" },
-    "safety": {
-      "type": "object",
-      "additionalProperties": false,
-      "properties": {
-        "allowAuthors": { "type": "array", "items": { "type": "string" } },
-        "blockedPaths": { "type": "array", "items": { "type": "string" } },
-        "maxChangedFiles": { "type": "integer", "minimum": 0 },
-        "requiredLabels": { "type": "array", "items": { "type": "string" } }
-      }
-    },
-    "worktree": {
-      "type": "object",
-      "additionalProperties": false,
-      "properties": {
-        "dirs": {
-          "type": "object",
-          "additionalProperties": false,
-          "properties": {
-            "pr": { "type": "string" }
-          }
-        }
-      }
-    }
+    "review": { "$ref": "#/$defs/review" }
   },
   "$defs": {
     "reviewer": {
@@ -128,7 +59,7 @@
         "model": { "type": "string", "minLength": 1 },
         "options": { "type": "object", "additionalProperties": true },
         "account": { "type": "string", "minLength": 1 },
-        "permission": { "$ref": "#/$defs/permission" },
+        "permissions": { "$ref": "#/$defs/permissions" },
         "persona": { "type": "string" }
       }
     },
@@ -149,21 +80,120 @@
             "email": { "type": "string", "minLength": 1 }
           }
         },
-        "permission": { "$ref": "#/$defs/permission" },
+        "permissions": { "$ref": "#/$defs/permissions" },
         "persona": { "type": "string" }
       }
     },
-    "agents": {
+    "automation": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "merge": { "type": "boolean" },
+        "close": { "type": "boolean" }
+      }
+    },
+    "reviewChecks": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "exclude": { "type": "array", "items": { "type": "string" } },
+        "wait": { "type": "boolean", "default": true },
+        "retryFailedJobs": { "type": "integer", "minimum": 0, "default": 3 }
+      }
+    },
+    "mergeChecks": {
       "type": "object",
       "additionalProperties": false,
       "properties": {
-        "permissions": { "$ref": "#/$defs/permission" },
-        "reviewers": {
+        "wait": { "type": "boolean", "default": true }
+      }
+    },
+    "concurrency": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "runs": { "type": "integer", "minimum": 1, "default": 3 },
+        "reviewers": { "type": "integer", "minimum": 1, "default": 3 }
+      }
+    },
+    "safety": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "allowAuthors": { "type": "array", "items": { "type": "string" } },
+        "blockedPaths": { "type": "array", "items": { "type": "string" } },
+        "maxChangedFiles": { "type": "integer", "minimum": 0 },
+        "requiredLabels": { "type": "array", "items": { "type": "string" } }
+      }
+    },
+    "reviewPrompts": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "review": { "type": "string" },
+        "rereview": { "type": "string" },
+        "reviewGuidelines": { "type": "string" },
+        "ciClassification": { "type": "string" },
+        "findingValidation": { "type": "string" },
+        "closeReconsideration": { "type": "string" }
+      }
+    },
+    "mergePrompts": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "edit": { "type": "string" },
+        "editGuidelines": { "type": "string" },
+        "ciClassification": { "type": "string" }
+      }
+    },
+    "reviewMerge": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "approvalPolicy": {
+          "enum": ["majority", "unanimous"],
+          "default": "majority"
+        },
+        "method": { "enum": ["merge", "squash", "rebase"] },
+        "auto": { "type": "boolean" },
+        "deleteBranch": { "type": "boolean" },
+        "queue": { "type": "boolean", "default": false }
+      }
+    },
+    "review": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "agents": {
           "type": "array",
           "minItems": 3,
           "items": { "$ref": "#/$defs/reviewer" }
         },
-        "editor": { "$ref": "#/$defs/editor" }
+        "prompts": { "$ref": "#/$defs/reviewPrompts" },
+        "checks": { "$ref": "#/$defs/reviewChecks" },
+        "safety": { "$ref": "#/$defs/safety" },
+        "automation": { "$ref": "#/$defs/automation" },
+        "concurrency": { "$ref": "#/$defs/concurrency" },
+        "merge": { "$ref": "#/$defs/reviewMerge" },
+        "output": { "type": "string" },
+        "worktree": { "type": "string" }
+      }
+    },
+    "merge": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "editor": { "$ref": "#/$defs/editor" },
+        "checks": { "$ref": "#/$defs/mergeChecks" },
+        "prompts": { "$ref": "#/$defs/mergePrompts" },
+        "automation": { "$ref": "#/$defs/automation" },
+        "maxThreadResolutionCycles": {
+          "type": "integer",
+          "minimum": 0,
+          "default": 5,
+          "description": "Maximum resolution attempts per unresolved review thread. Set 0 for unlimited attempts."
+        }
       }
     },
     "permissionAction": { "enum": ["allow", "ask", "deny"] },
@@ -176,7 +206,7 @@
         }
       ]
     },
-    "permission": {
+    "permissions": {
       "oneOf": [
         { "$ref": "#/$defs/permissionAction" },
         {
@@ -184,23 +214,6 @@
           "additionalProperties": { "$ref": "#/$defs/permissionRule" }
         }
       ]
-    },
-    "prompts": {
-      "type": "object",
-      "additionalProperties": false,
-      "properties": {
-        "review": { "type": "string" },
-        "rereview": { "type": "string" },
-        "edit": { "type": "string" },
-        "editGuidelines": { "type": "string" },
-        "findingValidation": { "type": "string" },
-        "closeReconsideration": { "type": "string" },
-        "rereviewCloseReconsideration": { "type": "string" },
-        "ciClassification": { "type": "string" },
-        "ciClassificationAfterEdit": { "type": "string" },
-        "report": { "type": "string" },
-        "reviewGuidelines": { "type": "string" }
-      }
     }
   }
 }