opencode-magi 0.7.0 → 0.9.0

package/README.md

@@ -17,7 +17,7 @@ OpenCode Magi recreates the review cycle humans already run on GitHub: multiple
 - Multi-agent reviews with an odd-number majority of 3 or more reviewers.
 - Optional unanimous approval policy for merge automation when every reviewer must approve before a PR is merged.
 - Finding-level voting before posting change requests, so only findings accepted by reviewer majority are submitted.
-- Each reviewer acts through its configured GitHub account, posting real reviews, approvals, change requests, and follow-up comments.
+- Multi-account review mode where each reviewer posts through its configured GitHub account, plus single-account review mode where one GitHub account posts the consensus result for multiple logical reviewers.
 - Re-review support for edited PRs: fixed threads are resolved, satisfied reviewers approve, and remaining issues are posted as additional comments.
 - Optional merge and close automation where an editor agent responds on behalf of the author, fixes changes it agrees with, pushes commits when needed, and repeats the reviewer/editor cycle until the PR can be approved, queued, merged, or closed.
 - Per-agent OpenCode permissions for reviewer, CI classifier, and editor child sessions.
@@ -64,20 +64,18 @@ Add the following content to the configuration file.
   "agents": {
     "refs": {
       "account-1": {
-        "model": "openai/gpt-5.5",
-        "account": "account-1"
+        "model": "openai/gpt-5.5"
       },
       "account-2": {
-        "model": "anthropic/claude-opus-4-7",
-        "account": "account-2"
+        "model": "anthropic/claude-opus-4-7"
       },
       "account-3": {
-        "model": "opencode/kimi-k2-6",
-        "account": "account-3"
+        "model": "opencode/kimi-k2-6"
       }
     }
   },
   "review": {
+    "account": "your-account",
     "reviewers": [
       { "ref": "account-1" },
       { "ref": "account-2" },
@@ -87,7 +85,26 @@ Add the following content to the configuration file.
 }
 ```
 
-After `refs` are expanded, `review.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.
+By default, `review.mode` is `"single"`. Magi uses one `review.account` to post reviewer-originated GitHub mutations while still running multiple logical reviewer agents and preserving majority voting, finding validation, and close reconsideration. The account must be authenticated with `gh auth token --user <account>`.
+
+For team setups that need separate GitHub review identities, set `review.mode: "multi"` and configure a unique account for each reviewer.
+
+```json
+{
+  "review": {
+    "mode": "multi",
+    "reviewers": [
+      { "id": "general", "model": "openai/gpt-5.5", "account": "account-1" },
+      {
+        "id": "security",
+        "model": "anthropic/claude-opus-4-7",
+        "account": "account-2"
+      },
+      { "id": "compat", "model": "opencode/kimi-k2-6", "account": "account-3" }
+    ]
+  }
+}
+```
 
 #### Set project config
 
@@ -165,7 +182,7 @@ Entries with `ref` are expanded from `agents.refs`. Fields set alongside `ref` o
 }
 ```
 
-After `refs` are expanded, `review.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. `merge.editor.account` is used by `/magi:merge` to push fixes, close PRs, and merge PRs.
+After `refs` are expanded, `review.reviewers[].account` is the GitHub account used to post reviews and approvals in `multi` mode. Must be authenticated with `gh auth token --user <account>` and must be unique. In `single` mode, `review.account` is used for reviewer-originated review posts, approvals, change requests, close comments, reviewer replies, and reviewer thread resolutions. `merge.editor.account` is still used by `/magi:merge` to push fixes, close PRs, and merge PRs.
 
 #### Validate config
 

package/dist/config/resolve.js

@@ -24,6 +24,31 @@ const DEFAULT_TRIAGE_CATEGORIES = [
         types: ["Feature"],
     },
 ];
