opencode-magi 0.0.0-dev-20260520173258 → 0.0.0-dev-20260520180659

package/dist/orchestrator/run-manager.js

@@ -164,6 +164,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 "";
@@ -536,6 +543,14 @@ export class MagiRunManager {
             ])),
             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);
@@ -626,6 +641,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" ||
@@ -919,7 +945,7 @@ export class MagiRunManager {
             if (!existing) {
                 await this.notify(state, questionWaitText({
                     agent: mapping.agent,
-                    pr: prMarkdownLink(state),
+                    pr: runLabel(state),
                     question,
                 }), { reply: true });
             }
@@ -938,7 +964,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") {
@@ -961,7 +987,7 @@ export class MagiRunManager {
                 dirty = true;
                 await this.notify(state, questionWaitText({
                     agent: mapping.agent,
-                    pr: prMarkdownLink(state),
+                    pr: runLabel(state),
                     question,
                 }), { reply: true });
             }
@@ -1031,6 +1057,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);
             });
@@ -1038,6 +1067,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}`,
@@ -1058,6 +1088,7 @@ export class MagiRunManager {
                     ? `Report: ${state.reportPath}`
                     : undefined,
                 editorLine,
+                triageCreatorLine,
                 ...classifierLines,
                 ...reviewerLines,
             ];
@@ -1084,6 +1115,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 ?? {}),
@@ -1126,13 +1158,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),
         ];
@@ -1152,10 +1193,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] };
     }
@@ -1266,6 +1307,7 @@ export class MagiRunManager {
             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,
@@ -1284,6 +1326,9 @@ export class MagiRunManager {
             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)}.`,
@@ -1293,6 +1338,189 @@ export class MagiRunManager {
         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)

package/dist/orchestrator/triage.js

