opencode-magi 0.6.1 → 0.8.0

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;
@@ -128,13 +183,14 @@ async function emitTriageModelProgress(input) {
     }
 }
 async function runVote(input) {
-    const prompt = await input.prompt({
-        context: input.context,
-        directory: input.directory,
-        issue: input.issue,
-        repository: input.repository,
-        voter: input.agent,
-    });
+    const prompt = input.promptText ??
+        (await input.prompt({
+            context: input.context,
+            directory: input.directory,
+            issue: input.issue,
+            repository: input.repository,
+            voter: input.agent,
+        }));
     await emitProgress(input.run, {
         phase: input.phase,
         type: "triage_agent_started",
@@ -216,7 +272,7 @@ export function chooseDuplicateOutput(input) {
 async function runDuplicateVote(input) {
     const agents = input.input.repository.agents.triage;
     if (!agents?.length)
-        throw new Error("triage.agents is required");
+        throw new Error("triage.voters is required");
     await emitProgress(input.input, { phase: "duplicate", type: "phase" });
     const outputs = await Promise.all(agents.map((agent) => runVote({
         agent,
@@ -258,9 +314,16 @@ async function runDuplicateVote(input) {
 async function runPhaseVote(input) {
     const agents = input.input.repository.agents.triage;
     if (!agents?.length)
-        throw new Error("triage.agents is required");
+        throw new Error("triage.voters is required");
     await emitProgress(input.input, { phase: input.phase, type: "phase" });
-    const outputs = await Promise.all(agents.map((agent) => runVote({
+    const promptTexts = await Promise.all(agents.map((agent) => input.prompt({
+        context: input.context,
+        directory: input.input.directory,
+        issue: input.input.issue,
+        repository: input.input.repository,
+        voter: agent,
+    })));
+    const outputs = await Promise.all(agents.map((agent, index) => runVote({
         agent,
         client: input.input.client,
         context: input.context,
@@ -269,6 +332,7 @@ async function runPhaseVote(input) {
         parse: input.parse,
         phase: input.phase,
         prompt: input.prompt,
+        promptText: promptTexts[index],
         repository: input.input.repository,
         run: input.input,
         schemaName: input.schemaName,
@@ -285,7 +349,96 @@ async function runPhaseVote(input) {
         voter: agents[index].key,
     })));
     await writeJson(join(input.outputDir, `${input.phase}-majority.json`), majority);
-    return { outputs, vote: majority.vote };
+    return {
+        outputs,
+        reason: chooseDecisionReason({
+            outputs,
+            threshold: majority.threshold,
+            vote: majority.vote,
+            voters: majority.vote ? majority.voters[majority.vote] : undefined,
+        }),
+        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([
@@ -366,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"],
@@ -409,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,
@@ -421,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 {
@@ -434,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";
@@ -507,7 +667,7 @@ async function runReconsiderationVote(input) {
 function triageReporter(repository, issue) {
     const agents = repository.agents.triage ?? [];
     if (!agents.length)
-        throw new Error("triage.agents is required");
+        throw new Error("triage.voters is required");
     const configured = repository.triage?.reporter;
     const reporter = configured
         ? agents.find((agent) => agent.key === configured)
@@ -518,26 +678,49 @@ function triageReporter(repository, issue) {
 }
 function decisionCommentBody(input) {
     const reason = input.reason?.trim();
-    const result = JSON.stringify(input.result);
     return reason
-        ? `Magi triage decision: ${result}\n\nReason: ${reason}`
-        : `Magi triage decision: ${result}\n\nAction: ${input.action}`;
+        ? reason
+        : decisionCommentFallback({ action: input.action, result: input.result });
+}
+function decisionCommentFallback(input) {
+    if (input.result.disposition === "accepted") {
+        const category = input.result.category
+            ? `${input.result.category} issue`
+            : "issue";
+        return input.action === "PR"
+            ? `Magi accepted this ${category} and will prepare an implementation pull request.`
+            : `Magi accepted this ${category}.`;
+    }
+    if (input.result.disposition === "rejected") {
+        const category = input.result.category
+            ? `${input.result.category} issue`
+            : "issue";
+        return `Magi does not plan to act on this ${category}.`;
+    }
+    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) {
     const agent = repository.agents.triage?.find((item) => item.key === key);
     if (!agent)
-        throw new Error(`Unknown triage agent: ${key}`);
+        throw new Error(`Unknown triage voter: ${key}`);
     return agent;
 }
 function askOutputs(outputs) {
     return (outputs ?? []).filter((output) => output.vote === "ASK");
 }
 function chooseDecisionReason(input) {
-    return (input.outputs?.find((output) => output.voter === input.reporter.key &&
-        output.vote === input.vote &&
-        output.reason)?.reason ??
-        input.outputs?.find((output) => output.vote === input.vote)?.reason ??
-        input.outputs?.find((output) => output.voter === input.reporter.key)?.reason);
+    if (!input.vote)
+        return undefined;
+    const canonicalVoter = input.voters?.[input.threshold - 1];
+    const canonicalReason = input.outputs?.find((output) => output.voter === canonicalVoter && output.vote === input.vote);
+    return (canonicalReason?.reason ??
+        input.outputs?.find((output) => output.vote === input.vote)?.reason);
 }
 async function postMarkedIssueComment(input) {
     const posted = await postIssueComment(input.exec, input.repository, input.issue, input.account, input.body);
@@ -637,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,
@@ -653,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,
@@ -685,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) {
@@ -867,7 +1066,7 @@ export async function runTriage(input) {
         throw new Error("triage configuration is required");
     const agents = input.repository.agents.triage;
     if (!agents?.length)
-        throw new Error("triage.agents is required");
+        throw new Error("triage.voters is required");
     const runId = input.runId ?? `run-${Date.now().toString(36)}`;
     const outputDir = issueRunOutputDir({
         config: input.config,
@@ -896,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 });
@@ -978,30 +1177,32 @@ 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,
                 outputDir,
             });
-            const reporter = triageReporter(input.repository, issue.number);
-            commentReason = chooseDecisionReason({
-                outputs: reconsideration.outputs,
-                reporter,
-                vote: reconsideration.vote ?? "ASK",
-            });
+            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;
             }
@@ -1024,6 +1225,7 @@ export async function runTriage(input) {
                 const relatedPrDecision = {
                     category: resolveIssueCategory(issue, input.repository) ?? null,
                     disposition: "accepted",
+                    signals: [],
                 };
                 const plan = {
                     action: "CLOSE",
@@ -1034,11 +1236,7 @@ export async function runTriage(input) {
                     postComment: true,
                 };
                 return finishWithResult({
-                    commentReason: chooseDecisionReason({
-                        outputs: existingPr.outputs,
-                        reporter: triageReporter(input.repository, issue.number),
-                        vote: "RELATED_PR_HANDLES_ISSUE",
-                    }),
+                    commentReason: existingPr.reason,
                     context,
                     input,
                     issue,
@@ -1057,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,
             });
         }
@@ -1072,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) {
@@ -1096,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;
@@ -1117,30 +1315,41 @@ export async function runTriage(input) {
                 phase: "acceptance",
                 prompt: composeTriageAcceptancePrompt,
                 schemaName: "triage acceptance",
-                votes: BINARY_VOTES,
-            });
-            const reporter = triageReporter(input.repository, issue.number);
-            commentReason = chooseDecisionReason({
-                outputs: acceptance.outputs,
-                reporter,
-                vote: acceptance.vote ?? "ASK",
+                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,
@@ -1152,9 +1361,9 @@ export async function runTriage(input) {
         processed,
         relationship,
         result: result ?? {
-            askReason: "acceptance_unclear",
             category: null,
-            disposition: "ask",
+            disposition: "needs_acceptance",
+            signals: [],
         },
         runId,
     });