@doist/doistbot-cli 1.0.5 → 1.0.6

package/sandbox/dist/tasks/review/check-run.js

@@ -135,7 +135,7 @@ export function buildSuccessSummary(review, pullRequestUrl, counts = countFindin
  * PR conversation comment.
  */
 async function postReviewCheckRun(params) {
-    const { octokit, owner, repo, sha, pullNumber, deliveryId, title, summaryBody } = params;
+    const { octokit, owner, repo, sha, pullNumber, deliveryId, checkRunId, title, summaryBody } = params;
     const pullRequestUrl = `https://github.com/${owner}/${repo}/pull/${pullNumber}`;
     const summary = appendReviewFeedbackLink(summaryBody, {
         owner,
@@ -153,6 +153,7 @@ async function postReviewCheckRun(params) {
         detailsUrl: pullRequestUrl,
         name: CHECK_RUN_NAME,
         externalId: deliveryId,
+        checkRunId,
     };
     if (params.status === 'in_progress') {
         await postCheckRun({ ...sharedArgs, status: 'in_progress' });

package/sandbox/dist/tasks/review/conversation-context.js

@@ -4,6 +4,7 @@ import { logger } from '../../core/logging.js';
 import { invokePiPrompt } from '../../core/pi.js';
 import { WORKSPACE_DIR } from '../../core/shared.js';
 import { resolveReviewProviderCredential } from '../../providers/credentials.js';
+import { normalizeGithubPriorityBadges } from './github-comment-format.js';
 import { stripReviewFeedbackFooter } from './review-feedback.js';
 // Roughly 6k tokens: large enough for substantive PR discussions while still
 // keeping conversation context secondary to the diff.
@@ -36,7 +37,7 @@ function shouldMaskPrAuthor(login, prAuthor) {
     return Boolean(normalizedLogin && normalizedPrAuthor && normalizedLogin === normalizedPrAuthor);
 }
 function cleanBody(body) {
-    return stripReviewFeedbackFooter(body);
+    return normalizeGithubPriorityBadges(stripReviewFeedbackFooter(body));
 }
 function toIssueCommentEntry(comment) {
     const author = comment.user?.login ?? 'unknown';

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

@@ -7,6 +7,7 @@ import { isDedupeResponse } from '../../../providers/schemas.js';
 const DEDUPE_TIMEOUT_MS = 5 * 60 * 1000;
 const DEDUPE_PROVIDER = 'gemini';
 const DEDUPE_MODEL_BY_PI_PROVIDER = {
+    google: 'gemini-3-flash-preview',
     openrouter: 'google/gemini-3-flash-preview',
 };
 const DEDUPE_THINKING_LEVEL = 'medium';
@@ -116,7 +117,7 @@ export async function dedupeMultiFocusFindings({ findings, availableModels, work
     if (!availableModels.includes(DEDUPE_PROVIDER)) {
         logger.error('Multi-focus dedupe unavailable because Gemini is not enabled', {
             provider: DEDUPE_PROVIDER,
-            model: DEDUPE_MODEL_BY_PI_PROVIDER.openrouter,
+            model: DEDUPE_MODEL_BY_PI_PROVIDER.google,
         });
         throw new Error('Multi-focus dedupe requires Gemini to be enabled');
     }
@@ -124,16 +125,16 @@ export async function dedupeMultiFocusFindings({ findings, availableModels, work
     if (!credential) {
         logger.error('Multi-focus dedupe unavailable because Gemini review credential is unavailable', {
             provider: DEDUPE_PROVIDER,
-            model: DEDUPE_MODEL_BY_PI_PROVIDER.openrouter,
+            model: DEDUPE_MODEL_BY_PI_PROVIDER.google,
         });
         throw new Error('Multi-focus dedupe requires a Gemini review credential');
     }
-    const piProviderId = credential.piProviderId ?? 'openrouter';
+    const piProviderId = credential.piProviderId ?? 'google';
     const providerConfig = {
         provider: DEDUPE_PROVIDER,
         apiKey: credential.apiKey,
         ...(credential.piProviderId ? { piProviderId: credential.piProviderId } : {}),
-        modelName: DEDUPE_MODEL_BY_PI_PROVIDER[piProviderId] ?? DEDUPE_MODEL_BY_PI_PROVIDER.openrouter,
+        modelName: DEDUPE_MODEL_BY_PI_PROVIDER[piProviderId] ?? DEDUPE_MODEL_BY_PI_PROVIDER.google,
     };
     for (let attempt = 1; attempt <= DEDUPE_MAX_ATTEMPTS; attempt += 1) {
         let result;

package/sandbox/dist/tasks/review/engines/multi-focus.js

@@ -4,16 +4,25 @@ import { buildReviewOutputFindings } from '../finding-output.js';
 import { buildMultiFocusPrompt, REVIEW_FOCUS_DEFINITIONS, } from '../multi-focus-prompt.js';
 import { buildFallbackSummary, summarizeReviewFindings } from '../review-summary.js';
 import { parseSeverity } from '../severity.js';
+import { buildGeminiFlashReviewSummaryModel } from '../summary-model.js';
 import { dedupeMultiFocusFindings } from './dedupe.js';
 import { getApiKeys, getAvailableModels, getProviderFailures, requestModelReview, } from './shared.js';
+const DEFAULT_REVIEW_MODELS_BY_FOCUS = {
+    general: ['gemini', 'openai'],
+    quality: ['gemini', 'openai'],
+    efficiency: ['gemini', 'openai'],
+    tests: ['deepseek', 'zai'],
+    standards: ['deepseek', 'zai'],
+};
 const LOW_PRIORITY_SUMMARY_NOTICE = 'I also included a few optional follow-up notes in the details below.';
-async function runFocusPass({ focus, model, basePrompt, standardsSection, apiKeys, workspaceDir, onProgress, }) {
+async function runFocusPass({ focus, model, basePrompt, standardsSection, apiKeys, workspaceDir, openRouterSessionId, onProgress, }) {
     const prompt = buildMultiFocusPrompt(basePrompt, focus, standardsSection);
     const result = await requestModelReview({
         model,
         prompt,
         apiKeys,
         workspaceDir,
+        openRouterSessionId,
         onProgress,
     });
     if (!result) {
@@ -94,6 +103,10 @@ function collectReviewObservations(focusRuns) {
     }
     return observations.slice(0, 8);
 }
+function getModelsForFocus(focus, availableModels) {
+    const preferredModels = DEFAULT_REVIEW_MODELS_BY_FOCUS[focus.name];
+    return preferredModels.filter((model) => availableModels.includes(model));
+}
 function formatSummaryOnlyFinding(finding) {
     const severity = parseSeverity(finding.body);
     const bodyWithoutSeverity = finding.body.replace(/^\s*\[P\d\]\s*/i, '').trim();
@@ -115,10 +128,24 @@ function appendSummaryOnlyFindings(summary, summaryFindings) {
     const title = `Optional follow-up note${notes.length === 1 ? '' : 's'} (${notes.length})`;
     return `${summary.trim()}\n\n${LOW_PRIORITY_SUMMARY_NOTICE}\n\n<details>\n<summary>${title}</summary>\n\n${notes.join('\n')}\n\n</details>`;
 }
-async function buildMultiFocusReviewOutput({ inlineFindings, summaryFindings, lineLookup, prTitle, prBody, reviewObservations, summaryCredential, workspaceDir, }) {
+function buildSummarySynthesisFindings({ inlineFindings, summaryFindings, }) {
+    return Array.from(new Set([
+        ...inlineFindings.map((finding) => finding.body.trim()),
+        ...summaryFindings.map((finding) => formatSummaryOnlyFinding(finding)),
+    ].filter(Boolean)));
+}
+async function buildMultiFocusReviewOutput({ inlineFindings, summaryFindings, lineLookup, prTitle, prBody, reviewObservations, summaryCredential, summaryFallbackModels, workspaceDir, }) {
     const comments = convertFindingsToComments(inlineFindings, lineLookup);
-    const findings = Array.from(new Set(comments.map((comment) => comment.body.trim()).filter(Boolean)));
-    const synthesizedSummary = summaryCredential == null
+    const inlineCommentFindings = Array.from(new Set(comments.map((comment) => comment.body.trim()).filter(Boolean)));
+    const findings = buildSummarySynthesisFindings({ inlineFindings, summaryFindings });
+    const hasReviewFindings = inlineFindings.length > 0 || summaryFindings.length > 0;
+    if (!hasReviewFindings) {
+        logger.info('Review summary synthesis skipped for clean review', {
+            inlineFindingsCount: inlineFindings.length,
+            summaryFindingsCount: summaryFindings.length,
+        });
+    }
+    const synthesizedSummary = summaryCredential == null || !hasReviewFindings
         ? null
         : await summarizeReviewFindings({
             credential: summaryCredential,
@@ -127,13 +154,14 @@ async function buildMultiFocusReviewOutput({ inlineFindings, summaryFindings, li
             prBody,
             findings,
             reviewObservations,
+            fallbackModels: summaryFallbackModels,
         });
     const summaryWithoutNotes = synthesizedSummary ||
-        (comments.length === 0 && summaryFindings.length > 0
+        (comments.length === 0 && hasReviewFindings
             ? buildNoInlineSummaryWithNotes(prTitle)
             : buildFallbackSummary({
                 prTitle,
-                findings,
+                findings: inlineCommentFindings,
             }));
     return {
         summary: appendSummaryOnlyFindings(summaryWithoutNotes, summaryFindings),
@@ -158,13 +186,14 @@ export async function runMultiFocusReviewEngine({ ctx, prompt, lineLookup, prTit
             providerFailures: [],
         };
     }
-    const focusRuns = await Promise.all(REVIEW_FOCUS_DEFINITIONS.flatMap((focus) => availableModels.map((model) => runFocusPass({
+    const focusRuns = await Promise.all(REVIEW_FOCUS_DEFINITIONS.flatMap((focus) => getModelsForFocus(focus, availableModels).map((model) => runFocusPass({
         focus,
         model,
         basePrompt: prompt,
         standardsSection,
         apiKeys,
         workspaceDir: ctx.workspaceDir,
+        openRouterSessionId: ctx.openRouterSessionId,
         onProgress,
     }))));
     const successfulRuns = focusRuns.filter((run) => run.status === 'succeeded');
@@ -194,7 +223,7 @@ export async function runMultiFocusReviewEngine({ ctx, prompt, lineLookup, prTit
             findings: allFindings,
             availableModels,
             workspaceDir: ctx.workspaceDir,
-            geminiCredential: ctx.geminiCredential,
+            geminiCredential: apiKeys.gemini,
         });
     }
     catch (error) {
@@ -204,6 +233,7 @@ export async function runMultiFocusReviewEngine({ ctx, prompt, lineLookup, prTit
         });
     }
     const routedFindings = routeLowPriorityFindings(dedupedFindings, lowPriorityFindingPlacement);
+    const geminiSummaryFallback = buildGeminiFlashReviewSummaryModel(apiKeys.gemini);
     const review = await buildMultiFocusReviewOutput({
         inlineFindings: routedFindings.inlineFindings,
         summaryFindings: routedFindings.summaryFindings,
@@ -211,7 +241,8 @@ export async function runMultiFocusReviewEngine({ ctx, prompt, lineLookup, prTit
         prTitle,
         prBody,
         reviewObservations,
-        summaryCredential: apiKeys.gemini,
+        summaryCredential: apiKeys.zai,
+        summaryFallbackModels: geminiSummaryFallback ? [geminiSummaryFallback] : [],
         workspaceDir: ctx.workspaceDir,
     });
     logger.info('Multi-focus review completed', {

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

@@ -3,11 +3,8 @@ import { getProvider } from '../../../providers/index.js';
 import { getReviewThinkingLevel } from '../thinking-level.js';
 export function getApiKeys(ctx) {
     const apiKeys = {};
-    if (ctx.reviewModelsEnabled.includes('gemini')) {
-        apiKeys.gemini = ctx.geminiCredential;
-    }
-    if (ctx.reviewModelsEnabled.includes('openai')) {
-        apiKeys.openai = ctx.openaiApiKey;
+    for (const model of ctx.reviewModelsEnabled) {
+        apiKeys[model] = ctx.apiKeys[model];
     }
     return apiKeys;
 }
@@ -17,6 +14,10 @@ export function getAvailableModels(apiKeys) {
         models.push('gemini');
     if (hasReviewProviderCredential(apiKeys.openai))
         models.push('openai');
+    if (hasReviewProviderCredential(apiKeys.deepseek))
+        models.push('deepseek');
+    if (hasReviewProviderCredential(apiKeys.zai))
+        models.push('zai');
     return models;
 }
 export function getProviderFailures(results) {
@@ -27,7 +28,7 @@ export function getProviderFailures(results) {
         error: result.error,
     }));
 }
-export async function requestModelReview({ model, prompt, apiKeys, workspaceDir, onProgress, }) {
+export async function requestModelReview({ model, prompt, apiKeys, workspaceDir, openRouterSessionId, onProgress, }) {
     const credential = getReviewProviderCredential(apiKeys, model);
     if (!credential) {
         return null;
@@ -37,6 +38,7 @@ export async function requestModelReview({ model, prompt, apiKeys, workspaceDir,
         ...credential,
         workspaceDir,
         thinkingLevel: getReviewThinkingLevel(model),
+        openRouterSessionId,
         onProgress,
     };
     try {

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

@@ -1,28 +1,82 @@
 import { parseSeverity } from './severity.js';
-const PRIORITY_BADGE_LABELS = {
-    P0: '🔴 P0',
-    P1: '🟠 P1',
-    P2: '🟡 P2',
+export const PRIORITY_BADGE_URLS = {
+    P0: 'https://res.cloudinary.com/dqrcfnzm9/image/upload/v1779779477/p0_xezwrq.svg',
+    P1: 'https://res.cloudinary.com/dqrcfnzm9/image/upload/v1779779477/p1_iqydtr.svg',
+    P2: 'https://res.cloudinary.com/dqrcfnzm9/image/upload/v1779779477/p2_skkn6d.svg',
+    P3: 'https://res.cloudinary.com/dqrcfnzm9/image/upload/v1782200379/p3_syntlm.svg',
 };
 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_ALT_PATTERN = /\balt=["'](P[0-3])["']/i;
 const INLINE_BADGE_SEPARATOR = '  ';
 export function renderPriorityBadge(severity) {
-    const label = PRIORITY_BADGE_LABELS[severity];
-    if (!label) {
+    const badgeUrl = PRIORITY_BADGE_URLS[severity];
+    // GitHub auto-links bare images to the asset, so keep an explicit anchor around the badge.
+    return `<a href="#"><img alt="${severity}" src="${badgeUrl}" align="top"></a>`;
+}
+function renderPriorityMetadata(severity) {
+    return `<!--[${severity}] -->`;
+}
+function renderPriorityBadgeWithMetadata(severity) {
+    return `${renderPriorityMetadata(severity)}${renderPriorityBadge(severity)}`;
+}
+function getOpeningFence(line) {
+    const fence = line.match(/^ {0,3}(`{3,}|~{3,})/)?.[1];
+    if (!fence) {
         return null;
     }
-    return `<big><kbd>${label}</kbd></big>`;
+    return {
+        marker: fence[0],
+        length: fence.length,
+    };
+}
+function isClosingFence(line, activeFence) {
+    const fence = line.match(/^ {0,3}(`{3,}|~{3,})\s*$/)?.[1];
+    return fence?.[0] === activeFence.marker && fence.length >= activeFence.length;
 }
 export function formatGithubReviewCommentBody(body) {
     const match = body.match(PRIORITY_PREFIX_PATTERN);
     const severity = match ? parseSeverity(match[0]) : null;
-    const badge = severity ? renderPriorityBadge(severity) : null;
-    if (!match || !badge) {
+    if (!match || !severity) {
         return body;
     }
     const separator = match[3] ?? INLINE_BADGE_SEPARATOR;
     const content = body.slice(match[0].length);
-    return `${badge}${separator}${content}`;
+    return `${renderPriorityBadgeWithMetadata(severity)}${separator}${content}`;
+}
+export function formatGithubReviewSummary(body) {
+    const parts = body.split(/(\r?\n)/);
+    let activeFence = null;
+    return parts
+        .map((part) => {
+        if (/^\r?\n$/.test(part)) {
+            return part;
+        }
+        if (activeFence) {
+            if (isClosingFence(part, activeFence)) {
+                activeFence = null;
+            }
+            return part;
+        }
+        const openingFence = getOpeningFence(part);
+        if (openingFence) {
+            activeFence = openingFence;
+            return part;
+        }
+        return normalizeGithubPriorityBadges(part).replace(PRIORITY_TAG_PATTERN, (_tag, severity) => renderPriorityBadgeWithMetadata(severity.toUpperCase()));
+    })
+        .join('');
+}
+export function normalizeGithubPriorityBadges(body) {
+    const normalizedBadges = body.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) => {
+        return `[${severity.toUpperCase()}] `;
+    });
 }
 export function formatGithubReviewComments(comments) {
     return comments.map((comment) => ({

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

@@ -1,4 +1,4 @@
-import { parseReviewModelsEnabled } from 'doistbot-repo-config';
+import { getDefaultReviewModels } from 'doistbot-repo-config';
 import { logger, withInfoLogsSuppressed, withLogsSuppressed } from '../../core/logging.js';
 import {} from './diff.js';
 import { createGitRunner, getLocalReviewFiles, resolveLocalAuthor, resolveRepositoryMetadata, tryGit, } from './local-git.js';
@@ -37,9 +37,7 @@ async function runLocalReviewWithLogging(input) {
         prAuthor: author,
         files,
         apiKeys: input.apiKeys,
-        reviewModelsEnabled: parseReviewModelsEnabled(process.env.REVIEW_MODELS_ENABLED, {
-            requiredModels: [],
-        }),
+        reviewModelsEnabled: getDefaultReviewModels(),
         lowPriorityFindingPlacement: 'inline',
         workspaceDir: input.workspaceDir,
         onProgress: input.onProgress,

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,53 @@ 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()) {
+        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,18 @@
 import { performance } from 'node:perf_hooks';
-import { parseReviewModelsEnabled as parseConfiguredReviewModelsEnabled } from 'doistbot-repo-config';
+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 { 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 { 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();
 function optionalEnv(name) {
     const value = process.env[name]?.trim();
     return value ? value : undefined;
@@ -29,16 +24,27 @@ 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: [...REQUIRED_PRODUCTION_REVIEW_MODELS],
+        reviewDispatchLockAcquired: process.env.REVIEW_DISPATCH_LOCK_ACQUIRED === 'true',
+        reviewDispatchLockCheckRunId: optionalNumberEnv('REVIEW_DISPATCH_LOCK_CHECK_RUN_ID'),
         dryRun: process.env.DRY_RUN?.toLowerCase() === 'true',
     };
 }
+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.reviewModelsEnabled.includes('gemini') && ctx.geminiApiKey) {
+        apiKeys.gemini = ctx.geminiApiKey;
     }
     if (ctx.reviewModelsEnabled.includes('openai') && ctx.openaiApiKey) {
         apiKeys.openai = ctx.openaiApiKey;
@@ -80,6 +86,7 @@ async function main() {
             sha: ctx.headSha,
             pullNumber: ctx.prNumber,
             deliveryId: ctx.deliveryId,
+            checkRunId: ctx.reviewDispatchLockCheckRunId,
         };
         if (input.conclusion === 'success') {
             await postReviewSuccessCheckRun({ ...baseArgs, review: input.review });
@@ -119,16 +126,18 @@ async function main() {
             // 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({
-                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;
+            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,
@@ -137,6 +146,7 @@ async function main() {
                 sha: ctx.headSha,
                 pullNumber: ctx.prNumber,
                 deliveryId: ctx.deliveryId,
+                checkRunId: ctx.reviewDispatchLockCheckRunId,
             });
         }
         else if (ctx.dryRun) {
@@ -184,8 +194,12 @@ async function main() {
         }
         reviewMetricModels = [...ctx.reviewModelsEnabled];
         const reviewApiKeys = {};
+        if (ctx.geminiApiKey) {
+            reviewApiKeys.gemini = ctx.geminiApiKey;
+        }
         if (ctx.openRouterApiKey) {
-            reviewApiKeys.gemini = createOpenRouterCredential(ctx.openRouterApiKey);
+            reviewApiKeys.deepseek = createOpenRouterCredential(ctx.openRouterApiKey);
+            reviewApiKeys.zai = createOpenRouterCredential(ctx.openRouterApiKey);
         }
         if (ctx.openaiApiKey) {
             reviewApiKeys.openai = ctx.openaiApiKey;
@@ -272,7 +286,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,

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

@@ -1,3 +1,4 @@
+import { createHash } from 'crypto';
 import fs from 'fs';
 import { logger } from '../../core/logging.js';
 import { hasReviewProviderCredential } from '../../providers/credentials.js';
@@ -8,6 +9,7 @@ import { buildMultiFocusSharedPrompt } from './multi-focus-prompt.js';
 import { loadStandardsSection } from './prompt.js';
 const REVIEW_GUIDANCE_FILES = ['AGENTS.md', 'CLAUDE.md', 'GEMINI.md'];
 const MASKED_PR_AUTHOR_LABEL = 'PR author';
+const OPENROUTER_SESSION_REPO_SEGMENT_MAX_LENGTH = 96;
 function getGuidanceFilePresence(workspaceDir) {
     return Object.fromEntries(REVIEW_GUIDANCE_FILES.map((fileName) => [
         fileName,
@@ -53,6 +55,20 @@ function getEnabledReviewModels({ apiKeys, reviewModelsEnabled, }) {
 function getMissingRequiredReviewModels(availableModels, requiredReviewModels = []) {
     return requiredReviewModels.filter((model) => !availableModels.includes(model));
 }
+function toOpenRouterSessionSegment(value, fallback) {
+    const normalized = value
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9._-]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .slice(0, OPENROUTER_SESSION_REPO_SEGMENT_MAX_LENGTH);
+    return normalized || fallback;
+}
+export function buildOpenRouterReviewSessionId({ owner, repo, prNumber, prompt, }) {
+    const repoSegment = toOpenRouterSessionSegment(`${owner}-${repo}`, 'repo');
+    const promptHash = createHash('sha256').update(prompt).digest('hex').slice(0, 32);
+    return `doistbot-review-${repoSegment}-pr-${prNumber}-${promptHash}`;
+}
 export async function runSharedReview(input) {
     const { annotatedFiles, lineLookup } = buildAnnotatedDiff(input.files);
     if (annotatedFiles.length === 0) {
@@ -134,9 +150,14 @@ export async function runSharedReview(input) {
         repo: input.repo,
         prNumber: input.prNumber,
         workspaceDir: input.workspaceDir,
-        geminiCredential: input.apiKeys.gemini,
-        openaiApiKey: input.apiKeys.openai,
+        apiKeys: input.apiKeys,
         reviewModelsEnabled: input.reviewModelsEnabled,
+        openRouterSessionId: buildOpenRouterReviewSessionId({
+            owner: input.owner,
+            repo: input.repo,
+            prNumber: input.prNumber,
+            prompt,
+        }),
     };
     const { review, availableModels, metricModels, mode, providerFailures } = await runMultiFocusReviewEngine({
         ctx: engineContext,