opencode-magi 0.0.0-dev-20260702001022 → 0.0.0-dev-20260714065541

package/dist/tools/review/action.js

@@ -11,9 +11,7 @@ export async function postReviews() {
     this.context.abort.throwIfAborted();
     if (this.state.dryRun)
         return;
-    this.state = await this.magi.updateState(this.state.output, {
-        text: `Posting reviews for ${this.getLink()}.`,
-    });
+    await this.updateEvent(`Posting reviews.`);
     if (!this.config.review.reviewers?.length)
         throw new MagiError("blocked", "No reviewers configured.");
     if (!this.state.reviewers)
@@ -45,7 +43,7 @@ export async function postReviews() {
                     .map((finding) => ({ ...finding, id }));
             });
             if (!findings.length) {
-                await this.notify(`Finished posting reviews for ${this.getLink()}.`);
+                await this.updateEvent(`Finished posting reviews.`);
                 return;
             }
             params.comments = findings.map(({ body, id, line, path, startLine }) => ({
@@ -63,7 +61,7 @@ export async function postReviews() {
         if (this.state.pr.verdict !== "APPROVED") {
             if (!this.state.operator?.sessionId)
                 throw new MagiError("blocked", "Reporter session ID not found.");
-            await this.notify(`Generating comment for ${this.getLink()} by operator.`);
+            await this.updateEvent(`Generating comment by operator.`);
             const contents = JSON.stringify(reviewers.flatMap(([, { outputs }]) => {
                 const output = outputs?.at(-1);
                 if (!output || output.verdict === "APPROVED")
@@ -89,12 +87,12 @@ export async function postReviews() {
                     throw new Error("Invalid output for operator.");
                 return parsed.comment;
             }, {
-                error: (_, count) => this.notify(`Attempt ${count} failed to post comment for ${this.getLink()} by operator. Retrying...`),
+                error: (_, count) => this.updateEvent(`Attempt ${count} failed to post comment by operator. Retrying...`),
                 retries: this.config.output.repairAttempts,
             });
             if (!output)
                 throw new MagiError("blocked", "Invalid output for operator.");
-            await this.notify(`Generated comment for ${this.getLink()} by operator.`);
+            await this.updateEvent(`Generated comment by operator.`);
             params.body = output;
         }
         params.body = [
@@ -116,10 +114,10 @@ export async function postReviews() {
         ].join("\n\n");
         const { data } = await octokit.rest.pulls.createReview(params);
         const posted = data.html_url;
-        this.state = await this.magi.updateState(this.state.output, {
+        await this.updateState({
             reviewers: Object.fromEntries(Object.keys(this.state.reviewers).map((id) => [id, { posted }])),
-            text: `Finished posting reviews for ${this.getLink()}.`,
         });
+        await this.updateEvent(`Finished posting reviews.`);
     }
     else {
         const worker = new Worker(this.config.review.concurrency.reviewers);
@@ -167,10 +165,8 @@ export async function postReviews() {
             const { data } = await octokit.rest.pulls.createReview(params);
             return [id, { posted: data.html_url }];
         }))));
-        this.state = await this.magi.updateState(this.state.output, {
-            reviewers,
-            text: `Finished posting reviews for ${this.getLink()}.`,
-        });
+        await this.updateState({ reviewers });
+        await this.updateEvent(`Finished posting reviews.`);
     }
 }
 export async function automate() {
@@ -184,10 +180,8 @@ export async function automate() {
     const automation = this.config[this.state.command].automation;
     const action = this.state.pr.verdict === "APPROVED" ? "merge" : "close";
     if (!automation[action]) {
-        this.state = await this.magi.updateState(this.state.output, {
-            pr: { automation: "SKIPPED" },
-            text: `Skipped ${action} automation for ${this.getLink()}.`,
-        });
+        await this.updateState({ pr: { automation: "SKIPPED" } });
+        await this.updateEvent(`Skipped ${action} automation.`);
         return "SKIPPED";
     }
     const account = this.state.operator.account;
@@ -197,25 +191,19 @@ export async function automate() {
         const failed = this.state.pr.checks.failed;
         const pending = this.state.pr.checks.pending;
         if (failed.length || pending.length) {
-            this.state = await this.magi.updateState(this.state.output, {
-                pr: { automation: "SKIPPED" },
-                text: `Skipped merge automation for ${this.getLink()} because unresolved CI checks remain.`,
-            });
+            await this.updateState({ pr: { automation: "SKIPPED" } });
+            await this.updateEvent(`Skipped merge automation because unresolved CI checks remain.`);
             return "SKIPPED";
         }
         if (await isConflict.call(this)) {
-            this.state = await this.magi.updateState(this.state.output, {
-                pr: { automation: "CONFLICT" },
-                text: `Merge automation found conflicts for ${this.getLink()}.`,
-            });
+            await this.updateState({ pr: { automation: "CONFLICT" } });
+            await this.updateEvent(`Merge automation found conflicts.`);
             return "CONFLICT";
         }
     }
     if (this.state.dryRun) {
-        this.state = await this.magi.updateState(this.state.output, {
-            pr: { automation: "SKIPPED" },
-            text: `Skipped ${action} automation for ${this.getLink()} during dry run.`,
-        });
+        await this.updateState({ pr: { automation: "SKIPPED" } });
+        await this.updateEvent(`Skipped ${action} automation during dry run.`);
         return "SKIPPED";
     }
     const token = await this.magi.getGhToken(account);
@@ -234,20 +222,14 @@ export async function automate() {
         }
     }
     if (action !== "merge" || this.config.review.merge.queue)
-        this.state = await this.magi.updateState(this.state.output, {
-            text: `${action === "merge" ? "Merging" : "Closing"} ${this.getLink()}.`,
-        });
+        await this.updateEvent(`${action === "merge" ? "Merging" : "Closing"}.`);
     else
-        this.state = await this.magi.updateState(this.state.output, {
-            text: `Waiting to merge ${this.getLink()}.`,
-        });
+        await this.updateEvent(`Waiting to merge.`);
     if (action === "merge" && this.config.review.merge.queue) {
         const octokit = await this.magi.createOctokit(this.config, this.context.abort, account);
         const graphql = this.magi.createGraphql(octokit);
         await graphql.enqueuePullRequest({ id: this.state.pr.metadata.node_id });
-        this.state = await this.magi.updateState(this.state.output, {
-            text: `Waiting for merge queue for ${this.getLink()}.`,
-        });
+        await this.updateEvent(`Waiting for merge queue.`);
         const result = await waitMergeQueue.call(this);
         if (result === "CONFLICT")
             return result;
@@ -279,31 +261,25 @@ export async function automate() {
                 if (status === "DIRTY")
                     return "CONFLICT";
                 if (status === "BEHIND") {
-                    this.state = await this.magi.updateState(this.state.output, {
-                        text: `Updating ${this.getLink()} with the base branch before merging.`,
-                    });
+                    await this.updateEvent(`Updating with the base branch before merging.`);
                     await this.exec(command(...prefix, "update-branch", ...suffix), options);
                     return;
                 }
                 if (status === "BLOCKED" && hasFailedChecks(checks))
-                    throw new MagiError("blocked", `Required checks failed before merging ${this.getLink()}.`);
+                    throw new MagiError("blocked", `Required checks failed before merging.`);
                 if (!auto && state === "OPEN")
-                    throw new MagiError("blocked", `Auto-merge is no longer enabled for ${this.getLink()}.`);
+                    throw new MagiError("blocked", `Auto-merge is no longer enabled.`);
             }, 30_000);
         };
         const runAutomation = async () => {
             try {
-                this.state = await this.magi.updateState(this.state.output, {
-                    text: `Merging ${this.getLink()}.`,
-                });
+                await this.updateEvent(`Merging.`);
                 await this.exec(command(...args), options);
                 if (action === "merge" && this.config.review.merge.auto) {
                     const result = await waitMerge();
                     if (result === "CONFLICT") {
-                        this.state = await this.magi.updateState(this.state.output, {
-                            pr: { automation: "CONFLICT" },
-                            text: `Merge automation found conflicts for ${this.getLink()}.`,
-                        });
+                        await this.updateState({ pr: { automation: "CONFLICT" } });
+                        await this.updateEvent(`Merge automation found conflicts.`);
                         return "CONFLICT";
                     }
                 }
@@ -314,24 +290,18 @@ export async function automate() {
                     throw e;
                 switch (true) {
                     case /\bconflicts?\b|merge commit cannot be cleanly created/i.test(message):
-                        this.state = await this.magi.updateState(this.state.output, {
-                            pr: { automation: "CONFLICT" },
-                            text: `Merge automation found conflicts for ${this.getLink()}.`,
-                        });
+                        await this.updateState({ pr: { automation: "CONFLICT" } });
+                        await this.updateEvent(`Merge automation found conflicts.`);
                         return "CONFLICT";
                     case /head (branch|ref) is (not up to date|out of date)/i.test(message):
-                        this.state = await this.magi.updateState(this.state.output, {
-                            text: `Updating ${this.getLink()} with the base branch before merging.`,
-                        });
+                        await this.updateEvent(`Updating with the base branch before merging.`);
                         await this.exec(command(...prefix, "update-branch", ...suffix), options);
                         await this.exec(command(...args), options);
                         if (this.config.review.merge.auto) {
                             const result = await waitMerge();
                             if (result === "CONFLICT") {
-                                this.state = await this.magi.updateState(this.state.output, {
-                                    pr: { automation: "CONFLICT" },
-                                    text: `Merge automation found conflicts for ${this.getLink()}.`,
-                                });
+                                await this.updateState({ pr: { automation: "CONFLICT" } });
+                                await this.updateEvent(`Merge automation found conflicts.`);
                                 return "CONFLICT";
                             }
                         }
@@ -347,10 +317,10 @@ export async function automate() {
         if (result)
             return result;
     }
-    this.state = await this.magi.updateState(this.state.output, {
+    await this.updateState({
         pr: { automation: action === "merge" ? "MERGED" : "CLOSED" },
-        text: `Finished ${action} automation for ${this.getLink()}.`,
     });
+    await this.updateEvent(`Finished ${action} automation.`);
     return action === "merge" ? "MERGED" : "CLOSED";
 }
 function hasFailedChecks(checks) {
@@ -399,13 +369,11 @@ async function waitMergeQueue(leftMergeQueue = false) {
     const nextLeftMergeQueue = state === "OPEN" && !isInMergeQueue && !mergeQueueEntry;
     if (leftMergeQueue && nextLeftMergeQueue) {
         if (await isConflict.call(this)) {
-            this.state = await this.magi.updateState(this.state.output, {
-                pr: { automation: "CONFLICT" },
-                text: `Merge automation found conflicts for ${this.getLink()}.`,
-            });
+            await this.updateState({ pr: { automation: "CONFLICT" } });
+            await this.updateEvent(`Merge automation found conflicts.`);
             return "CONFLICT";
         }
-        throw new MagiError("blocked", `PR left the merge queue before merging ${this.getLink()}.`);
+        throw new MagiError("blocked", `PR left the merge queue before merging.`);
     }
     await wait(30_000);
     return await waitMergeQueue.call(this, nextLeftMergeQueue);

package/dist/tools/review/check.js

@@ -24,10 +24,8 @@ const ci = {
 };
 export async function checkPr() {
     this.context.abort.throwIfAborted();
-    await this.magi.updateState(this.state.output, {
-        status: "running",
-        text: `Checking PR ${this.getLink()}.`,
-    });
+    await this.updateState({ status: "running" });
+    await this.updateEvent(`Checking PR.`);
     const { files, metadata } = await getMetadata.call(this);
     if (metadata.state !== "open")
         throw new MagiError("blocked", `PR is not open.`);
@@ -57,40 +55,32 @@ export async function checkPr() {
         throw new MagiError("blocked", `PR is safety blocked. ${errors.join(" ")}`);
     if (this.config.mode === "single") {
         if (this.config.account === metadata.user.login)
-            throw new MagiError("blocked", `Single mode account ${this.config.account} cannot review ${this.getLink()} because it opened the pull request. Configure account to a different account.`);
+            throw new MagiError("blocked", `Single mode account ${this.config.account} cannot review because it opened the pull request. Configure account to a different account.`);
     }
     else {
         const accounts = Object.values(this.state.reviewers ?? {})
             .filter(({ account }) => account === metadata.user.login)
             .map(({ account }) => account);
         if (accounts.length)
-            throw new MagiError("blocked", `Multi mode accounts ${accounts.join(", ")} cannot review ${this.getLink()} because they opened the pull request. Configure accounts to different accounts.`);
+            throw new MagiError("blocked", `Multi mode accounts ${accounts.join(", ")} cannot review because they opened the pull request. Configure accounts to different accounts.`);
     }
-    this.state = await this.magi.updateState(this.state.output, {
-        pr: { files, metadata },
-        text: `Finished checking PR ${this.getLink()}.`,
-    });
+    await this.updateState({ pr: { files, metadata } });
+    await this.updateEvent(`Finished checking PR.`);
 }
 export async function checkCi(wait = this.config.review.checks.wait) {
     this.context.abort.throwIfAborted();
-    this.state = await this.magi.updateState(this.state.output, {
-        text: `Checking CI for ${this.getLink()}.`,
-    });
+    await this.updateEvent(`Checking CI.`);
     if (wait)
         await watchChecks.call(this);
     const checks = await getChecks.call(this);
-    this.state = await this.magi.updateState(this.state.output, {
-        pr: { checks },
-        text: `Finished checking CI for ${this.getLink()}.`,
-    });
+    await this.updateState({ pr: { checks } });
+    await this.updateEvent(`Finished checking CI.`);
 }
 export async function classifyChecks() {
     this.context.abort.throwIfAborted();
     if (!this.state.pr?.checks?.failed.length)
         return;
-    await this.magi.updateState(this.state.output, {
-        text: `Classifying CI checks for ${this.getLink()}.`,
-    });
+    await this.updateEvent(`Classifying CI checks.`);
     if (!this.state.pr.metadata)
         throw new MagiError("blocked", "PR metadata not found.");
     if (!this.state.worktree)
@@ -115,7 +105,7 @@ export async function classifyChecks() {
     await Promise.all(Object.entries(this.state.reviewers ?? {}).map(([id, { sessionId }]) => worker.run(async () => {
         if (!sessionId)
             throw new Error(`No session ID found for reviewer ${id}.`);
-        await this.notify(`Classifying CI checks for ${this.getLink()} with reviewer ${id}.`);
+        await this.updateEvent(`Classifying CI checks with reviewer ${id}.`);
         const output = await retry(async (count) => {
             const raw = await this.magi.promptSession(sessionId, count === 1 ? taskMessage : repairMessage);
             await this.createAgentFile("ci-classification", id, raw, count);
@@ -124,7 +114,7 @@ export async function classifyChecks() {
                 throw new Error(`Invalid output for reviewer ${id}.`);
             return parsed;
         }, {
-            error: (_, count) => this.notify(`Attempt ${count} failed to classify CI checks for ${this.getLink()} with reviewer ${id}. Retrying...`),
+            error: (_, count) => this.updateEvent(`Attempt ${count} failed to classify CI checks with reviewer ${id}. Retrying...`),
             retries: this.config.output.repairAttempts,
         });
         if (!output)
@@ -152,10 +142,10 @@ export async function classifyChecks() {
                 .filter(([, { scope }]) => !scope)
                 .map(([id, { comment }]) => `- ${id}: ${comment}`),
         };
-        await this.notify(filterEmpty([
+        await this.updateEvent(filterEmpty([
             scope
-                ? `Check ${name} for ${this.getLink()} was classified as in scope by majority vote.`
-                : `Check ${name} for ${this.getLink()} was classified as out of scope by majority vote. Rerunning it.`,
+                ? `Check ${name} was classified as in scope by majority vote.`
+                : `Check ${name} was classified as out of scope by majority vote. Rerunning it.`,
             reasons.in.length
                 ? `In scope reasons:\n${reasons.in.join("\n")}`
                 : undefined,
@@ -164,10 +154,8 @@ export async function classifyChecks() {
                 : undefined,
         ]).join("\n\n"));
     }));
-    this.state = await this.magi.updateState(this.state.output, {
-        pr: { checks: { failed } },
-        text: `Finished classifying CI checks for ${this.getLink()}.`,
-    });
+    await this.updateState({ pr: { checks: { failed } } });
+    await this.updateEvent(`Finished classifying CI checks.`);
 }
 export async function rerunChecks() {
     this.context.abort.throwIfAborted();
@@ -180,9 +168,7 @@ export async function rerunChecks() {
     const failedChecks = checks.failed.filter(({ scope }) => !scope);
     if (!failedChecks.length)
         return;
-    await this.magi.updateState(this.state.output, {
-        text: `Rerunning CI checks for ${this.getLink()}.`,
-    });
+    await this.updateEvent(`Rerunning CI checks.`);
     let label = failedChecks.map(({ name }) => name).join(", ");
     if (this.state.dryRun) {
         checks.passed = [
@@ -193,7 +179,7 @@ export async function rerunChecks() {
     }
     else {
         await retry(async () => {
-            await this.notify(`Rerunning checks ${label} for ${this.getLink()}.`);
+            await this.updateEvent(`Rerunning checks ${label}.`);
             await Promise.all(checks.failed
                 .filter(({ scope }) => !scope)
                 .map(async ({ id }) => rerunCheck.call(this, id)));
@@ -211,9 +197,9 @@ export async function rerunChecks() {
             if (!failedChecks.length)
                 return;
             label = failedChecks.map(({ name }) => name).join(", ");
-            throw new Error(`Checks ${label} for ${this.getLink()} still failed.`);
+            throw new Error(`Checks ${label} still failed.`);
         }, {
-            error: (_, count) => this.notify(`Attempt ${count} failed to rerun checks ${label} for ${this.getLink()}. Retrying...`),
+            error: (_, count) => this.updateEvent(`Attempt ${count} failed to rerun checks ${label}. Retrying...`),
             retries: this.config.review.checks.retryFailedJobs,
         });
     }
@@ -221,18 +207,16 @@ export async function rerunChecks() {
     const failedChecksAfterRerun = checks.failed.filter(({ scope }) => !scope);
     const message = filterEmpty([
         passedChecksAfterRerun.length
-            ? `Reran checks ${passedChecksAfterRerun.map(({ name }) => name).join(", ")} for ${this.getLink()} passed.`
+            ? `Reran checks ${passedChecksAfterRerun.map(({ name }) => name).join(", ")} passed.`
             : undefined,
         failedChecksAfterRerun.length
-            ? `Reran checks ${failedChecksAfterRerun.map(({ name }) => name).join(", ")} for ${this.getLink()} failed.`
+            ? `Reran checks ${failedChecksAfterRerun.map(({ name }) => name).join(", ")} failed.`
             : undefined,
     ]).join("\n");
     if (message)
-        await this.notify(message);
-    this.state = await this.magi.updateState(this.state.output, {
-        pr: { checks },
-        text: `Finished rerunning checks for ${this.getLink()}.`,
-    });
+        await this.updateEvent(message);
+    await this.updateState({ pr: { checks } });
+    await this.updateEvent(`Finished rerunning checks.`);
 }
 export async function getMetadata() {
     const [{ data }, files] = await Promise.all([

package/dist/tools/review/context.js

@@ -2,9 +2,7 @@ import { MagiError } from "@/magi";
 import { command, filterEmpty, marker, quote } from "@/utils";
 export async function checkExistingReviews() {
     this.context.abort.throwIfAborted();
-    this.state = await this.magi.updateState(this.state.output, {
-        text: `Fetching existing reviews for ${this.getLink()}.`,
-    });
+    await this.updateEvent(`Fetching existing reviews.`);
     if (!this.state.pr?.metadata)
         throw new MagiError("blocked", "PR metadata not found.");
     if (!this.config.review.reviewers?.length)
@@ -14,9 +12,7 @@ export async function checkExistingReviews() {
         getCommits.call(this),
         getReviewThreads.call(this),
     ]);
-    this.state = await this.magi.updateState(this.state.output, {
-        pr: { commits, reviews, threads },
-    });
+    await this.updateState({ pr: { commits, reviews, threads } });
     const latestNonMergeCommit = commits
         .toReversed()
         .find(({ parents }) => parents.length < 2);
@@ -102,27 +98,23 @@ export async function checkExistingReviews() {
         }
     }
     const skip = Object.values(reviewers).every(({ status }) => status === "skip");
-    this.state = await this.magi.updateState(this.state.output, {
-        reviewers,
-        text: `Finished fetching existing reviews for ${this.getLink()}.`,
-    });
+    await this.updateState({ reviewers });
+    await this.updateEvent(`Finished fetching existing reviews.`);
     return skip;
 }
 export async function fetchReviewContext() {
     this.context.abort.throwIfAborted();
-    this.state = await this.magi.updateState(this.state.output, {
-        text: `Fetching review context for ${this.getLink()}.`,
-    });
+    await this.updateEvent(`Fetching review context.`);
     const [comments, issues, threads] = await Promise.all([
         getComments.call(this),
         getClosingIssues.call(this),
         getReviewThreads.call(this),
     ]);
     const inlineCommentTargets = await getInlineCommentTargets.call(this);
-    this.state = await this.magi.updateState(this.state.output, {
+    await this.updateState({
         pr: { comments, inlineCommentTargets, issues, threads },
-        text: `Finished fetching review context for ${this.getLink()}.`,
     });
+    await this.updateEvent(`Finished fetching review context.`);
 }
 export async function getComments() {
     return await this.octokit.paginate(this.octokit.rest.issues.listComments, {

package/dist/tools/review/index.js

@@ -1,7 +1,7 @@
 import { tool } from "@opencode-ai/plugin";
-import { filterEmpty, parsePrs, split, Worker } from "@/utils";
+import { parsePrs, split, Worker } from "@/utils";
 import { Review } from "./review";
-function overrideConfig(config, args, dryRun = false, sync = false) {
+function overrideConfig(config, args, dryRun = false) {
     for (let index = 0; index < args.length; index++) {
         const arg = args[index];
         const value = args[index + 1];
@@ -11,9 +11,6 @@ function overrideConfig(config, args, dryRun = false, sync = false) {
             case "--dry-run":
                 dryRun = true;
                 break;
-            case "--sync":
-                sync = true;
-                break;
             case "--retry-api-attempts":
                 config.github.retryApiAttempts = parseInt(value);
                 break;
@@ -49,7 +46,7 @@ function overrideConfig(config, args, dryRun = false, sync = false) {
                 break;
         }
     }
-    return { config, dryRun, sync };
+    return { config, dryRun };
 }
 export const review = function (magi) {
     return {
@@ -57,23 +54,18 @@ export const review = function (magi) {
             args: {
                 dryRun: tool.schema.boolean().optional(),
                 prs: tool.schema.string(),
-                sync: tool.schema.boolean().optional(),
             },
-            description: "Start background Magi review runs for one or more pull requests and post the reviews. After starting, monitor progress yourself when useful; do not tell users to call follow-up tools by name.",
+            description: "Review one or more pull requests and post the reviews.",
             async execute(args, context) {
                 const prs = parsePrs(args.prs);
-                const { config, dryRun, sync } = overrideConfig(await magi.getConfig({ reviewers: true }), split(args.prs), args.dryRun, args.sync);
+                const { config, dryRun } = overrideConfig(await magi.getConfig({ reviewers: true }), split(args.prs), args.dryRun);
                 const worker = new Worker(config.review.concurrency.runs);
-                const states = [];
-                const tasks = [];
-                for (const pr of prs) {
+                const reports = await Promise.all(prs.map(async (pr) => {
                     context.abort.throwIfAborted();
-                    const run = await Review.init(pr, magi, config, context, {
-                        dryRun,
-                        sync,
-                    });
-                    states.push(run.state);
-                    const task = worker.run(async () => {
+                    return worker.run(async () => {
+                        const run = await Review.init(pr, magi, config, context, {
+                            dryRun,
+                        });
                         try {
                             await run.checkPr();
                             const skip = await run.checkExistingReviews();
@@ -101,20 +93,8 @@ export const review = function (magi) {
                             await run.cleanup();
                         }
                     });
-                    tasks.push(task);
-                    if (!sync)
-                        void task;
-                }
-                if (sync) {
-                    const results = await Promise.all(tasks);
-                    const output = filterEmpty(results.map(({ text }) => text)).join("\n\n");
-                    if (results.some(({ status }) => status === "failed" || status === "cancelled"))
-                        throw new Error(output);
-                    return output;
-                }
-                else {
-                    return filterEmpty(states.map(({ text }) => text)).join("\n");
-                }
+                }));
+                return reports.join("\n\n");
             },
         }),
     };

package/dist/tools/review/report.js

@@ -5,13 +5,13 @@ import { filterEmpty, toTitleCase } from "@/utils";
 export async function createReport(e) {
     if (!e) {
         const status = "completed";
-        const text = createContent.call(this, { status });
+        const text = await createContent.call(this, { status });
         await writeFile(join(this.state.output, "report.md"), `${text}\n`);
-        return this.magi.updateState(this.state.output, {
+        await this.updateState({
             completedAt: new Date().toISOString(),
             status,
-            text,
         });
+        return text;
     }
     else {
         const error = e instanceof Error ? e.message : "Unknown error";
@@ -20,26 +20,27 @@ export async function createReport(e) {
             : this.context.abort.aborted
                 ? "cancelled"
                 : "failed";
-        const text = createContent.call(this, { error, status });
+        const text = await createContent.call(this, { error, status });
         await writeFile(join(this.state.output, "report.md"), `${text}\n`);
-        return this.magi.updateState(this.state.output, {
+        await this.updateState({
             completedAt: new Date().toISOString(),
-            error,
             status,
-            text: `${toTitleCase(status)} reviewing ${this.getLink()}.\n\n${text}`,
         });
+        return text;
     }
 }
-function createContent(input) {
+async function createContent(input) {
     return filterEmpty([
-        ...createMetaContent.call(this, input),
+        ...(await createMetaContent.call(this, input)),
         ...createCheckContent.call(this),
         ...createReviewerContent.call(this),
     ]).join("\n");
 }
-export function createMetaContent(input) {
+export async function createMetaContent(input) {
+    const events = await this.getEvents();
+    const lastAction = events.at(-1)?.message;
     const rows = [
-        `- **Pull Request:** ${this.getLink()}`,
+        `- **Pull Request:** [${this.state.pr.number}](${this.state.pr.url})`,
         `- **Mode**: ${toTitleCase(this.config.mode)}`,
         `- **Dry run**: ${this.state.dryRun ? "Yes" : "No"}`,
         `- **Status**: ${toTitleCase(input.status)}`,
@@ -47,8 +48,8 @@ export function createMetaContent(input) {
     ];
     if (this.state.pr?.verdict)
         rows.push(`- **Verdict**: ${toTitleCase(this.state.pr.verdict.toLocaleLowerCase())}`);
-    if (this.state.text)
-        rows.push(`- **Last action**: ${this.state.text}`);
+    if (lastAction)
+        rows.push(`- **Last action**: ${lastAction}`);
     if (input.error)
         rows.push(`- **Error**: ${input.error}`);
     return rows;