opencode-magi 0.0.0-dev-20260519144738 → 0.0.0-dev-20260520030110

package/dist/index.js

@@ -13,6 +13,7 @@ import { validateConfig } from "./config/validate";
 import { withGitHubApiRetry } from "./github/retry";
 import { mapPool } from "./orchestrator/pool";
 import { MagiRunManager } from "./orchestrator/run-manager";
+import { runTriage } from "./orchestrator/triage";
 const execAsync = promisify(nodeExec);
 const GLOBAL_CONFIG_PATH = join(homedir(), ".config", "opencode", "magi.json");
 const PROJECT_CONFIG_PATH = join(".opencode", "magi.json");
@@ -63,6 +64,16 @@ function parsePrToken(value) {
     }
     return pr;
 }
+function parseIssueToken(value) {
+    const trimmed = value.trim();
+    const issueUrl = trimmed.match(/(?:^|\/)issues\/(\d+)(?:[/?#].*)?$/);
+    const raw = issueUrl?.[1] ?? trimmed.replace(/^#/, "");
+    const issue = Number.parseInt(raw, 10);
+    if (!Number.isInteger(issue) || issue <= 0 || String(issue) !== raw) {
+        throw new Error("Specify one or more issue numbers or issue URLs.");
+    }
+    return issue;
+}
 export function parsePrs(value) {
     const prs = value
         .split(/[\s,]+/)
@@ -72,6 +83,15 @@ export function parsePrs(value) {
         throw new Error("Specify one or more PR numbers or PR URLs.");
     return prs;
 }
+export function parseIssues(value) {
+    const issues = value
+        .split(/[\s,]+/)
+        .filter(Boolean)
+        .map(parseIssueToken);
+    if (!issues.length)
+        throw new Error("Specify one or more issue numbers or issue URLs.");
+    return issues;
+}
 export function parseRunArguments(value, dryRun = false) {
     const tokens = value.split(/[\s,]+/).filter(Boolean);
     const prTokens = tokens.filter((token) => {
@@ -83,6 +103,17 @@ export function parseRunArguments(value, dryRun = false) {
     });
     return { dryRun, prs: parsePrs(prTokens.join(" ")) };
 }
+export function parseIssueRunArguments(value, dryRun = false) {
+    const tokens = value.split(/[\s,]+/).filter(Boolean);
+    const issueTokens = tokens.filter((token) => {
+        if (token === "--dry-run") {
+            dryRun = true;
+            return false;
+        }
+        return true;
+    });
+    return { dryRun, issues: parseIssues(issueTokens.join(" ")) };
+}
 function parseOptionalPr(value) {
     if (!value?.trim())
         return undefined;
@@ -337,6 +368,42 @@ export const MagiPlugin = async ({ client, directory }) => {
                         .join("\n");
                 },
             }),
+            magi_triage: tool({
+                description: "Triage one or more GitHub issues with configured Magi triage agents.",
+                args: {
+                    issues: tool.schema.string(),
+                    dryRun: tool.schema.boolean().optional(),
+                },
+                async execute(args, context) {
+                    const parsed = parseIssueRunArguments(args.issues, args.dryRun ?? false);
+                    const loaded = await loadConfig(directory);
+                    const retryingExec = withGitHubApiRetry(exec, loaded.config.github?.apiRetryAttempts ?? 3);
+                    const validation = await validateConfig(loaded.config, {
+                        checkAuth: true,
+                        directory,
+                        exec: retryingExec,
+                        modelCatalog: await modelCatalog(),
+                        requireReview: false,
+                        requireTriage: true,
+                    });
+                    if (!validation.ok)
+                        return JSON.stringify(validation, null, 2);
+                    const repository = resolveRepository(loaded.config);
+                    if (!repository.triage)
+                        return JSON.stringify({ errors: ["triage configuration is required"], ok: false }, null, 2);
+                    const results = await mapPool(parsed.issues, repository.triage.concurrency.runs, (issue) => runTriage({
+                        client: modelClient,
+                        config: loaded.config,
+                        directory,
+                        dryRun: parsed.dryRun,
+                        exec: retryingExec,
+                        issue,
+                        repository,
+                        signal: context.abort,
+                    }), { signal: context.abort });
+                    return results.map((result) => result.report).join("\n\n");
+                },
+            }),
             magi_status: tool({
                 description: [
                     "Show Magi background run status. Optionally filter by runId or PR and wait for completion.",

package/dist/orchestrator/majority.js

@@ -2,6 +2,20 @@ const VERDICTS = ["MERGE", "CHANGES_REQUESTED", "CLOSE"];
 export function majorityThreshold(total) {
     return Math.floor(total / 2) + 1;
 }
+export function aggregateStringMajority(results, votes) {
+    if (results.length < 3 || results.length % 2 === 0) {
+        throw new Error("majority requires an odd number of at least 3 results");
+    }
+    const counts = Object.fromEntries(votes.map((vote) => [vote, 0]));
+    const voters = Object.fromEntries(votes.map((vote) => [vote, []]));
+    for (const result of results) {
+        counts[result.vote] += 1;
+        voters[result.vote].push(result.reviewer);
+    }
+    const threshold = majorityThreshold(results.length);
+    const vote = votes.find((item) => counts[item] >= threshold);
+    return { counts, threshold, vote, voters };
+}
 export function aggregateMajority(results) {
     if (results.length < 3 || results.length % 2 === 0) {
         throw new Error("majority requires an odd number of at least 3 reviewer results");

package/dist/orchestrator/triage.js

@@ -0,0 +1,420 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { issueRunOutputDir } from "../config/output";
+import { worktreeBaseDir } from "../config/worktree";
+import { closeIssue, closePullRequest, configureGitIdentity, createPullRequest, fetchIssue, fetchIssueComments, fetchRelatedPullRequests, postIssueComment, pushHead, removeIssueLabels, removeWorktree, searchDuplicateIssues, shellQuote, } from "../github/commands";
+import { composeTriageBugPrompt, composeTriageCommentPrompt, composeTriageDuplicatePrompt, composeTriageExistingPrPrompt, composeTriageFeaturePrompt, composeTriageKindPrompt, } from "../prompts/compose";
+import { parseEditOutput, parseTriageBinaryOutput, parseTriageDuplicateOutput, parseTriageExistingPrOutput, parseTriageKindOutput, } from "../prompts/output";
+import { aggregateStringMajority, majorityThreshold } from "./majority";
+import { runModelText, runModelWithRepair } from "./model";
+const MARKER_PREFIX = "opencode-magi:triage";
+const KIND_VOTES = ["ASK", "BUG", "FEATURE"];
+const BINARY_VOTES = ["ASK", "NO", "YES"];
+const DUPLICATE_VOTES = ["DUPLICATE", "NOT_DUPLICATE"];
+const EXISTING_PR_VOTES = [
+    "RELATED_PR_DOES_NOT_HANDLE_ISSUE",
+    "RELATED_PR_HANDLES_ISSUE",
+];
+function marker(input) {
+    return `<!-- ${MARKER_PREFIX} v=1 issue=${input.issue} result=${input.result} action=${input.action} checkpoint=pending pr=${input.pr ?? "none"} processed=${(input.processed ?? []).join(",")} -->`;
+}
+export function parseTriageMarker(body) {
+    const match = body.match(/<!--\s*opencode-magi:triage\s+([^>]+?)\s*-->/);
+    if (!match)
+        return undefined;
+    const entries = Object.fromEntries(match[1]
+        .trim()
+        .split(/\s+/)
+        .map((part) => {
+        const index = part.indexOf("=");
+        return index === -1
+            ? [part, ""]
+            : [part.slice(0, index), part.slice(index + 1)];
+    }));
+    const version = Number(entries.v);
+    if (version !== 1)
+        return undefined;
+    return {
+        action: entries.action,
+        checkpoint: entries.checkpoint ? Number(entries.checkpoint) : undefined,
+        issue: entries.issue ? Number(entries.issue) : undefined,
+        pr: entries.pr,
+        processed: entries.processed
+            ? entries.processed.split(",").filter(Boolean).map(Number)
+            : [],
+        result: entries.result,
+        v: version,
+    };
+}
+function labelsContain(labels, targets) {
+    const set = new Set(labels.map((label) => label.toLowerCase()));
+    return targets.some((target) => set.has(target.toLowerCase()));
+}
+export function resolveIssueKind(issue, repository) {
+    const triage = repository.triage;
+    if (!triage)
+        throw new Error("triage configuration is required");
+    const bug = labelsContain(issue.labels, triage.kind.bug.label) ||
+        (issue.type != null && triage.kind.bug.type.includes(issue.type));
+    const feature = labelsContain(issue.labels, triage.kind.feature.label) ||
+        (issue.type != null && triage.kind.feature.type.includes(issue.type));
+    if (bug === feature)
+        return undefined;
+    return bug ? "BUG" : "FEATURE";
+}
+function issueContext(input) {
+    return JSON.stringify({
+        duplicateCandidates: input.relationship.duplicateCandidates,
+        issue: input.issue,
+        recentComments: input.relationship.comments.slice(-20),
+        relatedPullRequests: input.relationship.relatedPullRequests,
+    }, null, 2);
+}
+async function writeJson(path, value) {
+    await writeFile(path, `${JSON.stringify(value, null, 2)}\n`);
+}
+async function runVote(input) {
+    const prompt = await input.prompt({
+        context: input.context,
+        directory: input.directory,
+        issue: input.issue,
+        repository: input.repository,
+        reviewer: input.agent,
+    });
+    const result = await runModelWithRepair({
+        client: input.client,
+        model: input.agent.model,
+        options: input.agent.options,
+        parse: input.parse,
+        permission: input.agent.permission,
+        prompt,
+        repairAttempts: 3,
+        schemaName: input.schemaName,
+        signal: input.signal,
+        title: `Magi triage ${input.schemaName} #${input.issue} (${input.agent.key})`,
+    });
+    return { ...result.value, raw: result.raw, sessionId: result.sessionId };
+}
+export function chooseDuplicateOutput(input) {
+    const candidates = new Set(input.candidateNumbers);
+    const threshold = majorityThreshold(input.outputs.length);
+    const counts = new Map();
+    for (const output of input.outputs) {
+        if (output.vote !== "DUPLICATE" ||
+            output.duplicateOf == null ||
+            !candidates.has(output.duplicateOf)) {
+            continue;
+        }
+        counts.set(output.duplicateOf, (counts.get(output.duplicateOf) ?? 0) + 1);
+    }
+    const target = [...counts.entries()].find(([, count]) => count >= threshold)?.[0];
+    if (target == null)
+        return undefined;
+    return input.outputs.find((output) => output.vote === "DUPLICATE" && output.duplicateOf === target);
+}
+async function runDuplicateVote(input) {
+    const agents = input.input.repository.agents.triage;
+    if (!agents?.length)
+        throw new Error("triage.agents is required");
+    const outputs = await Promise.all(agents.map((agent) => runVote({
+        agent,
+        client: input.input.client,
+        context: input.context,
+        directory: input.input.directory,
+        issue: input.input.issue,
+        parse: parseTriageDuplicateOutput,
+        prompt: composeTriageDuplicatePrompt,
+        repository: input.input.repository,
+        schemaName: "triage duplicate",
+        signal: input.input.signal,
+    })));
+    const majority = aggregateStringMajority(outputs.map((output, index) => ({
+        reviewer: agents[index].key,
+        vote: output.vote,
+    })), DUPLICATE_VOTES);
+    await writeJson(join(input.outputDir, "duplicate-majority.json"), majority);
+    if (majority.vote !== "DUPLICATE")
+        return undefined;
+    return chooseDuplicateOutput({
+        candidateNumbers: input.candidateNumbers,
+        outputs,
+    });
+}
+async function runPhaseVote(input) {
+    const agents = input.input.repository.agents.triage;
+    if (!agents?.length)
+        throw new Error("triage.agents is required");
+    const outputs = await Promise.all(agents.map((agent) => runVote({
+        agent,
+        client: input.input.client,
+        context: input.context,
+        directory: input.input.directory,
+        issue: input.input.issue,
+        parse: input.parse,
+        prompt: input.prompt,
+        repository: input.input.repository,
+        schemaName: input.schemaName,
+        signal: input.input.signal,
+    })));
+    const majority = aggregateStringMajority(outputs.map((output, index) => ({
+        reviewer: agents[index].key,
+        vote: output.vote,
+    })), input.votes);
+    await writeJson(join(input.outputDir, `${input.phase}-majority.json`), majority);
+    return majority.vote;
+}
+async function relationshipScan(input, issue) {
+    const [comments, relatedPullRequests, duplicateCandidates] = await Promise.all([
+        fetchIssueComments(input.exec, input.repository, input.issue),
+        fetchRelatedPullRequests(input.exec, input.repository, input.issue),
+        searchDuplicateIssues(input.exec, input.repository, issue),
+    ]);
+    const previousMarker = comments
+        .map((comment) => parseTriageMarker(comment.body))
+        .filter((item) => Boolean(item))
+        .at(-1);
+    return { comments, duplicateCandidates, previousMarker, relatedPullRequests };
+}
+function safetyBlocked(input, issue, hasMarker) {
+    const triage = input.repository.triage;
+    if (!triage)
+        throw new Error("triage configuration is required");
+    const safety = triage.safety;
+    if (issue.state === "CLOSED")
+        return "issue is closed";
+    if (!hasMarker && safety.requiredLabels.length) {
+        const missing = safety.requiredLabels.filter((label) => !labelsContain(issue.labels, [label]));
+        if (missing.length)
+            return `missing required labels: ${missing.join(", ")}`;
+    }
+    if (safety.blockedLabels.some((label) => labelsContain(issue.labels, [label]))) {
+        return "issue has a blocked label";
+    }
+    if (safety.allowAuthors.length &&
+        !safety.allowAuthors.includes(issue.author)) {
+        return `issue author is not allowed: ${issue.author}`;
+    }
+    return undefined;
+}
+async function createImplementationPr(input) {
+    const creator = input.input.repository.agents.triageCreator;
+    if (!creator)
+        return undefined;
+    const branch = `magi/issue-${input.issue.number}-${Date.now().toString(36)}`;
+    const worktreePath = join(worktreeBaseDir(input.input.directory, input.input.config, "issue"), `issue-${input.issue.number}`);
+    await mkdir(dirname(worktreePath), { recursive: true });
+    await input.input.exec(`git worktree add -b ${shellQuote(branch)} ${shellQuote(worktreePath)}`);
+    try {
+        await configureGitIdentity(input.input.exec, worktreePath, creator.author);
+        const prompt = `Implement issue #${input.issue.number}.\n\n${input.context}\n\nReturn the edit output contract.`;
+        const result = await runModelWithRepair({
+            client: input.input.client,
+            model: creator.model,
+            options: creator.options,
+            parse: parseEditOutput,
+            permission: creator.permission,
+            prompt,
+            repairAttempts: 3,
+            schemaName: "edit",
+            signal: input.input.signal,
+            title: `Magi triage create PR #${input.issue.number}`,
+        });
+        await writeJson(join(input.outputDir, "create-pr.json"), result.value);
+        if (result.value.mode !== "EDITED")
+            return undefined;
+        await pushHead(input.input.exec, input.input.repository, worktreePath, creator.account, {
+            owner: input.input.repository.github.owner,
+            ref: branch,
+            repo: input.input.repository.github.repo,
+        });
+        return createPullRequest(input.input.exec, input.input.repository, creator.account, {
+            body: `Closes #${input.issue.number}`,
+            head: branch,
+            title: `fix: address issue #${input.issue.number}`,
+        });
+    }
+    finally {
+        await removeWorktree(input.input.exec, worktreePath).catch(() => undefined);
+    }
+}
+export async function runTriage(input) {
+    const triage = input.repository.triage;
+    if (!triage?.account)
+        throw new Error("triage.account is required");
+    const agents = input.repository.agents.triage;
+    if (!agents?.length)
+        throw new Error("triage.agents is required");
+    const runId = input.runId ?? `run-${Date.now().toString(36)}`;
+    const outputDir = issueRunOutputDir({
+        config: input.config,
+        directory: input.directory,
+        issue: input.issue,
+        runId,
+    });
+    await mkdir(outputDir, { recursive: true });
+    const issue = await fetchIssue(input.exec, input.repository, input.issue);
+    const relationship = await relationshipScan(input, issue);
+    const block = safetyBlocked(input, issue, Boolean(relationship.previousMarker));
+    await writeJson(join(outputDir, "issue.json"), issue);
+    await writeJson(join(outputDir, "relationship-summary.json"), relationship);
+    if (block) {
+        const report = `Magi triage blocked for #${input.issue}: ${block}`;
+        await writeFile(join(outputDir, "report.md"), `${report}\n`);
+        return { issue: input.issue, outputDir, report, result: "FAILED" };
+    }
+    const context = issueContext({ issue, relationship });
+    if (relationship.relatedPullRequests.length) {
+        const vote = await runPhaseVote({
+            context,
+            input,
+            outputDir,
+            parse: parseTriageExistingPrOutput,
+            phase: "existing-pr",
+            prompt: composeTriageExistingPrPrompt,
+            schemaName: "triage existing PR",
+            votes: EXISTING_PR_VOTES,
+        });
+        if (vote === "RELATED_PR_HANDLES_ISSUE") {
+            const merged = relationship.relatedPullRequests.some((pr) => pr.state === "MERGED");
+            if (merged && triage.automation.close) {
+                const body = `@${issue.author} Magi found a related merged pull request that appears to resolve this issue.\n\n${marker({ action: "CLOSE", issue: issue.number, result: "RESOLVED_BY_MERGED_PR" })}`;
+                if (!input.dryRun) {
+                    await postIssueComment(input.exec, input.repository, issue.number, triage.account, body);
+                    await closeIssue(input.exec, input.repository, issue.number, triage.account);
+                    await removeIssueLabels(input.exec, input.repository, issue.number, triage.automation.clear, triage.account);
+                }
+                const report = `Magi triage closed #${issue.number} because a related PR was merged.`;
+                await writeFile(join(outputDir, "report.md"), `${report}\n`);
+                return {
+                    issue: issue.number,
+                    outputDir,
+                    report,
+                    result: "BUG_ACCEPTED",
+                };
+            }
+            if (!input.dryRun) {
+                await removeIssueLabels(input.exec, input.repository, issue.number, triage.automation.clear, triage.account);
+            }
+            const report = `Magi triage cleared #${issue.number} because a related PR handles it.`;
+            await writeFile(join(outputDir, "report.md"), `${report}\n`);
+            return { issue: issue.number, outputDir, report, result: "CLEAR_ONLY" };
+        }
+    }
+    if (relationship.duplicateCandidates.length) {
+        const duplicate = await runDuplicateVote({
+            candidateNumbers: relationship.duplicateCandidates.map((candidate) => candidate.number),
+            context,
+            input,
+            outputDir,
+        });
+        if (duplicate) {
+            const body = `@${issue.author} Magi triage found this issue duplicates #${duplicate.duplicateOf}.\n\nReason: ${duplicate.reason}\n\n${marker({ action: "CLOSE", issue: issue.number, result: "DUPLICATE" })}`;
+            if (!input.dryRun) {
+                await postIssueComment(input.exec, input.repository, issue.number, triage.account, body);
+            }
+            if (!input.dryRun && triage.automation.close) {
+                for (const pr of relationship.relatedPullRequests.filter((pr) => pr.state === "OPEN")) {
+                    await closePullRequest(input.exec, input.repository, pr.number, triage.account);
+                }
+                await closeIssue(input.exec, input.repository, issue.number, triage.account);
+            }
+            if (!input.dryRun) {
+                await removeIssueLabels(input.exec, input.repository, issue.number, triage.automation.clear, triage.account);
+            }
+            const report = `Magi triage marked #${issue.number} duplicate of #${duplicate.duplicateOf}.`;
+            await writeFile(join(outputDir, "report.md"), `${report}\n`);
+            return { issue: issue.number, outputDir, report, result: "DUPLICATE" };
+        }
+    }
+    const kind = resolveIssueKind(issue, input.repository) ??
+        (await runPhaseVote({
+            context,
+            input,
+            outputDir,
+            parse: parseTriageKindOutput,
+            phase: "kind",
+            prompt: composeTriageKindPrompt,
+            schemaName: "triage kind",
+            votes: KIND_VOTES,
+        })) ??
+        "ASK";
+    let result = "ASK";
+    if (kind === "BUG") {
+        const vote = await runPhaseVote({
+            context,
+            input,
+            outputDir,
+            parse: parseTriageBinaryOutput,
+            phase: "bug",
+            prompt: composeTriageBugPrompt,
+            schemaName: "triage bug",
+            votes: BINARY_VOTES,
+        });
+        result =
+            vote === "YES" ? "BUG_ACCEPTED" : vote === "NO" ? "BUG_REJECTED" : "ASK";
+    }
+    if (kind === "FEATURE") {
+        const vote = await runPhaseVote({
+            context,
+            input,
+            outputDir,
+            parse: parseTriageBinaryOutput,
+            phase: "feature",
+            prompt: composeTriageFeaturePrompt,
+            schemaName: "triage feature",
+            votes: BINARY_VOTES,
+        });
+        result =
+            vote === "YES"
+                ? "FEATURE_ACCEPTED"
+                : vote === "NO"
+                    ? "FEATURE_REJECTED"
+                    : "ASK";
+    }
+    const needsClose = triage.automation.close &&
+        (result === "BUG_REJECTED" || result === "FEATURE_REJECTED");
+    const needsPr = triage.automation.pr &&
+        (result === "BUG_ACCEPTED" || result === "FEATURE_ACCEPTED");
+    const commentContext = `Result: ${result}\n\n${context}`;
+    const commentPrompt = composeTriageCommentPrompt({
+        author: issue.author,
+        context: commentContext,
+        directory: input.directory,
+        issue: issue.number,
+        repository: input.repository,
+    });
+    const comment = (await runModelText({
+        allowEmpty: false,
+        client: input.client,
+        model: agents[0].model,
+        options: agents[0].options,
+        permission: agents[0].permission,
+        prompt: commentPrompt,
+        signal: input.signal,
+        title: `Magi triage comment #${issue.number}`,
+    })).raw + `\n\n${marker({ action: result, issue: issue.number, result })}`;
+    let prUrl;
+    if (!input.dryRun) {
+        await postIssueComment(input.exec, input.repository, issue.number, triage.account, comment);
+        if (needsClose) {
+            for (const pr of relationship.relatedPullRequests.filter((pr) => pr.state === "OPEN")) {
+                await closePullRequest(input.exec, input.repository, pr.number, triage.account);
+            }
+            await closeIssue(input.exec, input.repository, issue.number, triage.account);
+        }
+        if (needsPr)
+            prUrl = await createImplementationPr({ context, input, issue, outputDir });
+        if (result !== "ASK") {
+            await removeIssueLabels(input.exec, input.repository, issue.number, triage.automation.clear, triage.account);
+        }
+    }
+    const report = [
+        `Magi triage result for #${issue.number}: ${result}`,
+        prUrl ? `Created PR: ${prUrl}` : undefined,
+        input.dryRun ? "Dry run: no GitHub mutations were performed." : undefined,
+    ]
+        .filter(Boolean)
+        .join("\n");
+    await writeFile(join(outputDir, "report.md"), `${report}\n`);
+    return { issue: issue.number, outputDir, report, result };
+}

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, } from "./contracts";
+import { ciClassificationAfterEditOutputContract, ciClassificationOutputContract, closeReconsiderationOutputContract, editOutputContract, findingValidationOutputContract, rereviewCloseReconsiderationOutputContract, rereviewOutputContract, reviewOutputContract, triageCommentClassificationOutputContract, triageDuplicateOutputContract, triageVoteOutputContract, } from "./contracts";
 async function readOptionalPrompt(directory, path, values = {}) {
     if (!path)
         return "";
@@ -65,6 +65,13 @@ function editValues(input) {
         worktreePath: input.worktreePath,
     };
 }
+function triageValues(input) {
+    return {
+        ...repositoryValues(input.repository),
+        context: input.context,
+        issue: String(input.issue),
+    };
+}
 function personaBlock(persona) {
     return persona ? `<persona>\n${persona}\n</persona>` : "";
 }
@@ -292,3 +299,77 @@ export async function composeCiClassificationAfterEditPrompt(input) {
         .filter(Boolean)
         .join("\n\n");
 }
+async function composeTriageVotePrompt(input) {
+    const values = triageValues(input);
+    const task = await taskBlock({
+        builtin: `triage/${input.builtin}`,
+        customPath: input.customPath,
+        directory: input.directory,
+        values,
+    });
+    return [
+        task,
+        languageBlock(input.repository.language),
+        personaBlock(input.reviewer.persona),
+        input.outputContract,
+    ]
+        .filter(Boolean)
+        .join("\n\n");
+}
+export function composeTriageCommentPrompt(input) {
+    return [
+        `<task>\nCompose one concise GitHub issue comment for issue #${input.issue}. Mention @${input.author}. Use the context below and do not include markdown fences.\n</task>`,
+        languageBlock(input.repository.language),
+        `<context>\n${input.context}\n</context>`,
+    ]
+        .filter(Boolean)
+        .join("\n\n");
+}
+export async function composeTriageExistingPrPrompt(input) {
+    return composeTriageVotePrompt({
+        ...input,
+        builtin: "existing-pr",
+        customPath: input.repository.triage?.prompts.existingPr,
+        outputContract: triageVoteOutputContract('"RELATED_PR_HANDLES_ISSUE" | "RELATED_PR_DOES_NOT_HANDLE_ISSUE"'),
+    });
+}
+export async function composeTriageDuplicatePrompt(input) {
+    return composeTriageVotePrompt({
+        ...input,
+        builtin: "duplicate",
+        customPath: input.repository.triage?.prompts.duplicate,
+        outputContract: triageDuplicateOutputContract,
+    });
+}
+export async function composeTriageKindPrompt(input) {
+    return composeTriageVotePrompt({
+        ...input,
+        builtin: "kind",
+        customPath: input.repository.triage?.prompts.kind,
+        outputContract: triageVoteOutputContract('"BUG" | "FEATURE" | "ASK"'),
+    });
+}
+export async function composeTriageBugPrompt(input) {
+    return composeTriageVotePrompt({
+        ...input,
+        builtin: "bug",
+        customPath: input.repository.triage?.prompts.bug,
+        outputContract: triageVoteOutputContract('"YES" | "NO" | "ASK"'),
+    });
+}
+export async function composeTriageFeaturePrompt(input) {
+    return composeTriageVotePrompt({
+        ...input,
+        builtin: "feature",
+        customPath: input.repository.triage?.prompts.feature,
+        outputContract: triageVoteOutputContract('"YES" | "NO" | "ASK"'),
+    });
+}
+export async function composeTriageCommentClassificationPrompt(input) {
+    return composeTriageVotePrompt({
+        ...input,
+        builtin: "comment-classification",
+        customPath: input.repository.triage?.prompts.commentClassification,
+        outputContract: triageCommentClassificationOutputContract,
+    });
+}