opencode-magi 0.0.0-dev-20260525091701 → 0.0.0-dev-20260525101932

package/dist/config/resolve.js

@@ -24,6 +24,31 @@ const DEFAULT_TRIAGE_CATEGORIES = [
         types: ["Feature"],
     },
 ];
+export const DEFAULT_TRIAGE_LABEL_RULES = [
+    { remove: ["triage"], when: { disposition: "accepted" } },
+    {
+        add: ["duplicate"],
+        remove: ["triage"],
+        when: { disposition: "duplicate" },
+    },
+    {
+        add: ["duplicate"],
+        remove: ["triage"],
+        when: { disposition: "already_handled" },
+    },
+    {
+        add: ["wontfix"],
+        remove: ["triage"],
+        when: { disposition: "rejected" },
+    },
+    {
+        add: ["invalid"],
+        remove: ["triage"],
+        when: { disposition: "invalid" },
+    },
+    { add: ["question"], when: { disposition: "needs_category" } },
+    { add: ["question"], when: { disposition: "needs_acceptance" } },
+];
 export function reviewerKey(reviewer, index) {
     return reviewer.id ?? `reviewer-${index + 1}`;
 }
@@ -191,9 +216,9 @@ export function resolveRepository(config) {
         },
         triage: {
             automation: {
-                clear: config.triage?.automation?.clear ?? ["triage"],
                 close: config.triage?.automation?.close ?? false,
                 create: config.triage?.automation?.create ?? false,
+                label: config.triage?.automation?.label ?? DEFAULT_TRIAGE_LABEL_RULES,
                 merge: config.triage?.automation?.merge ?? false,
                 review: config.triage?.automation?.review ?? false,
             },
@@ -216,6 +241,7 @@ export function resolveRepository(config) {
                 blockedLabels: config.triage?.safety?.blockedLabels ?? [],
                 requiredLabels: config.triage?.safety?.requiredLabels ?? ["triage"],
             },
+            signals: config.triage?.signals ?? [],
             worktree: config.triage?.worktree,
         },
     };

package/dist/config/validate.js

@@ -80,6 +80,7 @@ const TRIAGE_KEYS = new Set([
     "prompts",
     "reporter",
     "safety",
+    "signals",
     "voters",
     "worktree",
 ]);
@@ -98,13 +99,19 @@ const CLEAR_KEYS = new Set(["branch", "output", "session", "worktree"]);
 const CONCURRENCY_KEYS = new Set(["reviewers", "runs"]);
 const OUTPUT_KEYS = new Set(["repairAttempts"]);
 const TRIAGE_AUTOMATION_KEYS = new Set([
-    "clear",
     "close",
     "create",
+    "label",
     "merge",
     "review",
 ]);
 const TRIAGE_CATEGORY_KEYS = new Set(["description", "id", "labels", "types"]);
