opencode-magi 0.7.0 → 0.8.0

package/dist/orchestrator/review.js

@@ -163,6 +163,90 @@ export async function inlineCommentTargetsForDiff(input) {
         cwd: input.worktreePath,
     }));
 }
+function firstTargetLine(targets, path) {
+    const lines = targets.get(path);
+    if (!lines?.size)
+        return undefined;
+    return [...lines].sort((a, b) => a - b)[0];
+}
+function mergeInlineCommentTargets(left, right) {
+    const merged = new Map();
+    for (const [path, lines] of [...left, ...right]) {
+        const targetLines = merged.get(path) ?? new Set();
+        for (const line of lines)
+            targetLines.add(line);
+        merged.set(path, targetLines);
+    }
+    return merged;
+}
+function targetLineSummary(targets, path) {
+    const lines = targets.get(path);
+    if (!lines?.size)
+        return "(none)";
+    const sorted = [...lines].sort((a, b) => a - b);
+    const shown = sorted.slice(0, 12).join(", ");
+    return sorted.length > 12 ? `${shown}, ...` : shown;
+}
+function indentedExcerpt(lines) {
+    return lines
+        .slice(0, 24)
+        .map((line) => `  ${line}`)
+        .join("\n");
+}
+function parseMergeConflictSections(output) {
+    const conflictHeaders = new Set([
+        "added in both",
+        "changed in both",
+        "removed in local",
+        "removed in remote",
+    ]);
+    const sections = [];
+    let current;
+    for (const line of output.split("\n")) {
+        if (!line.trim())
+            continue;
+        if (!line.startsWith(" ") &&
+            !line.startsWith("+") &&
+            !line.startsWith("-") &&
+            !line.startsWith("@")) {
+            current = conflictHeaders.has(line)
+                ? { lines: [line], paths: new Set() }
+                : undefined;
+            if (current)
+                sections.push(current);
+            continue;
+        }
+        if (!current)
+            continue;
+        current.lines.push(line);
+        const path = /^  (?:base|our|their)\s+\d+\s+[0-9a-f]+\s+(.+)$/.exec(line)?.[1];
+        if (path)
+            current.paths.add(path);
+    }
+    return sections.flatMap((section) => [...section.paths].map((path) => ({
+        excerpt: indentedExcerpt(section.lines),
+        path,
+    })));
+}
+export async function mergeConflictContextForDiff(input) {
+    const mergeBase = (await input.exec(`git merge-base ${shellQuote(input.baseSha)} ${shellQuote(input.headSha)}`, { cwd: input.worktreePath })).trim();
+    const output = await input.exec(`git merge-tree ${shellQuote(mergeBase)} ${shellQuote(input.headSha)} ${shellQuote(input.baseSha)}`, { cwd: input.worktreePath });
+    const conflicts = parseMergeConflictSections(output);
+    if (!conflicts.length)
+        return "";
+    return [
+        "The PR currently has unresolved merge conflicts with the base branch.",
+        "Treat unresolved conflicts as review findings and request changes when they make the PR unsafe or impossible to merge.",
+        "Use suggestedLine when it is present; it is a valid right-side PR diff line for an inline finding.",
+        ...conflicts.map((conflict) => {
+            const suggestedLine = firstTargetLine(input.inlineCommentTargets, conflict.path);
+            const suggestedLineText = suggestedLine
+                ? `suggestedLine: ${suggestedLine}`
+                : "suggestedLine: (no right-side PR diff line found)";
+            return `<conflict_file>\npath: ${conflict.path}\n${suggestedLineText}\nrightSideDiffLines: ${targetLineSummary(input.inlineCommentTargets, conflict.path)}\nmergeTreeExcerpt:\n${conflict.excerpt}\n</conflict_file>`;
+        }),
+    ].join("\n");
+}
 function parsePostedFindingLocation(location) {
     const range = /^(.*):(\d+)-(\d+)$/.exec(location);
     if (range) {
@@ -709,6 +793,13 @@ export async function runReview(input) {
             toSha: meta.headRefOid,
             worktreePath,
         });
+        const mergeConflictContext = await mergeConflictContextForDiff({
+            baseSha: meta.baseRefOid,
+            exec,
+            headSha: meta.headRefOid,
+            inlineCommentTargets: initialInlineCommentTargets,
+            worktreePath,
+        });
         for (const reviewer of input.repository.agents.reviewers) {
             const assignment = mode.assignments.get(reviewer.account);
             if (assignment?.type !== "skip")
@@ -740,6 +831,9 @@ export async function runReview(input) {
                     toSha: meta.headRefOid,
                     worktreePath,
                 });
+                const rereviewInlineCommentTargets = mergeConflictContext
+                    ? mergeInlineCommentTargets(inlineCommentTargets, initialInlineCommentTargets)
+                    : inlineCommentTargets;
                 const unresolved = unresolvedThreadsByAccount.get(reviewer.account) ??
                     (await fetchUnresolvedThreads(exec, input.repository, input.pr, reviewer.account));
                 const prompt = await composeRereviewPrompt({
@@ -747,6 +841,7 @@ export async function runReview(input) {
                     ciFailureContext,
                     directory: input.directory,
                     headSha: meta.headRefOid,
+                    mergeConflictContext,
                     pr: input.pr,
                     previousReview: previousReviewText(previous),
                     previousHeadSha: previous.commit.oid,
@@ -787,7 +882,7 @@ export async function runReview(input) {
                         },
                         options: reviewer.options,
                         parentSessionId: input.parentSessionId,
-                        parse: (text) => parseRereviewOutputWithInlineTargets(text, inlineCommentTargets),
+                        parse: (text) => parseRereviewOutputWithInlineTargets(text, rereviewInlineCommentTargets),
                         permission: reviewer.permission,
                         prompt,
                         repairAttempts: input.config.output?.repairAttempts ?? 3,
@@ -819,6 +914,7 @@ export async function runReview(input) {
                 ciFailureContext,
                 directory: input.directory,
                 headSha: meta.headRefOid,
+                mergeConflictContext,
                 pr: input.pr,
                 repository: input.repository,
                 reviewContext,

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,
     });