@doist/doistbot-cli 1.0.5 → 1.0.7

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

@@ -1,56 +1,127 @@
+import { SpanStatusCode } from '@opentelemetry/api';
 import { logger } from '../../../core/logging.js';
+import { genAiProviderName, withPhase } from '../../../core/tracing.js';
 import { convertFindingsToComments } from '../comment-mapper.js';
 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';
+import { buildGeminiFlashCredential, getApiKeys, getAvailableModels, getEnabledReviewModels, getOpenRouterReviewCredential, getProviderFailures, requestModelReview, } from './shared.js';
+const DEFAULT_REVIEW_MODELS_BY_FOCUS = {
+    general: ['deepseek', 'zai', 'openai'],
+    quality: ['deepseek', 'zai', 'openai'],
+    efficiency: ['deepseek', 'zai', 'openai'],
+    tests: ['deepseek', 'zai'],
+    standards: ['deepseek', 'zai'],
+};
+// Default Gemini-flash pass on failure. tests/standards keep no fallback unless
+// a caller opts into a wider fallback set.
+const DEFAULT_GEMINI_FLASH_FALLBACK_FOCUSES = [
+    'general',
+    'quality',
+    'efficiency',
+];
+// Open models whose failed pass triggers that fallback.
+const GEMINI_FLASH_FALLBACK_MODELS = ['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, }) {
-    const prompt = buildMultiFocusPrompt(basePrompt, focus, standardsSection);
-    const result = await requestModelReview({
-        model,
-        prompt,
-        apiKeys,
-        workspaceDir,
-        onProgress,
-    });
-    if (!result) {
-        logger.warn('Multi-focus review pass failed without a result', {
-            focus: focus.name,
-            model,
-        });
-        return {
-            status: 'failed',
-            focus: focus.name,
+// Workflow phase orchestrating the council fan-out; one model span per pass.
+const MULTI_FOCUS_PHASE = 'review.multi-focus';
+const FOCUS_PASS_PHASE = 'review.focus-pass';
+async function runFocusPass({ focus, model, basePrompt, standardsSection, apiKeys, workspaceDir, openRouterSessionId, onProgress, }) {
+    // One model span per council pass. Started concurrently inside the engine's
+    // Promise.all, but withPhase captures the active context at span start, so
+    // each parents to `review.multi-focus` without nesting under a sibling.
+    // Provider is known now; the resolved model only after the invoke (via
+    // ModelReviewResult.requestModel), so request.model is stamped on return.
+    return withPhase(FOCUS_PASS_PHASE, {
+        'gen_ai.operation.name': 'chat',
+        'gen_ai.provider.name': genAiProviderName(model),
+        'review.focus': focus.name,
+    }, async (span) => {
+        const prompt = buildMultiFocusPrompt(basePrompt, focus, standardsSection);
+        const result = await requestModelReview({
             model,
-            error: `No review result returned for ${model}`,
-        };
-    }
-    if (result.error) {
-        logger.warn('Multi-focus review pass failed', {
-            focus: focus.name,
-            model,
-            error: result.error,
+            prompt,
+            apiKeys,
+            workspaceDir,
+            openRouterSessionId,
+            onProgress,
         });
+        if (result?.requestModel) {
+            span.setAttributes({ 'gen_ai.request.model': result.requestModel });
+        }
+        if (!result) {
+            const error = `No review result returned for ${model}`;
+            span.setStatus({ code: SpanStatusCode.ERROR, message: error });
+            logger.warn('Multi-focus review pass failed without a result', {
+                focus: focus.name,
+                model,
+            });
+            return {
+                status: 'failed',
+                focus: focus.name,
+                model,
+                error,
+            };
+        }
+        if (result.error) {
+            span.setStatus({ code: SpanStatusCode.ERROR, message: result.error });
+            logger.warn('Multi-focus review pass failed', {
+                focus: focus.name,
+                model,
+                error: result.error,
+            });
+            return {
+                status: 'failed',
+                focus: focus.name,
+                model,
+                error: result.error,
+            };
+        }
         return {
-            status: 'failed',
+            status: 'succeeded',
             focus: focus.name,
             model,
-            error: result.error,
+            summary: result.summary.trim(),
+            findings: result.findings.map((finding) => ({
+                ...finding,
+                focus: focus.name,
+            })),
         };
-    }
-    return {
-        status: 'succeeded',
-        focus: focus.name,
+    });
+}
+// Runs a focus's primary passes, then at most one Gemini-flash fallback pass for
+// that focus when a fallback-eligible primary failed and gemini is available.
+async function runFocusGroup({ focus, models, basePrompt, standardsSection, apiKeys, hasGeminiFallback, geminiFallbackFocuses, workspaceDir, openRouterSessionId, onProgress, }) {
+    const primaryRuns = await Promise.all(models.map((model) => runFocusPass({
+        focus,
         model,
-        summary: result.summary.trim(),
-        findings: result.findings.map((finding) => ({
-            ...finding,
-            focus: focus.name,
-        })),
-    };
+        basePrompt,
+        standardsSection,
+        apiKeys,
+        workspaceDir,
+        openRouterSessionId,
+        onProgress,
+    })));
+    const fallbackEligibleFailed = geminiFallbackFocuses.includes(focus.name) &&
+        primaryRuns.some((run) => run.status === 'failed' && GEMINI_FLASH_FALLBACK_MODELS.includes(run.model));
+    const flashAlreadyRan = models.includes('gemini');
+    if (!fallbackEligibleFailed || flashAlreadyRan || !hasGeminiFallback) {
+        return primaryRuns;
+    }
+    const flashRun = await runFocusPass({
+        focus,
+        model: 'gemini',
+        basePrompt,
+        standardsSection,
+        apiKeys: { ...apiKeys, gemini: buildGeminiFlashCredential(apiKeys.gemini) },
+        workspaceDir,
+        openRouterSessionId,
+        onProgress,
+    });
+    return [...primaryRuns, flashRun];
 }
 function routeLowPriorityFindings(findings, placement = 'summary') {
     if (placement === 'inline') {
@@ -94,6 +165,25 @@ function collectReviewObservations(focusRuns) {
     }
     return observations.slice(0, 8);
 }
+function getModelsForFocus(focus, availableModels, modelsByFocus = DEFAULT_REVIEW_MODELS_BY_FOCUS) {
+    const preferredModels = modelsByFocus[focus.name] ?? DEFAULT_REVIEW_MODELS_BY_FOCUS[focus.name];
+    const models = preferredModels.filter((model) => availableModels.includes(model));
+    // Last resort: a focus has no configured open/openai primary but Gemini is
+    // available (e.g. a Gemini-only local/CLI setup). Run Gemini so the review
+    // still produces a result instead of falling through to `review: null`.
+    if (models.length === 0 && availableModels.includes('gemini')) {
+        return ['gemini'];
+    }
+    return models;
+}
+function getEnabledFocusDefinitions(enabledFocuses) {
+    if (!enabledFocuses?.length) {
+        return REVIEW_FOCUS_DEFINITIONS;
+    }
+    const enabled = new Set(enabledFocuses);
+    const focusDefinitions = REVIEW_FOCUS_DEFINITIONS.filter((focus) => enabled.has(focus.name));
+    return focusDefinitions.length > 0 ? focusDefinitions : REVIEW_FOCUS_DEFINITIONS;
+}
 function formatSummaryOnlyFinding(finding) {
     const severity = parseSeverity(finding.body);
     const bodyWithoutSeverity = finding.body.replace(/^\s*\[P\d\]\s*/i, '').trim();
@@ -115,25 +205,42 @@ 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, summaryModel, 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 = summaryModel == null || !hasReviewFindings
         ? null
         : await summarizeReviewFindings({
-            credential: summaryCredential,
+            credential: summaryModel.credential,
+            provider: summaryModel.provider,
+            ...(summaryModel.modelName ? { modelName: summaryModel.modelName } : {}),
             workspaceDir,
             prTitle,
             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),
@@ -145,10 +252,14 @@ async function buildMultiFocusReviewOutput({ inlineFindings, summaryFindings, li
         }),
     };
 }
-export async function runMultiFocusReviewEngine({ ctx, prompt, lineLookup, prTitle, prBody, lowPriorityFindingPlacement, standardsSection, onProgress, }) {
+export async function runMultiFocusReviewEngine({ ctx, prompt, lineLookup, prTitle, prBody, lowPriorityFindingPlacement, standardsSection, enabledFocuses, onProgress, }) {
     const apiKeys = getApiKeys(ctx);
-    const availableModels = getAvailableModels(apiKeys);
+    const allAvailableModels = getAvailableModels(apiKeys);
+    const availableModels = getEnabledReviewModels(apiKeys, ctx.reviewModelsEnabled);
     const metricModels = availableModels.length > 0 ? [...availableModels] : [...ctx.reviewModelsEnabled];
+    const focusDefinitions = getEnabledFocusDefinitions(enabledFocuses);
+    const hasGeminiFallback = allAvailableModels.includes('gemini');
+    const geminiFallbackFocuses = ctx.geminiFallbackFocuses ?? DEFAULT_GEMINI_FLASH_FALLBACK_FOCUSES;
     if (availableModels.length === 0) {
         return {
             review: null,
@@ -158,78 +269,108 @@ export async function runMultiFocusReviewEngine({ ctx, prompt, lineLookup, prTit
             providerFailures: [],
         };
     }
-    const focusRuns = await Promise.all(REVIEW_FOCUS_DEFINITIONS.flatMap((focus) => availableModels.map((model) => runFocusPass({
-        focus,
-        model,
-        basePrompt: prompt,
-        standardsSection,
-        apiKeys,
-        workspaceDir: ctx.workspaceDir,
-        onProgress,
-    }))));
-    const successfulRuns = focusRuns.filter((run) => run.status === 'succeeded');
-    const providerFailures = getProviderFailures(focusRuns
-        .filter((run) => run.status === 'failed')
-        .map((run) => ({
-        model: run.model,
-        summary: '',
-        findings: [],
-        durationMs: 0,
-        error: run.error,
-    })));
-    if (successfulRuns.length === 0) {
+    // Workflow phase (no gen_ai.*): it fans out N model passes and post-
+    // processes them. The per-pass model spans are the gen-AI operations.
+    return withPhase(MULTI_FOCUS_PHASE, {
+        'review.models': availableModels.length,
+        'review.support_models': allAvailableModels.length,
+        'review.focuses': focusDefinitions.length,
+    }, async (span) => {
+        // One group per focus (its primary passes plus an optional Gemini-flash
+        // fallback), flattened into a single list of passes.
+        const focusGroups = await Promise.all(focusDefinitions.map((focus) => runFocusGroup({
+            focus,
+            models: getModelsForFocus(focus, availableModels, ctx.reviewModelsByFocus),
+            basePrompt: prompt,
+            standardsSection,
+            apiKeys,
+            hasGeminiFallback,
+            geminiFallbackFocuses,
+            workspaceDir: ctx.workspaceDir,
+            openRouterSessionId: ctx.openRouterSessionId,
+            onProgress,
+        })));
+        const focusRuns = focusGroups.flat();
+        const successfulRuns = focusRuns.filter((run) => run.status === 'succeeded');
+        const providerFailures = getProviderFailures(focusRuns
+            .filter((run) => run.status === 'failed')
+            .map((run) => ({
+            model: run.model,
+            summary: '',
+            findings: [],
+            durationMs: 0,
+            error: run.error,
+        })));
+        span.setAttributes({
+            'review.passes': focusRuns.length,
+            'review.passes.succeeded': successfulRuns.length,
+        });
+        if (successfulRuns.length === 0) {
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: 'all review passes failed',
+            });
+            return {
+                review: null,
+                availableModels,
+                metricModels,
+                mode: 'multi_focus',
+                providerFailures,
+            };
+        }
+        const allFindings = successfulRuns.flatMap((run) => run.findings);
+        const reviewObservations = collectReviewObservations(successfulRuns);
+        let dedupedFindings = allFindings;
+        try {
+            dedupedFindings = await dedupeMultiFocusFindings({
+                findings: allFindings,
+                availableModels: allAvailableModels,
+                workspaceDir: ctx.workspaceDir,
+                geminiCredential: apiKeys.gemini,
+                openRouterCredential: getOpenRouterReviewCredential(apiKeys, ctx.apiKeys),
+            });
+        }
+        catch (error) {
+            logger.warn('Multi-focus dedupe failed, continuing with raw findings', {
+                findingsCount: allFindings.length,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+        const routedFindings = routeLowPriorityFindings(dedupedFindings, lowPriorityFindingPlacement);
+        const geminiSummaryFallback = buildGeminiFlashReviewSummaryModel(apiKeys.gemini);
+        const summaryModel = ctx.reviewSummaryModel ??
+            (apiKeys.zai ? { provider: 'zai', credential: apiKeys.zai } : undefined);
+        const review = await buildMultiFocusReviewOutput({
+            inlineFindings: routedFindings.inlineFindings,
+            summaryFindings: routedFindings.summaryFindings,
+            lineLookup,
+            prTitle,
+            prBody,
+            reviewObservations,
+            summaryModel,
+            summaryFallbackModels: ctx.reviewSummaryModel == null && geminiSummaryFallback
+                ? [geminiSummaryFallback]
+                : [],
+            workspaceDir: ctx.workspaceDir,
+        });
+        logger.info('Multi-focus review completed', {
+            models: availableModels,
+            supportModels: allAvailableModels,
+            focuses: focusDefinitions.map((focus) => focus.name),
+            successfulRuns: successfulRuns.length,
+            findingsCount: allFindings.length,
+            dedupedFindingsCount: dedupedFindings.length,
+            inlineFindingsCount: routedFindings.inlineFindings.length,
+            summaryOnlyFindingsCount: routedFindings.summaryFindings.length,
+            reviewObservationsCount: reviewObservations.length,
+            commentsCount: review.comments.length,
+        });
         return {
-            review: null,
+            review,
             availableModels,
             metricModels,
             mode: 'multi_focus',
             providerFailures,
         };
-    }
-    const allFindings = successfulRuns.flatMap((run) => run.findings);
-    const reviewObservations = collectReviewObservations(successfulRuns);
-    let dedupedFindings = allFindings;
-    try {
-        dedupedFindings = await dedupeMultiFocusFindings({
-            findings: allFindings,
-            availableModels,
-            workspaceDir: ctx.workspaceDir,
-            geminiCredential: ctx.geminiCredential,
-        });
-    }
-    catch (error) {
-        logger.warn('Multi-focus dedupe failed, continuing with raw findings', {
-            findingsCount: allFindings.length,
-            error: error instanceof Error ? error.message : String(error),
-        });
-    }
-    const routedFindings = routeLowPriorityFindings(dedupedFindings, lowPriorityFindingPlacement);
-    const review = await buildMultiFocusReviewOutput({
-        inlineFindings: routedFindings.inlineFindings,
-        summaryFindings: routedFindings.summaryFindings,
-        lineLookup,
-        prTitle,
-        prBody,
-        reviewObservations,
-        summaryCredential: apiKeys.gemini,
-        workspaceDir: ctx.workspaceDir,
-    });
-    logger.info('Multi-focus review completed', {
-        models: availableModels,
-        focuses: REVIEW_FOCUS_DEFINITIONS.map((focus) => focus.name),
-        successfulRuns: successfulRuns.length,
-        findingsCount: allFindings.length,
-        dedupedFindingsCount: dedupedFindings.length,
-        inlineFindingsCount: routedFindings.inlineFindings.length,
-        summaryOnlyFindingsCount: routedFindings.summaryFindings.length,
-        reviewObservationsCount: reviewObservations.length,
-        commentsCount: review.comments.length,
     });
-    return {
-        review,
-        availableModels,
-        metricModels,
-        mode: 'multi_focus',
-        providerFailures,
-    };
 }

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

@@ -1,13 +1,16 @@
-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) {
     const apiKeys = {};
-    if (ctx.reviewModelsEnabled.includes('gemini')) {
-        apiKeys.gemini = ctx.geminiCredential;
+    for (const model of ctx.reviewModelsEnabled) {
+        apiKeys[model] = ctx.apiKeys[model];
     }
-    if (ctx.reviewModelsEnabled.includes('openai')) {
-        apiKeys.openai = ctx.openaiApiKey;
+    // 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;
 }
@@ -17,8 +20,29 @@ 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 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)
@@ -27,7 +51,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 +61,7 @@ export async function requestModelReview({ model, prompt, apiKeys, workspaceDir,
         ...credential,
         workspaceDir,
         thinkingLevel: getReviewThinkingLevel(model),
+        openRouterSessionId,
         onProgress,
     };
     try {
@@ -46,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

@@ -1,28 +1,90 @@
 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_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) {
-    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 `${renderPriorityBadge(severity)}${renderPriorityMetadata(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 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;
+    });
+    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

@@ -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,12 @@ async function runLocalReviewWithLogging(input) {
         prAuthor: author,
         files,
         apiKeys: input.apiKeys,
-        reviewModelsEnabled: parseReviewModelsEnabled(process.env.REVIEW_MODELS_ENABLED, {
-            requiredModels: [],
-        }),
+        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,