opencode-magi 0.0.0-dev-20260522220204 → 0.0.0-dev-20260522220322

package/dist/orchestrator/majority.js

@@ -10,7 +10,7 @@ export function aggregateStringMajority(results, votes) {
     const voters = Object.fromEntries(votes.map((vote) => [vote, []]));
     for (const result of results) {
         counts[result.vote] += 1;
-        voters[result.vote].push(result.reviewer);
+        voters[result.vote].push(result.voter);
     }
     const threshold = majorityThreshold(results.length);
     const vote = votes.find((item) => counts[item] >= threshold);

package/dist/orchestrator/merge.js

@@ -310,7 +310,7 @@ async function runRereview(input, worktreePath, previousHeadSha, cycle, sessionI
                 baseSha: meta.baseRefOid,
                 closeReason: entry.output.reason,
                 directory: input.directory,
-                headSha: meta.headRefOid,
+                headSha,
                 includeReviewGuidelines: !hasReviewerSession,
                 includeSessionContext: !hasReviewerSession,
                 pr: input.pr,

package/dist/orchestrator/run-manager.js

@@ -1507,56 +1507,56 @@ export class MagiRunManager {
             });
         }
         if (progress.type === "triage_agent_started") {
-            const reviewer = state.reviewers[progress.reviewer];
-            if (reviewer)
-                reviewer.status = "running";
+            const voter = state.reviewers[progress.voter];
+            if (voter)
+                voter.status = "running";
         }
         if (progress.type === "triage_agent_session") {
-            const reviewer = state.reviewers[progress.reviewer];
-            if (reviewer) {
+            const voter = state.reviewers[progress.voter];
+            if (voter) {
                 if (progress.options)
                     this.input.setSessionOptions?.(progress.sessionId, progress.options);
-                reviewer.sessionId = progress.sessionId;
-                reviewer.status = "running";
-                reviewer.lastUpdate = now();
+                voter.sessionId = progress.sessionId;
+                voter.status = "running";
+                voter.lastUpdate = now();
                 this.sessionToRun.set(progress.sessionId, {
-                    agent: progress.reviewer,
+                    agent: progress.voter,
                     runId,
                 });
             }
         }
         if (progress.type === "triage_agent_repair") {
-            const reviewer = state.reviewers[progress.reviewer];
-            if (reviewer) {
-                reviewer.status = "repairing";
-                reviewer.repairAttempts += 1;
-                reviewer.lastUpdate = now();
+            const voter = state.reviewers[progress.voter];
+            if (voter) {
+                voter.status = "repairing";
+                voter.repairAttempts += 1;
+                voter.lastUpdate = now();
             }
         }
         if (progress.type === "triage_agent_response") {
-            const reviewer = state.reviewers[progress.reviewer];
-            if (reviewer) {
-                reviewer.sessionId = progress.sessionId;
-                reviewer.lastUpdate = now();
+            const voter = state.reviewers[progress.voter];
+            if (voter) {
+                voter.sessionId = progress.sessionId;
+                voter.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();
+            const voter = state.reviewers[progress.voter];
+            if (voter) {
+                voter.sessionId = progress.sessionId;
+                voter.status = "completed";
+                voter.verdict = progress.vote;
+                voter.rawPath = join(state.outputDir, `${progress.voter}.${progress.phase}.raw.txt`);
+                voter.parsedPath = join(state.outputDir, `${progress.voter}.${progress.phase}.json`);
+                voter.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();
+            const voter = state.reviewers[progress.voter];
+            if (voter) {
+                voter.status = "failed";
+                voter.error = redactSecrets(progress.error);
+                voter.lastUpdate = now();
             }
         }
         if (progress.type === "triage_creator_started") {
@@ -1610,16 +1610,16 @@ export class MagiRunManager {
             }));
         }
         if (progress.type === "triage_agent_started") {
-            await this.notify(state, `**Triage agent ${progress.reviewer}** started ${progress.phase} for ${issue}.`);
+            await this.notify(state, `**Triage agent ${progress.voter}** started ${progress.phase} for ${issue}.`);
         }
         if (progress.type === "triage_agent_repair") {
-            await this.notify(state, `**Triage agent ${progress.reviewer}** started JSON regeneration for ${issue}.`);
+            await this.notify(state, `**Triage agent ${progress.voter}** 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}.`);
+            await this.notify(state, `**Triage agent ${progress.voter}** 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)}`);
+            await this.notify(state, `**Triage agent ${progress.voter}** failed ${progress.phase} for ${issue}: ${redactSecrets(progress.error)}`);
         }
         if (progress.type === "comment_posting") {
             await this.notify(state, `Posting triage comment for ${issue}.`);

package/dist/orchestrator/triage.js

@@ -106,24 +106,24 @@ async function emitTriageModelProgress(input) {
         await emitProgress(input.run, {
             options: input.progress.options,
             phase: input.phase,
-            reviewer: input.reviewer,
             sessionId: input.progress.sessionId,
             type: "triage_agent_session",
+            voter: input.voter,
         });
     }
     if (input.progress.type === "repair") {
         await emitProgress(input.run, {
             phase: input.phase,
-            reviewer: input.reviewer,
             type: "triage_agent_repair",
+            voter: input.voter,
         });
     }
     if (input.progress.type === "response") {
         await emitProgress(input.run, {
             phase: input.phase,
-            reviewer: input.reviewer,
             sessionId: input.progress.sessionId,
             type: "triage_agent_response",
+            voter: input.voter,
         });
     }
 }
@@ -133,12 +133,12 @@ async function runVote(input) {
         directory: input.directory,
         issue: input.issue,
         repository: input.repository,
-        reviewer: input.agent,
+        voter: input.agent,
     });
     await emitProgress(input.run, {
         phase: input.phase,
-        reviewer: input.agent.key,
         type: "triage_agent_started",
+        voter: input.agent.key,
     });
     let result;
     try {
@@ -148,8 +148,8 @@ async function runVote(input) {
             onProgress: (progress) => emitTriageModelProgress({
                 phase: input.phase,
                 progress,
-                reviewer: input.agent.key,
                 run: input.run,
+                voter: input.agent.key,
             }),
             options: input.agent.options,
             parentSessionId: input.run.parentSessionId,
@@ -166,28 +166,28 @@ async function runVote(input) {
         await emitProgress(input.run, {
             error: error instanceof Error ? error.message : String(error),
             phase: input.phase,
-            reviewer: input.agent.key,
             type: "triage_agent_failed",
+            voter: input.agent.key,
         });
         throw error;
     }
     await emitProgress(input.run, {
         phase: input.phase,
-        reviewer: input.agent.key,
         sessionId: result.sessionId,
         type: "triage_agent_completed",
+        voter: input.agent.key,
         vote: result.value.vote,
     });
     return {
         ...result.value,
         promptText: prompt,
         raw: result.raw,
-        reviewer: input.agent.key,
         sessionId: result.sessionId,
+        voter: input.agent.key,
     };
 }
 async function writeVoteArtifacts(input) {
-    const base = join(input.outputDir, `${input.reviewer}.${input.phase}`);
+    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`, {
@@ -233,14 +233,14 @@ async function runDuplicateVote(input) {
         signal: input.input.signal,
     })));
     const majority = aggregateStringMajority(outputs.map((output, index) => ({
-        reviewer: agents[index].key,
+        voter: agents[index].key,
         vote: output.vote,
     })), DUPLICATE_VOTES);
     await Promise.all(outputs.map((output, index) => writeVoteArtifacts({
         output,
         outputDir: input.outputDir,
         phase: "duplicate",
-        reviewer: agents[index].key,
+        voter: agents[index].key,
     })));
     await Promise.all(outputs.map((output, index) => writeJson(join(input.outputDir, `${agents[index].key}.duplicate.json`), {
         duplicateOf: output.duplicateOf,
@@ -275,14 +275,14 @@ async function runPhaseVote(input) {
         signal: input.input.signal,
     })));
     const majority = aggregateStringMajority(outputs.map((output, index) => ({
-        reviewer: agents[index].key,
+        voter: agents[index].key,
         vote: output.vote,
     })), input.votes);
     await Promise.all(outputs.map((output, index) => writeVoteArtifacts({
         output,
         outputDir: input.outputDir,
         phase: input.phase,
-        reviewer: agents[index].key,
+        voter: agents[index].key,
     })));
     await writeJson(join(input.outputDir, `${input.phase}-majority.json`), majority);
     return { outputs, vote: majority.vote };
@@ -463,7 +463,7 @@ async function classifyMentionReplies(input) {
         directory: input.input.directory,
         issue: input.input.issue,
         repository: input.input.repository,
-        reviewer: agent,
+        voter: agent,
     });
     const result = await runModelWithRepair({
         client: input.input.client,
@@ -533,12 +533,11 @@ function askOutputs(outputs) {
     return (outputs ?? []).filter((output) => output.vote === "ASK");
 }
 function chooseDecisionReason(input) {
-    return (input.outputs?.find((output) => output.reviewer === input.reporter.key &&
+    return (input.outputs?.find((output) => output.voter === input.reporter.key &&
         output.vote === input.vote &&
         output.reason)?.reason ??
         input.outputs?.find((output) => output.vote === input.vote)?.reason ??
-        input.outputs?.find((output) => output.reviewer === input.reporter.key)
-            ?.reason);
+        input.outputs?.find((output) => output.voter === input.reporter.key)?.reason);
 }
 async function postMarkedIssueComment(input) {
     const posted = await postIssueComment(input.exec, input.repository, input.issue, input.account, input.body);
@@ -586,7 +585,7 @@ async function persistProcessedMarker(input) {
 async function postAskComments(input) {
     const urls = [];
     for (const output of askOutputs(input.outputs)) {
-        const agent = agentForKey(input.repository, output.reviewer);
+        const agent = agentForKey(input.repository, output.voter);
         const body = input.mark
             ? `${output.body}\n\n${marker({
                 action: input.action,

package/dist/prompts/compose.js

@@ -333,7 +333,7 @@ async function composeTriageVotePrompt(input) {
     return [
         task,
         languageBlock(input.repository.language),
-        personaBlock(input.reviewer.persona),
+        personaBlock(input.voter.persona),
         input.outputContract,
     ]
         .filter(Boolean)

package/package.json

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