opencode-magi 0.6.1 → 0.8.0

package/README.md

@@ -78,7 +78,7 @@ Add the following content to the configuration file.
     }
   },
   "review": {
-    "agents": [
+    "reviewers": [
       { "ref": "account-1" },
       { "ref": "account-2" },
       { "ref": "account-3" }
@@ -87,7 +87,7 @@ Add the following content to the configuration file.
 }
 ```
 
-After refs are expanded, `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.
+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.
 
 #### Set project config
 
@@ -133,7 +133,7 @@ Add the following content to the configuration file.
     }
   },
   "review": {
-    "agents": [
+    "reviewers": [
       { "ref": "account-1" },
       { "ref": "account-2" },
       { "ref": "account-3" }
@@ -143,8 +143,7 @@ Add the following content to the configuration file.
     "editor": { "ref": "account-4" }
   },
   "triage": {
-    "account": "account-5",
-    "agents": [
+    "voters": [
       { "ref": "account-1" },
       { "ref": "account-2" },
       { "ref": "account-3" }
@@ -155,7 +154,18 @@ Add the following content to the configuration file.
 
 Entries with `ref` are expanded from `agents.refs`. Fields set alongside `ref` override fields from the preset.
 
-After refs are expanded, `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.
+`model` can be a single `provider/model` string, a single object with `id` and `options`, or an ordered candidate array. Candidate arrays are resolved during validation against OpenCode's model catalog; the first available model is selected. Put provider-specific options on model objects, not on the agent role.
+
+```json
+{
+  "model": {
+    "id": "openai/gpt-5.1",
+    "options": { "reasoningEffort": "high" }
+  }
+}
+```
+
+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.
 
 #### 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}`;
 }
@@ -33,6 +58,12 @@ export function triageAgentKey(agent, index) {
 export function validateReviewerId(id) {
     return ID_PATTERN.test(id);
 }
+function normalizedModel(model) {
+    if (typeof model !== "string") {
+        throw new Error("model must be normalized before resolving agents");
+    }
+    return model;
+}
 function clonePermissionValue(value) {
     return typeof value === "string" ? value : { ...value };
 }
@@ -86,25 +117,29 @@ export function resolveAgents(config) {
         editor: editor
             ? {
                 ...editor,
+                model: normalizedModel(editor.model),
                 permission: resolveEditorPermission(agents, editor),
             }
             : undefined,
-        reviewers: (config.review?.agents ?? []).map((reviewer, index) => ({
+        reviewers: (config.review?.reviewers ?? []).map((reviewer, index) => ({
             ...reviewer,
             key: reviewerKey(reviewer, index),
             index,
+            model: normalizedModel(reviewer.model),
             permission: resolveReviewerPermission(agents, reviewer),
         })),
-        triage: (config.triage?.agents ?? []).map((agent, index) => ({
+        triage: (config.triage?.voters ?? []).map((agent, index) => ({
             ...agent,
             key: triageAgentKey(agent, index),
             index,
+            model: normalizedModel(agent.model),
             permission: resolveTriageAgentPermission(agents, agent),
         })),
         triageCreator: creator
             ? {
                 ...creator,
                 account: creator.account ?? "",
+                model: normalizedModel(creator.model),
                 permission: resolveTriageCreatorPermission(agents, creator),
             }
             : undefined,
@@ -128,6 +163,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: {
@@ -180,9 +216,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,
             },
@@ -205,6 +241,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

@@ -4,7 +4,7 @@ import { access } from "node:fs/promises";
 import { homedir } from "node:os";
 import { isAbsolute, join } from "node:path";
 import schema from "../../schema.json" with { type: "json" };
-import { resolveAgents, validateReviewerId } from "./resolve";
+import { resolveAgents, reviewerKey, triageAgentKey, validateReviewerId, } from "./resolve";
 const RESERVED_REVIEWER_KEYS = new Set(["editor", "orchestrator", "system"]);
 const PERMISSION_ACTIONS = new Set(["allow", "ask", "deny"]);
 const AJV = new Ajv2020({ allErrors: true, strict: false });
@@ -27,7 +27,6 @@ const REVIEWER_KEYS = new Set([
     "account",
     "id",
     "model",
-    "options",
     "permissions",
     "persona",
 ]);
@@ -35,7 +34,6 @@ const EDITOR_KEYS = new Set([
     "account",
     "author",
     "model",
-    "options",
     "permissions",
     "persona",
 ]);
@@ -43,7 +41,6 @@ const TRIAGE_AGENT_KEYS = new Set([
     "account",
     "id",
     "model",
-    "options",
     "permissions",
     "persona",
 ]);
@@ -51,20 +48,19 @@ const TRIAGE_CREATOR_KEYS = new Set([
     "account",
     "author",
     "model",
-    "options",
     "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",
+    "reviewers",
     "safety",
     "worktree",
 ]);
@@ -76,7 +72,6 @@ const MERGE_KEYS = new Set([
     "prompts",
 ]);
 const TRIAGE_KEYS = new Set([
-    "agents",
     "automation",
     "categories",
     "concurrency",
@@ -85,6 +80,8 @@ const TRIAGE_KEYS = new Set([
     "prompts",
     "reporter",
     "safety",
+    "signals",
+    "voters",
     "worktree",
 ]);
 const REVIEW_MERGE_KEYS = new Set([
@@ -97,17 +94,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",
@@ -116,6 +120,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",
@@ -145,6 +161,7 @@ const TRIAGE_PROMPT_KEYS = new Set([
     "existingPr",
     "reconsider",
 ]);
+const MODEL_CANDIDATE_KEYS = new Set(["id", "options"]);
 function githubHost(config) {
     return config.github?.host ?? "github.com";
 }
@@ -190,14 +207,14 @@ function expandAgentRefs(config, errors) {
     const refsValue = isPlainObject(agents) ? agents.refs : undefined;
     const refsInvalid = refsValue != null && !isPlainObject(refsValue);
     const refs = isPlainObject(refsValue) ? refsValue : undefined;
-    if (Array.isArray(magiConfig.review?.agents)) {
-        magiConfig.review.agents = magiConfig.review.agents.map((agent, index) => expandAgentRefUse(agent, `review.agents[${index}]`, refs, refsInvalid, errors));
+    if (Array.isArray(magiConfig.review?.reviewers)) {
+        magiConfig.review.reviewers = magiConfig.review.reviewers.map((agent, index) => expandAgentRefUse(agent, `review.reviewers[${index}]`, refs, refsInvalid, errors));
     }
     if (isPlainObject(magiConfig.merge?.editor)) {
         magiConfig.merge.editor = expandAgentRefUse(magiConfig.merge.editor, "merge.editor", refs, refsInvalid, errors);
     }
-    if (Array.isArray(magiConfig.triage?.agents)) {
-        magiConfig.triage.agents = magiConfig.triage.agents.map((agent, index) => expandAgentRefUse(agent, `triage.agents[${index}]`, refs, refsInvalid, errors));
+    if (Array.isArray(magiConfig.triage?.voters)) {
+        magiConfig.triage.voters = magiConfig.triage.voters.map((agent, index) => expandAgentRefUse(agent, `triage.voters[${index}]`, refs, refsInvalid, errors));
     }
     if (isPlainObject(magiConfig.triage?.creator)) {
         magiConfig.triage.creator = expandAgentRefUse(magiConfig.triage.creator, "triage.creator", refs, refsInvalid, errors);
@@ -275,26 +292,97 @@ function validatePermissionConfig(permission, path, errors) {
         }
     }
 }
-function validateModel(model, path, errors, catalog) {
-    if (!model)
-        return;
+function modelValidationError(model, path, catalog) {
     const slash = model.indexOf("/");
-    if (slash <= 0 || slash === model.length - 1) {
-        errors.push(`${path} must be a full OpenCode model ID in provider/model form`);
-        return;
-    }
+    if (slash <= 0 || slash === model.length - 1)
+        return `${path} must be a full OpenCode model ID in provider/model form`;
     if (!catalog)
-        return;
+        return undefined;
     const providerId = model.slice(0, slash);
     const modelId = model.slice(slash + 1);
     const models = catalog[providerId];
-    if (!models) {
-        errors.push(`${path} uses unknown OpenCode provider: ${providerId}`);
+    if (!models)
+        return `${path} uses unknown OpenCode provider: ${providerId}`;
+    if (!models.includes(modelId))
+        return `${path} uses unknown OpenCode model: ${model}`;
+    return undefined;
+}
+function validateModelId(model, path, errors, catalog) {
+    const error = modelValidationError(model, path, catalog);
+    if (error) {
+        errors.push(error);
+        return false;
+    }
+    return true;
+}
+function readModelCandidate(value, path, errors) {
+    if (typeof value === "string")
+        return { id: value };
+    if (!isPlainObject(value)) {
+        errors.push(`${path} must be a string or an object`);
+        return undefined;
+    }
+    validateKnownKeys(value, path, MODEL_CANDIDATE_KEYS, errors);
+    if (typeof value.id !== "string") {
+        errors.push(`${path}.id must be a string`);
+        return undefined;
+    }
+    if (value.options != null && !isPlainObject(value.options)) {
+        errors.push(`${path}.options must be an object`);
+        return undefined;
+    }
+    return { id: value.id, options: value.options };
+}
+function validateAndNormalizeModel(target, path, errors, catalog) {
+    const model = target.model;
+    if (typeof model === "string") {
+        validateModelId(model, path, errors, catalog);
+        return;
+    }
+    if (isPlainObject(model)) {
+        const candidate = readModelCandidate(model, path, errors);
+        if (candidate &&
+            validateModelId(candidate.id, `${path}.id`, errors, catalog)) {
+            target.model = candidate.id;
+            if (candidate.options)
+                target.options = candidate.options;
+            else
+                delete target.options;
+        }
+        return;
+    }
+    if (!Array.isArray(model)) {
+        if (model != null)
+            errors.push(`${path} must be a string, an object, or an array`);
+        return;
+    }
+    if (!model.length) {
+        errors.push(`${path} must contain at least one model candidate`);
         return;
     }
-    if (!models.includes(modelId)) {
-        errors.push(`${path} uses unknown OpenCode model: ${model}`);
+    if (!catalog) {
+        errors.push(`${path} requires an OpenCode model catalog`);
+        return;
     }
+    const candidateErrors = [];
+    for (const [index, value] of model.entries()) {
+        const candidatePath = `${path}[${index}]`;
+        const candidate = readModelCandidate(value, candidatePath, errors);
+        if (!candidate)
+            continue;
+        const idPath = isPlainObject(value) ? `${candidatePath}.id` : candidatePath;
+        const error = modelValidationError(candidate.id, idPath, catalog);
+        if (!error) {
+            target.model = candidate.id;
+            if (candidate.options)
+                target.options = candidate.options;
+            else
+                delete target.options;
+            return;
+        }
+        candidateErrors.push(error);
+    }
+    errors.push(`${path} must contain at least one usable OpenCode model candidate${candidateErrors.length ? ` (${candidateErrors.join("; ")})` : ""}`);
 }
 function validateReviewerList(reviewers, path, errors, catalog) {
     if (reviewers == null)
@@ -315,14 +403,11 @@ function validateReviewerList(reviewers, path, errors, catalog) {
         validateKnownKeys(reviewer, `${path}[${index}]`, REVIEWER_KEYS, errors);
         if (!reviewer.model)
             errors.push(`${path}[${index}].model is required`);
-        validateString(reviewer.model, `${path}[${index}].model`, errors);
-        validateModel(reviewer.model, `${path}[${index}].model`, errors, catalog);
+        validateAndNormalizeModel(reviewer, `${path}[${index}].model`, errors, catalog);
         if (!reviewer.account)
             errors.push(`${path}[${index}].account is required`);
         validateString(reviewer.account, `${path}[${index}].account`, errors);
         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.permissions, `${path}[${index}].permissions`, errors);
         if (reviewer.id) {
             if (!validateReviewerId(reviewer.id)) {
@@ -334,18 +419,18 @@ function validateReviewerList(reviewers, path, errors, catalog) {
         }
     });
 }
-function validateTriageAgentList(agents, path, errors, catalog) {
-    if (agents == null)
+function validateTriageAgentList(voters, path, errors, catalog) {
+    if (voters == null)
         return;
-    if (!Array.isArray(agents)) {
+    if (!Array.isArray(voters)) {
         errors.push(`${path} must be an array`);
         return;
     }
-    if (agents.length < 3)
-        errors.push(`${path} must contain at least 3 agents`);
-    if (agents.length % 2 === 0)
-        errors.push(`${path} must contain an odd number of agents`);
-    agents.forEach((agent, index) => {
+    if (voters.length < 3)
+        errors.push(`${path} must contain at least 3 voters`);
+    if (voters.length % 2 === 0)
+        errors.push(`${path} must contain an odd number of voters`);
+    voters.forEach((agent, index) => {
         if (!agent || typeof agent !== "object") {
             errors.push(`${path}[${index}] must be an object`);
             return;
@@ -353,14 +438,11 @@ function validateTriageAgentList(agents, path, errors, catalog) {
         validateKnownKeys(agent, `${path}[${index}]`, TRIAGE_AGENT_KEYS, errors);
         if (!agent.model)
             errors.push(`${path}[${index}].model is required`);
-        validateString(agent.model, `${path}[${index}].model`, errors);
-        validateModel(agent.model, `${path}[${index}].model`, errors, catalog);
+        validateAndNormalizeModel(agent, `${path}[${index}].model`, errors, catalog);
         if (!agent.account)
             errors.push(`${path}[${index}].account is required`);
         validateString(agent.account, `${path}[${index}].account`, errors);
         validateString(agent.persona, `${path}[${index}].persona`, errors);
-        if (agent.options != null && !isPlainObject(agent.options))
-            errors.push(`${path}[${index}].options must be an object`);
         validatePermissionConfig(agent.permissions, `${path}[${index}].permissions`, errors);
         if (agent.id) {
             if (!validateReviewerId(agent.id)) {
@@ -406,15 +488,11 @@ function validateEditor(editor, path, errors, catalog) {
     if (!editor.model)
         errors.push(`${path}.model is required`);
     validateKnownKeys(editor, path, EDITOR_KEYS, errors);
-    validateString(editor.model, `${path}.model`, errors);
+    validateAndNormalizeModel(editor, `${path}.model`, errors, catalog);
     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)) {
@@ -450,12 +528,8 @@ function validateTriageCreator(creator, path, errors, catalog) {
     if (!creator.model)
         errors.push(`${path}.model is required`);
     validateString(creator.account, `${path}.account`, errors);
-    validateString(creator.model, `${path}.model`, errors);
+    validateAndNormalizeModel(creator, `${path}.model`, errors, catalog);
     validateString(creator.persona, `${path}.persona`, errors);
-    validateModel(creator.model, `${path}.model`, errors, catalog);
-    if (creator.options != null && !isPlainObject(creator.options)) {
-        errors.push(`${path}.options must be an object`);
-    }
     validatePermissionConfig(creator.permissions, `${path}.permissions`, errors);
     const author = creator.author;
     if (!author || !isPlainObject(author)) {
@@ -498,7 +572,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);
@@ -637,6 +711,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)) {
@@ -680,15 +827,20 @@ function validateTriage(config, errors, options) {
     const creator = triage.creator;
     const reporter = typeof triage.reporter === "string" ? triage.reporter : undefined;
     const safety = triage.safety;
-    if (!triage.agents)
-        errors.push("triage.agents is required");
-    validateTriageAgentList(triage.agents, "triage.agents", errors, options.modelCatalog);
-    if (Array.isArray(triage.agents)) {
-        const resolvedTriageAgents = resolveAgents(config).triage ?? [];
+    if (!triage.voters)
+        errors.push("triage.voters is required");
+    validateTriageAgentList(triage.voters, "triage.voters", errors, options.modelCatalog);
+    if (Array.isArray(triage.voters)) {
+        const resolvedTriageAgents = triage.voters.map((agent, index) => ({
+            account: agent && typeof agent === "object" && typeof agent.account === "string"
+                ? agent.account
+                : "",
+            key: agent && typeof agent === "object" ? triageAgentKey(agent, index) : "",
+        }));
         validateResolvedTriageAgents(resolvedTriageAgents, "triage.resolvedAgents", errors);
         if (reporter != null &&
             !resolvedTriageAgents.some((agent) => agent.key === reporter)) {
-            errors.push(`triage.reporter must match a triage agent key: ${reporter}`);
+            errors.push(`triage.reporter must match a triage voter key: ${reporter}`);
         }
     }
     validateString(triage.reporter, "triage.reporter", errors);
@@ -705,7 +857,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");
     }
@@ -720,6 +872,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);
@@ -778,10 +931,10 @@ async function fetchPermissions(config, exec, account) {
     return JSON.parse(raw);
 }
 async function validateWorktreeConfig(config, exec, options, errors) {
-    const agents = resolveAgents(config);
-    const checkEditor = Boolean(agents.editor && (options.requireEditor || options.requireWorktreeConfig));
+    const checkEditor = Boolean(config.merge?.editor &&
+        (options.requireEditor || options.requireWorktreeConfig));
     const checkTriageCreator = Boolean(config.triage?.automation?.create &&
-        agents.triageCreator &&
+        config.triage?.creator &&
         (options.requireTriage || options.requireWorktreeConfig));
     if (!checkEditor && !checkTriageCreator)
         return;
@@ -853,6 +1006,9 @@ export async function validateConfig(config, options = {}) {
     const warnings = [];
     if (!config || typeof config !== "object")
         errors.push("config must be an object");
+    if (options.requireModelCatalog && !options.modelCatalog) {
+        errors.push("OpenCode model catalog could not be loaded");
+    }
     expandAgentRefs(config, errors);
     if (config && typeof config === "object")
         validateJsonSchema(config, errors);
@@ -876,11 +1032,20 @@ export async function validateConfig(config, options = {}) {
         else {
             validateKnownKeys(config.review, "review", REVIEW_KEYS, 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);
+        if (!config.review.reviewers)
+            errors.push("review.reviewers is required");
+        validateReviewerList(config.review.reviewers, "review.reviewers", errors, options.modelCatalog);
+        if (Array.isArray(config.review.reviewers)) {
+            validateResolvedReviewers(config.review.reviewers.map((reviewer, index) => ({
+                account: reviewer &&
+                    typeof reviewer === "object" &&
+                    typeof reviewer.account === "string"
+                    ? reviewer.account
+                    : "",
+                key: reviewer && typeof reviewer === "object"
+                    ? reviewerKey(reviewer, index)
+                    : "",
+            })), "review.resolvedReviewers", errors);
         }
     }
     if (options.requireTriage && !config.triage) {