opencode-magi 0.0.0-dev-20260520171120 → 0.0.0-dev-20260520175008

package/dist/config/resolve.js

@@ -4,6 +4,26 @@ 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}`;
 }
@@ -90,6 +110,14 @@ export function resolveAgents(config) {
             : 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");
@@ -157,19 +185,10 @@ export function resolveRepository(config) {
                 close: config.triage?.automation?.close ?? false,
                 pr: config.triage?.automation?.pr ?? false,
             },
+            categories: resolveTriageCategories(config),
             concurrency: {
                 runs: config.triage?.concurrency?.runs ?? 3,
             },
-            kind: {
-                bug: {
-                    label: config.triage?.kind?.bug?.label ?? ["bug"],
-                    type: config.triage?.kind?.bug?.type ?? ["Bug"],
-                },
-                feature: {
-                    label: config.triage?.kind?.feature?.label ?? ["enhancement"],
-                    type: config.triage?.kind?.feature?.type ?? ["Feature"],
-                },
-            },
             output: config.triage?.output,
             prompts: config.triage?.prompts ?? {},
             safety: {

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",
@@ -76,9 +78,9 @@ const TRIAGE_KEYS = new Set([
     "account",
     "agents",
     "automation",
+    "categories",
     "concurrency",
     "creator",
-    "kind",
     "output",
     "prompts",
     "safety",
@@ -98,9 +100,8 @@ 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", "pr"]);
+const TRIAGE_CATEGORY_KEYS = new Set(["description", "id", "labels", "types"]);
 const TRIAGE_CONCURRENCY_KEYS = new Set(["runs"]);
-const TRIAGE_KIND_KEYS = new Set(["bug", "feature"]);
-const TRIAGE_KIND_RULE_KEYS = new Set(["label", "type"]);
 const TRIAGE_SAFETY_KEYS = new Set([
     "allowAuthors",
     "allowMentionActors",
@@ -129,14 +130,13 @@ const MERGE_PROMPT_KEYS = new Set([
 ]);
 const TRIAGE_PROMPT_KEYS = new Set([
     "action",
-    "bug",
+    "acceptance",
+    "category",
     "comment",
     "commentClassification",
     "createPr",
     "duplicate",
     "existingPr",
-    "feature",
-    "kind",
     "question",
     "reconsider",
 ]);
@@ -536,16 +536,44 @@ function validateStringArray(value, path, errors) {
             errors.push(`${path}[${index}] must be a string`);
     });
 }
-function validateStringArrayObject(value, path, keys, errors) {
-    if (value == null)
+function validateTriageCategories(categories, path, errors) {
+    if (categories == null)
         return;
-    if (!isPlainObject(value)) {
-        errors.push(`${path} must be an object`);
+    if (!Array.isArray(categories)) {
+        errors.push(`${path} must be an array`);
         return;
     }
-    validateKnownKeys(value, path, keys, errors);
-    for (const key of keys)
-        validateStringArray(value[key], `${path}.${key}`, errors);
+    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;
@@ -587,7 +615,6 @@ function validateTriage(config, errors, options) {
     validateKnownKeys(triage, "triage", TRIAGE_KEYS, errors);
     const automation = triage.automation;
     const concurrency = triage.concurrency;
-    const kind = triage.kind;
     const safety = triage.safety;
     if (!triage.account)
         errors.push("triage.account is required");
@@ -615,9 +642,7 @@ function validateTriage(config, errors, options) {
             concurrency.runs < 1)) {
         errors.push("triage.concurrency.runs must be a positive integer");
     }
-    validateKnownKeys(kind, "triage.kind", TRIAGE_KIND_KEYS, errors);
-    validateStringArrayObject(kind?.bug, "triage.kind.bug", TRIAGE_KIND_RULE_KEYS, errors);
-    validateStringArrayObject(kind?.feature, "triage.kind.feature", TRIAGE_KIND_RULE_KEYS, errors);
+    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);

package/dist/index.js

@@ -91,27 +91,133 @@ export function parseIssues(value) {
         throw new Error("Specify one or more issue numbers or issue URLs.");
     return issues;
 }
-export function parseRunArguments(value, dryRun = false) {
+export function parseRunArguments(value, dryRun = false, command = "review") {
     const tokens = value.split(/[\s,]+/).filter(Boolean);
-    const prTokens = tokens.filter((token) => {
+    const configOverrides = {};
+    const prTokens = [];
+    for (let index = 0; index < tokens.length; index++) {
+        const token = tokens[index];
         if (token === "--dry-run") {
             dryRun = true;
-            return false;
+            continue;
         }
-        return true;
-    });
-    return { dryRun, prs: parsePrs(prTokens.join(" ")) };
+        switch (token) {
+            case "--language":
+                setConfigOverride(configOverrides, ["language"], nextFlagValue(tokens, ++index, token));
+                break;
+            case "--merge":
+            case "--no-merge":
+                setConfigOverride(configOverrides, [command, "automation", "merge"], token === "--merge");
+                break;
+            case "--close":
+            case "--no-close":
+                setConfigOverride(configOverrides, [command, "automation", "close"], token === "--close");
+                break;
+            case "--max-cycles":
+                if (command !== "merge")
+                    throw unsupportedFlag(token, command);
+                setConfigOverride(configOverrides, ["merge", "maxThreadResolutionCycles"], parseIntegerFlag(nextFlagValue(tokens, ++index, token), token, 0));
+                break;
+            case "--retry-failed-jobs":
+                setConfigOverride(configOverrides, ["review", "checks", "retryFailedJobs"], parseIntegerFlag(nextFlagValue(tokens, ++index, token), token, 0));
+                break;
+            case "--reviewer-concurrency":
+                setConfigOverride(configOverrides, ["review", "concurrency", "reviewers"], parseIntegerFlag(nextFlagValue(tokens, ++index, token), token, 1));
+                break;
+            case "--run-concurrency":
+                setConfigOverride(configOverrides, ["review", "concurrency", "runs"], parseIntegerFlag(nextFlagValue(tokens, ++index, token), token, 1));
+                break;
+            case "--wait-checks":
+            case "--no-wait-checks":
+                setConfigOverride(configOverrides, ["review", "checks", "wait"], token === "--wait-checks");
+                break;
+            case "--wait-checks-after-edit":
+            case "--no-wait-checks-after-edit":
+                if (command !== "merge")
+                    throw unsupportedFlag(token, command);
+                setConfigOverride(configOverrides, ["merge", "checks", "wait"], token === "--wait-checks-after-edit");
+                break;
+            case "--pr":
+            case "--no-pr":
+                throw unsupportedFlag(token, command);
+            default:
+                if (token.startsWith("--"))
+                    throw unsupportedFlag(token, command);
+                prTokens.push(token);
+        }
+    }
+    return { configOverrides, dryRun, prs: parsePrs(prTokens.join(" ")) };
 }
 export function parseIssueRunArguments(value, dryRun = false) {
     const tokens = value.split(/[\s,]+/).filter(Boolean);
-    const issueTokens = tokens.filter((token) => {
+    const configOverrides = {};
+    const issueTokens = [];
+    for (let index = 0; index < tokens.length; index++) {
+        const token = tokens[index];
         if (token === "--dry-run") {
             dryRun = true;
-            return false;
+            continue;
         }
-        return true;
-    });
-    return { dryRun, issues: parseIssues(issueTokens.join(" ")) };
+        switch (token) {
+            case "--language":
+                setConfigOverride(configOverrides, ["language"], nextFlagValue(tokens, ++index, token));
+                break;
+            case "--close":
+            case "--no-close":
+                setConfigOverride(configOverrides, ["triage", "automation", "close"], token === "--close");
+                break;
+            case "--pr":
+            case "--no-pr":
+                setConfigOverride(configOverrides, ["triage", "automation", "pr"], token === "--pr");
+                break;
+            case "--run-concurrency":
+                setConfigOverride(configOverrides, ["triage", "concurrency", "runs"], parseIntegerFlag(nextFlagValue(tokens, ++index, token), token, 1));
+                break;
+            case "--merge":
+            case "--no-merge":
+            case "--max-cycles":
+            case "--retry-failed-jobs":
+            case "--reviewer-concurrency":
+            case "--wait-checks":
+            case "--no-wait-checks":
+            case "--wait-checks-after-edit":
+            case "--no-wait-checks-after-edit":
+                throw unsupportedFlag(token, "triage");
+            default:
+                if (token.startsWith("--"))
+                    throw unsupportedFlag(token, "triage");
+                issueTokens.push(token);
+        }
+    }
+    return { configOverrides, dryRun, issues: parseIssues(issueTokens.join(" ")) };
+}
+function nextFlagValue(tokens, index, flag) {
+    const value = tokens[index];
+    if (!value || value.startsWith("--"))
+        throw new Error(`${flag} requires a value.`);
+    return value;
+}
+function parseIntegerFlag(value, flag, minimum) {
+    const parsed = Number.parseInt(value, 10);
+    if (!Number.isInteger(parsed) ||
+        String(parsed) !== value ||
+        parsed < minimum) {
+        throw new Error(`${flag} must be an integer greater than or equal to ${minimum}.`);
+    }
+    return parsed;
+}
+function setConfigOverride(target, path, value) {
+    let current = target;
+    for (const key of path.slice(0, -1)) {
+        const existing = current[key];
+        const next = isPlainObject(existing) ? existing : {};
+        current[key] = next;
+        current = next;
+    }
+    current[path[path.length - 1]] = value;
+}
+function unsupportedFlag(flag, command) {
+    return new Error(`${flag} is not supported for /magi:${command}.`);
 }
 function parseOptionalPr(value) {
     if (!value?.trim())
@@ -322,10 +428,11 @@ export const MagiPlugin = async ({ client, directory }) => {
                     dryRun: tool.schema.boolean().optional(),
                 },
                 async execute(args, context) {
-                    const parsed = parseRunArguments(args.prs, args.dryRun ?? false);
+                    const parsed = parseRunArguments(args.prs, args.dryRun ?? false, "merge");
                     const loaded = await loadConfig(directory);
-                    const retryingExec = withGitHubApiRetry(exec, loaded.config.github?.apiRetryAttempts ?? 3);
-                    const validation = await validateConfig(loaded.config, {
+                    const config = mergeMagiConfig(loaded.config, parsed.configOverrides);
+                    const retryingExec = withGitHubApiRetry(exec, config.github?.apiRetryAttempts ?? 3);
+                    const validation = await validateConfig(config, {
                         checkAuth: true,
                         directory,
                         exec: retryingExec,
@@ -334,9 +441,9 @@ export const MagiPlugin = async ({ client, directory }) => {
                     });
                     if (!validation.ok)
                         return JSON.stringify(validation, null, 2);
-                    const repository = resolveRepository(loaded.config);
+                    const repository = resolveRepository(config);
                     const states = await mapPool(parsed.prs, repository.concurrency.runs, (pr) => runManager.startMerge({
-                        config: loaded.config,
+                        config,
                         dryRun: parsed.dryRun,
                         repository,
                         pr,
@@ -360,8 +467,9 @@ export const MagiPlugin = async ({ client, directory }) => {
                 async execute(args, context) {
                     const parsed = parseRunArguments(args.prs, args.dryRun ?? false);
                     const loaded = await loadConfig(directory);
-                    const retryingExec = withGitHubApiRetry(exec, loaded.config.github?.apiRetryAttempts ?? 3);
-                    const validation = await validateConfig(loaded.config, {
+                    const config = mergeMagiConfig(loaded.config, parsed.configOverrides);
+                    const retryingExec = withGitHubApiRetry(exec, config.github?.apiRetryAttempts ?? 3);
+                    const validation = await validateConfig(config, {
                         checkAuth: true,
                         directory,
                         exec: retryingExec,
@@ -369,9 +477,9 @@ export const MagiPlugin = async ({ client, directory }) => {
                     });
                     if (!validation.ok)
                         return JSON.stringify(validation, null, 2);
-                    const repository = resolveRepository(loaded.config);
+                    const repository = resolveRepository(config);
                     const states = await mapPool(parsed.prs, repository.concurrency.runs, (pr) => runManager.startReview({
-                        config: loaded.config,
+                        config,
                         dryRun: parsed.dryRun,
                         repository,
                         pr,
@@ -392,8 +500,9 @@ export const MagiPlugin = async ({ client, directory }) => {
                 async execute(args, context) {
                     const parsed = parseIssueRunArguments(args.issues, args.dryRun ?? false);
                     const loaded = await loadConfig(directory);
-                    const retryingExec = withGitHubApiRetry(exec, loaded.config.github?.apiRetryAttempts ?? 3);
-                    const validation = await validateConfig(loaded.config, {
+                    const config = mergeMagiConfig(loaded.config, parsed.configOverrides);
+                    const retryingExec = withGitHubApiRetry(exec, config.github?.apiRetryAttempts ?? 3);
+                    const validation = await validateConfig(config, {
                         checkAuth: true,
                         directory,
                         exec: retryingExec,
@@ -403,11 +512,11 @@ export const MagiPlugin = async ({ client, directory }) => {
                     });
                     if (!validation.ok)
                         return JSON.stringify(validation, null, 2);
-                    const repository = resolveRepository(loaded.config);
+                    const repository = resolveRepository(config);
                     if (!repository.triage)
                         return JSON.stringify({ errors: ["triage configuration is required"], ok: false }, null, 2);
                     const states = await mapPool(parsed.issues, repository.triage.concurrency.runs, (issue) => runManager.startTriage({
-                        config: loaded.config,
+                        config,
                         dryRun: parsed.dryRun,
                         issue,
                         parentSessionId: context.sessionID,

package/dist/orchestrator/run-manager.js

@@ -1273,10 +1273,12 @@ export class MagiRunManager {
         const completed = this.active.get(input.runId);
         if (!completed || completed.status === "cancelled")
             return;
-        completed.status = result.result === "FAILED" ? "failed" : "completed";
-        completed.phase = result.result;
+        const triageResult = JSON.stringify(result.result);
+        completed.status =
+            result.result.disposition === "failed" ? "failed" : "completed";
+        completed.phase = triageResult;
         completed.completedAt = now();
-        completed.verdict = result.result;
+        completed.verdict = triageResult;
         completed.reportPath = join(completed.outputDir, "report.md");
         for (const agent of Object.values(completed.reviewers)) {
             if (agent.status === "pending")

package/dist/orchestrator/triage.js

@@ -3,33 +3,27 @@ import { dirname, join } from "node:path";
 import { issueRunOutputDir } from "../config/output";
 import { worktreeBaseDir } from "../config/worktree";
 import { assignIssue, closeIssue, closePullRequest, configureGitIdentity, createPullRequest, fetchIssue, fetchIssueComments, fetchRelatedPullRequests, postIssueComment, pushHead, removeIssueLabels, removeWorktree, searchDuplicateIssues, shellQuote, updateIssueComment, } from "../github/commands";
-import { composeTriageBugPrompt, composeTriageActionPrompt, composeTriageCommentClassificationPrompt, composeTriageCommentPrompt, composeTriageCreatePrPrompt, composeTriageDuplicatePrompt, composeTriageExistingPrPrompt, composeTriageFeaturePrompt, composeTriageKindPrompt, composeTriageQuestionPrompt, composeTriageReconsiderPrompt, } from "../prompts/compose";
-import { parseTriageActionOutput, parseTriageBinaryOutput, parseTriageCommentClassificationOutput, parseTriageCreatePrOutput, parseTriageDuplicateOutput, parseTriageExistingPrOutput, parseTriageFinalOutput, parseTriageKindOutput, } from "../prompts/output";
+import { composeTriageAcceptancePrompt, composeTriageActionPrompt, composeTriageCategoryPrompt, composeTriageCommentClassificationPrompt, composeTriageCommentPrompt, composeTriageCreatePrPrompt, composeTriageDuplicatePrompt, composeTriageExistingPrPrompt, composeTriageQuestionPrompt, composeTriageReconsiderPrompt, } from "../prompts/compose";
+import { parseTriageActionOutput, parseTriageBinaryOutput, parseTriageCategoryOutput, parseTriageCommentClassificationOutput, parseTriageCreatePrOutput, parseTriageDuplicateOutput, parseTriageExistingPrOutput, } from "../prompts/output";
 import { aggregateStringMajority, majorityThreshold } from "./majority";
 import { runModelText, runModelWithRepair } from "./model";
 const MARKER_PREFIX = "opencode-magi:triage";
-const KIND_VOTES = ["ASK", "BUG", "FEATURE"];
 const BINARY_VOTES = ["ASK", "NO", "YES"];
 const DUPLICATE_VOTES = ["DUPLICATE", "NOT_DUPLICATE"];
 const EXISTING_PR_VOTES = [
     "RELATED_PR_DOES_NOT_HANDLE_ISSUE",
     "RELATED_PR_HANDLES_ISSUE",
 ];
-const FINAL_VOTES = [
-    "ASK",
-    "BUG_ACCEPTED",
-    "BUG_REJECTED",
-    "DUPLICATE",
-    "FEATURE_ACCEPTED",
-    "FEATURE_REJECTED",
-];
 const RECONSIDERATION_CLASSES = new Set([
     "CLARIFICATION",
     "NEW_EVIDENCE",
     "OBJECTION",
 ]);
 function marker(input) {
-    return `<!-- ${MARKER_PREFIX} v=1 issue=${input.issue} result=${input.result} action=${input.action} checkpoint=${input.checkpoint ?? "pending"} pr=${input.pr ?? "none"} processed=${(input.processed ?? []).join(",")} -->`;
+    const askReason = input.decision.askReason
+        ? ` askReason=${input.decision.askReason}`
+        : "";
+    return `<!-- ${MARKER_PREFIX} v=2 issue=${input.issue} category=${input.decision.category ?? "none"} disposition=${input.decision.disposition}${askReason} action=${input.action} checkpoint=${input.checkpoint ?? "pending"} pr=${input.pr ?? "none"} processed=${(input.processed ?? []).join(",")} -->`;
 }
 export function parseTriageMarker(body) {
     const match = body.match(/<!--\s*opencode-magi:triage\s+([^>]+?)\s*-->/);
@@ -45,13 +39,26 @@ export function parseTriageMarker(body) {
             : [part.slice(0, index), part.slice(index + 1)];
     }));
     const version = Number(entries.v);
-    if (version !== 1)
+    if (version !== 1 && version !== 2)
         return undefined;
     return {
         action: entries.action,
+        askReason: entries.askReason === "acceptance_unclear" ||
+            entries.askReason === "category_unclear"
+            ? entries.askReason
+            : undefined,
+        category: entries.category === "none" ? null : entries.category || undefined,
         checkpoint: entries.checkpoint && Number.isFinite(Number(entries.checkpoint))
             ? Number(entries.checkpoint)
             : undefined,
+        disposition: entries.disposition === "accepted" ||
+            entries.disposition === "rejected" ||
+            entries.disposition === "ask" ||
+            entries.disposition === "duplicate" ||
+            entries.disposition === "clear_only" ||
+            entries.disposition === "failed"
+            ? entries.disposition
+            : undefined,
         issue: entries.issue ? Number(entries.issue) : undefined,
         pr: entries.pr,
         processed: entries.processed
@@ -69,17 +76,15 @@ function existingClearLabels(issue, labels) {
     const existing = new Set(issue.labels.map((label) => label.toLowerCase()));
     return labels.filter((label) => existing.has(label.toLowerCase()));
 }
-export function resolveIssueKind(issue, repository) {
+export function resolveIssueCategory(issue, repository) {
     const triage = repository.triage;
     if (!triage)
         throw new Error("triage configuration is required");
-    const bug = labelsContain(issue.labels, triage.kind.bug.label) ||
-        (issue.type != null && triage.kind.bug.type.includes(issue.type));
-    const feature = labelsContain(issue.labels, triage.kind.feature.label) ||
-        (issue.type != null && triage.kind.feature.type.includes(issue.type));
-    if (bug === feature)
+    const matches = triage.categories.filter((category) => labelsContain(issue.labels, category.labels) ||
+        (issue.type != null && category.types.includes(issue.type)));
+    if (matches.length !== 1)
         return undefined;
-    return bug ? "BUG" : "FEATURE";
+    return matches[0].id;
 }
 function issueContext(input) {
     return JSON.stringify({
@@ -288,22 +293,42 @@ export function eligibleMentionReplies(input) {
     });
 }
 function finalResultFromMarker(marker) {
-    if (marker.result === "RESOLVED_BY_MERGED_PR")
-        return "BUG_ACCEPTED";
-    return isFinalResult(marker.result) ? marker.result : "FAILED";
-}
-function isFinalResult(value) {
-    return (value === "ASK" ||
-        value === "BUG_ACCEPTED" ||
-        value === "BUG_REJECTED" ||
-        value === "CLEAR_ONLY" ||
-        value === "DUPLICATE" ||
-        value === "FEATURE_ACCEPTED" ||
-        value === "FEATURE_REJECTED" ||
-        value === "FAILED");
+    if (marker.disposition) {
+        return {
+            askReason: marker.askReason,
+            category: marker.category ?? null,
+            disposition: marker.disposition,
+        };
+    }
+    switch (marker.result) {
+        case "BUG_ACCEPTED":
+        case "RESOLVED_BY_MERGED_PR":
+            return { category: "bug", disposition: "accepted" };
+        case "BUG_REJECTED":
+            return { category: "bug", disposition: "rejected" };
+        case "FEATURE_ACCEPTED":
+            return { category: "feature", disposition: "accepted" };
+        case "FEATURE_REJECTED":
+            return { category: "feature", disposition: "rejected" };
+        case "ASK":
+            return {
+                askReason: "acceptance_unclear",
+                category: null,
+                disposition: "ask",
+            };
+        case "CLEAR_ONLY":
+            return { category: null, disposition: "clear_only" };
+        case "DUPLICATE":
+            return { category: null, disposition: "duplicate" };
+        default:
+            return { category: null, disposition: "failed" };
+    }
+}
+function decisionText(decision) {
+    return JSON.stringify(decision);
 }
 function actionPlan(input) {
-    if (input.result === "CLEAR_ONLY") {
+    if (input.result.disposition === "clear_only") {
         return {
             action: "CLEAR_ONLY",
             allowedActions: ["CLEAR_ONLY"],
@@ -313,7 +338,7 @@ function actionPlan(input) {
             postComment: false,
         };
     }
-    if (input.result === "ASK") {
+    if (input.result.disposition === "ask") {
         return {
             action: "ASK",
             allowedActions: ["ASK"],
@@ -324,11 +349,9 @@ function actionPlan(input) {
         };
     }
     const closeIssue = input.triage.automation.close &&
-        (input.result === "BUG_REJECTED" ||
-            input.result === "DUPLICATE" ||
-            input.result === "FEATURE_REJECTED");
-    const createPr = input.triage.automation.pr &&
-        (input.result === "BUG_ACCEPTED" || input.result === "FEATURE_ACCEPTED");
+        (input.result.disposition === "rejected" ||
+            input.result.disposition === "duplicate");
+    const createPr = input.triage.automation.pr && input.result.disposition === "accepted";
     return {
         action: closeIssue ? "CLOSE" : createPr ? "PR" : "COMMENT",
         allowedActions: [closeIssue ? "CLOSE" : createPr ? "PR" : "COMMENT"],
@@ -428,18 +451,34 @@ async function runReconsiderationVote(input) {
         context: input.context,
         input: input.input,
         outputDir: input.outputDir,
-        parse: parseTriageFinalOutput,
+        parse: parseTriageBinaryOutput,
         phase: "reconsider",
         prompt: composeTriageReconsiderPrompt,
         schemaName: "triage reconsider",
-        votes: FINAL_VOTES,
+        votes: BINARY_VOTES,
     });
 }
 async function composeResultComment(input) {
     const agents = input.input.repository.agents.triage;
     if (!agents?.length)
         throw new Error("triage.agents is required");
-    const prompt = await (input.result === "ASK"
+    if (input.result.disposition === "ask" &&
+        input.result.askReason === "category_unclear") {
+        const language = input.input.repository.language?.toLowerCase() ?? "";
+        const body = language.includes("ja") || language.includes("japanese")
+            ? `@${input.issue.author} 現在の説明だけでは、何をすべきか判断できません。\n\n期待する動作、実際の動作、必要な理由、関連する例・ログ・スクリーンショットなどを追記してください。`
+            : `@${input.issue.author} I can't determine what should be done from the current description.\n\nPlease add more detail, such as the expected behavior, the actual behavior, the reason this is needed, or any relevant examples, logs, or screenshots.`;
+        const comment = `${body}\n\n${marker({
+            action: input.action,
+            checkpoint: "pending",
+            decision: input.result,
+            issue: input.issue.number,
+            processed: input.processed,
+        })}`;
+        await writeFile(join(input.outputDir, "comment.md"), `${comment}\n`);
+        return comment;
+    }
+    const prompt = await (input.result.disposition === "ask"
         ? composeTriageQuestionPrompt
         : composeTriageCommentPrompt)({
         author: input.issue.author,
@@ -461,9 +500,9 @@ async function composeResultComment(input) {
         `\n\n${marker({
             action: input.action,
             checkpoint: "pending",
+            decision: input.result,
             issue: input.issue.number,
             processed: input.processed,
-            result: input.result,
         })}`;
     await writeFile(join(input.outputDir, "comment.md"), `${comment}\n`);
     return comment;
@@ -486,10 +525,10 @@ async function persistProcessedMarker(input) {
     const updatedMarker = marker({
         action: input.marker.action ?? input.marker.result ?? "ASK",
         checkpoint: markerCheckpoint(input.marker),
+        decision: finalResultFromMarker(input.marker),
         issue: input.issue.number,
         pr: input.pr ?? markerPr(input.marker),
         processed: input.processed,
-        result: input.marker.result ?? "ASK",
     });
     const body = previousComment.body.replace(/<!--\s*opencode-magi:triage\s+[^>]+?\s*-->/, updatedMarker);
     if (body === previousComment.body)
@@ -516,7 +555,7 @@ async function finishWithResult(input) {
     const comment = plan.postComment
         ? await composeResultComment({
             action: plan.action,
-            context: `Result: ${input.result}\nAction: ${plan.action}\n\n${input.context}`,
+            context: `Result: ${decisionText(input.result)}\nAction: ${plan.action}\n\n${input.context}`,
             input: input.input,
             issue: input.issue,
             outputDir: input.outputDir,
@@ -576,7 +615,7 @@ async function finishWithResult(input) {
         }
     }
     const report = [
-        `Magi triage result for #${input.issue.number}: ${input.result}`,
+        `Magi triage result for #${input.issue.number}: ${decisionText(input.result)}`,
         prUrl ? `Created PR: ${prUrl}` : undefined,
         input.input.dryRun
             ? "Dry run: no GitHub mutations were performed."
@@ -690,7 +729,12 @@ export async function runTriage(input) {
     if (block) {
         const report = `Magi triage blocked for #${input.issue}: ${block}`;
         await writeFile(join(outputDir, "report.md"), `${report}\n`);
-        return { issue: input.issue, outputDir, report, result: "FAILED" };
+        return {
+            issue: input.issue,
+            outputDir,
+            report,
+            result: { category: null, disposition: "failed" },
+        };
     }
     let context = issueContext({ issue, relationship });
     await writeFile(join(outputDir, "context.md"), `${context}\n`);
@@ -765,8 +809,18 @@ export async function runTriage(input) {
             },
         });
         await writeFile(join(outputDir, "context.md"), `${context}\n`);
+        const vote = await runReconsiderationVote({ context, input, outputDir });
+        const previous = finalResultFromMarker(relationship.previousMarker);
         result =
-            (await runReconsiderationVote({ context, input, outputDir })) ?? "ASK";
+            vote === "YES"
+                ? { category: previous.category, disposition: "accepted" }
+                : vote === "NO"
+                    ? { category: previous.category, disposition: "rejected" }
+                    : {
+                        askReason: "acceptance_unclear",
+                        category: previous.category,
+                        disposition: "ask",
+                    };
     }
     if (!result && relationship.relatedPullRequests.length) {
         const vote = await runPhaseVote({
@@ -782,6 +836,10 @@ export async function runTriage(input) {
         if (vote === "RELATED_PR_HANDLES_ISSUE") {
             const merged = relationship.relatedPullRequests.some((pr) => pr.state === "MERGED");
             if (merged && triage.automation.close) {
+                const relatedPrDecision = {
+                    category: resolveIssueCategory(issue, input.repository) ?? null,
+                    disposition: "accepted",
+                };
                 const plan = {
                     action: "CLOSE",
                     allowedActions: ["CLOSE"],
@@ -795,16 +853,16 @@ export async function runTriage(input) {
                     input,
                     outputDir,
                     plan,
-                    result: "BUG_ACCEPTED",
+                    result: relatedPrDecision,
                 });
                 const body = await composeResultComment({
                     action: "CLOSE",
-                    context: `Result: BUG_ACCEPTED\nAction: CLOSE\n\n${context}`,
+                    context: `Result: ${decisionText(relatedPrDecision)}\nAction: CLOSE\n\n${context}`,
                     input,
                     issue,
                     outputDir,
                     processed,
-                    result: "BUG_ACCEPTED",
+                    result: relatedPrDecision,
                 });
                 if (!input.dryRun) {
                     await postMarkedIssueComment({
@@ -834,7 +892,7 @@ export async function runTriage(input) {
                     issue: issue.number,
                     outputDir,
                     report,
-                    result: "BUG_ACCEPTED",
+                    result: relatedPrDecision,
                 };
             }
             return finishWithResult({
@@ -844,7 +902,7 @@ export async function runTriage(input) {
                 outputDir,
                 processed,
                 relationship,
-                result: "CLEAR_ONLY",
+                result: { category: null, disposition: "clear_only" },
             });
         }
     }
@@ -857,59 +915,60 @@ export async function runTriage(input) {
         });
         if (duplicate) {
             context = `${context}\n\nDuplicate decision: ${JSON.stringify(duplicate)}`;
-            result = "DUPLICATE";
+            result = { category: null, disposition: "duplicate" };
         }
     }
     if (!result) {
-        const resolvedKind = resolveIssueKind(issue, input.repository);
-        await writeJson(join(outputDir, "kind-resolution.json"), {
-            kind: resolvedKind,
-            source: resolvedKind ? "config" : "vote",
+        const resolvedCategory = resolveIssueCategory(issue, input.repository);
+        await writeJson(join(outputDir, "category-resolution.json"), {
+            category: resolvedCategory,
+            source: resolvedCategory ? "config" : "vote",
         });
-        const kind = resolvedKind ??
+        const category = resolvedCategory ??
             (await runPhaseVote({
                 context,
                 input,
                 outputDir,
-                parse: parseTriageKindOutput,
-                phase: "kind",
-                prompt: composeTriageKindPrompt,
-                schemaName: "triage kind",
-                votes: KIND_VOTES,
+                parse: (text) => parseTriageCategoryOutput(text, triage.categories.map((item) => item.id)),
+                phase: "category",
+                prompt: composeTriageCategoryPrompt,
+                schemaName: "triage category",
+                votes: ["ASK", ...triage.categories.map((item) => item.id)],
             })) ??
             "ASK";
-        result = "ASK";
-        if (kind === "BUG") {
-            const vote = await runPhaseVote({
-                context,
-                input,
-                outputDir,
-                parse: parseTriageBinaryOutput,
-                phase: "bug",
-                prompt: composeTriageBugPrompt,
-                schemaName: "triage bug",
-                votes: BINARY_VOTES,
-            });
-            result =
-                vote === "YES" ? "BUG_ACCEPTED" : vote === "NO" ? "BUG_REJECTED" : "ASK";
+        if (category === "ASK") {
+            result = {
+                askReason: "category_unclear",
+                category: null,
+                disposition: "ask",
+            };
         }
-        if (kind === "FEATURE") {
+        else {
+            const categoryConfig = triage.categories.find((item) => item.id === category);
+            const voteContext = JSON.stringify({
+                category: categoryConfig,
+                triageContext: context,
+            }, null, 2);
             const vote = await runPhaseVote({
-                context,
+                context: voteContext,
                 input,
                 outputDir,
                 parse: parseTriageBinaryOutput,
-                phase: "feature",
-                prompt: composeTriageFeaturePrompt,
-                schemaName: "triage feature",
+                phase: "acceptance",
+                prompt: composeTriageAcceptancePrompt,
+                schemaName: "triage acceptance",
                 votes: BINARY_VOTES,
             });
             result =
                 vote === "YES"
-                    ? "FEATURE_ACCEPTED"
+                    ? { category, disposition: "accepted" }
                     : vote === "NO"
-                        ? "FEATURE_REJECTED"
-                        : "ASK";
+                        ? { category, disposition: "rejected" }
+                        : {
+                            askReason: "acceptance_unclear",
+                            category,
+                            disposition: "ask",
+                        };
         }
     }
     return finishWithResult({
@@ -919,6 +978,10 @@ export async function runTriage(input) {
         outputDir,
         processed,
         relationship,
-        result: result ?? "ASK",
+        result: result ?? {
+            askReason: "acceptance_unclear",
+            category: null,
+            disposition: "ask",
+        },
     });
 }

package/dist/permissions/editor.json

@@ -1,7 +1,14 @@
 {
     "bash": {
+        "bun *": "allow",
+        "bunx *": "allow",
+        "corepack *": "allow",
         "git add*": "allow",
-        "git commit*": "allow"
+        "git commit*": "allow",
+        "npm *": "allow",
+        "npx *": "allow",
+        "pnpm *": "allow",
+        "yarn *": "allow"
     },
     "edit": "allow"
 }

package/dist/prompts/compose.js

@@ -67,9 +67,16 @@ function editValues(input) {
     };
 }
 function triageValues(input) {
+    const categories = input.repository.triage?.categories ?? [];
+    const categoryOptions = categories
+        .map((category) => category.description
+        ? `- ${category.id}: ${category.description}`
+        : `- ${category.id}`)
+        .join("\n");
     return {
         ...repositoryValues(input.repository),
         author: input.author ?? "",
+        categoryOptions,
         context: input.context,
         issue: String(input.issue),
         worktreePath: input.worktreePath ?? "",
@@ -401,27 +408,23 @@ export async function composeTriageDuplicatePrompt(input) {
         outputContract: triageDuplicateOutputContract,
     });
 }
-export async function composeTriageKindPrompt(input) {
+export async function composeTriageCategoryPrompt(input) {
+    const categories = input.repository.triage?.categories ?? [];
+    const votes = ["ASK", ...categories.map((category) => category.id)]
+        .map((vote) => JSON.stringify(vote))
+        .join(" | ");
     return composeTriageVotePrompt({
         ...input,
-        builtin: "kind",
-        customPath: input.repository.triage?.prompts.kind,
-        outputContract: triageVoteOutputContract('"BUG" | "FEATURE" | "ASK"'),
+        builtin: "category",
+        customPath: input.repository.triage?.prompts.category,
+        outputContract: triageVoteOutputContract(votes),
     });
 }
-export async function composeTriageBugPrompt(input) {
+export async function composeTriageAcceptancePrompt(input) {
     return composeTriageVotePrompt({
         ...input,
-        builtin: "bug",
-        customPath: input.repository.triage?.prompts.bug,
-        outputContract: triageVoteOutputContract('"YES" | "NO" | "ASK"'),
-    });
-}
-export async function composeTriageFeaturePrompt(input) {
-    return composeTriageVotePrompt({
-        ...input,
-        builtin: "feature",
-        customPath: input.repository.triage?.prompts.feature,
+        builtin: "acceptance",
+        customPath: input.repository.triage?.prompts.acceptance,
         outputContract: triageVoteOutputContract('"YES" | "NO" | "ASK"'),
     });
 }
@@ -438,6 +441,6 @@ export async function composeTriageReconsiderPrompt(input) {
         ...input,
         builtin: "reconsider",
         customPath: input.repository.triage?.prompts.reconsider,
-        outputContract: triageVoteOutputContract('"ASK" | "BUG_ACCEPTED" | "BUG_REJECTED" | "DUPLICATE" | "FEATURE_ACCEPTED" | "FEATURE_REJECTED"'),
+        outputContract: triageVoteOutputContract('"YES" | "NO" | "ASK"'),
     });
 }

package/dist/prompts/contracts.js

@@ -253,13 +253,12 @@ const outputContractsBySchemaName = {
     "rereview close reconsideration": rereviewCloseReconsiderationOutputContract,
     review: reviewOutputContract,
     "triage action": triageActionOutputContract,
-    "triage bug": triageVoteOutputContract('"YES" | "NO" | "ASK"'),
+    "triage acceptance": triageVoteOutputContract('"YES" | "NO" | "ASK"'),
+    "triage category": triageVoteOutputContract('"ASK" or one of the configured category IDs'),
     "triage comment classification": triageCommentClassificationOutputContract,
     "triage duplicate": triageDuplicateOutputContract,
     "triage existing PR": triageVoteOutputContract('"RELATED_PR_HANDLES_ISSUE" | "RELATED_PR_DOES_NOT_HANDLE_ISSUE"'),
-    "triage feature": triageVoteOutputContract('"YES" | "NO" | "ASK"'),
-    "triage kind": triageVoteOutputContract('"BUG" | "FEATURE" | "ASK"'),
-    "triage reconsider": triageVoteOutputContract('"ASK" | "BUG_ACCEPTED" | "BUG_REJECTED" | "DUPLICATE" | "FEATURE_ACCEPTED" | "FEATURE_REJECTED"'),
+    "triage reconsider": triageVoteOutputContract('"YES" | "NO" | "ASK"'),
 };
 export function repairPrompt(schemaName) {
     const outputContract = outputContractsBySchemaName[schemaName];

package/dist/prompts/output.js

@@ -104,18 +104,8 @@ export function parseTriageExistingPrOutput(text) {
         "RELATED_PR_HANDLES_ISSUE",
     ]);
 }
-export function parseTriageKindOutput(text) {
-    return parseTriageVote(text, ["ASK", "BUG", "FEATURE"]);
-}
-export function parseTriageFinalOutput(text) {
-    return parseTriageVote(text, [
-        "ASK",
-        "BUG_ACCEPTED",
-        "BUG_REJECTED",
-        "DUPLICATE",
-        "FEATURE_ACCEPTED",
-        "FEATURE_REJECTED",
-    ]);
+export function parseTriageCategoryOutput(text, categories) {
+    return parseTriageVote(text, ["ASK", ...categories]);
 }
 export function parseTriageBinaryOutput(text) {
     return parseTriageVote(text, ["ASK", "NO", "YES"]);

package/dist/prompts/templates/triage/acceptance.md

@@ -0,0 +1,7 @@
+Evaluate issue #{issue} in {owner}/{repo} for the selected category.
+
+Choose YES when the issue should be accepted for the project. Choose NO when it should be rejected, is not actionable, or is not appropriate for this project. Choose ASK when specific missing information is required before deciding.
+
+<context>
+{context}
+</context>

package/dist/prompts/templates/triage/category.md

@@ -0,0 +1,10 @@
+Classify issue #{issue} in {owner}/{repo}.
+
+Choose ASK when more information is required to classify what should be done. Otherwise choose exactly one configured category ID.
+
+Configured categories:
+{categoryOptions}
+
+<context>
+{context}
+</context>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-magi",
-  "version": "0.0.0-dev-20260520171120",
+  "version": "0.0.0-dev-20260520175008",
   "description": "Multi-agent PR review and merge orchestration plugin for OpenCode.",
   "license": "MIT",
   "author": "Hirotomo Yamada <hirotomo.yamada@avap.co.jp>",

package/schema.json

@@ -194,9 +194,8 @@
       "properties": {
         "existingPr": { "type": "string" },
         "duplicate": { "type": "string" },
-        "kind": { "type": "string" },
-        "bug": { "type": "string" },
-        "feature": { "type": "string" },
+        "category": { "type": "string" },
+        "acceptance": { "type": "string" },
         "action": { "type": "string" },
         "question": { "type": "string" },
         "comment": { "type": "string" },
@@ -205,20 +204,19 @@
         "createPr": { "type": "string" }
       }
     },
-    "triageKindRule": {
+    "triageCategory": {
       "type": "object",
       "additionalProperties": false,
+      "required": ["id"],
       "properties": {
-        "label": { "type": "array", "items": { "type": "string" } },
-        "type": { "type": "array", "items": { "type": "string" } }
-      }
-    },
-    "triageKind": {
-      "type": "object",
-      "additionalProperties": false,
-      "properties": {
-        "bug": { "$ref": "#/$defs/triageKindRule" },
-        "feature": { "$ref": "#/$defs/triageKindRule" }
+        "id": {
+          "type": "string",
+          "pattern": "^[A-Za-z0-9_-]+$",
+          "not": { "enum": ["ASK", "none"] }
+        },
+        "labels": { "type": "array", "items": { "type": "string" } },
+        "types": { "type": "array", "items": { "type": "string" } },
+        "description": { "type": "string" }
       }
     },
     "triageAutomation": {
@@ -308,7 +306,10 @@
           "items": { "$ref": "#/$defs/triageAgent" }
         },
         "creator": { "$ref": "#/$defs/triageCreator" },
-        "kind": { "$ref": "#/$defs/triageKind" },
+        "categories": {
+          "type": "array",
+          "items": { "$ref": "#/$defs/triageCategory" }
+        },
         "automation": { "$ref": "#/$defs/triageAutomation" },
         "safety": { "$ref": "#/$defs/triageSafety" },
         "concurrency": { "$ref": "#/$defs/triageConcurrency" },

package/dist/prompts/templates/triage/bug.md

@@ -1,7 +0,0 @@
-Evaluate bug issue #{issue} in {owner}/{repo}.
-
-Choose YES when the bug is reproduced or otherwise valid based on strong evidence. Choose NO when it is not reproduced, invalid, a misunderstanding, or not actionable as a bug. Choose ASK when specific missing information is required.
-
-<context>
-{context}
-</context>

package/dist/prompts/templates/triage/feature.md

@@ -1,7 +0,0 @@
-Evaluate feature issue #{issue} in {owner}/{repo}.
-
-Choose YES when the feature should be implemented. Choose NO when it should not be implemented for this project. Choose ASK when specific missing information is required.
-
-<context>
-{context}
-</context>

package/dist/prompts/templates/triage/kind.md

@@ -1,7 +0,0 @@
-Classify issue #{issue} in {owner}/{repo}.
-
-Choose BUG when it reports broken existing behavior. Choose FEATURE when it requests new behavior or enhancement. Choose ASK when more information is required to classify it.
-
-<context>
-{context}
-</context>