@@ -6,7 +6,7 @@ import { assignIssue, closeIssue, closePullRequest, configureGitIdentity, create
 import { composeTriageAcceptancePrompt, composeTriageActionPrompt, composeTriageCategoryPrompt, composeTriageCommentClassificationPrompt, composeTriageCommentPrompt, composeTriageCreatePrPrompt, composeTriageDuplicatePrompt, composeTriageExistingPrPrompt, composeTriageQuestionPrompt, composeTriageReconsiderPrompt, } from "../prompts/compose";
 import { parseTriageActionOutput, parseTriageBinaryOutput, parseTriageCategoryOutput, parseTriageCommentClassificationOutput, parseTriageCreatePrOutput, parseTriageDuplicateOutput, parseTriageExistingPrOutput, } from "../prompts/output";
 import { aggregateStringMajority, majorityThreshold } from "./majority";
-import { runModelText, runModelWithRepair } from "./model";
+import { runModelText, runModelWithRepair, } from "./model";
 const MARKER_PREFIX = "opencode-magi:triage";
 const BINARY_VOTES = ["ASK", "NO", "YES"];
 const DUPLICATE_VOTES = ["DUPLICATE", "NOT_DUPLICATE"];
@@ -98,6 +98,35 @@ function issueContext(input) {
 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,
+            reviewer: input.reviewer,
+            sessionId: input.progress.sessionId,
+            type: "triage_agent_session",
+        });
+    }
+    if (input.progress.type === "repair") {
+        await emitProgress(input.run, {
+            phase: input.phase,
+            reviewer: input.reviewer,
+            type: "triage_agent_repair",
+        });
+    }
+    if (input.progress.type === "response") {
+        await emitProgress(input.run, {
+            phase: input.phase,
+            reviewer: input.reviewer,
+            sessionId: input.progress.sessionId,
+            type: "triage_agent_response",
+        });
+    }
+}
 async function runVote(input) {
     const prompt = await input.prompt({
         context: input.context,
@@ -106,17 +135,47 @@ async function runVote(input) {
         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})`,
+    await emitProgress(input.run, {
+        phase: input.phase,
+        reviewer: input.agent.key,
+        type: "triage_agent_started",
+    });
+    let result;
+    try {
+        result = await runModelWithRepair({
+            client: input.client,
+            model: input.agent.model,
+            onProgress: (progress) => emitTriageModelProgress({
+                phase: input.phase,
+                progress,
+                reviewer: input.agent.key,
+                run: input.run,
+            }),
+            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})`,
+        });
+    }
+    catch (error) {
+        await emitProgress(input.run, {
+            error: error instanceof Error ? error.message : String(error),
+            phase: input.phase,
+            reviewer: input.agent.key,
+            type: "triage_agent_failed",
+        });
+        throw error;
+    }
+    await emitProgress(input.run, {
+        phase: input.phase,
+        reviewer: input.agent.key,
+        sessionId: result.sessionId,
+        type: "triage_agent_completed",
+        vote: result.value.vote,
     });
     return {
         ...result.value,
@@ -155,6 +214,7 @@ async function runDuplicateVote(input) {
     const agents = input.input.repository.agents.triage;
     if (!agents?.length)
         throw new Error("triage.agents is required");
+    await emitProgress(input.input, { phase: "duplicate", type: "phase" });
     const outputs = await Promise.all(agents.map((agent) => runVote({
         agent,
         client: input.input.client,
@@ -162,8 +222,10 @@ async function runDuplicateVote(input) {
         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,
     })));
@@ -194,6 +256,7 @@ async function runPhaseVote(input) {
     const agents = input.input.repository.agents.triage;
     if (!agents?.length)
         throw new Error("triage.agents is required");
+    await emitProgress(input.input, { phase: input.phase, type: "phase" });
     const outputs = await Promise.all(agents.map((agent) => runVote({
         agent,
         client: input.input.client,
@@ -201,8 +264,10 @@ async function runPhaseVote(input) {
         directory: input.input.directory,
         issue: input.input.issue,
         parse: input.parse,
+        phase: input.phase,
         prompt: input.prompt,
         repository: input.input.repository,
+        run: input.input,
         schemaName: input.schemaName,
         signal: input.input.signal,
     })));
@@ -544,6 +609,11 @@ async function finishWithResult(input) {
     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",
+    });
     await runActionPrompt({
         context: input.context,
         input: input.input,
@@ -565,7 +635,8 @@ async function finishWithResult(input) {
         : undefined;
     if (!input.input.dryRun) {
         if (comment) {
-            await postMarkedIssueComment({
+            await emitProgress(input.input, { type: "comment_posting" });
+            const posted = await postMarkedIssueComment({
                 account: triage.account ?? "",
                 body: comment,
                 exec: input.input.exec,
@@ -573,6 +644,10 @@ async function finishWithResult(input) {
                 outputDir: input.outputDir,
                 repository: input.input.repository,
             });
+            await emitProgress(input.input, {
+                type: "comment_posted",
+                url: posted.url,
+            });
         }
         if (plan.clearLabels) {
             const clearLabels = existingClearLabels(input.issue, triage.automation.clear);
@@ -597,8 +672,10 @@ async function finishWithResult(input) {
                 issue: input.issue,
                 outputDir: input.outputDir,
             });
-            if (prUrl)
+            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({
@@ -659,48 +736,86 @@ async function createImplementationPr(input) {
     const triage = input.input.repository.triage;
     if (!triage?.account)
         throw new Error("triage.account is required");
-    await assignIssue(input.input.exec, input.input.repository, input.issue.number, triage.account);
-    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)}`);
+    await emitProgress(input.input, { type: "pr_creation_started" });
+    await emitProgress(input.input, { type: "triage_creator_started" });
     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,
+        await assignIssue(input.input.exec, input.input.repository, input.issue.number, triage.account);
+        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)}`);
+        await emitProgress(input.input, {
+            branch,
+            type: "worktree_created",
             worktreePath,
         });
-        const result = await runModelWithRepair({
-            client: input.input.client,
-            model: creator.model,
-            options: creator.options,
-            parse: parseTriageCreatePrOutput,
-            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}`,
-        });
+        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,
+                parse: parseTriageCreatePrOutput,
+                permission: creator.permission,
+                prompt,
+                repairAttempts: 3,
+                schemaName: "edit",
+                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;
+            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);
+        }
     }
-    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) {
@@ -718,7 +833,12 @@ export async function runTriage(input) {
         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);
@@ -738,6 +858,7 @@ export async function runTriage(input) {
     }
     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;
     if (relationship.previousMarker) {
@@ -848,6 +969,11 @@ export async function runTriage(input) {
                     createPr: false,
                     postComment: true,
                 };
+                await emitProgress(input, {
+                    action: plan.action,
+                    result: relatedPrDecision,
+                    type: "decision",
+                });
                 await runActionPrompt({
                     context,
                     input,
@@ -865,7 +991,8 @@ export async function runTriage(input) {
                     result: relatedPrDecision,
                 });
                 if (!input.dryRun) {
-                    await postMarkedIssueComment({
+                    await emitProgress(input, { type: "comment_posting" });
+                    const posted = await postMarkedIssueComment({
                         account: triage.account,
                         body,
                         exec: input.exec,
@@ -873,6 +1000,7 @@ export async function runTriage(input) {
                         outputDir,
                         repository: input.repository,
                     });
+                    await emitProgress(input, { type: "comment_posted", url: posted.url });
                     const clearLabels = existingClearLabels(issue, triage.automation.clear);
                     if (clearLabels.length) {
                         await removeIssueLabels(input.exec, input.repository, issue.number, clearLabels, triage.account);

package/dist/permissions/editor.json

@@ -1,7 +1,14 @@
 {
     "bash": {
+        "bun *": "allow",
+        "bunx *": "allow",
+        "corepack *": "allow",
         "git add*": "allow",
-        "git commit*": "allow"
+        "git commit*": "allow",
+        "npm *": "allow",
+        "npx *": "allow",
+        "pnpm *": "allow",
+        "yarn *": "allow"
     },
     "edit": "allow"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-magi",
-  "version": "0.0.0-dev-20260520173258",
+  "version": "0.0.0-dev-20260520180659",
   "description": "Multi-agent PR review and merge orchestration plugin for OpenCode.",
   "license": "MIT",
   "author": "Hirotomo Yamada <hirotomo.yamada@avap.co.jp>",