opencode-magi 0.10.0 → 0.12.0

package/dist/orchestrator/triage.js

@@ -1,1370 +0,0 @@
-import { mkdir, writeFile } from "node:fs/promises";
-import { dirname, join } from "node:path";
-import { issueRunOutputDir } from "../config/output";
-import { issueRunWorktreeDir } from "../config/worktree";
-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",
-    "RELATED_PR_HANDLES_ISSUE",
-];
-const RECONSIDERATION_CLASSES = new Set([
-    "CLARIFICATION",
-    "NEW_EVIDENCE",
-    "OBJECTION",
-]);
-function marker(input) {
-    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*-->/);
-    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 && version !== 2)
-        return undefined;
-    const askReason = entries.askReason === "acceptance_unclear" ||
-        entries.askReason === "category_unclear"
-        ? entries.askReason
-        : undefined;
-    return {
-        action: entries.action,
-        askReason,
-        category: entries.category === "none" ? null : entries.category || undefined,
-        checkpoint: entries.checkpoint && Number.isFinite(Number(entries.checkpoint))
-            ? Number(entries.checkpoint)
-            : 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,
-    };
-}
-function labelsContain(labels, targets) {
-    const set = new Set(labels.map((label) => label.toLowerCase()));
-    return targets.some((target) => set.has(target.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;
-    if (!triage)
-        throw new Error("triage configuration is required");
-    const matches = triage.categories.filter((category) => labelsContain(issue.labels, category.labels) ||
-        (issue.type != null && category.types.includes(issue.type)));
-    if (matches.length !== 1)
-        return undefined;
-    return matches[0].id;
-}
-function issueContext(input) {
-    return JSON.stringify({
-        duplicateCandidates: input.relationship.duplicateCandidates,
-        issue: input.issue,
-        recentComments: input.relationship.comments.slice(-20),
-        reconsideration: input.reconsideration,
-        relatedPullRequests: input.relationship.relatedPullRequests,
-    }, null, 2);
-}
-async function writeJson(path, value) {
-    await writeFile(path, `${JSON.stringify(value, null, 2)}\n`);
-}
-async function emitProgress(input, progress) {
-    await input.onProgress?.(progress);
-}
-async function emitTriageModelProgress(input) {
-    if (input.progress.type === "session_created") {
-        await emitProgress(input.run, {
-            options: input.progress.options,
-            phase: input.phase,
-            sessionId: input.progress.sessionId,
-            type: "triage_agent_session",
-            voter: input.voter,
-        });
-    }
-    if (input.progress.type === "repair") {
-        await emitProgress(input.run, {
-            phase: input.phase,
-            type: "triage_agent_repair",
-            voter: input.voter,
-        });
-    }
-    if (input.progress.type === "response") {
-        await emitProgress(input.run, {
-            phase: input.phase,
-            sessionId: input.progress.sessionId,
-            type: "triage_agent_response",
-            voter: input.voter,
-        });
-    }
-}
-async function runVote(input) {
-    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",
-        voter: input.agent.key,
-    });
-    let result;
-    try {
-        result = await runModelWithRepair({
-            client: input.client,
-            model: input.agent.model,
-            onProgress: (progress) => emitTriageModelProgress({
-                phase: input.phase,
-                progress,
-                run: input.run,
-                voter: input.agent.key,
-            }),
-            options: input.agent.options,
-            parentSessionId: input.run.parentSessionId,
-            parse: input.parse,
-            permission: input.agent.permission,
-            prompt,
-            repairAttempts: input.run.config.output?.repairAttempts ?? 3,
-            schemaName: input.schemaName,
-            signal: input.signal,
-            title: `Magi triage ${input.schemaName} #${input.issue} (${input.agent.key})`,
-        });
-    }
-    catch (error) {
-        await emitProgress(input.run, {
-            error: error instanceof Error ? error.message : String(error),
-            phase: input.phase,
-            type: "triage_agent_failed",
-            voter: input.agent.key,
-        });
-        throw error;
-    }
-    await emitProgress(input.run, {
-        phase: input.phase,
-        sessionId: result.sessionId,
-        type: "triage_agent_completed",
-        voter: input.agent.key,
-        vote: result.value.vote,
-    });
-    return {
-        ...result.value,
-        promptText: prompt,
-        raw: result.raw,
-        sessionId: result.sessionId,
-        voter: input.agent.key,
-    };
-}
-async function writeVoteArtifacts(input) {
-    const base = join(input.outputDir, `${input.voter}.${input.phase}`);
-    await writeFile(`${base}.prompt.txt`, `${input.output.promptText}\n`);
-    await writeFile(`${base}.raw.txt`, `${input.output.raw}\n`);
-    await writeJson(`${base}.json`, {
-        body: input.output.body,
-        reason: input.output.reason,
-        vote: input.output.vote,
-    });
-}
-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.voters is required");
-    await emitProgress(input.input, { phase: "duplicate", type: "phase" });
-    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,
-        phase: "duplicate",
-        prompt: composeTriageDuplicatePrompt,
-        repository: input.input.repository,
-        run: input.input,
-        schemaName: "triage duplicate",
-        signal: input.input.signal,
-    })));
-    const majority = aggregateStringMajority(outputs.map((output, index) => ({
-        voter: agents[index].key,
-        vote: output.vote,
-    })), DUPLICATE_VOTES);
-    await Promise.all(outputs.map((output, index) => writeVoteArtifacts({
-        output,
-        outputDir: input.outputDir,
-        phase: "duplicate",
-        voter: agents[index].key,
-    })));
-    await Promise.all(outputs.map((output, index) => writeJson(join(input.outputDir, `${agents[index].key}.duplicate.json`), {
-        duplicateOf: output.duplicateOf,
-        reason: output.reason,
-        vote: output.vote,
-    })));
-    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.voters is required");
-    await emitProgress(input.input, { phase: input.phase, type: "phase" });
-    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,
-        directory: input.input.directory,
-        issue: input.input.issue,
-        parse: input.parse,
-        phase: input.phase,
-        prompt: input.prompt,
-        promptText: promptTexts[index],
-        repository: input.input.repository,
-        run: input.input,
-        schemaName: input.schemaName,
-        signal: input.input.signal,
-    })));
-    const majority = aggregateStringMajority(outputs.map((output, index) => ({
-        voter: agents[index].key,
-        vote: output.vote,
-    })), input.votes);
-    await Promise.all(outputs.map((output, index) => writeVoteArtifacts({
-        output,
-        outputDir: input.outputDir,
-        phase: input.phase,
-        voter: agents[index].key,
-    })));
-    await writeJson(join(input.outputDir, `${input.phase}-majority.json`), majority);
-    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([
-        fetchIssueComments(input.exec, input.repository, input.issue),
-        fetchRelatedPullRequests(input.exec, input.repository, input.issue),
-        searchDuplicateIssues(input.exec, input.repository, issue),
-    ]);
-    const triageAccounts = new Set((input.repository.agents.triage ?? []).map((agent) => agent.account));
-    const markers = comments
-        .filter((comment) => triageAccounts.has(comment.author))
-        .map((comment) => {
-        const parsed = parseTriageMarker(comment.body);
-        return parsed
-            ? { ...parsed, account: comment.author, commentId: comment.id }
-            : undefined;
-    })
-        .filter(Boolean);
-    const previousMarker = markers.at(-1);
-    const mentionReplies = previousMarker
-        ? eligibleMentionReplies({
-            account: previousMarker.account ?? "",
-            comments,
-            marker: previousMarker,
-            processed: previousMarker.processed,
-            repository: input.repository,
-        })
-        : [];
-    return {
-        comments,
-        duplicateCandidates,
-        mentionReplies,
-        previousMarker,
-        relatedPullRequests,
-    };
-}
-function mentionsAccount(body, account) {
-    return new RegExp(`@${account.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`, "i").test(body);
-}
-function markerCheckpoint(marker) {
-    return marker.checkpoint ?? marker.commentId;
-}
-function markerPr(marker) {
-    const pr = Number(marker.pr);
-    return Number.isInteger(pr) && pr > 0 ? pr : undefined;
-}
-function pullRequestNumberFromUrl(url) {
-    const match = url.match(/\/pull\/(\d+)(?:\D|$)/);
-    const number = match ? Number(match[1]) : undefined;
-    return number && Number.isInteger(number) ? number : undefined;
-}
-export function mentionAllowed(comment, repository) {
-    const safety = repository.triage?.safety;
-    if (!safety)
-        return false;
-    const actorAllowed = safety.allowMentionActors.length
-        ? safety.allowMentionActors.includes(comment.author)
-        : false;
-    const roleAllowed = safety.allowMentionRoles.length
-        ? safety.allowMentionRoles.includes(comment.authorAssociation ?? "")
-        : false;
-    return safety.allowMentionActors.length || safety.allowMentionRoles.length
-        ? actorAllowed || roleAllowed
-        : true;
-}
-export function eligibleMentionReplies(input) {
-    const checkpoint = markerCheckpoint(input.marker);
-    const processed = new Set(input.processed);
-    return input.comments.filter((comment) => {
-        if (checkpoint != null && comment.id <= checkpoint)
-            return false;
-        if (processed.has(comment.id))
-            return false;
-        if (!mentionsAccount(comment.body, input.account))
-            return false;
-        return mentionAllowed(comment, input.repository);
-    });
-}
-function finalResultFromMarker(marker) {
-    if (marker.disposition) {
-        return {
-            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", signals: [] };
-        case "BUG_REJECTED":
-            return { category: "bug", disposition: "rejected", signals: [] };
-        case "FEATURE_ACCEPTED":
-            return { category: "feature", disposition: "accepted", signals: [] };
-        case "FEATURE_REJECTED":
-            return { category: "feature", disposition: "rejected", signals: [] };
-        case "ASK":
-            return {
-                category: null,
-                disposition: "needs_acceptance",
-                signals: [],
-            };
-        case "CLEAR_ONLY":
-            return { category: null, disposition: "already_handled", signals: [] };
-        case "DUPLICATE":
-            return { category: null, disposition: "duplicate", signals: [] };
-        default:
-            return { category: null, disposition: "failed", signals: [] };
-    }
-}
-function decisionText(decision) {
-    return JSON.stringify(decision);
-}
-function actionPlan(input) {
-    if (input.result.disposition === "already_handled") {
-        return {
-            action: "CLEAR_ONLY",
-            allowedActions: ["CLEAR_ONLY"],
-            clearLabels: true,
-            closeIssue: false,
-            createPr: false,
-            postComment: false,
-        };
-    }
-    if (input.result.disposition === "needs_category" ||
-        input.result.disposition === "needs_acceptance") {
-        return {
-            action: "ASK",
-            allowedActions: ["ASK"],
-            clearLabels: true,
-            closeIssue: false,
-            createPr: false,
-            postComment: true,
-        };
-    }
-    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 {
-        action: closeIssue ? "CLOSE" : createPr ? "PR" : "COMMENT",
-        allowedActions: [closeIssue ? "CLOSE" : createPr ? "PR" : "COMMENT"],
-        clearLabels: true,
-        closeIssue,
-        createPr,
-        postComment: true,
-    };
-}
-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 &&
-        (labelChanges.add.length > 0 || labelChanges.remove.length > 0);
-    const closeIssue = input.marker.action === "CLOSE" &&
-        base.closeIssue &&
-        input.issue.state === "OPEN";
-    const createPr = input.marker.action === "PR" &&
-        base.createPr &&
-        !markerPr(input.marker) &&
-        !input.relationship.relatedPullRequests.length;
-    if (!clearLabels && !closeIssue && !createPr)
-        return undefined;
-    const action = closeIssue ? "CLOSE" : createPr ? "PR" : "CLEAR_ONLY";
-    return {
-        ...base,
-        action,
-        allowedActions: [action],
-        clearLabels,
-        closeIssue,
-        createPr,
-        postComment: false,
-    };
-}
-async function classifyMentionReplies(input) {
-    const agent = triageReporter(input.input.repository, input.input.issue);
-    const prompt = await composeTriageCommentClassificationPrompt({
-        context: JSON.stringify({ context: input.context, mentionReplies: input.replies }, null, 2),
-        directory: input.input.directory,
-        issue: input.input.issue,
-        repository: input.input.repository,
-        voter: agent,
-    });
-    const result = await runModelWithRepair({
-        client: input.input.client,
-        model: agent.model,
-        onProgress: async (progress) => {
-            if (progress.type !== "session_created")
-                return;
-            await emitProgress(input.input, {
-                agent: agent.key,
-                key: `triage:comment-classification:${agent.key}:${progress.sessionId}`,
-                options: progress.options,
-                sessionId: progress.sessionId,
-                type: "triage_session",
-            });
-        },
-        options: agent.options,
-        parentSessionId: input.input.parentSessionId,
-        parse: parseTriageCommentClassificationOutput,
-        permission: agent.permission,
-        prompt,
-        repairAttempts: input.input.config.output?.repairAttempts ?? 3,
-        schemaName: "triage comment classification",
-        signal: input.input.signal,
-        title: `Magi triage comment classification #${input.input.issue} (${agent.key})`,
-    });
-    await writeJson(join(input.outputDir, "comment-classification.json"), result.value);
-    return result.value;
-}
-async function runReconsiderationVote(input) {
-    return runPhaseVote({
-        context: input.context,
-        input: input.input,
-        outputDir: input.outputDir,
-        parse: parseTriageBinaryOutput,
-        phase: "reconsider",
-        prompt: composeTriageReconsiderPrompt,
-        schemaName: "triage reconsider",
-        votes: BINARY_VOTES,
-    });
-}
-function triageReporter(repository, issue) {
-    const agents = repository.agents.triage ?? [];
-    if (!agents.length)
-        throw new Error("triage.voters is required");
-    const configured = repository.triage?.reporter;
-    const reporter = configured
-        ? agents.find((agent) => agent.key === configured)
-        : agents[Math.abs(issue) % agents.length];
-    if (!reporter)
-        throw new Error(`Unknown triage reporter: ${configured}`);
-    return reporter;
-}
-function decisionCommentBody(input) {
-    const reason = input.reason?.trim();
-    return reason
-        ? 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 voter: ${key}`);
-    return agent;
-}
-function askOutputs(outputs) {
-    return (outputs ?? []).filter((output) => output.vote === "ASK");
-}
-function chooseDecisionReason(input) {
-    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);
-    const body = input.body.replace("checkpoint=pending", `checkpoint=${posted.id}`);
-    const updated = body === input.body
-        ? posted
-        : await updateIssueComment(input.exec, input.repository, posted.id, input.account, body);
-    await writeJson(join(input.outputDir, `posted-${updated.id}.json`), {
-        account: input.account,
-        ...updated,
-    });
-    return updated;
-}
-async function postPlainIssueComment(input) {
-    const posted = await postIssueComment(input.exec, input.repository, input.issue, input.account, input.body);
-    await writeJson(join(input.outputDir, `posted-${posted.id}.json`), {
-        account: input.account,
-        ...posted,
-    });
-    return posted;
-}
-async function persistProcessedMarker(input) {
-    if (!input.marker.commentId)
-        return;
-    const previousComment = input.comments.find((comment) => comment.id === input.marker.commentId);
-    if (!previousComment)
-        return;
-    const updatedMarker = marker({
-        action: input.marker.action ?? input.marker.result ?? "ASK",
-        checkpoint: markerCheckpoint(input.marker),
-        decision: finalResultFromMarker(input.marker),
-        issue: input.issue.number,
-        pr: input.pr ?? markerPr(input.marker),
-        processed: input.processed,
-    });
-    const body = previousComment.body.replace(/<!--\s*opencode-magi:triage\s+[^>]+?\s*-->/, updatedMarker);
-    if (body === previousComment.body)
-        return;
-    const updated = await updateIssueComment(input.exec, input.repository, input.marker.commentId, input.account, body);
-    await writeJson(join(input.outputDir, "processed.json"), {
-        processed: input.processed,
-        updated,
-    });
-}
-async function postAskComments(input) {
-    const urls = [];
-    for (const output of askOutputs(input.outputs)) {
-        const agent = agentForKey(input.repository, output.voter);
-        const body = input.mark
-            ? `${output.body}\n\n${marker({
-                action: input.action,
-                checkpoint: "pending",
-                decision: input.result,
-                issue: input.issue.number,
-                processed: input.processed,
-            })}`
-            : output.body;
-        if (!body?.trim())
-            continue;
-        await writeFile(join(input.outputDir, `${agent.key}.ask-comment.md`), `${body}\n`);
-        if (input.dryRun) {
-            urls.push(`dry-run:would-comment:${agent.key}`);
-            continue;
-        }
-        await emitProgress(input.run, { type: "comment_posting" });
-        const posted = input.mark
-            ? await postMarkedIssueComment({
-                account: agent.account,
-                body,
-                exec: input.exec,
-                issue: input.issue.number,
-                outputDir: input.outputDir,
-                repository: input.repository,
-            })
-            : await postPlainIssueComment({
-                account: agent.account,
-                body,
-                exec: input.exec,
-                issue: input.issue.number,
-                outputDir: input.outputDir,
-                repository: input.repository,
-            });
-        urls.push(posted.url);
-        await emitProgress(input.run, { type: "comment_posted", url: posted.url });
-    }
-    return urls;
-}
-async function finishWithResult(input) {
-    const triage = input.input.repository.triage;
-    if (!triage)
-        throw new Error("triage configuration is required");
-    const plan = input.plan ?? actionPlan({ result: input.result, triage });
-    await emitProgress(input.input, {
-        action: plan.action,
-        result: input.result,
-        type: "decision",
-    });
-    let prUrl;
-    const reporter = triageReporter(input.input.repository, input.issue.number);
-    const comment = plan.postComment &&
-        input.result.disposition !== "needs_category" &&
-        input.result.disposition !== "needs_acceptance"
-        ? `${decisionCommentBody({
-            action: plan.action,
-            reason: input.commentReason,
-            result: input.result,
-        })}\n\n${marker({
-            action: plan.action,
-            checkpoint: "pending",
-            decision: input.result,
-            issue: input.issue.number,
-            processed: input.processed,
-        })}`
-        : undefined;
-    if (comment) {
-        await writeFile(join(input.outputDir, "comment.md"), `${comment}\n`);
-    }
-    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,
-            exec: input.input.exec,
-            issue: input.issue,
-            mark: input.markAskComments ?? false,
-            outputs: input.askOutputs,
-            outputDir: input.outputDir,
-            processed: input.processed,
-            repository: input.input.repository,
-            result: input.result,
-            run: input.input,
-        });
-    }
-    if (!input.input.dryRun) {
-        if (comment) {
-            await emitProgress(input.input, { type: "comment_posting" });
-            const posted = await postMarkedIssueComment({
-                account: reporter.account,
-                body: comment,
-                exec: input.input.exec,
-                issue: input.issue.number,
-                outputDir: input.outputDir,
-                repository: input.input.repository,
-            });
-            await emitProgress(input.input, {
-                type: "comment_posted",
-                url: posted.url,
-            });
-        }
-        if (plan.clearLabels) {
-            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) {
-            const closedPrs = [];
-            for (const pr of input.relationship.relatedPullRequests.filter((pr) => pr.state === "OPEN")) {
-                await closePullRequest(input.input.exec, input.input.repository, pr.number, reporter.account);
-                closedPrs.push(pr.number);
-            }
-            if (closedPrs.length)
-                await writeJson(join(input.outputDir, "closed-prs.json"), closedPrs);
-            await closeIssue(input.input.exec, input.input.repository, input.issue.number, reporter.account);
-        }
-        if (plan.createPr) {
-            prUrl = await createImplementationPr({
-                context: input.context,
-                input: input.input,
-                issue: input.issue,
-                outputDir: input.outputDir,
-                runId: input.runId,
-            });
-            if (prUrl) {
-                await writeJson(join(input.outputDir, "pr.json"), { url: prUrl });
-                await emitProgress(input.input, { type: "pr_created", url: prUrl });
-            }
-        }
-        if (input.previousMarker && prUrl) {
-            await persistProcessedMarker({
-                account: input.previousMarker.account ?? reporter.account,
-                comments: input.relationship.comments,
-                exec: input.input.exec,
-                issue: input.issue,
-                marker: input.previousMarker,
-                outputDir: input.outputDir,
-                pr: pullRequestNumberFromUrl(prUrl),
-                processed: input.processed ?? input.previousMarker.processed,
-                repository: input.input.repository,
-            });
-        }
-    }
-    const report = [
-        `Magi triage result for #${input.issue.number}: ${decisionText(input.result)}`,
-        prUrl ? `Created PR: ${prUrl}` : undefined,
-        input.input.dryRun
-            ? "Dry run: no GitHub mutations were performed."
-            : undefined,
-    ]
-        .filter(Boolean)
-        .join("\n");
-    await writeFile(join(input.outputDir, "report.md"), `${report}\n`);
-    return {
-        issue: input.issue.number,
-        outputDir: input.outputDir,
-        prUrl,
-        report,
-        result: input.result,
-    };
-}
-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;
-    await emitProgress(input.input, { type: "pr_creation_started" });
-    await emitProgress(input.input, { type: "triage_creator_started" });
-    try {
-        await assignIssue(input.input.exec, input.input.repository, input.issue.number, creator.account);
-        const branch = `magi/issue-${input.issue.number}-${Date.now().toString(36)}`;
-        const worktreePath = issueRunWorktreeDir({
-            config: input.input.config,
-            directory: input.input.directory,
-            issue: input.issue.number,
-            runId: input.runId,
-        });
-        await mkdir(dirname(worktreePath), { recursive: true });
-        await input.input.exec(`git worktree add -b ${shellQuote(branch)} ${shellQuote(worktreePath)}`);
-        await emitProgress(input.input, {
-            branch,
-            type: "worktree_created",
-            worktreePath,
-        });
-        try {
-            await configureGitIdentity(input.input.exec, worktreePath, creator.author);
-            const prompt = await composeTriageCreatePrPrompt({
-                context: input.context,
-                directory: input.input.directory,
-                issue: input.issue.number,
-                repository: input.input.repository,
-                worktreePath,
-            });
-            const result = await runModelWithRepair({
-                client: input.input.client,
-                model: creator.model,
-                onProgress: async (progress) => {
-                    if (progress.type === "session_created") {
-                        await emitProgress(input.input, {
-                            options: progress.options,
-                            sessionId: progress.sessionId,
-                            type: "triage_creator_session",
-                        });
-                    }
-                    if (progress.type === "repair") {
-                        await emitProgress(input.input, { type: "triage_creator_repair" });
-                    }
-                    if (progress.type === "response") {
-                        await emitProgress(input.input, {
-                            sessionId: progress.sessionId,
-                            type: "triage_creator_response",
-                        });
-                    }
-                },
-                options: creator.options,
-                parentSessionId: input.input.parentSessionId,
-                parse: parseTriageCreatePrOutput,
-                permission: creator.permission,
-                prompt,
-                repairAttempts: input.input.config.output?.repairAttempts ?? 3,
-                schemaName: "triage create PR",
-                signal: input.input.signal,
-                title: `Magi triage create PR #${input.issue.number}`,
-            });
-            await emitProgress(input.input, {
-                sessionId: result.sessionId,
-                type: "triage_creator_completed",
-            });
-            await writeJson(join(input.outputDir, "create-pr.json"), result.value);
-            if (result.value.mode !== "EDITED")
-                return undefined;
-            const pullRequest = result.value.pullRequest;
-            if (!pullRequest)
-                throw new Error("EDITED requires pullRequest");
-            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: pullRequest.body,
-                head: branch,
-                title: pullRequest.title,
-            });
-        }
-        finally {
-            await removeWorktree(input.input.exec, worktreePath).catch(() => undefined);
-        }
-    }
-    catch (error) {
-        await emitProgress(input.input, {
-            error: error instanceof Error ? error.message : String(error),
-            type: "triage_creator_failed",
-        });
-        throw error;
-    }
-}
-export async function runTriage(input) {
-    const triage = input.repository.triage;
-    if (!triage)
-        throw new Error("triage configuration is required");
-    const agents = input.repository.agents.triage;
-    if (!agents?.length)
-        throw new Error("triage.voters 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 });
-    await emitProgress(input, { phase: "fetching issue", type: "phase" });
-    const issue = await fetchIssue(input.exec, input.repository, input.issue);
-    await emitProgress(input, {
-        phase: "scanning issue relationships",
-        type: "phase",
-    });
-    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, "comments.json"), relationship.comments);
-    await writeJson(join(outputDir, "relationship-summary.json"), relationship);
-    if (relationship.previousMarker)
-        await writeJson(join(outputDir, "previous-triage.json"), relationship.previousMarker);
-    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: { category: null, disposition: "blocked", signals: [] },
-        };
-    }
-    let context = issueContext({ issue, relationship });
-    await writeFile(join(outputDir, "context.md"), `${context}\n`);
-    await emitProgress(input, { phase: "triaging", type: "phase" });
-    let processed = relationship.previousMarker?.processed ?? [];
-    let result;
-    let askCommentOutputs;
-    let commentReason;
-    let markAskComments = false;
-    if (relationship.previousMarker) {
-        if (!relationship.mentionReplies.length) {
-            const result = finalResultFromMarker(relationship.previousMarker);
-            const plan = previousAutomationPlan({
-                issue,
-                marker: relationship.previousMarker,
-                relationship,
-                result,
-                triage,
-            });
-            if (plan) {
-                return finishWithResult({
-                    context,
-                    input,
-                    issue,
-                    outputDir,
-                    plan,
-                    previousMarker: relationship.previousMarker,
-                    processed,
-                    relationship,
-                    result,
-                    runId,
-                });
-            }
-            const report = `Magi triage skipped #${issue.number} because no eligible mention replies were found for reconsideration.`;
-            await writeFile(join(outputDir, "report.md"), `${report}\n`);
-            return { issue: issue.number, outputDir, report, result };
-        }
-        const classifications = await classifyMentionReplies({
-            context,
-            input,
-            outputDir,
-            replies: relationship.mentionReplies,
-        });
-        const triggeringComments = relationship.mentionReplies.filter((comment) => classifications.comments.some((item) => item.commentId === comment.id &&
-            RECONSIDERATION_CLASSES.has(item.classification)));
-        processed = [
-            ...new Set([
-                ...processed,
-                ...classifications.comments.map((comment) => comment.commentId),
-            ]),
-        ];
-        if (!triggeringComments.length) {
-            if (!input.dryRun) {
-                await persistProcessedMarker({
-                    account: relationship.previousMarker.account ?? "",
-                    comments: relationship.comments,
-                    exec: input.exec,
-                    issue,
-                    marker: relationship.previousMarker,
-                    outputDir,
-                    processed,
-                    repository: input.repository,
-                });
-            }
-            const result = finalResultFromMarker(relationship.previousMarker);
-            const report = `Magi triage skipped #${issue.number} because allowed mention replies did not request reconsideration.`;
-            await writeFile(join(outputDir, "report.md"), `${report}\n`);
-            return { issue: issue.number, outputDir, report, result };
-        }
-        context = issueContext({
-            issue,
-            relationship,
-            reconsideration: {
-                classifications,
-                previousMarker: relationship.previousMarker,
-                triggeringComments,
-            },
-        });
-        await writeFile(join(outputDir, "context.md"), `${context}\n`);
-        const previous = finalResultFromMarker(relationship.previousMarker);
-        if (previous.disposition !== "needs_acceptance") {
-            const reconsideration = await runReconsiderationVote({
-                context,
-                input,
-                outputDir,
-            });
-            commentReason = reconsideration.reason;
-            result =
-                reconsideration.vote === "YES"
-                    ? {
-                        category: previous.category,
-                        disposition: "accepted",
-                        signals: [],
-                    }
-                    : reconsideration.vote === "NO"
-                        ? {
-                            category: previous.category,
-                            disposition: "rejected",
-                            signals: [],
-                        }
-                        : {
-                            category: previous.category,
-                            disposition: "needs_acceptance",
-                            signals: [],
-                        };
-            if (result.disposition === "needs_acceptance") {
-                askCommentOutputs = askOutputs(reconsideration.outputs);
-                markAskComments = true;
-            }
-        }
-    }
-    if (!result && relationship.relatedPullRequests.length) {
-        const existingPr = await runPhaseVote({
-            context,
-            input,
-            outputDir,
-            parse: parseTriageExistingPrOutput,
-            phase: "existing-pr",
-            prompt: composeTriageExistingPrPrompt,
-            schemaName: "triage existing PR",
-            votes: EXISTING_PR_VOTES,
-        });
-        if (existingPr.vote === "RELATED_PR_HANDLES_ISSUE") {
-            const merged = relationship.relatedPullRequests.some((pr) => pr.state === "MERGED");
-            if (merged && triage.automation.close) {
-                const relatedPrDecision = {
-                    category: resolveIssueCategory(issue, input.repository) ?? null,
-                    disposition: "accepted",
-                    signals: [],
-                };
-                const plan = {
-                    action: "CLOSE",
-                    allowedActions: ["CLOSE"],
-                    clearLabels: true,
-                    closeIssue: true,
-                    createPr: false,
-                    postComment: true,
-                };
-                return finishWithResult({
-                    commentReason: existingPr.reason,
-                    context,
-                    input,
-                    issue,
-                    outputDir,
-                    plan,
-                    processed,
-                    relationship,
-                    result: relatedPrDecision,
-                    runId,
-                });
-            }
-            return finishWithResult({
-                context,
-                input,
-                issue,
-                outputDir,
-                processed,
-                relationship,
-                result: { category: null, disposition: "already_handled", signals: [] },
-                runId,
-            });
-        }
-    }
-    if (!result && relationship.duplicateCandidates.length) {
-        const duplicate = await runDuplicateVote({
-            candidateNumbers: relationship.duplicateCandidates.map((candidate) => candidate.number),
-            context,
-            input,
-            outputDir,
-        });
-        if (duplicate) {
-            context = `${context}\n\nDuplicate decision: ${JSON.stringify(duplicate)}`;
-            commentReason = duplicate.reason;
-            result = { category: null, disposition: "duplicate", signals: [] };
-        }
-    }
-    if (!result) {
-        const resolvedCategory = resolveIssueCategory(issue, input.repository);
-        await writeJson(join(outputDir, "category-resolution.json"), {
-            category: resolvedCategory,
-            source: resolvedCategory ? "config" : "vote",
-        });
-        const categoryVote = resolvedCategory
-            ? undefined
-            : await runPhaseVote({
-                context,
-                input,
-                outputDir,
-                parse: (text) => parseTriageCategoryOutput(text, triage.categories.map((item) => item.id)),
-                phase: "category",
-                prompt: composeTriageCategoryPrompt,
-                schemaName: "triage category",
-                votes: ["ASK", ...triage.categories.map((item) => item.id)],
-            });
-        const category = resolvedCategory ?? categoryVote?.vote ?? "ASK";
-        if (category === "ASK") {
-            result = {
-                category: null,
-                disposition: "needs_category",
-                signals: [],
-            };
-            askCommentOutputs = askOutputs(categoryVote?.outputs);
-            markAskComments = false;
-        }
-        else {
-            const categoryConfig = triage.categories.find((item) => item.id === category);
-            const voteContext = JSON.stringify({
-                category: categoryConfig,
-                triageContext: context,
-            }, null, 2);
-            const acceptance = await runPhaseVote({
-                context: voteContext,
-                input,
-                outputDir,
-                parse: parseTriageBinaryOutput,
-                phase: "acceptance",
-                prompt: composeTriageAcceptancePrompt,
-                schemaName: "triage acceptance",
-                votes: ACCEPTANCE_VOTES,
-            });
-            commentReason = acceptance.reason;
-            result =
-                acceptance.vote === "YES"
-                    ? { category, disposition: "accepted", signals: [] }
-                    : acceptance.vote === "NO"
-                        ? { 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,
-        context,
-        input,
-        issue,
-        markAskComments,
-        outputDir,
-        processed,
-        relationship,
-        result: result ?? {
-            category: null,
-            disposition: "needs_acceptance",
-            signals: [],
-        },
-        runId,
-    });
-}