opencode-magi 0.2.0 → 0.3.0

package/dist/orchestrator/run-manager.js

@@ -1,12 +1,13 @@
 import { randomUUID } from "node:crypto";
 import { mkdir, readFile, readdir, rm, rmdir, writeFile, } from "node:fs/promises";
 import { dirname, isAbsolute, join, relative, resolve } from "node:path";
-import { outputBaseDirs, prRunOutputDir } from "../config/output";
+import { issueRunOutputDir, outputBaseDirs, prRunOutputDir, } from "../config/output";
 import { worktreeBaseDirs } from "../config/worktree";
 import { removeBranch, removeWorktree, } from "../github/commands";
 import { withGitHubApiRetry } from "../github/retry";
 import { runMerge, } from "./merge";
 import { runReview } from "./review";
+import { runTriage } from "./triage";
 const EVENT_LAST_UPDATE_THROTTLE_MS = 5_000;
 const DEFAULT_CLEAR_OPTIONS = {
     branch: true,
@@ -20,12 +21,33 @@ function createRunId() {
 function now() {
     return new Date().toISOString();
 }
+export function redactSecrets(value) {
+    return value
+        .replace(/\b(GH_TOKEN|GITHUB_TOKEN|GH_ENTERPRISE_TOKEN)=('[^']*'|"[^"]*"|\S+)/g, "$1=<redacted>")
+        .replace(/(password=)([^;'\s]+)/g, "$1<redacted>");
+}
+function errorMessage(error) {
+    return redactSecrets(error instanceof Error ? error.message : String(error));
+}
 function isActiveStatus(status) {
     return (status === "blocked" ||
         status === "preparing" ||
         status === "running" ||
         status === "posting");
 }
+function matchesNumberFilter(value, filter) {
+    if (filter == null)
+        return true;
+    return Array.isArray(filter)
+        ? value != null && filter.includes(value)
+        : value === filter;
+}
+function hasAllRequestedPrStates(states, pr) {
+    if (pr == null)
+        return true;
+    const prs = Array.isArray(pr) ? pr : [pr];
+    return prs.every((item) => states.some((state) => state.pr === item));
+}
 function isWithinDirectory(directory, path) {
     const relation = relative(directory, path);
     return (relation === "" || (!relation.startsWith("..") && !isAbsolute(relation)));
@@ -67,13 +89,35 @@ function prUrl(repository, pr) {
     const host = repository.github.host || "github.com";
     return `https://${host}/${repository.github.owner}/${repository.github.repo}/pull/${pr}`;
 }
+function pullRequestNumberFromUrl(url) {
+    const match = url.match(/(?:^|\/)pull\/(\d+)(?:[/?#].*)?$/);
+    if (!match)
+        return undefined;
+    const pr = Number.parseInt(match[1], 10);
+    return Number.isInteger(pr) && pr > 0 ? pr : undefined;
+}
+function issueUrl(repository, issue) {
+    const host = repository.github.host || "github.com";
+    return `https://${host}/${repository.github.owner}/${repository.github.repo}/issues/${issue}`;
+}
 function prMarkdownLink(state) {
     if (state.pr == null)
         return state.runId;
     return state.prUrl ? `[#${state.pr}](${state.prUrl})` : `#${state.pr}`;
 }
+function issueMarkdownLink(state) {
+    if (state.issue == null)
+        return state.runId;
+    return state.issueUrl
+        ? `[#${state.issue}](${state.issueUrl})`
+        : `#${state.issue}`;
+}
 function runLabel(state) {
-    return state.pr == null ? state.runId : prMarkdownLink(state);
+    if (state.pr != null)
+        return prMarkdownLink(state);
+    if (state.issue != null)
+        return issueMarkdownLink(state);
+    return state.runId;
 }
 function reviewerCompletionText(input) {
     const reviewer = `**Reviewer ${input.reviewer}**`;
@@ -127,6 +171,13 @@ function editorFailureText(input) {
     const repairs = repairAttemptsText(input.repairAttempts);
     return `**Editor** failed editing ${input.pr}${repairs}: ${input.error}`;
 }
+function triageCreatorFailureText(input) {
+    const repairs = repairAttemptsText(input.repairAttempts);
+    return `**Triage creator** failed creating an implementation PR for ${input.issue}${repairs}: ${input.error}`;
+}
+function triageDecisionNotification(input) {
+    return `Triage decided ${input.issue}: ${input.result}. Planned action: ${input.action}.`;
+}
 function repairAttemptsText(attempts) {
     if (!attempts)
         return "";
@@ -469,12 +520,70 @@ export class MagiRunManager {
         });
         return state;
     }
+    async startTriage(input) {
+        const runId = createRunId();
+        const outputDir = issueRunOutputDir({
+            config: input.config,
+            directory: this.input.directory,
+            issue: input.issue,
+            runId,
+        });
+        const createdAt = now();
+        const state = {
+            command: "triage",
+            createdAt,
+            dryRun: input.dryRun,
+            issue: input.issue,
+            issueUrl: issueUrl(input.repository, input.issue),
+            outputDir,
+            parentSessionId: input.parentSessionId,
+            phase: "queued",
+            repository: input.repository.alias,
+            reviewers: Object.fromEntries((input.repository.agents.triage ?? []).map((agent) => [
+                agent.key,
+                {
+                    account: "",
+                    repairAttempts: 0,
+                    status: "pending",
+                    toolCalls: 0,
+                },
+            ])),
+            runId,
+            status: "preparing",
+            triageCreator: input.repository.agents.triageCreator
+                ? {
+                    account: input.repository.agents.triageCreator.account,
+                    repairAttempts: 0,
+                    status: "pending",
+                    toolCalls: 0,
+                }
+                : undefined,
+            updatedAt: createdAt,
+        };
+        this.active.set(runId, state);
+        this.runPaths.set(runId, join(outputDir, "state.json"));
+        for (const dir of outputBaseDirs(this.input.directory, input.config))
+            this.outputDirs.add(dir);
+        await this.persist(state);
+        await this.notify(state, `Started Magi triage for ${issueMarkdownLink(state)}.`);
+        const controller = new AbortController();
+        this.controllers.set(runId, controller);
+        void this.executeTriage({
+            ...input,
+            runId,
+            signal: controller.signal,
+        }).catch(async (error) => {
+            await this.failRun(runId, error);
+        });
+        return state;
+    }
     async status(input = {}) {
         const timeoutMs = Math.min(input.timeoutMs ?? 60_000, 600_000);
         const startedAt = Date.now();
         while (input.block) {
             const states = await this.filteredStates(input);
             if (states.length &&
+                hasAllRequestedPrStates(states, input.pr) &&
                 states.every((state) => !isActiveStatus(state.status)))
                 return states;
             if (Date.now() - startedAt >= timeoutMs)
@@ -539,6 +648,17 @@ export class MagiRunManager {
                 .abort?.({ path: { id: state.editor.sessionId } })
                 .catch(() => undefined);
         }
+        if (state.triageCreator?.status === "pending" ||
+            state.triageCreator?.status === "running" ||
+            state.triageCreator?.status === "repairing" ||
+            state.triageCreator?.status === "blocked") {
+            state.triageCreator.status = "cancelled";
+        }
+        if (state.triageCreator?.sessionId) {
+            await this.input.client.session
+                .abort?.({ path: { id: state.triageCreator.sessionId } })
+                .catch(() => undefined);
+        }
         for (const reviewer of Object.values(state.reviewers)) {
             if (reviewer.status === "pending" ||
                 reviewer.status === "running" ||
@@ -832,7 +952,7 @@ export class MagiRunManager {
             if (!existing) {
                 await this.notify(state, questionWaitText({
                     agent: mapping.agent,
-                    pr: prMarkdownLink(state),
+                    pr: runLabel(state),
                     question,
                 }), { reply: true });
             }
@@ -851,7 +971,7 @@ export class MagiRunManager {
                 agent.error = `Permission ${permission?.permission ?? "request"} is waiting for approval.`;
                 markUpdated(true);
                 dirty = true;
-                await this.notify(state, `Magi ${mapping.agent} is waiting for permission on ${prMarkdownLink(state)}: ${agent.error}`, { reply: true });
+                await this.notify(state, `Magi ${mapping.agent} is waiting for permission on ${runLabel(state)}: ${agent.error}`, { reply: true });
             }
         }
         if (input.event.type === "question.asked") {
@@ -874,7 +994,7 @@ export class MagiRunManager {
                 dirty = true;
                 await this.notify(state, questionWaitText({
                     agent: mapping.agent,
-                    pr: prMarkdownLink(state),
+                    pr: runLabel(state),
                     question,
                 }), { reply: true });
             }
@@ -927,7 +1047,7 @@ export class MagiRunManager {
         }
         if (input.event.type === "session.error") {
             agent.status = "failed";
-            agent.error = JSON.stringify(input.event.properties?.error ?? "session error");
+            agent.error = redactSecrets(JSON.stringify(input.event.properties?.error ?? "session error"));
             markUpdated(true);
             dirty = true;
         }
@@ -944,6 +1064,9 @@ export class MagiRunManager {
             const editorLine = state.editor
                 ? this.formatAgentLine("editor", state.editor, options)
                 : undefined;
+            const triageCreatorLine = state.triageCreator
+                ? this.formatAgentLine("triageCreator", state.triageCreator, options)
+                : undefined;
             const reviewerLines = Object.entries(state.reviewers).map(([key, reviewer]) => {
                 return this.formatAgentLine(key, reviewer, options);
             });
@@ -951,6 +1074,7 @@ export class MagiRunManager {
             const lines = [
                 options.verbose ? `Run: ${state.runId}` : undefined,
                 state.pr == null ? undefined : `PR: #${state.pr}`,
+                state.issue == null ? undefined : `Issue: #${state.issue}`,
                 `Command: ${state.command}`,
                 state.dryRun ? "Dry run: true" : undefined,
                 `Status: ${state.status}`,
@@ -971,6 +1095,7 @@ export class MagiRunManager {
                     ? `Report: ${state.reportPath}`
                     : undefined,
                 editorLine,
+                triageCreatorLine,
                 ...classifierLines,
                 ...reviewerLines,
             ];
@@ -997,6 +1122,7 @@ export class MagiRunManager {
     collectSessionIds(state) {
         const ids = [
             state.editor?.sessionId,
+            state.triageCreator?.sessionId,
             ...Object.values(state.reviewers).map((reviewer) => reviewer.sessionId),
             ...Object.values(state.ciClassifiers ?? {}).map((classifier) => classifier.sessionId),
             ...Object.values(state.sessionIds ?? {}),
@@ -1039,13 +1165,22 @@ export class MagiRunManager {
     agentState(state, key) {
         if (key.startsWith("ci:"))
             return state.ciClassifiers?.[key.slice(3)];
-        return key === "editor" ? state.editor : state.reviewers[key];
+        if (key === "editor")
+            return state.editor;
+        if (key === "triageCreator")
+            return state.triageCreator;
+        return state.reviewers[key];
     }
     agentEntries(state) {
         return [
             ...(state.editor
                 ? [["editor", state.editor]]
                 : []),
+            ...(state.triageCreator
+                ? [
+                    ["triageCreator", state.triageCreator],
+                ]
+                : []),
             ...Object.entries(state.ciClassifiers ?? {}).map(([key, value]) => [`ci:${key}`, value]),
             ...Object.entries(state.reviewers),
         ];
@@ -1065,10 +1200,10 @@ export class MagiRunManager {
         if (!matches.length) {
             return key
                 ? `No pending ${kind} request found for ${key}.`
-                : `No pending ${kind} request found for ${prMarkdownLink(state)}.`;
+                : `No pending ${kind} request found for ${runLabel(state)}.`;
         }
         if (matches.length > 1) {
-            return `Multiple pending ${kind} requests found for ${prMarkdownLink(state)}. Specify agent or requestId.`;
+            return `Multiple pending ${kind} requests found for ${runLabel(state)}. Specify agent or requestId.`;
         }
         return { key: matches[0][0], state: matches[0][1] };
     }
@@ -1077,6 +1212,7 @@ export class MagiRunManager {
     }
     async executeReview(input) {
         const result = await runReview({
+            approvalPolicy: input.repository.merge.approvalPolicy,
             client: this.input.client,
             config: input.config,
             directory: this.input.directory,
@@ -1164,6 +1300,258 @@ export class MagiRunManager {
         this.active.delete(input.runId);
         this.controllers.delete(input.runId);
     }
+    async executeTriage(input) {
+        const state = this.active.get(input.runId);
+        if (state) {
+            state.status = "running";
+            state.phase = "triaging";
+            await this.persist(state);
+        }
+        const result = await runTriage({
+            client: this.input.client,
+            config: input.config,
+            directory: this.input.directory,
+            dryRun: input.dryRun,
+            exec: withGitHubApiRetry(this.input.exec, input.config.github?.apiRetryAttempts ?? 3),
+            issue: input.issue,
+            onProgress: (progress) => this.applyTriageProgress(input.runId, progress),
+            repository: input.repository,
+            runId: input.runId,
+            signal: input.signal,
+        });
+        const completed = this.active.get(input.runId);
+        if (!completed || completed.status === "cancelled")
+            return;
+        const triageResult = JSON.stringify(result.result);
+        completed.status =
+            result.result.disposition === "failed" ? "failed" : "completed";
+        completed.phase = triageResult;
+        completed.completedAt = now();
+        completed.verdict = triageResult;
+        completed.reportPath = join(completed.outputDir, "report.md");
+        for (const agent of Object.values(completed.reviewers)) {
+            if (agent.status === "pending")
+                agent.status = "completed";
+        }
+        if (completed.triageCreator?.status === "pending") {
+            completed.triageCreator.status = "skipped";
+        }
+        await this.persist(completed);
+        await this.notify(completed, [
+            `Finished triage for ${issueMarkdownLink(completed)}.`,
+            "",
+            result.report,
+        ].join("\n"), { reply: true });
+        const followUpPr = result.prUrl
+            ? pullRequestNumberFromUrl(result.prUrl)
+            : undefined;
+        const triageAutomation = input.repository.triage?.automation;
+        if (followUpPr != null && triageAutomation?.merge) {
+            await this.startMerge({
+                config: input.config,
+                dryRun: input.dryRun,
+                parentSessionId: input.parentSessionId,
+                pr: followUpPr,
+                repository: input.repository,
+                signal: input.signal,
+            });
+        }
+        else if (followUpPr != null && triageAutomation?.review) {
+            await this.startReview({
+                config: input.config,
+                dryRun: input.dryRun,
+                parentSessionId: input.parentSessionId,
+                pr: followUpPr,
+                repository: input.repository,
+                signal: input.signal,
+            });
+        }
+        this.active.delete(input.runId);
+        this.controllers.delete(input.runId);
+    }
+    async applyTriageProgress(runId, progress) {
+        const state = this.active.get(runId);
+        if (!state)
+            return;
+        const issue = issueMarkdownLink(state);
+        const creatorState = () => state.triageCreator ??
+            (state.triageCreator = {
+                account: "triageCreator",
+                repairAttempts: 0,
+                status: "pending",
+                toolCalls: 0,
+            });
+        state.updatedAt = now();
+        if (progress.type === "phase") {
+            state.phase = progress.phase;
+            state.status = "running";
+        }
+        if (progress.type === "decision") {
+            state.phase = `decision: ${progress.result.disposition}`;
+            state.verdict = JSON.stringify(progress.result);
+        }
+        if (progress.type === "comment_posting") {
+            state.phase = "posting triage comment";
+            state.status = "posting";
+        }
+        if (progress.type === "comment_posted") {
+            state.status = "running";
+        }
+        if (progress.type === "pr_creation_started") {
+            state.phase = "creating implementation PR";
+            state.status = "running";
+        }
+        if (progress.type === "worktree_created") {
+            state.worktreePath = progress.worktreePath;
+            state.worktreeBranch = progress.branch;
+        }
+        if (progress.type === "triage_agent_started") {
+            const reviewer = state.reviewers[progress.reviewer];
+            if (reviewer)
+                reviewer.status = "running";
+        }
+        if (progress.type === "triage_agent_session") {
+            const reviewer = state.reviewers[progress.reviewer];
+            if (reviewer) {
+                if (progress.options)
+                    this.input.setSessionOptions?.(progress.sessionId, progress.options);
+                reviewer.sessionId = progress.sessionId;
+                reviewer.status = "running";
+                reviewer.lastUpdate = now();
+                this.sessionToRun.set(progress.sessionId, {
+                    agent: progress.reviewer,
+                    runId,
+                });
+            }
+        }
+        if (progress.type === "triage_agent_repair") {
+            const reviewer = state.reviewers[progress.reviewer];
+            if (reviewer) {
+                reviewer.status = "repairing";
+                reviewer.repairAttempts += 1;
+                reviewer.lastUpdate = now();
+            }
+        }
+        if (progress.type === "triage_agent_response") {
+            const reviewer = state.reviewers[progress.reviewer];
+            if (reviewer) {
+                reviewer.sessionId = progress.sessionId;
+                reviewer.lastUpdate = now();
+            }
+        }
+        if (progress.type === "triage_agent_completed") {
+            const reviewer = state.reviewers[progress.reviewer];
+            if (reviewer) {
+                reviewer.sessionId = progress.sessionId;
+                reviewer.status = "completed";
+                reviewer.verdict = progress.vote;
+                reviewer.rawPath = join(state.outputDir, `${progress.reviewer}.${progress.phase}.raw.txt`);
+                reviewer.parsedPath = join(state.outputDir, `${progress.reviewer}.${progress.phase}.json`);
+                reviewer.lastUpdate = now();
+            }
+        }
+        if (progress.type === "triage_agent_failed") {
+            const reviewer = state.reviewers[progress.reviewer];
+            if (reviewer) {
+                reviewer.status = "failed";
+                reviewer.error = redactSecrets(progress.error);
+                reviewer.lastUpdate = now();
+            }
+        }
+        if (progress.type === "triage_creator_started") {
+            creatorState().status = "running";
+        }
+        if (progress.type === "triage_creator_session") {
+            const creator = creatorState();
+            if (progress.options)
+                this.input.setSessionOptions?.(progress.sessionId, progress.options);
+            creator.sessionId = progress.sessionId;
+            creator.status = "running";
+            creator.lastUpdate = now();
+            this.sessionToRun.set(progress.sessionId, {
+                agent: "triageCreator",
+                runId,
+            });
+        }
+        if (progress.type === "triage_creator_repair") {
+            const creator = creatorState();
+            creator.status = "repairing";
+            creator.repairAttempts += 1;
+            creator.lastUpdate = now();
+        }
+        if (progress.type === "triage_creator_response") {
+            const creator = creatorState();
+            creator.sessionId = progress.sessionId;
+            creator.lastUpdate = now();
+        }
+        if (progress.type === "triage_creator_completed") {
+            const creator = creatorState();
+            creator.sessionId = progress.sessionId;
+            creator.status = "completed";
+            creator.parsedPath = join(state.outputDir, "create-pr.json");
+            creator.lastUpdate = now();
+        }
+        if (progress.type === "triage_creator_failed") {
+            const creator = creatorState();
+            creator.status = "failed";
+            creator.error = redactSecrets(progress.error);
+            creator.lastUpdate = now();
+        }
+        await this.persist(state);
+        if (progress.type === "phase") {
+            await this.notify(state, `Triage phase for ${issue}: ${progress.phase}.`);
+        }
+        if (progress.type === "decision") {
+            await this.notify(state, triageDecisionNotification({
+                action: progress.action,
+                issue,
+                result: JSON.stringify(progress.result),
+            }));
+        }
+        if (progress.type === "triage_agent_started") {
+            await this.notify(state, `**Triage agent ${progress.reviewer}** started ${progress.phase} for ${issue}.`);
+        }
+        if (progress.type === "triage_agent_repair") {
+            await this.notify(state, `**Triage agent ${progress.reviewer}** started JSON regeneration for ${issue}.`);
+        }
+        if (progress.type === "triage_agent_completed") {
+            await this.notify(state, `**Triage agent ${progress.reviewer}** completed ${progress.phase} for ${issue}: ${progress.vote}.`);
+        }
+        if (progress.type === "triage_agent_failed") {
+            await this.notify(state, `**Triage agent ${progress.reviewer}** failed ${progress.phase} for ${issue}: ${redactSecrets(progress.error)}`);
+        }
+        if (progress.type === "comment_posting") {
+            await this.notify(state, `Posting triage comment for ${issue}.`);
+        }
+        if (progress.type === "comment_posted") {
+            await this.notify(state, `Posted triage comment for ${issue}: ${progress.url}`);
+        }
+        if (progress.type === "pr_creation_started") {
+            await this.notify(state, `Started implementation PR creation for ${issue}.`);
+        }
+        if (progress.type === "worktree_created") {
+            await this.notify(state, `Worktree is ready for ${issue}.`);
+        }
+        if (progress.type === "triage_creator_started") {
+            await this.notify(state, `**Triage creator** started creating an implementation PR for ${issue}.`);
+        }
+        if (progress.type === "triage_creator_repair") {
+            await this.notify(state, `**Triage creator** started JSON regeneration for ${issue}.`);
+        }
+        if (progress.type === "triage_creator_completed") {
+            await this.notify(state, `**Triage creator** completed implementation changes for ${issue}.`);
+        }
+        if (progress.type === "triage_creator_failed") {
+            await this.notify(state, triageCreatorFailureText({
+                error: redactSecrets(progress.error),
+                issue,
+                repairAttempts: state.triageCreator?.repairAttempts ?? 0,
+            }));
+        }
+        if (progress.type === "pr_created") {
+            await this.notify(state, `Created implementation PR for ${issue}: ${progress.url}`);
+        }
+    }
     async applyReviewProgress(runId, progress) {
         const state = this.active.get(runId);
         if (!state)
@@ -1226,7 +1614,7 @@ export class MagiRunManager {
         if (progress.type === "ci_classifier_failed") {
             const classifier = state.ciClassifiers?.[progress.reviewer];
             if (classifier) {
-                classifier.error = progress.error;
+                classifier.error = redactSecrets(progress.error);
                 classifier.status = "failed";
                 classifier.lastUpdate = now();
             }
@@ -1282,7 +1670,7 @@ export class MagiRunManager {
             if (!reviewer)
                 return;
             reviewer.status = "failed";
-            reviewer.error = progress.error;
+            reviewer.error = redactSecrets(progress.error);
             reviewer.lastUpdate = now();
         }
         if (progress.type === "reviewer_completed") {
@@ -1328,7 +1716,7 @@ export class MagiRunManager {
             await this.notify(state, `**CI classifier ${progress.reviewer}** completed for ${prMarkdownLink(state)}: ${progress.classification} - ${progress.reason}`);
         }
         if (progress.type === "ci_classifier_failed") {
-            await this.notify(state, `**CI classifier ${progress.reviewer}** failed for ${prMarkdownLink(state)}: ${progress.error}`);
+            await this.notify(state, `**CI classifier ${progress.reviewer}** failed for ${prMarkdownLink(state)}: ${redactSecrets(progress.error)}`);
         }
         if (progress.type === "worktree_created") {
             await this.notify(state, `Worktree is ready for ${prMarkdownLink(state)}.`);
@@ -1344,7 +1732,7 @@ export class MagiRunManager {
         }
         if (progress.type === "reviewer_failed") {
             await this.notify(state, reviewerFailureText({
-                error: progress.error,
+                error: redactSecrets(progress.error),
                 pr: prMarkdownLink(state),
                 repairAttempts: state.reviewers[progress.reviewer]?.repairAttempts ?? 0,
                 reviewer: progress.reviewer,
@@ -1451,7 +1839,7 @@ export class MagiRunManager {
         }
         if (progress.type === "editor_failed") {
             editor.status = "failed";
-            editor.error = progress.error;
+            editor.error = redactSecrets(progress.error);
             editor.lastUpdate = now();
         }
         if (progress.type === "editor_completed") {
@@ -1475,7 +1863,7 @@ export class MagiRunManager {
         }
         if (progress.type === "editor_failed") {
             await this.notify(state, editorFailureText({
-                error: progress.error,
+                error: redactSecrets(progress.error),
                 pr: prMarkdownLink(state),
                 repairAttempts: state.editor?.repairAttempts ?? 0,
             }));
@@ -1493,7 +1881,7 @@ export class MagiRunManager {
         state.status = "failed";
         state.phase = "failed";
         state.completedAt = now();
-        state.error = error instanceof Error ? error.message : String(error);
+        state.error = errorMessage(error);
         if (state.editor?.status === "pending" ||
             state.editor?.status === "running" ||
             state.editor?.status === "repairing" ||
@@ -1547,7 +1935,8 @@ export class MagiRunManager {
             : await this.listStates(input.outputDir);
         return states
             .filter((state) => input.command == null || state.command === input.command)
-            .filter((state) => input.pr == null || state.pr === input.pr)
+            .filter((state) => input.issue == null || state.issue === input.issue)
+            .filter((state) => matchesNumberFilter(state.pr, input.pr))
             .sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
     }
     async selectState(input) {
@@ -1560,6 +1949,8 @@ export class MagiRunManager {
             return input.runId;
         if (input.pr != null)
             return `PR #${input.pr}`;
+        if (input.issue != null)
+            return `issue #${input.issue}`;
         return "all runs";
     }
     absoluteOutputDir(dir) {