opencode-magi 0.1.0 → 0.2.0

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,50 +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(["dir"]);
+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";
 }
@@ -210,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`);
@@ -233,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");
@@ -247,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 (config.checks?.waitAfterEdit != null &&
-        typeof config.checks.waitAfterEdit !== "boolean") {
-        errors.push("checks.waitAfterEdit must be a boolean");
+    if (checks?.wait != null && typeof checks.wait !== "boolean") {
+        errors.push("review.checks.wait 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) {
@@ -358,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);
@@ -392,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)
@@ -420,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);
@@ -454,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);
@@ -530,28 +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?.dir != null && typeof config.worktree.dir !== "string") {
-        errors.push("worktree.dir 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

@@ -0,0 +1,13 @@
+import { isAbsolute, join } from "node:path";
+const DEFAULT_WORKTREE_DIRS = {
+    pr: ".magi/worktrees/pr",
+};
+function resolvePath(directory, path) {
+    return isAbsolute(path) ? path : join(directory, path);
+}
+export function worktreeBaseDir(directory, config, kind) {
+    return resolvePath(directory, config.review?.worktree ?? DEFAULT_WORKTREE_DIRS[kind]);
+}
+export function worktreeBaseDirs(directory, config = {}) {
+    return [worktreeBaseDir(directory, config, "pr")];
+}

package/dist/github/commands.js

@@ -41,7 +41,7 @@ async function withWorktreeCreateLock(key, run) {
 async function checkoutPullRequestWithRetry(exec, repository, pr, worktreePath) {
     for (let attempt = 0;; attempt += 1) {
         try {
-            await exec(`gh pr checkout ${pr} --repo ${shellQuote(repoSpecifier(repository))}`, {
+            await exec(`gh pr checkout ${pr} --repo ${shellQuote(repoSpecifier(repository))} --detach`, {
                 cwd: worktreePath,
             });
             return;
@@ -70,6 +70,9 @@ export function repoSpecifier(repository) {
         ? repoSlug(repository)
         : `${host}/${repoSlug(repository)}`;
 }
+function repositoryGitUrl(repository, owner, repo) {
+    return `https://${githubHost(repository)}/${owner}/${repo}.git`;
+}
 export function ghHostOption(repository) {
     const host = githubHost(repository);
     return host === "github.com" ? "" : ` --hostname ${shellQuote(host)}`;
@@ -78,7 +81,7 @@ export async function ghToken(exec, repository, account) {
     return (await exec(`gh auth token${ghHostOption(repository)} --user ${shellQuote(account)}`)).trim();
 }
 export async function fetchPullRequest(exec, repository, pr) {
-    const json = await exec(`gh pr view ${pr} --repo ${shellQuote(repoSpecifier(repository))} --json number,title,url,isDraft,baseRefOid,headRefOid,baseRefName,headRefName`);
+    const json = await exec(`gh pr view ${pr} --repo ${shellQuote(repoSpecifier(repository))} --json number,title,url,isDraft,baseRefOid,headRefOid,baseRefName,headRefName,headRepository,headRepositoryOwner`);
     return JSON.parse(json);
 }
 export async function fetchPullRequestReviews(exec, repository, pr) {
@@ -318,9 +321,10 @@ export async function closePullRequest(exec, repository, pr, account) {
     const token = await ghToken(exec, repository, account);
     return exec(`GH_TOKEN=${shellQuote(token)} gh pr close ${pr} --repo ${shellQuote(repoSpecifier(repository))}`);
 }
-export async function pushHead(exec, repository, worktreePath, account) {
+export async function pushHead(exec, repository, worktreePath, account, head) {
     const token = await ghToken(exec, repository, account);
-    await exec(`git -c credential.helper= -c credential.helper=${shellQuote(`!f() { echo username=x-access-token; echo password=${token}; }; f`)} push origin HEAD`, { cwd: worktreePath });
+    const url = repositoryGitUrl(repository, head.owner, head.repo);
+    await exec(`git -c credential.helper= -c credential.helper=${shellQuote(`!f() { echo username=x-access-token; echo password=${token}; }; f`)} push ${shellQuote(url)} ${shellQuote(`HEAD:refs/heads/${head.ref}`)}`, { cwd: worktreePath });
 }
 export async function configureGitIdentity(exec, worktreePath, identity) {
     if (identity.name) {

package/dist/index.js

@@ -7,6 +7,7 @@ import { promisify } from "node:util";
 import { MAGI_COMMANDS } from "./commands";
 import { loadConfig, mergeMagiConfig } from "./config/load";
 import { outputBaseDirs } from "./config/output";
+import { worktreeBaseDirs } from "./config/worktree";
 import { resolveRepository } from "./config/resolve";
 import { validateConfig } from "./config/validate";
 import { withGitHubApiRetry } from "./github/retry";
@@ -189,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);
@@ -435,6 +436,9 @@ export const MagiPlugin = async ({ client, directory }) => {
                             : undefined,
                         pr: parseOptionalPr(args.pr),
                         runId: args.runId,
+                        worktreeDir: loaded
+                            ? worktreeBaseDirs(directory, loaded.config)
+                            : undefined,
                     });
                 },
             }),

package/dist/orchestrator/merge.js

@@ -109,7 +109,13 @@ async function runEditor(input, worktreePath, cycle, unresolvedThreads) {
     await input.onProgress?.({ cycle, type: "editor_completed" });
     if (!input.dryRun) {
         if (result.value.mode === "EDITED") {
-            await pushHead(input.exec, input.repository, worktreePath, editor.account);
+            const meta = await fetchPullRequest(input.exec, input.repository, input.pr);
+            const headOwner = meta.headRepositoryOwner?.login;
+            const headRepo = meta.headRepository?.name;
+            if (!headOwner || !headRepo) {
+                throw new Error("Pull request head repository is missing");
+            }
+            await pushHead(input.exec, input.repository, worktreePath, editor.account, { owner: headOwner, ref: meta.headRefName, repo: headRepo });
         }
     }
     throwIfAborted(input.signal);
@@ -565,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,