@doist/doistbot-cli 1.0.6 → 1.0.8

package/sandbox/dist/tasks/issue-triage/prompt.js

@@ -1,8 +1,8 @@
-import { fillPromptTemplate, loadPromptTemplateFile } from '../../core/prompt-template.js';
+import { fillPromptTemplate, loadPromptTemplateFile, resolvePromptFile, } from '../../core/prompt-template.js';
 const PROMPT_FILE = 'issue-triage-prompt.md';
 export function loadPromptTemplate() {
     return loadPromptTemplateFile({
-        fileName: PROMPT_FILE,
+        fileName: resolvePromptFile(import.meta.url, PROMPT_FILE),
         promptLabel: 'issue triage',
     });
 }

package/sandbox/dist/tasks/issue-triage/triage.js

@@ -3,7 +3,7 @@ import path from 'path';
 import { SpanStatusCode } from '@opentelemetry/api';
 import { recordTaskMetrics } from '../../core/datadog-metrics.js';
 import { logger } from '../../core/logging.js';
-import { loadPromptTemplateFile } from '../../core/prompt-template.js';
+import { loadPromptTemplateFile, resolvePromptFile } from '../../core/prompt-template.js';
 import { removeIssueCommentReactionIfPresent } from '../../core/reactions.js';
 import { REPOS_SUBDIR, WORKSPACE_DIR } from '../../core/shared.js';
 import { withPhase } from '../../core/tracing.js';
