opencode-magi 0.1.0 → 0.3.0

package/dist/config/validate.js

@@ -9,28 +9,26 @@ 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 });
 const validateSchema = AJV.compile(schema);
+const TRIAGE_CATEGORY_ID_PATTERN = /^[A-Za-z0-9_-]+$/;
+const RESERVED_TRIAGE_CATEGORY_IDS = new Set(["ASK", "none"]);
 const CONFIG_KEYS = new Set([
     "$schema",
     "agents",
-    "automation",
     "clear",
-    "checks",
-    "concurrency",
     "github",
     "language",
     "merge",
     "output",
-    "prompts",
-    "safety",
-    "worktree",
+    "review",
+    "triage",
 ]);
-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 +36,117 @@ const EDITOR_KEYS = new Set([
     "author",
     "model",
     "options",
-    "permission",
+    "permissions",
+    "persona",
+]);
+const TRIAGE_AGENT_KEYS = new Set([
+    "id",
+    "model",
+    "options",
+    "permissions",
+    "persona",
+]);
+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",
+    "safety",
+    "worktree",
+]);
 const MERGE_KEYS = new Set([
+    "automation",
+    "checks",
+    "editor",
+    "maxThreadResolutionCycles",
+    "prompts",
+]);
+const TRIAGE_KEYS = new Set([
+    "account",
+    "agents",
+    "automation",
+    "categories",
+    "concurrency",
+    "creator",
+    "output",
+    "prompts",
+    "safety",
+    "worktree",
+]);
+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 TRIAGE_AUTOMATION_KEYS = new Set([
+    "clear",
+    "close",
+    "create",
+    "merge",
+    "review",
+]);
+const TRIAGE_CATEGORY_KEYS = new Set(["description", "id", "labels", "types"]);
+const TRIAGE_CONCURRENCY_KEYS = new Set(["runs"]);
+const TRIAGE_SAFETY_KEYS = new Set([
+    "allowAuthors",
+    "allowMentionActors",
+    "allowMentionRoles",
+    "blockedLabels",
+    "requiredLabels",
+]);
 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",
+]);
+const TRIAGE_PROMPT_KEYS = new Set([
+    "action",
+    "acceptance",
+    "category",
+    "comment",
+    "commentClassification",
+    "create",
+    "createGuidelines",
+    "duplicate",
+    "existingPr",
+    "question",
+    "reconsider",
+]);
 function githubHost(config) {
     return config.github?.host ?? "github.com";
 }
@@ -210,7 +275,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`);
@@ -221,6 +286,41 @@ function validateReviewerList(reviewers, path, errors, catalog) {
         }
     });
 }
+function validateTriageAgentList(agents, path, errors, catalog) {
+    if (agents == null)
+        return;
+    if (!Array.isArray(agents)) {
+        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 (!agent || typeof agent !== "object") {
+            errors.push(`${path}[${index}] must be an object`);
+            return;
+        }
+        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);
+        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)) {
+                errors.push(`${path}[${index}].id may contain only letters, numbers, underscores, and hyphens`);
+            }
+            if (RESERVED_REVIEWER_KEYS.has(agent.id)) {
+                errors.push(`${path}[${index}].id is reserved: ${agent.id}`);
+            }
+        }
+    });
+}
 function validateResolvedReviewers(reviewers, path, errors) {
     const keys = new Set();
     const accounts = new Set();
@@ -233,7 +333,93 @@ function validateResolvedReviewers(reviewers, path, errors) {
         accounts.add(reviewer.account);
     }
 }
+function validateResolvedAgentKeys(agents, path, errors) {
+    const keys = new Set();
+    for (const agent of agents) {
+        if (keys.has(agent.key))
+            errors.push(`${path} has duplicate agent key: ${agent.key}`);
+        keys.add(agent.key);
+    }
+}
+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 validateTriageCreator(creator, path, errors, catalog) {
+    if (!creator)
+        return;
+    if (!isPlainObject(creator)) {
+        errors.push(`${path} must be an object`);
+        return;
+    }
+    validateKnownKeys(creator, path, TRIAGE_CREATOR_KEYS, errors);
+    if (!creator.model)
+        errors.push(`${path}.model is required`);
+    validateString(creator.account, `${path}.account`, errors);
+    validateString(creator.model, `${path}.model`, errors);
+    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)) {
+        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`);
+        return;
+    }
+    validateKnownKeys(author, `${path}.author`, AUTHOR_KEYS, errors);
+    if (!author.name)
+        errors.push(`${path}.author.name is required`);
+    validateString(author.name, `${path}.author.name`, errors);
+    if (!author.email)
+        errors.push(`${path}.author.email is required`);
+    validateString(author.email, `${path}.author.email`, errors);
+}
 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 +433,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 validateConcurrency(config, errors) {
-    if (config.concurrency != null && !isPlainObject(config.concurrency)) {
-        errors.push("concurrency must be an object");
+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");
     }
-    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");
+}
+function validateConcurrency(config, errors) {
+    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) {
@@ -357,34 +543,142 @@ function validateStringArray(value, path, errors) {
             errors.push(`${path}[${index}] must be a string`);
     });
 }
