opencode-magi 0.7.0 → 0.9.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;
@@ -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 "";
@@ -35,6 +35,7 @@ function repositoryValues(repository) {
 }
 function reviewValues(input) {
     const ciFailureContext = input.ciFailureContext?.trim() ?? "";
+    const mergeConflictContext = input.mergeConflictContext?.trim() ?? "";
     return {
         ...repositoryValues(input.repository),
         baseSha: input.baseSha,
@@ -44,6 +45,10 @@ function reviewValues(input) {
             : "",
         headSha: input.headSha,
         jsonEncodedWorktreePath: JSON.stringify(input.worktreePath),
+        mergeConflictContext,
+        mergeConflictContextBlock: mergeConflictContext
+            ? `<merge_conflict_context>\n${mergeConflictContext}\n</merge_conflict_context>`
+            : "",
         pr: String(input.pr),
         reviewContext: input.reviewContext ?? "",
         worktreePath: input.worktreePath,
@@ -67,6 +72,17 @@ function editValues(input) {
         worktreePath: input.worktreePath,
     };
 }
+function mergeConflictValues(input) {
+    return {
+        ...repositoryValues(input.repository),
+        baseBranch: input.baseBranch,
+        baseSha: input.baseSha,
+        conflictedFiles: input.conflictedFiles,
+        headSha: input.headSha,
+        pr: String(input.pr),
+        worktreePath: input.worktreePath,
+    };
+}
 function triageValues(input) {
     const categories = input.repository.triage?.categories ?? [];
     const categoryOptions = categories
@@ -74,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 ?? "",
     };
 }
@@ -97,6 +117,12 @@ function previousReviewBlock(previousReview) {
 function reviewContextBlock(reviewContext) {
     return reviewContext?.trim() ? reviewContext.trim() : "";
 }
+function mergeConflictContextBlock(mergeConflictContext) {
+    const body = mergeConflictContext?.trim();
+    return body
+        ? `<merge_conflict_context>\n${body}\n</merge_conflict_context>`
+        : "";
+}
 async function reviewGuidelinesBlock(input) {
     const body = (await readOptionalPrompt(input.directory, input.path, input.values)).trim();
     return body ? `<review_guidelines>\n${body}\n</review_guidelines>` : "";
@@ -136,6 +162,7 @@ export async function composeReviewPrompt(input) {
     return [
         task,
         reviewContextBlock(input.reviewContext),
+        mergeConflictContextBlock(input.mergeConflictContext),
         languageBlock(input.repository.language),
         personaBlock(input.reviewer.persona),
         await reviewGuidelinesBlock({
@@ -159,6 +186,7 @@ export async function composeRereviewPrompt(input) {
     return [
         task,
         reviewContextBlock(input.reviewContext),
+        mergeConflictContextBlock(input.mergeConflictContext),
         input.includeSessionContext === false
             ? ""
             : languageBlock(input.repository.language),
@@ -200,6 +228,28 @@ export async function composeEditPrompt(input) {
         .filter(Boolean)
         .join("\n\n");
 }
+export async function composeMergeConflictPrompt(input) {
+    const values = mergeConflictValues(input);
+    const task = await taskBlock({
+        builtin: "merge/conflict",
+        directory: input.directory,
+        values,
+    });
+    const persona = input.repository.agents.editor?.persona;
+    return [
+        task,
+        languageBlock(input.repository.language),
+        personaBlock(persona),
+        await editGuidelinesBlock({
+            directory: input.directory,
+            path: input.repository.prompts.editGuidelines,
+            values,
+        }),
+        editOutputContract,
+    ]
+        .filter(Boolean)
+        .join("\n\n");
+}
 export async function composeFindingValidationPrompt(input) {
     const values = { ...reviewValues(input), findings: input.findings };
     const task = await taskBlock({
@@ -395,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) {