@@ -79,7 +79,7 @@ function buildPrompt({ ctx, issue, comments, labelNames, clonedRepositories, dec
         OUTPUT_CONTRACT: outputContract,
         FIX_ASSESSMENT_INSTRUCTIONS: enableAutoFix
             ? loadPromptTemplateFile({
-                fileName: 'fix-assessment-instructions.md',
+                fileName: resolvePromptFile(import.meta.url, 'fix-assessment-instructions.md'),
                 promptLabel: 'fix-assessment-instructions',
             })
             : '',

package/sandbox/dist/tasks/persist-logs/llm-query-planner.js

@@ -3,17 +3,17 @@ import path from 'path';
 import { logger } from '../../core/logging.js';
 import { invokePiPrompt } from '../../core/pi.js';
 import { scrubPii } from '../../core/pii-scrubber.js';
-import { loadPromptTemplateFile } from '../../core/prompt-template.js';
+import { loadPromptTemplateFile, resolvePromptFile } from '../../core/prompt-template.js';
 import { startDdProxy } from './dd-proxy.js';
 export const PERSIST_LOGS_PROVIDER = 'openai';
 const TIMEOUT_MS = 20 * 60 * 1000; // 20 minutes — investigation can take a while
 function buildPrompt(params, proxyPort) {
     const ddApiReference = loadPromptTemplateFile({
-        fileName: 'persist-logs-dd-api-reference.md',
+        fileName: resolvePromptFile(import.meta.url, 'persist-logs-dd-api-reference.md'),
         promptLabel: 'persist-logs DD API reference',
     });
     const template = loadPromptTemplateFile({
-        fileName: 'persist-logs-investigation-prompt.md',
+        fileName: resolvePromptFile(import.meta.url, 'persist-logs-investigation-prompt.md'),
         promptLabel: 'persist-logs investigation prompt',
     });
     const scrubbedTitle = scrubPii(params.issueTitle);

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

@@ -1,8 +1,10 @@
+import { SpanStatusCode } from '@opentelemetry/api';
 import { logger } from '../../../core/logging.js';
 import { invokePiPrompt } from '../../../core/pi.js';
 import { logPiProgressEvent } from '../../../core/pi-progress-logging.js';
+import { genAiProviderName, withPhase } from '../../../core/tracing.js';
 import { resolveReviewProviderCredential } from '../../../providers/credentials.js';
-import { extractJsonFromResponse } from '../../../providers/helpers.js';
+import { extractJsonFromResponse, readProviderErrorDetails } from '../../../providers/helpers.js';
 import { isDedupeResponse } from '../../../providers/schemas.js';
 const DEDUPE_TIMEOUT_MS = 5 * 60 * 1000;
 const DEDUPE_PROVIDER = 'gemini';
@@ -14,6 +16,59 @@ const DEDUPE_THINKING_LEVEL = 'medium';
 const DEDUPE_MAX_ATTEMPTS = 2;
 const DEDUPE_RETRY_DELAY_MS = 1_000;
 const DEDUPE_SYSTEM_PROMPT = 'You are a JSON-only duplicate-finding classifier. Use only the findings JSON in the user prompt. Do not inspect files, do not search the repository, and do not use tools. Return only valid JSON matching the requested schema.';
+const DEDUPE_PHASE = 'review.dedupe';
+const DEDUPE_PROVIDER_UNAVAILABLE_LOG_TYPE = 'review.dedupe.provider_unavailable';
+function getDedupeProviderRoute(providerConfig) {
+    return providerConfig.piProviderId ?? 'google';
+}
+function toDedupeProviderConfig(credential, piProviderId) {
+    return {
+        provider: DEDUPE_PROVIDER,
+        apiKey: credential.apiKey,
+        ...(piProviderId === 'google' ? {} : { piProviderId }),
+        modelName: DEDUPE_MODEL_BY_PI_PROVIDER[piProviderId] ?? DEDUPE_MODEL_BY_PI_PROVIDER.google,
+    };
+}
+function buildOpenRouterDedupeProviderConfig(credential) {
+    const resolvedCredential = resolveReviewProviderCredential(credential);
+    if (!resolvedCredential) {
+        return undefined;
+    }
+    return toDedupeProviderConfig(resolvedCredential, 'openrouter');
+}
+function buildDedupeProviderConfigs({ geminiCredential, openRouterCredential, }) {
+    const primaryPiProviderId = geminiCredential.piProviderId ?? 'google';
+    const primaryConfig = toDedupeProviderConfig(geminiCredential, primaryPiProviderId);
+    const openRouterConfig = primaryPiProviderId === 'openrouter'
+        ? undefined
+        : buildOpenRouterDedupeProviderConfig(openRouterCredential);
+    return openRouterConfig ? [primaryConfig, openRouterConfig] : [primaryConfig];
+}
+function logDedupeProviderUnavailable({ providerConfig, attempt, error, shouldRetry, timedOut, }) {
+    const details = readProviderErrorDetails(error);
+    function log(message, meta) {
+        if (shouldRetry) {
+            logger.warn(message, meta);
+        }
+        else {
+            logger.error(message, meta);
+        }
+    }
+    log('Multi-focus dedupe provider unavailable', {
+        type: DEDUPE_PROVIDER_UNAVAILABLE_LOG_TYPE,
+        provider: providerConfig.provider,
+        provider_route: getDedupeProviderRoute(providerConfig),
+        model: providerConfig.modelName,
+        attempt,
+        attempts_total: DEDUPE_MAX_ATTEMPTS,
+        retrying: shouldRetry,
+        error_code: details.errorCode,
+        status: details.status,
+        reason: details.reason,
+        error: details.rawError,
+        timed_out: timedOut ?? false,
+    });
+}
 function buildDedupePrompt(findings) {
     const payload = {
         findings: findings.map((finding) => ({
@@ -110,7 +165,7 @@ export function applyDedupeGroups(findings, groups) {
     });
     return findings.filter((finding) => !dropped.has(finding.id));
 }
-export async function dedupeMultiFocusFindings({ findings, availableModels, workspaceDir, geminiCredential, }) {
+export async function dedupeMultiFocusFindings({ findings, availableModels, workspaceDir, geminiCredential, openRouterCredential, }) {
     if (findings.length <= 1) {
         return findings;
     }
@@ -129,45 +184,58 @@ export async function dedupeMultiFocusFindings({ findings, availableModels, work
         });
         throw new Error('Multi-focus dedupe requires a Gemini review credential');
     }
-    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.google,
-    };
+    return runDedupeAttempts({
+        findings,
+        workspaceDir,
+        providerConfigs: buildDedupeProviderConfigs({
+            geminiCredential: credential,
+            openRouterCredential,
+        }),
+    });
+}
+async function runDedupeAttempts({ findings, workspaceDir, providerConfigs, }) {
     for (let attempt = 1; attempt <= DEDUPE_MAX_ATTEMPTS; attempt += 1) {
+        const providerConfig = providerConfigs[Math.min(attempt - 1, providerConfigs.length - 1)];
         let result;
         try {
-            result = await invokePiPrompt({
-                provider: providerConfig.provider,
-                apiKey: providerConfig.apiKey,
-                ...(providerConfig.piProviderId
-                    ? { piProviderId: providerConfig.piProviderId }
-                    : {}),
-                prompt: buildDedupePrompt(findings),
-                cwd: workspaceDir,
-                timeoutMs: DEDUPE_TIMEOUT_MS,
-                capabilityPreset: 'read-only',
-                modelName: providerConfig.modelName,
-                thinkingLevel: DEDUPE_THINKING_LEVEL,
-                systemPrompt: DEDUPE_SYSTEM_PROMPT,
-                onProgress: (event) => {
-                    logDedupeProgress(providerConfig, event);
-                },
+            // One span per actual invoke: a fail-then-succeed retry shows up as a
+            // separate error span and ok span, not one inflated span. Provider/
+            // model are known here, so the span carries full gen_ai.*.
+            result = await withPhase(DEDUPE_PHASE, {
+                'gen_ai.operation.name': 'chat',
+                'gen_ai.provider.name': genAiProviderName(providerConfig.provider),
+                'gen_ai.request.model': providerConfig.modelName,
+                'review.provider_route': getDedupeProviderRoute(providerConfig),
+            }, async (span) => {
+                const invocation = await invokePiPrompt({
+                    provider: providerConfig.provider,
+                    apiKey: providerConfig.apiKey,
+                    ...(providerConfig.piProviderId
+                        ? { piProviderId: providerConfig.piProviderId }
+                        : {}),
+                    prompt: buildDedupePrompt(findings),
+                    cwd: workspaceDir,
+                    timeoutMs: DEDUPE_TIMEOUT_MS,
+                    capabilityPreset: 'read-only',
+                    modelName: providerConfig.modelName,
+                    thinkingLevel: DEDUPE_THINKING_LEVEL,
+                    systemPrompt: DEDUPE_SYSTEM_PROMPT,
+                    onProgress: (event) => {
+                        logDedupeProgress(providerConfig, event);
+                    },
+                });
+                if (!invocation.ok) {
+                    span.setStatus({
+                        code: SpanStatusCode.ERROR,
+                        message: invocation.error ?? 'dedupe request failed',
+                    });
+                }
+                return invocation;
             });
         }
         catch (error) {
             const shouldRetry = attempt < DEDUPE_MAX_ATTEMPTS;
-            logger.warn(shouldRetry
-                ? 'Multi-focus dedupe request threw, retrying'
-                : 'Multi-focus dedupe request threw', {
-                provider: providerConfig.provider,
-                model: providerConfig.modelName,
-                attempt,
-                attempts_total: DEDUPE_MAX_ATTEMPTS,
-                error: error instanceof Error ? error.message : String(error),
-            });
+            logDedupeProviderUnavailable({ providerConfig, attempt, error, shouldRetry });
             if (shouldRetry) {
                 await waitForDedupeRetry(attempt);
                 continue;
@@ -176,15 +244,12 @@ export async function dedupeMultiFocusFindings({ findings, availableModels, work
         }
         if (!result.ok) {
             const shouldRetry = attempt < DEDUPE_MAX_ATTEMPTS;
-            logger.warn(shouldRetry
-                ? 'Multi-focus dedupe request failed, retrying'
-                : 'Multi-focus dedupe request failed', {
-                provider: providerConfig.provider,
-                model: providerConfig.modelName,
+            logDedupeProviderUnavailable({
+                providerConfig,
                 attempt,
-                attempts_total: DEDUPE_MAX_ATTEMPTS,
-                error: result.error,
-                timed_out: result.timedOut,
+                error: result.error ?? 'dedupe request failed',
+                shouldRetry,
+                timedOut: result.timedOut,
             });
             if (shouldRetry) {
                 await waitForDedupeRetry(attempt);

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

@@ -1,4 +1,6 @@
+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';
@@ -6,60 +8,120 @@ import { buildFallbackSummary, summarizeReviewFindings } from '../review-summary
 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: ['gemini', 'openai'],
-    quality: ['gemini', 'openai'],
-    efficiency: ['gemini', 'openai'],
+    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.';
+// 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, }) {
-    const prompt = buildMultiFocusPrompt(basePrompt, focus, standardsSection);
-    const result = await requestModelReview({
-        model,
-        prompt,
-        apiKeys,
-        workspaceDir,
-        openRouterSessionId,
-        onProgress,
-    });
-    if (!result) {
-        logger.warn('Multi-focus review pass failed without a result', {
-            focus: focus.name,
+    // 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,
+            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',
-            focus: focus.name,
-            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,
-        });
-        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') {
@@ -103,9 +165,24 @@ 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 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);
@@ -134,7 +211,7 @@ function buildSummarySynthesisFindings({ inlineFindings, summaryFindings, }) {
         ...summaryFindings.map((finding) => formatSummaryOnlyFinding(finding)),
     ].filter(Boolean)));
 }
-async function buildMultiFocusReviewOutput({ inlineFindings, summaryFindings, lineLookup, prTitle, prBody, reviewObservations, summaryCredential, summaryFallbackModels, workspaceDir, }) {
+async function buildMultiFocusReviewOutput({ inlineFindings, summaryFindings, lineLookup, prTitle, prBody, reviewObservations, summaryModel, summaryFallbackModels, workspaceDir, }) {
     const comments = convertFindingsToComments(inlineFindings, lineLookup);
     const inlineCommentFindings = Array.from(new Set(comments.map((comment) => comment.body.trim()).filter(Boolean)));
     const findings = buildSummarySynthesisFindings({ inlineFindings, summaryFindings });
@@ -145,10 +222,12 @@ async function buildMultiFocusReviewOutput({ inlineFindings, summaryFindings, li
             summaryFindingsCount: summaryFindings.length,
         });
     }
-    const synthesizedSummary = summaryCredential == null || !hasReviewFindings
+    const synthesizedSummary = summaryModel == null || !hasReviewFindings
         ? null
         : await summarizeReviewFindings({
-            credential: summaryCredential,
+            credential: summaryModel.credential,
+            provider: summaryModel.provider,
+            ...(summaryModel.modelName ? { modelName: summaryModel.modelName } : {}),
             workspaceDir,
             prTitle,
             prBody,
@@ -173,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,
@@ -186,81 +269,108 @@ export async function runMultiFocusReviewEngine({ ctx, prompt, lineLookup, prTit
             providerFailures: [],
         };
     }
-    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');
-    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: apiKeys.gemini,
-        });
-    }
-    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 review = await buildMultiFocusReviewOutput({
-        inlineFindings: routedFindings.inlineFindings,
-        summaryFindings: routedFindings.summaryFindings,
-        lineLookup,
-        prTitle,
-        prBody,
-        reviewObservations,
-        summaryCredential: apiKeys.zai,
-        summaryFallbackModels: geminiSummaryFallback ? [geminiSummaryFallback] : [],
-        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,
-    };
 }