+function validateTriageCategories(categories, path, errors) {
+    if (categories == null)
+        return;
+    if (!Array.isArray(categories)) {
+        errors.push(`${path} must be an array`);
+        return;
+    }
+    const ids = new Set();
+    categories.forEach((item, index) => {
+        const itemPath = `${path}[${index}]`;
+        if (!isPlainObject(item)) {
+            errors.push(`${itemPath} must be an object`);
+            return;
+        }
+        const category = item;
+        validateKnownKeys(category, itemPath, TRIAGE_CATEGORY_KEYS, errors);
+        if (!category.id) {
+            errors.push(`${itemPath}.id is required`);
+        }
+        else if (typeof category.id !== "string") {
+            errors.push(`${itemPath}.id must be a string`);
+        }
+        else if (!TRIAGE_CATEGORY_ID_PATTERN.test(category.id)) {
+            errors.push(`${itemPath}.id must match /^[A-Za-z0-9_-]+$/`);
+        }
+        else if (RESERVED_TRIAGE_CATEGORY_IDS.has(category.id)) {
+            errors.push(`${itemPath}.id is reserved: ${category.id}`);
+        }
+        else if (ids.has(category.id)) {
+            errors.push(`${itemPath}.id must be unique`);
+        }
+        else {
+            ids.add(category.id);
+        }
+        validateStringArray(category.labels, `${itemPath}.labels`, errors);
+        validateStringArray(category.types, `${itemPath}.types`, errors);
+        validateString(category.description, `${itemPath}.description`, errors);
+    });
+}
 function validateSafety(config, errors) {
-    if (config.safety != null && !isPlainObject(config.safety)) {
-        errors.push("safety must be an object");
+    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");
     }
-    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");
+}
+function validatePromptObject(prompts, path, keys, errors) {
+    if (prompts == null)
+        return;
+    if (!isPlainObject(prompts)) {
+        errors.push(`${path} must be an object`);
+        return;
+    }
+    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) {
-    if (config.prompts == null)
+function validateTriage(config, errors, options) {
+    const triage = config.triage;
+    if (!triage)
         return;
-    if (!isPlainObject(config.prompts)) {
-        errors.push("prompts must be an object");
+    if (!isPlainObject(triage)) {
+        errors.push("triage 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(triage, "triage", TRIAGE_KEYS, errors);
+    const automation = triage.automation;
+    const concurrency = triage.concurrency;
+    const safety = triage.safety;
+    if (!triage.account)
+        errors.push("triage.account is required");
+    validateString(triage.account, "triage.account", errors);
+    if (!triage.agents)
+        errors.push("triage.agents is required");
+    validateTriageAgentList(triage.agents, "triage.agents", errors, options.modelCatalog);
+    if (Array.isArray(triage.agents)) {
+        validateResolvedAgentKeys(resolveAgents(config).triage ?? [], "triage.resolvedAgents", errors);
+    }
+    validateTriageCreator(triage.creator, "triage.creator", errors, options.modelCatalog);
+    if (automation?.create && !triage.creator)
+        errors.push("triage.creator is required when triage.automation.create is true");
+    if (automation != null && !isPlainObject(automation)) {
+        errors.push("triage.automation must be an object");
+    }
+    validateKnownKeys(automation, "triage.automation", TRIAGE_AUTOMATION_KEYS, errors);
+    validateBoolean(automation?.close, "triage.automation.close", errors);
+    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);
+    if (automation?.review && !automation.create) {
+        errors.push("triage.automation.review requires triage.automation.create to be true");
+    }
+    if (automation?.merge && !automation.create) {
+        errors.push("triage.automation.merge requires triage.automation.create to be true");
+    }
+    validateKnownKeys(concurrency, "triage.concurrency", TRIAGE_CONCURRENCY_KEYS, errors);
+    if (concurrency?.runs != null &&
+        (typeof concurrency.runs !== "number" ||
+            !Number.isInteger(concurrency.runs) ||
+            concurrency.runs < 1)) {
+        errors.push("triage.concurrency.runs must be a positive integer");
+    }
+    validateTriageCategories(triage.categories, "triage.categories", errors);
+    validateKnownKeys(safety, "triage.safety", TRIAGE_SAFETY_KEYS, errors);
+    validateStringArray(safety?.allowAuthors, "triage.safety.allowAuthors", errors);
+    validateStringArray(safety?.allowMentionActors, "triage.safety.allowMentionActors", errors);
+    validateStringArray(safety?.allowMentionRoles, "triage.safety.allowMentionRoles", errors);
+    validateStringArray(safety?.blockedLabels, "triage.safety.blockedLabels", errors);
+    validateStringArray(safety?.requiredLabels, "triage.safety.requiredLabels", errors);
+    validateString(triage.output, "triage.output", errors);
+    validateString(triage.worktree, "triage.worktree", errors);
+}
+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);
+    validatePromptObject(config.triage?.prompts, "triage.prompts", TRIAGE_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]),
+        ...Object.entries(config.triage?.prompts ?? {}).map(([key, value]) => [`triage.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,17 +686,21 @@ 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)
         accounts.add(agents.editor.account);
+    if (config.triage?.account)
+        accounts.add(config.triage.account);
+    if (agents.triageCreator?.account)
+        accounts.add(agents.triageCreator.account);
     await Promise.all([...accounts].filter(Boolean).map(async (account) => {
         try {
             await exec(`gh auth token${ghHostOption(config)} --user ${JSON.stringify(account)}`);
@@ -414,13 +712,35 @@ async function validateAuth(config, exec, errors) {
 }
 async function fetchPermissions(config, exec, account) {
     const token = (await exec(`gh auth token${ghHostOption(config)} --user ${JSON.stringify(account)}`)).trim();
-    const raw = await exec(`GH_TOKEN=${JSON.stringify(token)} gh api${ghHostOption(config)} repos/${config.github?.owner}/${config.github?.repo} --jq .permissions`);
+    const raw = await exec(`gh api${ghHostOption(config)} repos/${config.github?.owner}/${config.github?.repo} --jq .permissions`, { env: { GH_TOKEN: token } });
     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 checkTriageCreator = Boolean(config.triage?.automation?.create &&
+        agents.triageCreator &&
+        (options.requireTriage || options.requireWorktreeConfig));
+    if (!checkEditor && !checkTriageCreator)
+        return;
+    if (!exec)
+        return;
+    const error = "git config extensions.worktreeConfig must be true when editor or triage PR creator is configured";
+    try {
+        const value = (await exec("git config --bool --get extensions.worktreeConfig"))
+            .trim()
+            .toLowerCase();
+        if (value !== "true")
+            errors.push(error);
+    }
+    catch {
+        errors.push(error);
+    }
+}
 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);
@@ -432,6 +752,29 @@ async function validateRepositoryPermissions(config, exec, errors, warnings) {
             warnings.push(`Could not validate repository permissions for GitHub account: ${reviewer.account} (${error.message})`);
         }
     }));
+    if (config.triage?.account) {
+        try {
+            const permissions = await fetchPermissions(config, exec, config.triage.account);
+            if (!permissions.pull) {
+                errors.push(`GitHub account cannot read repository for issue triage: ${config.triage.account}`);
+            }
+        }
+        catch (error) {
+            warnings.push(`Could not validate repository permissions for GitHub account: ${config.triage.account} (${error.message})`);
+        }
+    }
+    if (agents.triageCreator?.account &&
+        agents.triageCreator.account !== config.triage?.account) {
+        try {
+            const permissions = await fetchPermissions(config, exec, agents.triageCreator.account);
+            if (!permissions.push) {
+                errors.push(`GitHub account cannot push to repository for triage PR creation: ${agents.triageCreator.account}`);
+            }
+        }
+        catch (error) {
+            warnings.push(`Could not validate repository permissions for GitHub account: ${agents.triageCreator.account} (${error.message})`);
+        }
+    }
     if (!agents.editor)
         return;
     try {
@@ -454,70 +797,41 @@ 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 ((options.requireReview ?? true) && !config.review) {
+        errors.push("review is required");
+    }
+    else if (config.review) {
+        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);
         }
     }
+    if (options.requireTriage && !config.triage) {
+        errors.push("triage is required");
+    }
     validateMerge(config, errors, options);
+    validateReviewMerge(config, errors);
     validateAutomation(config, errors);
     validateClear(config, errors);
     validateChecks(config, errors);
     validateConcurrency(config, errors);
     validateSafety(config, errors);
+    validateTriage(config, errors, options);
     await validatePrompts(config, errors, options.directory);
     if (config.output != null && !isPlainObject(config.output)) {
         errors.push("output must be an object");
@@ -530,28 +844,9 @@ 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);
+    await validateWorktreeConfig(config, options.exec, options, errors);
     if (options.checkAuth && !errors.length) {
         if (!options.exec) {
             errors.push("validateConfig requires exec when checkAuth is true");