+export const DEFAULT_TRIAGE_LABEL_RULES = [
+    { remove: ["triage"], when: { disposition: "accepted" } },
+    {
+        add: ["duplicate"],
+        remove: ["triage"],
+        when: { disposition: "duplicate" },
+    },
+    {
+        add: ["duplicate"],
+        remove: ["triage"],
+        when: { disposition: "already_handled" },
+    },
+    {
+        add: ["wontfix"],
+        remove: ["triage"],
+        when: { disposition: "rejected" },
+    },
+    {
+        add: ["invalid"],
+        remove: ["triage"],
+        when: { disposition: "invalid" },
+    },
+    { add: ["question"], when: { disposition: "needs_category" } },
+    { add: ["question"], when: { disposition: "needs_acceptance" } },
+];
 export function reviewerKey(reviewer, index) {
     return reviewer.id ?? `reviewer-${index + 1}`;
 }
@@ -88,6 +113,9 @@ 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;
     return {
         editor: editor
             ? {
@@ -98,6 +126,7 @@ export function resolveAgents(config) {
             : undefined,
         reviewers: (config.review?.reviewers ?? []).map((reviewer, index) => ({
             ...reviewer,
+            account: singleReviewAccount ?? reviewer.account ?? "",
             key: reviewerKey(reviewer, index),
             index,
             model: normalizedModel(reviewer.model),
@@ -138,6 +167,7 @@ export function resolveRepository(config) {
         agents: resolveAgents(config),
         automation: {
             close: config.merge?.automation?.close ?? false,
+            conflict: config.merge?.automation?.conflict ?? false,
             merge: config.merge?.automation?.merge ?? true,
         },
         checks: {
@@ -178,6 +208,10 @@ 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,
@@ -190,9 +224,9 @@ export function resolveRepository(config) {
         },
         triage: {
             automation: {
-                clear: config.triage?.automation?.clear ?? ["triage"],
                 close: config.triage?.automation?.close ?? false,
                 create: config.triage?.automation?.create ?? false,
+                label: config.triage?.automation?.label ?? DEFAULT_TRIAGE_LABEL_RULES,
                 merge: config.triage?.automation?.merge ?? false,
                 review: config.triage?.automation?.review ?? false,
             },
@@ -215,6 +249,7 @@ export function resolveRepository(config) {
                 blockedLabels: config.triage?.safety?.blockedLabels ?? [],
                 requiredLabels: config.triage?.safety?.requiredLabels ?? ["triage"],
             },
+            signals: config.triage?.signals ?? [],
             worktree: config.triage?.worktree,
         },
     };

package/dist/config/validate.js

@@ -54,10 +54,12 @@ 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",
@@ -80,6 +82,7 @@ const TRIAGE_KEYS = new Set([
     "prompts",
     "reporter",
     "safety",
+    "signals",
     "voters",
     "worktree",
 ]);
@@ -93,17 +96,24 @@ const REVIEW_MERGE_KEYS = new Set([
 const REVIEW_CHECKS_KEYS = new Set(["exclude", "retryFailedJobs", "wait"]);
 const MERGE_CHECKS_KEYS = new Set(["wait"]);
 const AUTOMATION_KEYS = new Set(["close", "merge"]);
+const MERGE_AUTOMATION_KEYS = new Set(["close", "conflict", "merge"]);
 const CLEAR_KEYS = new Set(["branch", "output", "session", "worktree"]);
 const CONCURRENCY_KEYS = new Set(["reviewers", "runs"]);
 const OUTPUT_KEYS = new Set(["repairAttempts"]);
 const TRIAGE_AUTOMATION_KEYS = new Set([
-    "clear",
     "close",
     "create",
+    "label",
     "merge",
     "review",
 ]);
 const TRIAGE_CATEGORY_KEYS = new Set(["description", "id", "labels", "types"]);
+const TRIAGE_LABEL_RULE_KEYS = new Set(["add", "remove", "when"]);
+const TRIAGE_LABEL_RULE_WHEN_KEYS = new Set([
+    "category",
+    "disposition",
+    "signals",
+]);
 const TRIAGE_CONCURRENCY_KEYS = new Set(["runs"]);
 const TRIAGE_SAFETY_KEYS = new Set([
     "allowAuthors",
@@ -112,6 +122,18 @@ const TRIAGE_SAFETY_KEYS = new Set([
     "blockedLabels",
     "requiredLabels",
 ]);
+const TRIAGE_SIGNAL_KEYS = new Set(["description", "id"]);
+const TRIAGE_DISPOSITIONS = new Set([
+    "accepted",
+    "rejected",
+    "invalid",
+    "duplicate",
+    "already_handled",
+    "needs_category",
+    "needs_acceptance",
+    "blocked",
+    "failed",
+]);
 const SAFETY_KEYS = new Set([
     "allowAuthors",
     "blockedPaths",
@@ -364,7 +386,7 @@ function validateAndNormalizeModel(target, path, errors, catalog) {
     }
     errors.push(`${path} must contain at least one usable OpenCode model candidate${candidateErrors.length ? ` (${candidateErrors.join("; ")})` : ""}`);
 }
-function validateReviewerList(reviewers, path, errors, catalog) {
+function validateReviewerList(reviewers, path, errors, catalog, mode = "single") {
     if (reviewers == null)
         return;
     if (!Array.isArray(reviewers)) {
@@ -384,7 +406,7 @@ function validateReviewerList(reviewers, path, errors, catalog) {
         if (!reviewer.model)
             errors.push(`${path}[${index}].model is required`);
         validateAndNormalizeModel(reviewer, `${path}[${index}].model`, errors, catalog);
-        if (!reviewer.account)
+        if (mode === "multi" && !reviewer.account)
             errors.push(`${path}[${index}].account is required`);
         validateString(reviewer.account, `${path}[${index}].account`, errors);
         validateString(reviewer.persona, `${path}[${index}].persona`, errors);
@@ -434,18 +456,31 @@ function validateTriageAgentList(voters, path, errors, catalog) {
         }
     });
 }
-function validateResolvedReviewers(reviewers, path, errors) {
+function validateResolvedReviewers(reviewers, path, errors, mode = "single") {
     const keys = new Set();
     const accounts = new Set();
     for (const reviewer of reviewers) {
         if (keys.has(reviewer.key))
             errors.push(`${path} has duplicate reviewer key: ${reviewer.key}`);
         keys.add(reviewer.key);
-        if (accounts.has(reviewer.account))
+        if (mode === "multi" && accounts.has(reviewer.account))
             errors.push(`${path} has duplicate reviewer account: ${reviewer.account}`);
         accounts.add(reviewer.account);
     }
 }
+function reviewMode(config) {
+    return config.review?.mode === "multi" ? "multi" : "single";
+}
+function validateReviewIdentity(config, errors) {
+    const mode = config.review?.mode;
+    if (mode != null && mode !== "multi" && mode !== "single") {
+        errors.push("review.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");
+    }
+}
 function validateResolvedTriageAgents(agents, path, errors) {
     const keys = new Set();
     const accounts = new Set();
@@ -552,7 +587,7 @@ function validateMerge(config, errors, options) {
         errors.push("merge must be an object");
     }
     validateKnownKeys(merge, "merge", MERGE_KEYS, errors);
-    validateBooleanObject(merge?.automation, "merge.automation", AUTOMATION_KEYS, errors);
+    validateBooleanObject(merge?.automation, "merge.automation", MERGE_AUTOMATION_KEYS, errors);
     const checks = merge?.checks;
     validateKnownKeys(checks, "merge.checks", MERGE_CHECKS_KEYS, errors);
     validateBoolean(checks?.wait, "merge.checks.wait", errors);
@@ -691,6 +726,79 @@ function validateTriageCategories(categories, path, errors) {
         validateString(category.description, `${itemPath}.description`, errors);
     });
 }
+function validateTriageSignals(signals, path, errors) {
+    if (signals == null)
+        return;
+    if (!Array.isArray(signals)) {
+        errors.push(`${path} must be an array`);
+        return;
+    }
+    const ids = new Set();
+    signals.forEach((item, index) => {
+        const itemPath = `${path}[${index}]`;
+        if (!isPlainObject(item)) {
+            errors.push(`${itemPath} must be an object`);
+            return;
+        }
+        const signal = item;
+        validateKnownKeys(signal, itemPath, TRIAGE_SIGNAL_KEYS, errors);
+        if (!signal.id) {
+            errors.push(`${itemPath}.id is required`);
+        }
+        else if (typeof signal.id !== "string") {
+            errors.push(`${itemPath}.id must be a string`);
+        }
+        else if (!TRIAGE_CATEGORY_ID_PATTERN.test(signal.id)) {
+            errors.push(`${itemPath}.id must match /^[A-Za-z0-9_-]+$/`);
+        }
+        else if (ids.has(signal.id)) {
+            errors.push(`${itemPath}.id must be unique`);
+        }
+        else {
+            ids.add(signal.id);
+        }
+        if (!signal.description) {
+            errors.push(`${itemPath}.description is required`);
+        }
+        else {
+            validateString(signal.description, `${itemPath}.description`, errors);
+        }
+    });
+}
+function validateTriageLabelRules(rules, path, errors) {
+    if (rules == null)
+        return;
+    if (!Array.isArray(rules)) {
+        errors.push(`${path} must be an array`);
+        return;
+    }
+    rules.forEach((item, index) => {
+        const itemPath = `${path}[${index}]`;
+        if (!isPlainObject(item)) {
+            errors.push(`${itemPath} must be an object`);
+            return;
+        }
+        const rule = item;
+        validateKnownKeys(rule, itemPath, TRIAGE_LABEL_RULE_KEYS, errors);
+        validateStringArray(rule.add, `${itemPath}.add`, errors);
+        validateStringArray(rule.remove, `${itemPath}.remove`, errors);
+        if (!isPlainObject(rule.when)) {
+            errors.push(`${itemPath}.when must be an object`);
+            return;
+        }
+        validateKnownKeys(rule.when, `${itemPath}.when`, TRIAGE_LABEL_RULE_WHEN_KEYS, errors);
+        if (!Object.keys(rule.when).length) {
+            errors.push(`${itemPath}.when must not be empty`);
+        }
+        if (rule.when.disposition != null &&
+            (typeof rule.when.disposition !== "string" ||
+                !TRIAGE_DISPOSITIONS.has(rule.when.disposition))) {
+            errors.push(`${itemPath}.when.disposition must be a triage disposition`);
+        }
+        validateString(rule.when.category, `${itemPath}.when.category`, errors);
+        validateStringArray(rule.when.signals, `${itemPath}.when.signals`, errors);
+    });
+}
 function validateSafety(config, errors) {
     const safety = config.review?.safety;
     if (safety != null && !isPlainObject(safety)) {
@@ -764,7 +872,7 @@ function validateTriage(config, errors, options) {
     validateBoolean(automation?.create, "triage.automation.create", errors);
     validateBoolean(automation?.merge, "triage.automation.merge", errors);
     validateBoolean(automation?.review, "triage.automation.review", errors);
-    validateStringArray(automation?.clear, "triage.automation.clear", errors);
+    validateTriageLabelRules(automation?.label, "triage.automation.label", errors);
     if (automation?.review && !automation.create) {
         errors.push("triage.automation.review requires triage.automation.create to be true");
     }
@@ -779,6 +887,7 @@ function validateTriage(config, errors, options) {
         errors.push("triage.concurrency.runs must be a positive integer");
     }
     validateTriageCategories(triage.categories, "triage.categories", errors);
+    validateTriageSignals(triage.signals, "triage.signals", errors);
     validateKnownKeys(safety, "triage.safety", TRIAGE_SAFETY_KEYS, errors);
     validateStringArray(safety?.allowAuthors, "triage.safety.allowAuthors", errors);
     validateStringArray(safety?.allowMentionActors, "triage.safety.allowMentionActors", errors);
@@ -814,8 +923,14 @@ async function validatePrompts(config, errors, directory) {
 async function validateAuth(config, exec, errors) {
     const accounts = new Set();
     const agents = resolveAgents(config);
-    for (const reviewer of agents.reviewers)
-        accounts.add(reviewer.account);
+    if (reviewMode(config) === "single") {
+        if (config.review?.account)
+            accounts.add(config.review.account);
+    }
+    else {
+        for (const reviewer of agents.reviewers)
+            accounts.add(reviewer.account);
+    }
     for (const agent of agents.triage ?? [])
         accounts.add(agent.account);
     if (agents.editor)
@@ -862,15 +977,20 @@ async function validateRepositoryPermissions(config, exec, errors, warnings) {
     if (!config.github?.owner || !config.github.repo)
         return;
     const agents = resolveAgents(config);
-    await Promise.all(agents.reviewers.map(async (reviewer) => {
+    const reviewAccounts = reviewMode(config) === "single"
+        ? config.review?.account
+            ? [config.review.account]
+            : []
+        : agents.reviewers.map((reviewer) => reviewer.account);
+    await Promise.all(reviewAccounts.map(async (account) => {
         try {
-            const permissions = await fetchPermissions(config, exec, reviewer.account);
+            const permissions = await fetchPermissions(config, exec, account);
             if (!permissions.pull) {
-                errors.push(`GitHub account cannot read repository for PR review: ${reviewer.account}`);
+                errors.push(`GitHub account cannot read repository for PR review: ${account}`);
             }
         }
         catch (error) {
-            warnings.push(`Could not validate repository permissions for GitHub account: ${reviewer.account} (${error.message})`);
+            warnings.push(`Could not validate repository permissions for GitHub account: ${account} (${error.message})`);
         }
     }));
     await Promise.all((agents.triage ?? []).map(async (agent) => {
@@ -932,15 +1052,17 @@ export async function validateConfig(config, options = {}) {
         errors.push("review is required");
     }
     else if (config.review) {
+        const mode = reviewMode(config);
         if (!isPlainObject(config.review)) {
             errors.push("review must be an object");
         }
         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);
+        validateReviewerList(config.review.reviewers, "review.reviewers", errors, options.modelCatalog, mode);
         if (Array.isArray(config.review.reviewers)) {
             validateResolvedReviewers(config.review.reviewers.map((reviewer, index) => ({
                 account: reviewer &&
@@ -951,7 +1073,7 @@ export async function validateConfig(config, options = {}) {
                 key: reviewer && typeof reviewer === "object"
                     ? reviewerKey(reviewer, index)
                     : "",
-            })), "review.resolvedReviewers", errors);
+            })), "review.resolvedReviewers", errors, mode);
         }
     }
     if (options.requireTriage && !config.triage) {

package/dist/github/commands.js

@@ -404,6 +404,15 @@ export async function assignIssue(exec, repository, issue, account) {
     const token = await ghToken(exec, repository, account);
     return exec(`gh issue edit ${issue} --repo ${shellQuote(repoSpecifier(repository))} --add-assignee ${shellQuote(account)}`, ghTokenEnv(token));
 }
+export async function addIssueLabels(exec, repository, issue, labels, account) {
+    const token = await ghToken(exec, repository, account);
+    const added = [];
+    for (const label of labels) {
+        await exec(`gh issue edit ${issue} --repo ${shellQuote(repoSpecifier(repository))} --add-label ${shellQuote(label)}`, ghTokenEnv(token));
+        added.push(label);
+    }
+    return added;
+}
 export async function removeIssueLabels(exec, repository, issue, labels, account) {
     const token = await ghToken(exec, repository, account);
     const removed = [];
@@ -583,8 +592,18 @@ export async function removeWorktree(exec, worktreePath) {
 export async function removeBranch(exec, branch) {
     await exec(`git branch -D ${shellQuote(branch)}`);
 }
-export async function postApproval(exec, repository, pr, account) {
+export async function postApproval(exec, repository, pr, account, body) {
     const token = await ghToken(exec, repository, account);
+    if (body != null) {
+        const payloadPath = join(tmpdir(), `magi-approve-${process.pid}-${Date.now()}.json`);
+        await writeFile(payloadPath, JSON.stringify({ body, event: "APPROVE" }));
+        try {
+            return await exec(`gh api${ghHostOption(repository)} repos/${repository.github.owner}/${repository.github.repo}/pulls/${pr}/reviews --method POST --input ${shellQuote(payloadPath)} --jq .html_url`, ghTokenEnv(token));
+        }
+        finally {
+            await rm(payloadPath, { force: true });
+        }
+    }
     return exec(`gh pr review ${pr} --repo ${shellQuote(repoSpecifier(repository))} --approve`, ghTokenEnv(token));
 }
 export async function postCloseComment(exec, repository, pr, account, body) {
@@ -598,9 +617,9 @@ export async function postCloseComment(exec, repository, pr, account, body) {
         await rm(payloadPath, { force: true });
     }
 }
-function findingComment(finding) {
+function findingComment(finding, body) {
     const comment = {
-        body: `**Issue:** ${finding.issue}\n\n**Fix:** ${finding.fix}`,
+        body: body ?? `**Issue:** ${finding.issue}\n\n**Fix:** ${finding.fix}`,
         line: finding.line,
         path: finding.path,
         side: "RIGHT",
@@ -616,13 +635,13 @@ function changesRequestedBody(findings) {
         ? "Changes requested: 1 inline comment."
         : `Changes requested: ${findings.length} inline comments.`;
 }
-export async function postChangesRequested(exec, repository, pr, account, findings) {
+export async function postChangesRequested(exec, repository, pr, account, findings, options = {}) {
     const token = await ghToken(exec, repository, account);
     const payloadPath = join(tmpdir(), `magi-review-${process.pid}-${Date.now()}.json`);
-    const body = changesRequestedBody(findings);
+    const body = options.body ?? changesRequestedBody(findings);
     await writeFile(payloadPath, JSON.stringify({
         body,
-        comments: findings.map(findingComment),
+        comments: findings.map((finding, index) => findingComment(finding, options.commentBodies?.[index])),
         event: "REQUEST_CHANGES",
     }));
     try {
@@ -685,6 +704,29 @@ export async function waitForAutoMerge(exec, repository, pr, intervalMs = 30_000
         await new Promise((resolve) => setTimeout(resolve, intervalMs));
     }
 }
+export async function fetchBaseBranch(exec, repository, meta, worktreePath) {
+    await exec(`git fetch --no-tags ${shellQuote(repositoryGitUrl(repository, repository.github.owner, repository.github.repo))} ${shellQuote(`refs/heads/${meta.baseRefName}`)}`, { cwd: worktreePath });
+}
+export async function mergeBaseNoCommit(exec, baseSha, worktreePath) {
+    await exec(`git merge --no-commit --no-ff ${shellQuote(baseSha)}`, {
+        cwd: worktreePath,
+    }).catch(() => undefined);
+}
+export async function listUnmergedFiles(exec, worktreePath) {
+    const output = await exec("git diff --name-only --diff-filter=U", {
+        cwd: worktreePath,
+    });
+    return output
+        .split("\n")
+        .map((line) => line.trim())
+        .filter(Boolean);
+}
+export async function abortMerge(exec, worktreePath) {
+    await exec("git merge --abort", { cwd: worktreePath }).catch(() => undefined);
+}
+export async function currentHeadSha(exec, worktreePath) {
+    return (await exec("git rev-parse HEAD", { cwd: worktreePath })).trim();
+}
 export async function closePullRequest(exec, repository, pr, account) {
     const token = await ghToken(exec, repository, account);
     return exec(`gh pr close ${pr} --repo ${shellQuote(repoSpecifier(repository))}`, ghTokenEnv(token));