+const TRIAGE_LABEL_RULE_KEYS = new Set(["add", "remove", "when"]);
+const TRIAGE_LABEL_RULE_WHEN_KEYS = new Set([
+    "category",
+    "disposition",
+    "signals",
+]);
 const TRIAGE_CONCURRENCY_KEYS = new Set(["runs"]);
 const TRIAGE_SAFETY_KEYS = new Set([
     "allowAuthors",
@@ -113,6 +120,18 @@ const TRIAGE_SAFETY_KEYS = new Set([
     "blockedLabels",
     "requiredLabels",
 ]);
+const TRIAGE_SIGNAL_KEYS = new Set(["description", "id"]);
+const TRIAGE_DISPOSITIONS = new Set([
+    "accepted",
+    "rejected",
+    "invalid",
+    "duplicate",
+    "already_handled",
+    "needs_category",
+    "needs_acceptance",
+    "blocked",
+    "failed",
+]);
 const SAFETY_KEYS = new Set([
     "allowAuthors",
     "blockedPaths",
@@ -692,6 +711,79 @@ function validateTriageCategories(categories, path, errors) {
         validateString(category.description, `${itemPath}.description`, errors);
     });
 }
+function validateTriageSignals(signals, path, errors) {
+    if (signals == null)
+        return;
+    if (!Array.isArray(signals)) {
+        errors.push(`${path} must be an array`);
+        return;
+    }
+    const ids = new Set();
+    signals.forEach((item, index) => {
+        const itemPath = `${path}[${index}]`;
+        if (!isPlainObject(item)) {
+            errors.push(`${itemPath} must be an object`);
+            return;
+        }
+        const signal = item;
+        validateKnownKeys(signal, itemPath, TRIAGE_SIGNAL_KEYS, errors);
+        if (!signal.id) {
+            errors.push(`${itemPath}.id is required`);
+        }
+        else if (typeof signal.id !== "string") {
+            errors.push(`${itemPath}.id must be a string`);
+        }
+        else if (!TRIAGE_CATEGORY_ID_PATTERN.test(signal.id)) {
+            errors.push(`${itemPath}.id must match /^[A-Za-z0-9_-]+$/`);
+        }
+        else if (ids.has(signal.id)) {
+            errors.push(`${itemPath}.id must be unique`);
+        }
+        else {
+            ids.add(signal.id);
+        }
+        if (!signal.description) {
+            errors.push(`${itemPath}.description is required`);
+        }
+        else {
+            validateString(signal.description, `${itemPath}.description`, errors);
+        }
+    });
+}
+function validateTriageLabelRules(rules, path, errors) {
+    if (rules == null)
+        return;
+    if (!Array.isArray(rules)) {
+        errors.push(`${path} must be an array`);
+        return;
+    }
+    rules.forEach((item, index) => {
+        const itemPath = `${path}[${index}]`;
+        if (!isPlainObject(item)) {
+            errors.push(`${itemPath} must be an object`);
+            return;
+        }
+        const rule = item;
+        validateKnownKeys(rule, itemPath, TRIAGE_LABEL_RULE_KEYS, errors);
+        validateStringArray(rule.add, `${itemPath}.add`, errors);
+        validateStringArray(rule.remove, `${itemPath}.remove`, errors);
+        if (!isPlainObject(rule.when)) {
+            errors.push(`${itemPath}.when must be an object`);
+            return;
+        }
+        validateKnownKeys(rule.when, `${itemPath}.when`, TRIAGE_LABEL_RULE_WHEN_KEYS, errors);
+        if (!Object.keys(rule.when).length) {
+            errors.push(`${itemPath}.when must not be empty`);
+        }
+        if (rule.when.disposition != null &&
+            (typeof rule.when.disposition !== "string" ||
+                !TRIAGE_DISPOSITIONS.has(rule.when.disposition))) {
+            errors.push(`${itemPath}.when.disposition must be a triage disposition`);
+        }
+        validateString(rule.when.category, `${itemPath}.when.category`, errors);
+        validateStringArray(rule.when.signals, `${itemPath}.when.signals`, errors);
+    });
+}
 function validateSafety(config, errors) {
     const safety = config.review?.safety;
     if (safety != null && !isPlainObject(safety)) {
@@ -765,7 +857,7 @@ function validateTriage(config, errors, options) {
     validateBoolean(automation?.create, "triage.automation.create", errors);
     validateBoolean(automation?.merge, "triage.automation.merge", errors);
     validateBoolean(automation?.review, "triage.automation.review", errors);
-    validateStringArray(automation?.clear, "triage.automation.clear", errors);
+    validateTriageLabelRules(automation?.label, "triage.automation.label", errors);
     if (automation?.review && !automation.create) {
         errors.push("triage.automation.review requires triage.automation.create to be true");
     }
@@ -780,6 +872,7 @@ function validateTriage(config, errors, options) {
         errors.push("triage.concurrency.runs must be a positive integer");
     }
     validateTriageCategories(triage.categories, "triage.categories", errors);
+    validateTriageSignals(triage.signals, "triage.signals", errors);
     validateKnownKeys(safety, "triage.safety", TRIAGE_SAFETY_KEYS, errors);
     validateStringArray(safety?.allowAuthors, "triage.safety.allowAuthors", errors);
     validateStringArray(safety?.allowMentionActors, "triage.safety.allowMentionActors", errors);

package/dist/github/commands.js

@@ -404,6 +404,15 @@ export async function assignIssue(exec, repository, issue, account) {
     const token = await ghToken(exec, repository, account);
     return exec(`gh issue edit ${issue} --repo ${shellQuote(repoSpecifier(repository))} --add-assignee ${shellQuote(account)}`, ghTokenEnv(token));
 }
+export async function addIssueLabels(exec, repository, issue, labels, account) {
+    const token = await ghToken(exec, repository, account);
+    const added = [];
+    for (const label of labels) {
+        await exec(`gh issue edit ${issue} --repo ${shellQuote(repoSpecifier(repository))} --add-label ${shellQuote(label)}`, ghTokenEnv(token));
+        added.push(label);
+    }
+    return added;
+}
 export async function removeIssueLabels(exec, repository, issue, labels, account) {
     const token = await ghToken(exec, repository, account);
     const removed = [];

package/dist/orchestrator/triage.js

@@ -2,13 +2,14 @@ import { mkdir, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { issueRunOutputDir } from "../config/output";
 import { issueRunWorktreeDir } from "../config/worktree";
-import { assignIssue, closeIssue, closePullRequest, configureGitIdentity, createPullRequest, fetchIssue, fetchIssueComments, fetchRelatedPullRequests, postIssueComment, pushHead, removeIssueLabels, removeWorktree, searchDuplicateIssues, shellQuote, updateIssueComment, } from "../github/commands";
-import { composeTriageAcceptancePrompt, composeTriageCategoryPrompt, composeTriageCommentClassificationPrompt, composeTriageCreatePrPrompt, composeTriageDuplicatePrompt, composeTriageExistingPrPrompt, composeTriageReconsiderPrompt, } from "../prompts/compose";
-import { parseTriageBinaryOutput, parseTriageCategoryOutput, parseTriageCommentClassificationOutput, parseTriageCreatePrOutput, parseTriageDuplicateOutput, parseTriageExistingPrOutput, } from "../prompts/output";
+import { addIssueLabels, assignIssue, closeIssue, closePullRequest, configureGitIdentity, createPullRequest, fetchIssue, fetchIssueComments, fetchRelatedPullRequests, postIssueComment, pushHead, removeIssueLabels, removeWorktree, searchDuplicateIssues, shellQuote, updateIssueComment, } from "../github/commands";
+import { composeTriageAcceptancePrompt, composeTriageCategoryPrompt, composeTriageCommentClassificationPrompt, composeTriageCreatePrPrompt, composeTriageDuplicatePrompt, composeTriageExistingPrPrompt, composeTriageReconsiderPrompt, composeTriageSignalPrompt, } from "../prompts/compose";
+import { parseTriageBinaryOutput, parseTriageCategoryOutput, parseTriageCommentClassificationOutput, parseTriageCreatePrOutput, parseTriageDuplicateOutput, parseTriageExistingPrOutput, parseTriageSignalOutput, } from "../prompts/output";
 import { aggregateStringMajority, majorityThreshold } from "./majority";
 import { runModelWithRepair, } from "./model";
 const MARKER_PREFIX = "opencode-magi:triage";
 const BINARY_VOTES = ["ASK", "NO", "YES"];
+const ACCEPTANCE_VOTES = ["ASK", "INVALID", "NO", "YES"];
 const DUPLICATE_VOTES = ["DUPLICATE", "NOT_DUPLICATE"];
 const EXISTING_PR_VOTES = [
     "RELATED_PR_DOES_NOT_HANDLE_ISSUE",
@@ -20,10 +21,29 @@ const RECONSIDERATION_CLASSES = new Set([
     "OBJECTION",
 ]);
 function marker(input) {
-    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(",")} -->`;
+    return `<!-- ${MARKER_PREFIX} v=2 issue=${input.issue} category=${input.decision.category ?? "none"} disposition=${input.decision.disposition} signals=${input.decision.signals.join(",")} action=${input.action} checkpoint=${input.checkpoint ?? "pending"} pr=${input.pr ?? "none"} processed=${(input.processed ?? []).join(",")} -->`;
+}
+function markerDisposition(input) {
+    switch (input.disposition) {
+        case "accepted":
+        case "rejected":
+        case "invalid":
+        case "duplicate":
+        case "already_handled":
+        case "needs_category":
+        case "needs_acceptance":
+        case "blocked":
+        case "failed":
+            return input.disposition;
+        case "ask":
+            return input.askReason === "category_unclear"
+                ? "needs_category"
+                : "needs_acceptance";
+        case "clear_only":
+            return "already_handled";
+        default:
+            return undefined;
+    }
 }
 export function parseTriageMarker(body) {
     const match = body.match(/<!--\s*opencode-magi:triage\s+([^>]+?)\s*-->/);
@@ -41,30 +61,28 @@ export function parseTriageMarker(body) {
     const version = Number(entries.v);
     if (version !== 1 && version !== 2)
         return undefined;
+    const askReason = entries.askReason === "acceptance_unclear" ||
+        entries.askReason === "category_unclear"
+        ? entries.askReason
+        : undefined;
     return {
         action: entries.action,
-        askReason: entries.askReason === "acceptance_unclear" ||
-            entries.askReason === "category_unclear"
-            ? entries.askReason
-            : undefined,
+        askReason,
         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,
+        disposition: markerDisposition({
+            askReason,
+            disposition: entries.disposition,
+        }),
         issue: entries.issue ? Number(entries.issue) : undefined,
         pr: entries.pr,
         processed: entries.processed
             ? entries.processed.split(",").filter(Boolean).map(Number)
             : [],
         result: entries.result,
+        signals: entries.signals ? entries.signals.split(",").filter(Boolean) : [],
         v: version,
     };
 }
@@ -72,9 +90,46 @@ function labelsContain(labels, targets) {
     const set = new Set(labels.map((label) => label.toLowerCase()));
     return targets.some((target) => set.has(target.toLowerCase()));
 }
-function existingClearLabels(issue, labels) {
-    const existing = new Set(issue.labels.map((label) => label.toLowerCase()));
-    return labels.filter((label) => existing.has(label.toLowerCase()));
+function addLabel(labels, label) {
+    const key = label.toLowerCase();
+    if (!labels.has(key))
+        labels.set(key, label);
+}
+function labelRuleMatches(rule, result) {
+    const when = rule.when;
+    if (when.disposition && when.disposition !== result.disposition)
+        return false;
+    if (when.category && when.category !== result.category)
+        return false;
+    if (when.signals?.length) {
+        const signals = new Set(result.signals);
+        if (when.signals.some((signal) => !signals.has(signal)))
+            return false;
+    }
+    return true;
+}
+export function triageLabelChanges(input) {
+    const add = new Map();
+    const remove = new Map();
+    for (const rule of input.rules) {
+        if (!labelRuleMatches(rule, input.result))
+            continue;
+        for (const label of rule.add ?? [])
+            addLabel(add, label);
+        for (const label of rule.remove ?? [])
+            addLabel(remove, label);
+    }
+    for (const key of add.keys())
+        remove.delete(key);
+    const existing = new Set(input.issueLabels.map((label) => label.toLowerCase()));
+    return {
+        add: [...add]
+            .filter(([key]) => !existing.has(key))
+            .map(([, label]) => label),
+        remove: [...remove]
+            .filter(([key]) => existing.has(key))
+            .map(([, label]) => label),
+    };
 }
 export function resolveIssueCategory(issue, repository) {
     const triage = repository.triage;
@@ -305,6 +360,86 @@ async function runPhaseVote(input) {
         vote: majority.vote,
     };
 }
+async function runSignalVote(input) {
+    const agents = input.input.repository.agents.triage;
+    const signals = input.input.repository.triage?.signals ?? [];
+    if (!agents?.length)
+        throw new Error("triage.voters is required");
+    if (!signals.length)
+        return [];
+    await emitProgress(input.input, { phase: "signal", type: "phase" });
+    const signalIds = signals.map((signal) => signal.id);
+    const promptTexts = await Promise.all(agents.map((agent) => composeTriageSignalPrompt({
+        context: input.context,
+        directory: input.input.directory,
+        issue: input.input.issue,
+        repository: input.input.repository,
+        voter: agent,
+    })));
+    const outputs = await Promise.all(agents.map(async (agent, index) => {
+        const prompt = promptTexts[index];
+        await emitProgress(input.input, {
+            phase: "signal",
+            type: "triage_agent_started",
+            voter: agent.key,
+        });
+        const result = await runModelWithRepair({
+            client: input.input.client,
+            model: agent.model,
+            onProgress: (progress) => emitTriageModelProgress({
+                phase: "signal",
+                progress,
+                run: input.input,
+                voter: agent.key,
+            }),
+            options: agent.options,
+            parentSessionId: input.input.parentSessionId,
+            parse: (text) => parseTriageSignalOutput(text, signalIds),
+            permission: agent.permission,
+            prompt,
+            repairAttempts: input.input.config.output?.repairAttempts ?? 3,
+            schemaName: "triage signal",
+            signal: input.input.signal,
+            title: `Magi triage signal #${input.input.issue} (${agent.key})`,
+        });
+        await emitProgress(input.input, {
+            phase: "signal",
+            sessionId: result.sessionId,
+            type: "triage_agent_completed",
+            voter: agent.key,
+            vote: result.value.signals.map((signal) => signal.id).join(",") || "none",
+        });
+        return {
+            ...result.value,
+            promptText: prompt,
+            raw: result.raw,
+            sessionId: result.sessionId,
+            voter: agent.key,
+        };
+    }));
+    const threshold = majorityThreshold(outputs.length);
+    const counts = new Map();
+    for (const output of outputs) {
+        for (const id of new Set(output.signals.map((signal) => signal.id))) {
+            counts.set(id, (counts.get(id) ?? 0) + 1);
+        }
+    }
+    const selected = signalIds.filter((id) => (counts.get(id) ?? 0) >= threshold);
+    await Promise.all(outputs.map((output) => {
+        const base = join(input.outputDir, `${output.voter}.signal`);
+        return Promise.all([
+            writeFile(`${base}.prompt.txt`, `${output.promptText}\n`),
+            writeFile(`${base}.raw.txt`, `${output.raw}\n`),
+            writeJson(`${base}.json`, { signals: output.signals }),
+        ]);
+    }));
+    await writeJson(join(input.outputDir, "signal-majority.json"), {
+        counts: Object.fromEntries(counts),
+        selected,
+        threshold,
+    });
+    return selected;
+}
 async function relationshipScan(input, issue) {
     const [comments, relatedPullRequests, duplicateCandidates] = await Promise.all([
         fetchIssueComments(input.exec, input.repository, input.issue),
@@ -384,40 +519,40 @@ export function eligibleMentionReplies(input) {
 function finalResultFromMarker(marker) {
     if (marker.disposition) {
         return {
-            askReason: marker.askReason,
             category: marker.category ?? null,
             disposition: marker.disposition,
+            signals: marker.signals,
         };
     }
     switch (marker.result) {
         case "BUG_ACCEPTED":
         case "RESOLVED_BY_MERGED_PR":
-            return { category: "bug", disposition: "accepted" };
+            return { category: "bug", disposition: "accepted", signals: [] };
         case "BUG_REJECTED":
-            return { category: "bug", disposition: "rejected" };
+            return { category: "bug", disposition: "rejected", signals: [] };
         case "FEATURE_ACCEPTED":
-            return { category: "feature", disposition: "accepted" };
+            return { category: "feature", disposition: "accepted", signals: [] };
         case "FEATURE_REJECTED":
-            return { category: "feature", disposition: "rejected" };
+            return { category: "feature", disposition: "rejected", signals: [] };
         case "ASK":
             return {
-                askReason: "acceptance_unclear",
                 category: null,
-                disposition: "ask",
+                disposition: "needs_acceptance",
+                signals: [],
             };
         case "CLEAR_ONLY":
-            return { category: null, disposition: "clear_only" };
+            return { category: null, disposition: "already_handled", signals: [] };
         case "DUPLICATE":
-            return { category: null, disposition: "duplicate" };
+            return { category: null, disposition: "duplicate", signals: [] };
         default:
-            return { category: null, disposition: "failed" };
+            return { category: null, disposition: "failed", signals: [] };
     }
 }
 function decisionText(decision) {
     return JSON.stringify(decision);
 }
 function actionPlan(input) {
-    if (input.result.disposition === "clear_only") {
+    if (input.result.disposition === "already_handled") {
         return {
             action: "CLEAR_ONLY",
             allowedActions: ["CLEAR_ONLY"],
@@ -427,11 +562,12 @@ function actionPlan(input) {
             postComment: false,
         };
     }
-    if (input.result.disposition === "ask") {
+    if (input.result.disposition === "needs_category" ||
+        input.result.disposition === "needs_acceptance") {
         return {
             action: "ASK",
             allowedActions: ["ASK"],
-            clearLabels: false,
+            clearLabels: true,
             closeIssue: false,
             createPr: false,
             postComment: true,
@@ -439,6 +575,7 @@ function actionPlan(input) {
     }
     const closeIssue = input.triage.automation.close &&
         (input.result.disposition === "rejected" ||
+            input.result.disposition === "invalid" ||
             input.result.disposition === "duplicate");
     const createPr = input.triage.automation.create && input.result.disposition === "accepted";
     return {
@@ -452,8 +589,13 @@ function actionPlan(input) {
 }
 function previousAutomationPlan(input) {
     const base = actionPlan({ result: input.result, triage: input.triage });
+    const labelChanges = triageLabelChanges({
+        issueLabels: input.issue.labels,
+        result: input.result,
+        rules: input.triage.automation.label,
+    });
     const clearLabels = base.clearLabels &&
-        existingClearLabels(input.issue, input.triage.automation.clear).length > 0;
+        (labelChanges.add.length > 0 || labelChanges.remove.length > 0);
     const closeIssue = input.marker.action === "CLOSE" &&
         base.closeIssue &&
         input.issue.state === "OPEN";
@@ -558,6 +700,9 @@ function decisionCommentFallback(input) {
     if (input.result.disposition === "duplicate") {
         return "Magi marked this issue as a duplicate.";
     }
+    if (input.result.disposition === "invalid") {
+        return "Magi marked this issue as invalid or not actionable.";
+    }
     return "Magi completed triage for this issue.";
 }
 function agentForKey(repository, key) {
@@ -675,7 +820,9 @@ async function finishWithResult(input) {
     });
     let prUrl;
     const reporter = triageReporter(input.input.repository, input.issue.number);
-    const comment = plan.postComment && input.result.disposition !== "ask"
+    const comment = plan.postComment &&
+        input.result.disposition !== "needs_category" &&
+        input.result.disposition !== "needs_acceptance"
         ? `${decisionCommentBody({
             action: plan.action,
             reason: input.commentReason,
@@ -691,7 +838,19 @@ async function finishWithResult(input) {
     if (comment) {
         await writeFile(join(input.outputDir, "comment.md"), `${comment}\n`);
     }
-    if (input.result.disposition === "ask" && input.askOutputs) {
+    const labelChanges = plan.clearLabels
+        ? triageLabelChanges({
+            issueLabels: input.issue.labels,
+            result: input.result,
+            rules: triage.automation.label,
+        })
+        : { add: [], remove: [] };
+    if (plan.clearLabels) {
+        await writeJson(join(input.outputDir, "label-changes.json"), labelChanges);
+    }
+    if ((input.result.disposition === "needs_category" ||
+        input.result.disposition === "needs_acceptance") &&
+        input.askOutputs) {
         await postAskComments({
             action: plan.action,
             dryRun: input.input.dryRun,
@@ -723,9 +882,11 @@ async function finishWithResult(input) {
             });
         }
         if (plan.clearLabels) {
-            const clearLabels = existingClearLabels(input.issue, triage.automation.clear);
-            if (clearLabels.length) {
-                await removeIssueLabels(input.input.exec, input.input.repository, input.issue.number, clearLabels, reporter.account);
+            if (labelChanges.remove.length) {
+                await removeIssueLabels(input.input.exec, input.input.repository, input.issue.number, labelChanges.remove, reporter.account);
+            }
+            if (labelChanges.add.length) {
+                await addIssueLabels(input.input.exec, input.input.repository, input.issue.number, labelChanges.add, reporter.account);
             }
         }
         if (plan.closeIssue) {
@@ -934,7 +1095,7 @@ export async function runTriage(input) {
             issue: input.issue,
             outputDir,
             report,
-            result: { category: null, disposition: "failed" },
+            result: { category: null, disposition: "blocked", signals: [] },
         };
     }
     let context = issueContext({ issue, relationship });
@@ -1016,8 +1177,7 @@ export async function runTriage(input) {
         });
         await writeFile(join(outputDir, "context.md"), `${context}\n`);
         const previous = finalResultFromMarker(relationship.previousMarker);
-        if (previous.disposition !== "ask" ||
-            previous.askReason !== "acceptance_unclear") {
+        if (previous.disposition !== "needs_acceptance") {
             const reconsideration = await runReconsiderationVote({
                 context,
                 input,
@@ -1026,15 +1186,23 @@ export async function runTriage(input) {
             commentReason = reconsideration.reason;
             result =
                 reconsideration.vote === "YES"
-                    ? { category: previous.category, disposition: "accepted" }
+                    ? {
+                        category: previous.category,
+                        disposition: "accepted",
+                        signals: [],
+                    }
                     : reconsideration.vote === "NO"
-                        ? { category: previous.category, disposition: "rejected" }
+                        ? {
+                            category: previous.category,
+                            disposition: "rejected",
+                            signals: [],
+                        }
                         : {
-                            askReason: "acceptance_unclear",
                             category: previous.category,
-                            disposition: "ask",
+                            disposition: "needs_acceptance",
+                            signals: [],
                         };
-            if (result.disposition === "ask") {
+            if (result.disposition === "needs_acceptance") {
                 askCommentOutputs = askOutputs(reconsideration.outputs);
                 markAskComments = true;
             }
@@ -1057,6 +1225,7 @@ export async function runTriage(input) {
                 const relatedPrDecision = {
                     category: resolveIssueCategory(issue, input.repository) ?? null,
                     disposition: "accepted",
+                    signals: [],
                 };
                 const plan = {
                     action: "CLOSE",
@@ -1086,7 +1255,7 @@ export async function runTriage(input) {
                 outputDir,
                 processed,
                 relationship,
-                result: { category: null, disposition: "clear_only" },
+                result: { category: null, disposition: "already_handled", signals: [] },
                 runId,
             });
         }
@@ -1101,7 +1270,7 @@ export async function runTriage(input) {
         if (duplicate) {
             context = `${context}\n\nDuplicate decision: ${JSON.stringify(duplicate)}`;
             commentReason = duplicate.reason;
-            result = { category: null, disposition: "duplicate" };
+            result = { category: null, disposition: "duplicate", signals: [] };
         }
     }
     if (!result) {
@@ -1125,9 +1294,9 @@ export async function runTriage(input) {
         const category = resolvedCategory ?? categoryVote?.vote ?? "ASK";
         if (category === "ASK") {
             result = {
-                askReason: "category_unclear",
                 category: null,
-                disposition: "ask",
+                disposition: "needs_category",
+                signals: [],
             };
             askCommentOutputs = askOutputs(categoryVote?.outputs);
             markAskComments = false;
@@ -1146,25 +1315,41 @@ export async function runTriage(input) {
                 phase: "acceptance",
                 prompt: composeTriageAcceptancePrompt,
                 schemaName: "triage acceptance",
-                votes: BINARY_VOTES,
+                votes: ACCEPTANCE_VOTES,
             });
             commentReason = acceptance.reason;
             result =
                 acceptance.vote === "YES"
-                    ? { category, disposition: "accepted" }
+                    ? { category, disposition: "accepted", signals: [] }
                     : acceptance.vote === "NO"
-                        ? { category, disposition: "rejected" }
-                        : {
-                            askReason: "acceptance_unclear",
-                            category,
-                            disposition: "ask",
-                        };
-            if (result.disposition === "ask") {
+                        ? { category, disposition: "rejected", signals: [] }
+                        : acceptance.vote === "INVALID"
+                            ? { category, disposition: "invalid", signals: [] }
+                            : {
+                                category,
+                                disposition: "needs_acceptance",
+                                signals: [],
+                            };
+            if (result.disposition === "needs_acceptance") {
                 askCommentOutputs = askOutputs(acceptance.outputs);
                 markAskComments = true;
             }
         }
     }
+    if (result &&
+        result.disposition !== "blocked" &&
+        result.disposition !== "failed" &&
+        triage.signals.length) {
+        const signalContext = `${context}\n\nFinal triage result: ${JSON.stringify(result)}`;
+        result = {
+            ...result,
+            signals: await runSignalVote({
+                context: signalContext,
+                input,
+                outputDir,
+            }),
+        };
+    }
     return finishWithResult({
         askOutputs: askCommentOutputs,
         commentReason,
@@ -1176,9 +1361,9 @@ export async function runTriage(input) {
         processed,
         relationship,
         result: result ?? {
-            askReason: "acceptance_unclear",
             category: null,
-            disposition: "ask",
+            disposition: "needs_acceptance",
+            signals: [],
         },
         runId,
     });

package/dist/prompts/compose.js

@@ -1,7 +1,7 @@
 import { readFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { isAbsolute, join } from "node:path";
-import { ciClassificationAfterEditOutputContract, ciClassificationOutputContract, closeReconsiderationOutputContract, editOutputContract, findingValidationOutputContract, rereviewCloseReconsiderationOutputContract, rereviewOutputContract, reviewOutputContract, triageCommentClassificationOutputContract, triageCreatePrOutputContract, triageDuplicateOutputContract, triageVoteOutputContract, } from "./contracts";
+import { ciClassificationAfterEditOutputContract, ciClassificationOutputContract, closeReconsiderationOutputContract, editOutputContract, findingValidationOutputContract, rereviewCloseReconsiderationOutputContract, rereviewOutputContract, reviewOutputContract, triageCommentClassificationOutputContract, triageCreatePrOutputContract, triageDuplicateOutputContract, triageSignalOutputContract, triageVoteOutputContract, } from "./contracts";
 async function readOptionalPrompt(directory, path, values = {}) {
     if (!path)
         return "";
@@ -90,12 +90,16 @@ function triageValues(input) {
         ? `- ${category.id}: ${category.description}`
         : `- ${category.id}`)
         .join("\n");
+    const signalOptions = (input.repository.triage?.signals ?? [])
+        .map((signal) => `- ${signal.id}: ${signal.description}`)
+        .join("\n");
     return {
         ...repositoryValues(input.repository),
         author: input.author ?? "",
         categoryOptions,
         context: input.context,
         issue: String(input.issue),
+        signalOptions,
         worktreePath: input.worktreePath ?? "",
     };
 }
@@ -441,7 +445,14 @@ export async function composeTriageAcceptancePrompt(input) {
         ...input,
         builtin: "acceptance",
         customPath: input.repository.triage?.prompts.acceptance,
-        outputContract: triageVoteOutputContract('"YES" | "NO" | "ASK"'),
+        outputContract: triageVoteOutputContract('"YES" | "NO" | "INVALID" | "ASK"'),
+    });
+}
+export async function composeTriageSignalPrompt(input) {
+    return composeTriageVotePrompt({
+        ...input,
+        builtin: "signal",
+        outputContract: triageSignalOutputContract,
     });
 }
 export async function composeTriageCommentClassificationPrompt(input) {

package/dist/prompts/contracts.js

@@ -256,6 +256,24 @@ The object must match this shape:
   ]
 }
 </output_contract>`.trim();
+export const triageSignalOutputContract = `
+<output_contract>
+Return exactly one JSON object and nothing else. Do not wrap it in markdown.
+
+The object must match this shape:
+{
+  "signals": [
+    {
+      "id": "configured_signal_id",
+      "reason": "Short rationale."
+    }
+  ]
+}
+
+Rules:
+- Return only configured signal IDs that apply.
+- Return an empty signals array when none apply.
+</output_contract>`.trim();
 const outputContractsBySchemaName = {
     "CI classification": ciClassificationOutputContract,
     "close reconsideration": closeReconsiderationOutputContract,
@@ -264,13 +282,14 @@ const outputContractsBySchemaName = {
     rereview: rereviewOutputContract,
     "rereview close reconsideration": rereviewCloseReconsiderationOutputContract,
     review: reviewOutputContract,
-    "triage acceptance": triageVoteOutputContract('"YES" | "NO" | "ASK"'),
+    "triage acceptance": triageVoteOutputContract('"YES" | "NO" | "INVALID" | "ASK"'),
     "triage category": triageVoteOutputContract('"ASK" or one of the configured category IDs'),
     "triage create PR": triageCreatePrOutputContract,
     "triage comment classification": triageCommentClassificationOutputContract,
     "triage duplicate": triageDuplicateOutputContract,
     "triage existing PR": triageVoteOutputContract('"RELATED_PR_HANDLES_ISSUE" | "RELATED_PR_DOES_NOT_HANDLE_ISSUE"'),
     "triage reconsider": triageVoteOutputContract('"YES" | "NO" | "ASK"'),
+    "triage signal": triageSignalOutputContract,
 };
 export function repairPrompt(schemaName) {
     const outputContract = outputContractsBySchemaName[schemaName];

package/dist/prompts/output.js

@@ -112,7 +112,25 @@ export function parseTriageCategoryOutput(text, categories) {
     return parseTriageVote(text, ["ASK", ...categories]);
 }
 export function parseTriageBinaryOutput(text) {
-    return parseTriageVote(text, ["ASK", "NO", "YES"]);
+    return parseTriageVote(text, ["ASK", "INVALID", "NO", "YES"]);
+}
+export function parseTriageSignalOutput(text, signalIds) {
+    const data = extractJson(text);
+    if (!data || typeof data !== "object")
+        throw new Error("triage signal output must be an object");
+    const ids = new Set(signalIds);
+    return {
+        signals: requireArray(data.signals, "signals").map((item, index) => {
+            const value = item;
+            const id = requireString(value.id, `signals[${index}].id`);
+            if (!ids.has(id))
+                throw new Error(`signals[${index}].id is not configured`);
+            return {
+                id,
+                reason: requireString(value.reason, `signals[${index}].reason`),
+            };
+        }),
+    };
 }
 export function parseTriageDuplicateOutput(text) {
     const data = extractJson(text);

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

@@ -1,6 +1,6 @@
 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.
+Choose YES when the issue should be accepted for the project. Choose NO when it should not be worked on for normal wontfix reasons. Choose INVALID when the report is unreproducible, contradictory, based on an impossible premise, or otherwise not actionable as an issue. Choose ASK when specific missing information is required before deciding.
 
 <context>
 {context}

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

@@ -0,0 +1,10 @@
+Evaluate optional triage signals for issue #{issue} in {owner}/{repo}.
+
+Configured signals:
+{signalOptions}
+
+Return every configured signal that applies to the final triage result and issue context. Do not invent signal IDs.
+
+<context>
+{context}
+</context>

package/package.json

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

package/schema.json

@@ -279,6 +279,47 @@
         "description": { "type": "string" }
       }
     },
+    "triageSignal": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["id", "description"],
+      "properties": {
+        "id": { "type": "string", "pattern": "^[A-Za-z0-9_-]+$" },
+        "description": { "type": "string", "minLength": 1 }
+      }
+    },
+    "triageLabelRuleCondition": {
+      "type": "object",
+      "additionalProperties": false,
+      "minProperties": 1,
+      "properties": {
+        "disposition": {
+          "enum": [
+            "accepted",
+            "rejected",
+            "invalid",
+            "duplicate",
+            "already_handled",
+            "needs_category",
+            "needs_acceptance",
+            "blocked",
+            "failed"
+          ]
+        },
+        "category": { "type": "string" },
+        "signals": { "type": "array", "items": { "type": "string" } }
+      }
+    },
+    "triageLabelRule": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["when"],
+      "properties": {
+        "when": { "$ref": "#/$defs/triageLabelRuleCondition" },
+        "add": { "type": "array", "items": { "type": "string" } },
+        "remove": { "type": "array", "items": { "type": "string" } }
+      }
+    },
     "triageAutomation": {
       "type": "object",
       "additionalProperties": false,
@@ -287,10 +328,9 @@
         "create": { "type": "boolean", "default": false },
         "review": { "type": "boolean", "default": false },
         "merge": { "type": "boolean", "default": false },
-        "clear": {
+        "label": {
           "type": "array",
-          "items": { "type": "string" },
-          "default": ["triage"]
+          "items": { "$ref": "#/$defs/triageLabelRule" }
         }
       }
     },
@@ -371,6 +411,10 @@
           "type": "array",
           "items": { "$ref": "#/$defs/triageCategory" }
         },
+        "signals": {
+          "type": "array",
+          "items": { "$ref": "#/$defs/triageSignal" }
+        },
         "automation": { "$ref": "#/$defs/triageAutomation" },
         "safety": { "$ref": "#/$defs/triageSafety" },
         "concurrency": { "$ref": "#/$defs/triageConcurrency" },