@doist/doistbot-cli 1.0.6 → 1.0.8

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

@@ -1,4 +1,5 @@
-import { getReviewProviderCredential, hasReviewProviderCredential, } from '../../../providers/credentials.js';
+import { DEFAULT_GEMINI_FLASH_MODEL } from '../../../core/pi.js';
+import { getReviewProviderCredential, hasReviewProviderCredential, resolveReviewProviderCredential, } from '../../../providers/credentials.js';
 import { getProvider } from '../../../providers/index.js';
 import { getReviewThinkingLevel } from '../thinking-level.js';
 export function getApiKeys(ctx) {
@@ -6,6 +7,11 @@ export function getApiKeys(ctx) {
     for (const model of ctx.reviewModelsEnabled) {
         apiKeys[model] = ctx.apiKeys[model];
     }
+    // Gemini is a support credential for fallback, dedupe, and utility work. It
+    // does not need to be part of the routed primary model set.
+    if (ctx.apiKeys.gemini) {
+        apiKeys.gemini = ctx.apiKeys.gemini;
+    }
     return apiKeys;
 }
 export function getAvailableModels(apiKeys) {
@@ -20,6 +26,23 @@ export function getAvailableModels(apiKeys) {
         models.push('zai');
     return models;
 }
+export function getEnabledReviewModels(apiKeys, reviewModelsEnabled) {
+    return reviewModelsEnabled.filter((model) => hasReviewProviderCredential(apiKeys[model]));
+}
+export function getOpenRouterReviewCredential(...apiKeySets) {
+    for (const apiKeys of apiKeySets) {
+        if (!apiKeys) {
+            continue;
+        }
+        for (const credential of Object.values(apiKeys)) {
+            const resolved = resolveReviewProviderCredential(credential);
+            if (resolved?.piProviderId === 'openrouter') {
+                return credential;
+            }
+        }
+    }
+    return undefined;
+}
 export function getProviderFailures(results) {
     return results
         .filter((result) => result.error)
@@ -48,3 +71,15 @@ export async function requestModelReview({ model, prompt, apiKeys, workspaceDir,
         return null;
     }
 }
+// Resolves the gemini credential and stamps the flash model id onto it, so the
+// fallback pass runs flash via the existing apiKeys path (no extra param).
+export function buildGeminiFlashCredential(credential) {
+    const resolved = resolveReviewProviderCredential(credential);
+    if (!resolved)
+        return undefined;
+    // No piProviderId → always the Google provider (never OpenRouter) for Gemini.
+    return {
+        apiKey: resolved.apiKey,
+        modelName: DEFAULT_GEMINI_FLASH_MODEL,
+    };
+}

package/sandbox/dist/tasks/review/github-comment-format.js

@@ -8,7 +8,9 @@ export const PRIORITY_BADGE_URLS = {
 const PRIORITY_PREFIX_PATTERN = /^\s*\[(P[0-3])\]([^\S\r\n]*)(\r?\n)?/i;
 const PRIORITY_TAG_PATTERN = /\[(P[0-3])\]/gi;
 const PRIORITY_METADATA_PATTERN = /<!--\s*\[(P[0-3])\]\s*-->\s*(?:\[\1\]\s*)?/gi;
-const PRIORITY_BADGE_HTML_PATTERN = /(?:<a\b[^>]*>\s*)?<img\b(?=[^>]*\balt=["']P[0-3]["'])(?=[^>]*\bsrc=["']https:\/\/res\.cloudinary\.com\/dqrcfnzm9\/image\/upload\/v\d+\/p[0-3]_[^"']+\.svg["'])[^>]*>(?:\s*<\/a>)?([^\S\r\n]*)/gi;
+const PRIORITY_BADGE_HTML_SOURCE = String.raw `(?:<a\b[^>]*>\s*)?<img\b(?=[^>]*\balt=["']P[0-3]["'])(?=[^>]*\bsrc=["']https:\/\/res\.cloudinary\.com\/dqrcfnzm9\/image\/upload\/v\d+\/p[0-3]_[^"']+\.svg["'])[^>]*>(?:\s*<\/a>)?`;
+const PRIORITY_BADGE_WITH_METADATA_PATTERN = new RegExp(`${PRIORITY_BADGE_HTML_SOURCE}[^\\S\\r\\n]*<!--\\s*\\[(P[0-3])\\]\\s*-->([^\\S\\r\\n]*)`, 'gi');
+const PRIORITY_BADGE_HTML_PATTERN = new RegExp(`${PRIORITY_BADGE_HTML_SOURCE}([^\\S\\r\\n]*)`, 'gi');
 const PRIORITY_BADGE_ALT_PATTERN = /\balt=["'](P[0-3])["']/i;
 const INLINE_BADGE_SEPARATOR = '  ';
 export function renderPriorityBadge(severity) {
@@ -20,7 +22,7 @@ function renderPriorityMetadata(severity) {
     return `<!--[${severity}] -->`;
 }
 function renderPriorityBadgeWithMetadata(severity) {
-    return `${renderPriorityMetadata(severity)}${renderPriorityBadge(severity)}`;
+    return `${renderPriorityBadge(severity)}${renderPriorityMetadata(severity)}`;
 }
 function getOpeningFence(line) {
     const fence = line.match(/^ {0,3}(`{3,}|~{3,})/)?.[1];
@@ -70,13 +72,19 @@ export function formatGithubReviewSummary(body) {
         .join('');
 }
 export function normalizeGithubPriorityBadges(body) {
-    const normalizedBadges = body.replace(PRIORITY_BADGE_HTML_PATTERN, (badge, separator) => {
+    const normalizedBadgeMetadata = body.replace(PRIORITY_BADGE_WITH_METADATA_PATTERN, (badge, metadataSeverity, separator) => {
+        const badgeSeverity = badge.match(PRIORITY_BADGE_ALT_PATTERN)?.[1]?.toUpperCase();
+        const severity = metadataSeverity.toUpperCase();
+        return badgeSeverity === severity ? `[${severity}]${separator ? ' ' : ''}` : badge;
+    });
+    const normalizedBadges = normalizedBadgeMetadata.replace(PRIORITY_BADGE_HTML_PATTERN, (badge, separator) => {
         const severity = badge.match(PRIORITY_BADGE_ALT_PATTERN)?.[1]?.toUpperCase();
         return severity ? `[${severity}]${separator ? ' ' : ''}` : badge;
     });
-    return normalizedBadges.replace(PRIORITY_METADATA_PATTERN, (_match, severity) => {
+    const normalizedMetadata = normalizedBadges.replace(PRIORITY_METADATA_PATTERN, (_match, severity) => {
         return `[${severity.toUpperCase()}] `;
     });
+    return normalizedMetadata;
 }
 export function formatGithubReviewComments(comments) {
     return comments.map((comment) => ({

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

@@ -37,7 +37,12 @@ async function runLocalReviewWithLogging(input) {
         prAuthor: author,
         files,
         apiKeys: input.apiKeys,
-        reviewModelsEnabled: getDefaultReviewModels(),
+        reviewModelsEnabled: input.reviewModelsEnabled ?? getDefaultReviewModels(),
+        ...(input.reviewModelsByFocus ? { reviewModelsByFocus: input.reviewModelsByFocus } : {}),
+        ...(input.geminiFallbackFocuses
+            ? { geminiFallbackFocuses: input.geminiFallbackFocuses }
+            : {}),
+        ...(input.reviewSummaryModel ? { reviewSummaryModel: input.reviewSummaryModel } : {}),
         lowPriorityFindingPlacement: 'inline',
         workspaceDir: input.workspaceDir,
         onProgress: input.onProgress,

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

@@ -71,6 +71,9 @@ export async function summarizeReviewFindings({ credential, provider = 'zai', mo
         ...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,

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

@@ -1,18 +1,22 @@
 import { performance } from 'node:perf_hooks';
+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 { 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, 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 = getDefaultReviewModels();
+const REVIEW_FOCUSES = REVIEW_FOCUS_DEFINITIONS.map((focus) => focus.name);
 function optionalEnv(name) {
     const value = process.env[name]?.trim();
     return value ? value : undefined;
@@ -27,12 +31,50 @@ function parseContext() {
         geminiApiKey: optionalEnv('GEMINI_API_KEY'),
         openRouterApiKey: optionalEnv('OPENROUTER_API_KEY'),
         openaiApiKey: optionalEnv('OPENAI_KEY'),
-        reviewModelsEnabled: [...REQUIRED_PRODUCTION_REVIEW_MODELS],
+        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) {
@@ -43,7 +85,7 @@ function optionalNumberEnv(name) {
 }
 function getConversationSummaryApiKeys(ctx) {
     const apiKeys = {};
-    if (ctx.reviewModelsEnabled.includes('gemini') && ctx.geminiApiKey) {
+    if (ctx.geminiApiKey) {
         apiKeys.gemini = ctx.geminiApiKey;
     }
     if (ctx.reviewModelsEnabled.includes('openai') && ctx.openaiApiKey) {
@@ -63,83 +105,35 @@ 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,
-            checkRunId: ctx.reviewDispatchLockCheckRunId,
-        };
-        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).
-            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({
+    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,
@@ -147,133 +141,206 @@ async function main() {
                 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,
-            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,
+            };
+            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.
+            await postStaleReviewPointerIfHeadMoved({
+                octokit: checkRunOctokit,
                 owner: ctx.owner,
                 repo: ctx.repo,
                 pullNumber: ctx.prNumber,
-                prAuthor: pr.user?.login ?? undefined,
-                summaryApiKeys: getConversationSummaryApiKeys(ctx),
-                workspaceDir: WORKSPACE_DIR,
+                reviewedSha: ctx.headSha,
+                reviewedTitle: getReviewCheckRunTitle(input),
             });
         }
-        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,
-            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: [] },
+        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 {
-                await postFinalCheckRun({ conclusion: 'failure' });
+                // 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');
             }
-            return;
-        }
-        const { review } = reviewResult;
-        if (ctx.dryRun) {
-            logger.info('Dry run enabled, printing review output instead of posting to GitHub', {
-                commentsCount: review.comments.length,
+            await cloneRepository({
+                app,
+                owner: ctx.owner,
+                repo: ctx.repo,
+                prNumber: ctx.prNumber,
+                installationId: ctx.installationId,
             });
-            process.stdout.write(`${formatReviewForTerminal({
-                review,
-            })}\n`);
-        }
-        else {
-            await submitReview({
-                octokit: writeOctokit,
+            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,
-                pull_number: ctx.prNumber,
-                deliveryId: ctx.deliveryId,
-                review,
+                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,
             });
-            await postFinalCheckRun({ conclusion: 'success', review });
+            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 submitReview({
+                    octokit: writeOctokit,
+                    owner: ctx.owner,
+                    repo: ctx.repo,
+                    pull_number: ctx.prNumber,
+                    deliveryId: ctx.deliveryId,
+                    review,
+                });
+                await postFinalCheckRun({ conclusion: 'success', review });
+            }
+            logger.info('Review task completed');
+            reviewCompletedSuccessfully = true;
         }
-        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,
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            logger.error('Review failed', {
+                error: message,
             });
+            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;
         }
-    }
+        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);
     }