@doist/doistbot-cli 1.0.5 → 1.0.7

package/sandbox/dist/tasks/review/review-summary.js

@@ -51,7 +51,7 @@ Keep it human and compact: the opener should be 1 sentence, or 2 only if the PR
 Respond with only valid JSON in this exact shape:
 {"summary":"<your summary>","comments":[]}`;
 }
-export async function summarizeReviewFindings({ credential, prTitle, prBody, findings, reviewObservations, workspaceDir, requestReview = requestReviewSummary, }) {
+export async function summarizeReviewFindings({ credential, provider = 'zai', modelName, fallbackModels = [], prTitle, prBody, findings, reviewObservations, workspaceDir, requestReview = requestReviewSummary, }) {
     const prompt = buildReviewSummaryPrompt({
         prTitle,
         prBody,
@@ -62,15 +62,56 @@ export async function summarizeReviewFindings({ credential, prTitle, prBody, fin
         findingsCount: findings.length,
         reviewObservationsCount: reviewObservations?.length ?? 0,
     });
-    const result = await requestReview({ credential, prompt, workspaceDir });
-    const summary = result?.summary?.trim() ?? '';
-    if (!summary) {
-        logger.warn('Review summary model returned an empty summary', {
+    const summaryModels = [
+        {
+            provider,
+            credential,
+            ...(modelName ? { modelName } : {}),
+        },
+        ...fallbackModels,
+    ];
+    for (const [index, summaryModel] of summaryModels.entries()) {
+        // The `review.summary` span lives in requestReviewSummary, around the
+        // actual model invoke — so a missing-credential config error returns
+        // before any span and never shows a fake model attempt.
+        const result = await requestReview({
+            credential: summaryModel.credential,
+            provider: summaryModel.provider,
+            ...(summaryModel.modelName ? { modelName: summaryModel.modelName } : {}),
+            prompt,
+            workspaceDir,
+        });
+        if (result.status === 'failed') {
+            logger.warn('Review summary synthesis failed', {
+                findingsCount: findings.length,
+                reviewObservationsCount: reviewObservations?.length ?? 0,
+                failureReason: result.reason,
+                provider: summaryModel.provider,
+                ...(summaryModel.modelName ? { modelName: summaryModel.modelName } : {}),
+                attempt: index + 1,
+                attemptsTotal: summaryModels.length,
+                ...(result.error ? { error: result.error } : {}),
+                ...(result.timedOut !== undefined ? { timedOut: result.timedOut } : {}),
+                ...(result.durationMs !== undefined ? { durationMs: result.durationMs } : {}),
+                ...(result.outputChars !== undefined ? { outputChars: result.outputChars } : {}),
+            });
+            continue;
+        }
+        const summary = result.summary.trim();
+        logger.info('Review summary synthesis succeeded', {
             findingsCount: findings.length,
+            reviewObservationsCount: reviewObservations?.length ?? 0,
+            provider: summaryModel.provider,
+            ...(summaryModel.modelName ? { modelName: summaryModel.modelName } : {}),
+            attempt: index + 1,
+            attemptsTotal: summaryModels.length,
+            durationMs: result.durationMs,
+            outputChars: result.outputChars,
+            summaryChars: summary.length,
         });
-        return null;
+        return summary;
     }
-    return summary;
+    return null;
 }
 export function buildFallbackSummary({ prTitle, findings, }) {
     const safeTitle = prTitle.trim();

package/sandbox/dist/tasks/review/review.js

@@ -1,23 +1,22 @@
 import { performance } from 'node:perf_hooks';
-import { parseReviewModelsEnabled as parseConfiguredReviewModelsEnabled } from 'doistbot-repo-config';
+import { SpanStatusCode } from '@opentelemetry/api';
+import { getDefaultReviewModels } from 'doistbot-repo-config';
 import { recordTaskMetrics } from '../../core/datadog-metrics.js';
 import { logger } from '../../core/logging.js';
-import { createOpenRouterCredential } from '../../providers/credentials.js';
 import { cloneRepository, createGitHubClients, parseBaseContext, requiredEnv, WORKSPACE_DIR, } from '../../core/shared.js';
+import { withPhase } from '../../core/tracing.js';
+import { createOpenRouterCredential } from '../../providers/credentials.js';
 import { getReviewCheckRunTitle, isAnotherReviewInProgress, postReviewFailureCheckRun, postReviewInProgressCheckRun, postReviewSuccessCheckRun, postStaleReviewPointerIfHeadMoved, } from './check-run.js';
 import { fetchReviewConversationContext } from './conversation-context.js';
 import {} from './diff.js';
 import { formatReviewForTerminal } from './format.js';
-import { formatGithubReviewComments } from './github-comment-format.js';
+import { formatGithubReviewComments, formatGithubReviewSummary } from './github-comment-format.js';
+import { REVIEW_FOCUS_DEFINITIONS } from './multi-focus-prompt.js';
 import { appendReviewFeedbackLink } from './review-feedback.js';
 import { runSharedReview } from './runner.js';
 const REVIEW_EVENT = 'COMMENT';
-const REQUIRED_PRODUCTION_REVIEW_MODELS = ['gemini', 'openai'];
-function parseReviewModelsEnabled() {
-    // Parsed/defaulted in webhook-handler before being passed as task env.
-    const raw = process.env.REVIEW_MODELS_ENABLED;
-    return parseConfiguredReviewModelsEnabled(raw, { defaultModels: [] });
-}
+const REQUIRED_PRODUCTION_REVIEW_MODELS = getDefaultReviewModels();
+const REVIEW_FOCUSES = REVIEW_FOCUS_DEFINITIONS.map((focus) => focus.name);
 function optionalEnv(name) {
     const value = process.env[name]?.trim();
     return value ? value : undefined;
@@ -29,16 +28,65 @@ function parseContext() {
         branch: requiredEnv('BRANCH'),
         baseBranch: requiredEnv('BASE_BRANCH'),
         headSha: optionalEnv('HEAD_SHA'),
+        geminiApiKey: optionalEnv('GEMINI_API_KEY'),
         openRouterApiKey: optionalEnv('OPENROUTER_API_KEY'),
         openaiApiKey: optionalEnv('OPENAI_KEY'),
-        reviewModelsEnabled: parseReviewModelsEnabled(),
+        reviewModelsEnabled: parseReviewModelsEnv(process.env.REVIEW_MODELS_ENABLED),
+        reviewFocusesEnabled: parseReviewFocusesEnv(process.env.REVIEW_FOCUSES_ENABLED),
+        reviewRoutingCategory: optionalEnv('REVIEW_ROUTING_CATEGORY'),
+        reviewRoutingRuleId: optionalEnv('REVIEW_ROUTING_RULE_ID'),
+        reviewDispatchLockAcquired: process.env.REVIEW_DISPATCH_LOCK_ACQUIRED === 'true',
+        reviewDispatchLockCheckRunId: optionalNumberEnv('REVIEW_DISPATCH_LOCK_CHECK_RUN_ID'),
         dryRun: process.env.DRY_RUN?.toLowerCase() === 'true',
     };
 }
+export function parseReviewModelsEnv(value) {
+    return parseCsvAllowList({
+        value,
+        allowedValues: REQUIRED_PRODUCTION_REVIEW_MODELS,
+        fallback: REQUIRED_PRODUCTION_REVIEW_MODELS,
+        envName: 'REVIEW_MODELS_ENABLED',
+    });
+}
+export function parseReviewFocusesEnv(value) {
+    return parseCsvAllowList({
+        value,
+        allowedValues: REVIEW_FOCUSES,
+        fallback: REVIEW_FOCUSES,
+        envName: 'REVIEW_FOCUSES_ENABLED',
+    });
+}
+function parseCsvAllowList({ value, allowedValues, fallback, envName, }) {
+    if (value === undefined) {
+        return [...fallback];
+    }
+    const allowed = new Set(allowedValues);
+    const requested = value
+        .split(',')
+        .map((item) => item.trim())
+        .filter((item) => item.length > 0);
+    if (requested.length === 0) {
+        throw new Error(`${envName} must include at least one supported value when set.`);
+    }
+    const unsupported = requested.filter((item) => !allowed.has(item));
+    if (unsupported.length > 0) {
+        throw new Error(`${envName} contains unsupported value(s): ${[...new Set(unsupported)].join(', ')}. ` +
+            `Supported values: ${allowedValues.join(', ')}.`);
+    }
+    return [...new Set(requested)];
+}
+function optionalNumberEnv(name) {
+    const value = optionalEnv(name);
+    if (value === undefined) {
+        return undefined;
+    }
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
 function getConversationSummaryApiKeys(ctx) {
     const apiKeys = {};
-    if (ctx.reviewModelsEnabled.includes('gemini') && ctx.openRouterApiKey) {
-        apiKeys.gemini = createOpenRouterCredential(ctx.openRouterApiKey);
+    if (ctx.geminiApiKey) {
+        apiKeys.gemini = ctx.geminiApiKey;
     }
     if (ctx.reviewModelsEnabled.includes('openai') && ctx.openaiApiKey) {
         apiKeys.openai = ctx.openaiApiKey;
@@ -57,209 +105,242 @@ async function main() {
     logger.info('Review task started', {
         dryRun: ctx.dryRun,
         reviewModelsEnabled: ctx.reviewModelsEnabled,
+        reviewFocusesEnabled: ctx.reviewFocusesEnabled,
+        reviewRoutingCategory: ctx.reviewRoutingCategory,
+        reviewRoutingRuleId: ctx.reviewRoutingRuleId,
     });
-    const { app, readOctokit, writeOctokit } = await createGitHubClients(ctx);
-    // GitHub's Check Runs API requires App-installation auth; calling it with
-    // writeOctokit (the doistbot PAT) returns 403. Centralize the choice here
-    // so it can't drift as new Check Run call sites get added.
-    // See: https://docs.github.com/rest/checks/runs#create-a-check-run
-    const checkRunOctokit = readOctokit;
     let exitCode = 0;
     let reviewCompletedSuccessfully = false;
     let reviewMetricModels = [];
-    // Centralizes the boilerplate for posting the final Check Run from the
-    // ~7 cleanup paths in this function. Skips silently when no headSha is
-    // available (rare; logged at startup) or when running under dryRun.
-    async function postFinalCheckRun(input) {
-        if (ctx.dryRun || !ctx.headSha)
-            return;
-        const baseArgs = {
-            octokit: checkRunOctokit,
-            owner: ctx.owner,
-            repo: ctx.repo,
-            sha: ctx.headSha,
-            pullNumber: ctx.prNumber,
-            deliveryId: ctx.deliveryId,
-        };
-        if (input.conclusion === 'success') {
-            await postReviewSuccessCheckRun({ ...baseArgs, review: input.review });
-        }
-        else {
-            await postReviewFailureCheckRun(baseArgs);
-        }
-        // If the PR head moved during the review, also drop a neutral stale-
-        // pointer Check Run on the current head so reviewers can find their
-        // way back to the original. Closes the in-progress-during-push gap
-        // the webhook-side fix (#311) can't cover on its own — see the helper
-        // doc-comment for the full timeline this handles.
-        await postStaleReviewPointerIfHeadMoved({
-            octokit: checkRunOctokit,
-            owner: ctx.owner,
-            repo: ctx.repo,
-            pullNumber: ctx.prNumber,
-            reviewedSha: ctx.headSha,
-            reviewedTitle: getReviewCheckRunTitle(input),
-        });
-    }
-    try {
-        if (!ctx.dryRun && ctx.headSha) {
-            // Concurrency lock + "review running" signal both come from the
-            // same Check Run: an `in_progress` run is posted at start (and
-            // upserted to the final conclusion when the review completes).
-            //
-            // Caveat: the lock is keyed by the *triggering* SHA, but the
-            // review pipeline itself (cloneRepository / pulls.listFiles)
-            // operates on the PR's current head — they're not pinned to
-            // ctx.headSha. So a new commit landing during a review can slip
-            // past this lock and produce a duplicate review of the same final
-            // PR state. Cost is bounded (≤2× LLM per fast-push-during-review)
-            // and the case is rare; pinning the pipeline is its own follow-up
-            // (see PR #274's "Deferred" section, finding C2).
-            //
-            // There's also a small TOCTOU window between this check and the
-            // in_progress post — same race the prior comment-based lock had,
-            // and same bound (one duplicate review when it fires).
-            const otherInProgress = await isAnotherReviewInProgress({
+    await withPhase('review', {
+        task: 'review',
+        'gen_ai.operation.name': 'invoke_agent',
+        'gen_ai.agent.name': 'doistbot.review',
+        'pr.number': ctx.prNumber,
+        dry_run: ctx.dryRun,
+    }, async (span) => {
+        // Inside the span so installation-auth/setup failures are captured
+        // by the root `review` trace.
+        const { app, readOctokit, writeOctokit } = await createGitHubClients(ctx);
+        // GitHub's Check Runs API requires App-installation auth; calling it
+        // with writeOctokit (the doistbot PAT) returns 403. Centralize the
+        // choice here so it can't drift as new Check Run call sites get added.
+        // See: https://docs.github.com/rest/checks/runs#create-a-check-run
+        const checkRunOctokit = readOctokit;
+        // Centralizes the boilerplate for posting the final Check Run from the
+        // ~7 cleanup paths below. Skips silently when no headSha is available
+        // (rare; logged at startup) or when running under dryRun.
+        async function postFinalCheckRun(input) {
+            if (ctx.dryRun || !ctx.headSha)
+                return;
+            const baseArgs = {
                 octokit: checkRunOctokit,
                 owner: ctx.owner,
                 repo: ctx.repo,
                 sha: ctx.headSha,
+                pullNumber: ctx.prNumber,
                 deliveryId: ctx.deliveryId,
-            });
-            if (otherInProgress) {
-                logger.info('Another review is already in progress on this SHA, skipping');
-                return;
+                checkRunId: ctx.reviewDispatchLockCheckRunId,
+            };
+            if (input.conclusion === 'success') {
+                await postReviewSuccessCheckRun({ ...baseArgs, review: input.review });
+            }
+            else {
+                await postReviewFailureCheckRun(baseArgs);
             }
-            await postReviewInProgressCheckRun({
+            // If the PR head moved during the review, also drop a neutral
+            // stale-pointer Check Run on the current head so reviewers can
+            // find their way back to the original. Closes the in-progress-
+            // during-push gap the webhook-side fix (#311) can't cover on its
+            // own — see the helper doc-comment for the full timeline.
+            await postStaleReviewPointerIfHeadMoved({
                 octokit: checkRunOctokit,
                 owner: ctx.owner,
                 repo: ctx.repo,
-                sha: ctx.headSha,
                 pullNumber: ctx.prNumber,
-                deliveryId: ctx.deliveryId,
+                reviewedSha: ctx.headSha,
+                reviewedTitle: getReviewCheckRunTitle(input),
             });
         }
-        else if (ctx.dryRun) {
-            logger.info('Dry run enabled, skipping check-run posting');
-        }
-        else {
-            // No HEAD_SHA available — can't post Check Runs (which need a
-            // SHA) and can't lock. Reviews proceed unguarded; a rare
-            // simultaneous /review may double-bill on the same PR. Log so
-            // this is visible.
-            logger.warn('HEAD_SHA missing; review will proceed without a Check Run lock or status posting');
-        }
-        await cloneRepository({
-            app,
-            owner: ctx.owner,
-            repo: ctx.repo,
-            prNumber: ctx.prNumber,
-            installationId: ctx.installationId,
-        });
-        const [prResponse, files] = await Promise.all([
-            readOctokit.rest.pulls.get({
-                owner: ctx.owner,
-                repo: ctx.repo,
-                pull_number: ctx.prNumber,
-            }),
-            readOctokit.paginate(readOctokit.rest.pulls.listFiles, {
+        try {
+            if (!ctx.dryRun && ctx.headSha) {
+                // Concurrency lock + "review running" signal both come from the
+                // same Check Run: an `in_progress` run is posted at start (and
+                // upserted to the final conclusion when the review completes).
+                //
+                // Caveat: the lock is keyed by the *triggering* SHA, but the
+                // review pipeline itself (cloneRepository / pulls.listFiles)
+                // operates on the PR's current head — they're not pinned to
+                // ctx.headSha. So a new commit landing during a review can slip
+                // past this lock and produce a duplicate review of the same final
+                // PR state. Cost is bounded (≤2× LLM per fast-push-during-review)
+                // and the case is rare; pinning the pipeline is its own follow-up
+                // (see PR #274's "Deferred" section, finding C2).
+                //
+                // There's also a small TOCTOU window between this check and the
+                // in_progress post — same race the prior comment-based lock had,
+                // and same bound (one duplicate review when it fires).
+                if (!ctx.reviewDispatchLockAcquired) {
+                    const otherInProgress = await isAnotherReviewInProgress({
+                        octokit: checkRunOctokit,
+                        owner: ctx.owner,
+                        repo: ctx.repo,
+                        sha: ctx.headSha,
+                        deliveryId: ctx.deliveryId,
+                    });
+                    if (otherInProgress) {
+                        logger.info('Another review is already in progress on this SHA, skipping');
+                        return;
+                    }
+                }
+                await postReviewInProgressCheckRun({
+                    octokit: checkRunOctokit,
+                    owner: ctx.owner,
+                    repo: ctx.repo,
+                    sha: ctx.headSha,
+                    pullNumber: ctx.prNumber,
+                    deliveryId: ctx.deliveryId,
+                    checkRunId: ctx.reviewDispatchLockCheckRunId,
+                });
+            }
+            else if (ctx.dryRun) {
+                logger.info('Dry run enabled, skipping check-run posting');
+            }
+            else {
+                // No HEAD_SHA available — can't post Check Runs (which need a
+                // SHA) and can't lock. Reviews proceed unguarded; a rare
+                // simultaneous /review may double-bill on the same PR. Log so
+                // this is visible.
+                logger.warn('HEAD_SHA missing; review will proceed without a Check Run lock or status posting');
+            }
+            await cloneRepository({
+                app,
                 owner: ctx.owner,
                 repo: ctx.repo,
-                pull_number: ctx.prNumber,
-                per_page: 100,
-            }),
-        ]);
-        const pr = prResponse.data;
-        const prAuthor = pr.user?.login ?? 'unknown';
-        function loadPrConversation() {
-            return fetchReviewConversationContext({
-                octokit: readOctokit,
+                prNumber: ctx.prNumber,
+                installationId: ctx.installationId,
+            });
+            const [prResponse, files] = await Promise.all([
+                readOctokit.rest.pulls.get({
+                    owner: ctx.owner,
+                    repo: ctx.repo,
+                    pull_number: ctx.prNumber,
+                }),
+                readOctokit.paginate(readOctokit.rest.pulls.listFiles, {
+                    owner: ctx.owner,
+                    repo: ctx.repo,
+                    pull_number: ctx.prNumber,
+                    per_page: 100,
+                }),
+            ]);
+            const pr = prResponse.data;
+            const prAuthor = pr.user?.login ?? 'unknown';
+            function loadPrConversation() {
+                return fetchReviewConversationContext({
+                    octokit: readOctokit,
+                    owner: ctx.owner,
+                    repo: ctx.repo,
+                    pullNumber: ctx.prNumber,
+                    prAuthor: pr.user?.login ?? undefined,
+                    summaryApiKeys: getConversationSummaryApiKeys(ctx),
+                    workspaceDir: WORKSPACE_DIR,
+                });
+            }
+            reviewMetricModels = [...ctx.reviewModelsEnabled];
+            const reviewApiKeys = {};
+            if (ctx.geminiApiKey) {
+                reviewApiKeys.gemini = ctx.geminiApiKey;
+            }
+            if (ctx.openRouterApiKey) {
+                reviewApiKeys.deepseek = createOpenRouterCredential(ctx.openRouterApiKey);
+                reviewApiKeys.zai = createOpenRouterCredential(ctx.openRouterApiKey);
+            }
+            if (ctx.openaiApiKey) {
+                reviewApiKeys.openai = ctx.openaiApiKey;
+            }
+            const reviewResult = await runSharedReview({
                 owner: ctx.owner,
                 repo: ctx.repo,
-                pullNumber: ctx.prNumber,
-                prAuthor: pr.user?.login ?? undefined,
-                summaryApiKeys: getConversationSummaryApiKeys(ctx),
+                prNumber: ctx.prNumber,
+                branch: ctx.branch,
+                baseBranch: ctx.baseBranch,
+                prTitle: pr.title ?? '',
+                prBody: pr.body ?? '',
+                loadPrConversation,
+                prAuthor,
+                files: files,
+                apiKeys: reviewApiKeys,
+                reviewModelsEnabled: ctx.reviewModelsEnabled,
+                reviewFocusesEnabled: ctx.reviewFocusesEnabled,
+                requiredReviewModels: ctx.reviewModelsEnabled,
                 workspaceDir: WORKSPACE_DIR,
             });
-        }
-        reviewMetricModels = [...ctx.reviewModelsEnabled];
-        const reviewApiKeys = {};
-        if (ctx.openRouterApiKey) {
-            reviewApiKeys.gemini = createOpenRouterCredential(ctx.openRouterApiKey);
-        }
-        if (ctx.openaiApiKey) {
-            reviewApiKeys.openai = ctx.openaiApiKey;
-        }
-        const reviewResult = await runSharedReview({
-            owner: ctx.owner,
-            repo: ctx.repo,
-            prNumber: ctx.prNumber,
-            branch: ctx.branch,
-            baseBranch: ctx.baseBranch,
-            prTitle: pr.title ?? '',
-            prBody: pr.body ?? '',
-            loadPrConversation,
-            prAuthor,
-            files: files,
-            apiKeys: reviewApiKeys,
-            reviewModelsEnabled: ctx.reviewModelsEnabled,
-            requiredReviewModels: REQUIRED_PRODUCTION_REVIEW_MODELS,
-            workspaceDir: WORKSPACE_DIR,
-        });
-        reviewMetricModels = reviewResult.metricModels;
-        if (reviewResult.status === 'skipped') {
-            if (reviewResult.reason === 'no_diff' || reviewResult.reason === 'empty_diff') {
-                await postFinalCheckRun({
-                    conclusion: 'success',
-                    review: { summary: '', comments: [] },
+            reviewMetricModels = reviewResult.metricModels;
+            if (reviewResult.status === 'skipped') {
+                if (reviewResult.reason === 'no_diff' || reviewResult.reason === 'empty_diff') {
+                    await postFinalCheckRun({
+                        conclusion: 'success',
+                        review: { summary: '', comments: [] },
+                    });
+                }
+                else {
+                    // no_models / no_review / empty_review post a failing
+                    // check run, so the span must end ERROR to match — a
+                    // return-based failure won't trip withPhase's throw path.
+                    span.setStatus({
+                        code: SpanStatusCode.ERROR,
+                        message: `review skipped: ${reviewResult.reason}`,
+                    });
+                    await postFinalCheckRun({ conclusion: 'failure' });
+                }
+                return;
+            }
+            const { review } = reviewResult;
+            if (ctx.dryRun) {
+                logger.info('Dry run enabled, printing review output instead of posting to GitHub', {
+                    commentsCount: review.comments.length,
                 });
+                process.stdout.write(`${formatReviewForTerminal({
+                    review,
+                })}\n`);
             }
             else {
-                await postFinalCheckRun({ conclusion: 'failure' });
+                await submitReview({
+                    octokit: writeOctokit,
+                    owner: ctx.owner,
+                    repo: ctx.repo,
+                    pull_number: ctx.prNumber,
+                    deliveryId: ctx.deliveryId,
+                    review,
+                });
+                await postFinalCheckRun({ conclusion: 'success', review });
             }
-            return;
-        }
-        const { review } = reviewResult;
-        if (ctx.dryRun) {
-            logger.info('Dry run enabled, printing review output instead of posting to GitHub', {
-                commentsCount: review.comments.length,
-            });
-            process.stdout.write(`${formatReviewForTerminal({
-                review,
-            })}\n`);
+            logger.info('Review task completed');
+            reviewCompletedSuccessfully = true;
         }
-        else {
-            await submitReview({
-                octokit: writeOctokit,
-                owner: ctx.owner,
-                repo: ctx.repo,
-                pull_number: ctx.prNumber,
-                deliveryId: ctx.deliveryId,
-                review,
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            logger.error('Review failed', {
+                error: message,
             });
-            await postFinalCheckRun({ conclusion: 'success', review });
+            await postFinalCheckRun({ conclusion: 'failure' });
+            // Set the span status before the run exits; deferring process.exit
+            // until after withPhase lets phase.end flush.
+            span.setStatus({ code: SpanStatusCode.ERROR, message });
+            exitCode = 1;
         }
-        logger.info('Review task completed');
-        reviewCompletedSuccessfully = true;
-    }
-    catch (error) {
-        logger.error('Review failed', {
-            error: error instanceof Error ? error.message : String(error),
-        });
-        await postFinalCheckRun({ conclusion: 'failure' });
-        exitCode = 1;
-    }
-    finally {
-        if (reviewMetricModels.length > 0) {
-            await recordTaskMetrics({
-                type: 'review',
-                repository: `${ctx.owner}/${ctx.repo}`,
-                model: reviewMetricModels,
-                outcome: reviewCompletedSuccessfully ? 'success' : 'failure',
-                durationMs: performance.now() - startedAt,
-            });
+        finally {
+            if (reviewMetricModels.length > 0) {
+                await recordTaskMetrics({
+                    type: 'review',
+                    repository: `${ctx.owner}/${ctx.repo}`,
+                    model: reviewMetricModels,
+                    outcome: reviewCompletedSuccessfully ? 'success' : 'failure',
+                    durationMs: performance.now() - startedAt,
+                });
+            }
         }
-    }
+    });
     if (exitCode !== 0) {
         process.exit(exitCode);
     }
@@ -272,7 +353,7 @@ async function submitReview({ octokit, owner, repo, pull_number, deliveryId, rev
         event: REVIEW_EVENT,
     };
     if (review.summary?.length) {
-        const summaryWithFeedbackLink = appendReviewFeedbackLink(review.summary, {
+        const summaryWithFeedbackLink = appendReviewFeedbackLink(formatGithubReviewSummary(review.summary), {
             owner,
             repo,
             prNumber: pull_number,