opencode-magi 0.2.0 → 0.4.0

package/README.md

@@ -126,6 +126,23 @@ Add the following content to the configuration file.
         "email": "your-email@example.com"
       }
     }
+  },
+  "triage": {
+    "account": "your-triage-account",
+    "agents": [
+      {
+        "id": "general",
+        "model": "openai/gpt-5.5"
+      },
+      {
+        "id": "maintenance",
+        "model": "anthropic/claude-opus-4-7"
+      },
+      {
+        "id": "product",
+        "model": "opencode/kimi-k2-6"
+      }
+    ]
   }
 }
 ```
@@ -149,6 +166,8 @@ Run commands from OpenCode.
 /magi:review --dry-run 123
 /magi:merge 123
 /magi:merge --dry-run 123
+/magi:triage 47 48
+/magi:triage --dry-run 47
 /magi:clear
 ```
 

package/dist/commands.js

@@ -7,6 +7,10 @@ export const MAGI_COMMANDS = {
         description: "Review and merge pull requests with Magi",
         template: [`Call the \`magi_merge\` tool.`, "PR: $ARGUMENTS"].join("\n"),
     },
+    "magi:triage": {
+        description: "Triage GitHub issues with Magi",
+        template: [`Call the \`magi_triage\` tool.`, "Issue: $ARGUMENTS"].join("\n"),
+    },
     "magi:review": {
         description: "Review pull requests with Magi",
         template: [`Call the \`magi_review\` tool.`, "PR: $ARGUMENTS"].join("\n"),

package/dist/config/output.js

@@ -1,16 +1,25 @@
 import { isAbsolute, join } from "node:path";
 const DEFAULT_OUTPUT_DIRS = {
+    issue: ".magi/runs/issue",
     pr: ".magi/runs/pr",
 };
 function resolvePath(directory, path) {
     return isAbsolute(path) ? path : join(directory, path);
 }
 export function outputBaseDir(directory, config, kind) {
-    return resolvePath(directory, config.review?.output ?? DEFAULT_OUTPUT_DIRS[kind]);
+    return resolvePath(directory, kind === "issue"
+        ? (config.triage?.output ?? DEFAULT_OUTPUT_DIRS[kind])
+        : (config.review?.output ?? DEFAULT_OUTPUT_DIRS[kind]));
 }
 export function outputBaseDirs(directory, config) {
-    return [outputBaseDir(directory, config, "pr")];
+    return [
+        outputBaseDir(directory, config, "pr"),
+        outputBaseDir(directory, config, "issue"),
+    ];
 }
 export function prRunOutputDir(input) {
     return join(outputBaseDir(input.directory, input.config, "pr"), String(input.pr), ...(input.runId ? [input.runId] : []));
 }
+export function issueRunOutputDir(input) {
+    return join(outputBaseDir(input.directory, input.config, "issue"), String(input.issue), ...(input.runId ? [input.runId] : []));
+}

package/dist/config/resolve.js

@@ -4,9 +4,32 @@ const ID_PATTERN = /^[A-Za-z0-9_-]+$/;
 const DEFAULT_COMMON_PERMISSION = commonPermission;
 const DEFAULT_REVIEWER_PERMISSION = DEFAULT_COMMON_PERMISSION;
 const DEFAULT_EDITOR_PERMISSION = mergePermissions(DEFAULT_COMMON_PERMISSION, editorPermission);
+const DEFAULT_TRIAGE_CATEGORIES = [
+    {
+        description: "Something is broken or behaves incorrectly.",
+        id: "bug",
+        labels: ["bug"],
+        types: ["Bug"],
+    },
+    {
+        description: "Maintenance, refactoring, chores, or planned work.",
+        id: "task",
+        labels: ["task"],
+        types: ["Task"],
+    },
+    {
+        description: "New or improved user-facing capability.",
+        id: "feature",
+        labels: ["enhancement"],
+        types: ["Feature"],
+    },
+];
 export function reviewerKey(reviewer, index) {
     return reviewer.id ?? `reviewer-${index + 1}`;
 }
+export function triageAgentKey(agent, index) {
+    return agent.id ?? `triage-${index + 1}`;
+}
 export function validateReviewerId(id) {
     return ID_PATTERN.test(id);
 }
@@ -49,9 +72,16 @@ export function resolveReviewerPermission(agents, reviewer) {
 export function resolveEditorPermission(agents, editor) {
     return mergePermissions(mergePermissions(DEFAULT_EDITOR_PERMISSION, agents.permissions), editor.permissions);
 }
+export function resolveTriageAgentPermission(agents, agent) {
+    return mergePermissions(mergePermissions(DEFAULT_REVIEWER_PERMISSION, agents.permissions), agent.permissions);
+}
+export function resolveTriageCreatorPermission(agents, creator) {
+    return mergePermissions(mergePermissions(DEFAULT_EDITOR_PERMISSION, agents.permissions), creator.permissions);
+}
 export function resolveAgents(config) {
     const agents = config.agents ?? {};
     const editor = config.merge?.editor;
+    const creator = config.triage?.creator;
     return {
         editor: editor
             ? {
@@ -65,8 +95,29 @@ export function resolveAgents(config) {
             index,
             permission: resolveReviewerPermission(agents, reviewer),
         })),
+        triage: (config.triage?.agents ?? []).map((agent, index) => ({
+            ...agent,
+            key: triageAgentKey(agent, index),
+            index,
+            permission: resolveTriageAgentPermission(agents, agent),
+        })),
+        triageCreator: creator
+            ? {
+                ...creator,
+                account: creator.account ?? config.triage?.account ?? "",
+                permission: resolveTriageCreatorPermission(agents, creator),
+            }
+            : undefined,
     };
 }
+function resolveTriageCategories(config) {
+    return (config.triage?.categories ?? DEFAULT_TRIAGE_CATEGORIES).map((category) => ({
+        description: category.description,
+        id: category.id ?? "",
+        labels: category.labels ?? [],
+        types: category.types ?? [],
+    }));
+}
 export function resolveRepository(config) {
     if (!config.github?.owner)
         throw new Error("github.owner is required");
@@ -119,7 +170,7 @@ export function resolveRepository(config) {
         },
         reviewAutomation: {
             close: config.review?.automation?.close ?? false,
-            merge: config.review?.automation?.merge ?? false,
+            merge: config.review?.automation?.merge ?? true,
         },
         safety: {
             allowAuthors: config.review?.safety?.allowAuthors ?? [],
@@ -127,5 +178,34 @@ export function resolveRepository(config) {
             maxChangedFiles: config.review?.safety?.maxChangedFiles,
             requiredLabels: config.review?.safety?.requiredLabels ?? [],
         },
+        triage: {
+            account: config.triage?.account,
+            automation: {
+                clear: config.triage?.automation?.clear ?? ["triage"],
+                close: config.triage?.automation?.close ?? false,
+                create: config.triage?.automation?.create ?? false,
+                merge: config.triage?.automation?.merge ?? false,
+                review: config.triage?.automation?.review ?? false,
+            },
+            categories: resolveTriageCategories(config),
+            concurrency: {
+                runs: config.triage?.concurrency?.runs ?? 3,
+            },
+            output: config.triage?.output,
+            prompts: config.triage?.prompts ?? {},
+            safety: {
+                allowAuthors: config.triage?.safety?.allowAuthors ?? [],
+                allowMentionActors: config.triage?.safety?.allowMentionActors ?? [],
+                allowMentionRoles: config.triage?.safety?.allowMentionRoles ?? [
+                    "AUTHOR",
+                    "OWNER",
+                    "MEMBER",
+                    "COLLABORATOR",
+                ],
+                blockedLabels: config.triage?.safety?.blockedLabels ?? [],
+                requiredLabels: config.triage?.safety?.requiredLabels ?? ["triage"],
+            },
+            worktree: config.triage?.worktree,
+        },
     };
 }

package/dist/config/validate.js

@@ -9,6 +9,8 @@ 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",
@@ -18,6 +20,7 @@ const CONFIG_KEYS = new Set([
     "merge",
     "output",
     "review",
+    "triage",
 ]);
 const AGENTS_KEYS = new Set(["permissions"]);
 const REVIEWER_KEYS = new Set([
@@ -36,6 +39,21 @@ const EDITOR_KEYS = new Set([
     "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([
@@ -56,6 +74,18 @@ const MERGE_KEYS = new Set([
     "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",
@@ -69,6 +99,22 @@ 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(["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",
@@ -88,6 +134,19 @@ const MERGE_PROMPT_KEYS = new Set([
     "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";
 }
@@ -98,6 +157,56 @@ function ghHostOption(config) {
 function isPlainObject(value) {
     return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
+function expandAgentRefUse(value, path, refs, refsInvalid, errors) {
+    if (!isPlainObject(value) || !Object.hasOwn(value, "ref"))
+        return value;
+    const use = { ...value };
+    const ref = use.ref;
+    delete use.ref;
+    if (typeof ref !== "string") {
+        errors.push(`${path}.ref must be a string`);
+        return use;
+    }
+    if (refsInvalid) {
+        errors.push(`agents.refs must be an object to resolve ${path}.ref`);
+        return use;
+    }
+    const preset = refs?.[ref];
+    if (preset == null) {
+        errors.push(`${path}.ref references unknown agents.refs preset: ${ref}`);
+        return use;
+    }
+    if (!isPlainObject(preset)) {
+        errors.push(`agents.refs.${ref} must be an object when referenced by ${path}.ref`);
+        return use;
+    }
+    const presetFields = { ...preset };
+    delete presetFields.ref;
+    return { ...presetFields, ...use };
+}
+function expandAgentRefs(config, errors) {
+    if (!config || typeof config !== "object")
+        return;
+    const magiConfig = config;
+    const agents = magiConfig.agents;
+    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 (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 (isPlainObject(magiConfig.triage?.creator)) {
+        magiConfig.triage.creator = expandAgentRefUse(magiConfig.triage.creator, "triage.creator", refs, refsInvalid, errors);
+    }
+    if (isPlainObject(magiConfig.agents))
+        delete magiConfig.agents.refs;
+}
 function validateKnownKeys(value, path, keys, errors) {
     if (!isPlainObject(value))
         return;
@@ -227,6 +336,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();
@@ -239,6 +383,14 @@ 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;
@@ -282,6 +434,40 @@ function validateEditor(editor, path, errors, catalog) {
         }
     }
 }
+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) {
@@ -407,6 +593,45 @@ 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) {
     const safety = config.review?.safety;
     if (safety != null && !isPlainObject(safety)) {
@@ -436,12 +661,70 @@ function validatePromptObject(prompts, path, keys, errors) {
             errors.push(`${path}.${key} must be a string`);
     }
 }
+function validateTriage(config, errors, options) {
+    const triage = config.triage;
+    if (!triage)
+        return;
+    if (!isPlainObject(triage)) {
+        errors.push("triage must be an object");
+        return;
+    }
+    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")
@@ -464,6 +747,10 @@ async function validateAuth(config, exec, errors) {
         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)}`);
@@ -475,9 +762,31 @@ 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;
@@ -493,6 +802,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 {
@@ -510,6 +842,7 @@ export async function validateConfig(config, options = {}) {
     const warnings = [];
     if (!config || typeof config !== "object")
         errors.push("config must be an object");
+    expandAgentRefs(config, errors);
     if (config && typeof config === "object")
         validateJsonSchema(config, errors);
     validateKnownKeys(config, "config", CONFIG_KEYS, errors);
@@ -522,10 +855,10 @@ export async function validateConfig(config, options = {}) {
         validateKnownKeys(config.agents, "agents", AGENTS_KEYS, errors);
         validatePermissionConfig(config.agents?.permissions, "agents.permissions", errors);
     }
-    if (!config.review) {
+    if ((options.requireReview ?? true) && !config.review) {
         errors.push("review is required");
     }
-    else {
+    else if (config.review) {
         if (!isPlainObject(config.review)) {
             errors.push("review must be an object");
         }
@@ -539,6 +872,9 @@ export async function validateConfig(config, options = {}) {
             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);
@@ -546,6 +882,7 @@ export async function validateConfig(config, options = {}) {
     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");
@@ -560,6 +897,7 @@ export async function validateConfig(config, options = {}) {
     }
     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");