@doist/doistbot-cli 1.0.4 → 1.0.6

package/sandbox/dist/tasks/persist-logs/dd-proxy.js

@@ -7,8 +7,8 @@ const DD_HOST = 'api.datadoghq.com';
  * Starts a localhost HTTP proxy that forwards requests to the Datadog API,
  * scrubs PII from responses, and logs each query for auditability.
  *
- * Claude hits http://localhost:{port}/api/v2/... instead of the DD API directly.
- * The proxy injects DD auth headers so Claude never sees the API keys.
+ * The agent hits http://localhost:{port}/api/v2/... instead of the DD API directly.
+ * The proxy injects DD auth headers so the agent never sees the API keys.
  */
 export function startDdProxy({ port, datadogApiKey, datadogAppKey }) {
     return new Promise((resolve, reject) => {

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

@@ -49,7 +49,7 @@ export async function runInvestigation(params) {
     });
     // Ensure output directory exists
     fs.mkdirSync(params.outputDir, { recursive: true });
-    // Start the DD proxy — Claude queries localhost, proxy injects auth and scrubs PII from responses
+    // Start the DD proxy so the agent queries localhost; the proxy injects auth and scrubs PII.
     const proxy = await startDdProxy({
         port: DD_PROXY_PORT,
         datadogApiKey: params.datadogApiKey,

package/sandbox/dist/tasks/persist-logs/persist-logs.js

@@ -441,7 +441,7 @@ export function buildSnapshotComment({ analysisContent, csvContent, worklogConte
         '_Links expire in 7 days. Use `@doistbot /refresh-s3-urls` to generate new links._',
     ].join('\n');
     const csvPreview = buildCsvPreview(csvContent);
-    // Always prepend the marker — Claude's output won't contain it
+    // Always prepend the marker; model output won't contain it.
     const analysis = analysisContent
         ? `${LOG_SNAPSHOT_MARKER}\n${analysisContent}`
         : `${LOG_SNAPSHOT_MARKER}\n## Datadog Log Snapshot\n\n**${totalLogs} log entries** captured from Datadog.`;

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

@@ -3,6 +3,8 @@ import { fetchIssueComments } from '../../core/github-issues.js';
 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.
@@ -14,11 +16,8 @@ const GITHUB_ACTIONS_BOT_LOGIN = 'github-actions[bot]';
 const MASKED_PR_AUTHOR_LABEL = 'PR author';
 function getSummaryProviders(apiKeys) {
     return [
-        ...(apiKeys?.gemini ? [{ provider: 'gemini', apiKey: apiKeys.gemini }] : []),
-        ...(apiKeys?.openai ? [{ provider: 'openai', apiKey: apiKeys.openai }] : []),
-        ...(apiKeys?.anthropic
-            ? [{ provider: 'anthropic', apiKey: apiKeys.anthropic }]
-            : []),
+        ...(apiKeys?.gemini ? [{ provider: 'gemini', credential: apiKeys.gemini }] : []),
+        ...(apiKeys?.openai ? [{ provider: 'openai', credential: apiKeys.openai }] : []),
     ];
 }
 function isRelevantBotLogin(login) {
@@ -38,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';
@@ -253,7 +252,7 @@ If a section has no relevant information, use "- None."
 ${rawContext}
 </pr_conversation>`;
 }
-async function summarizeConversationContextWithModel({ provider, apiKey, rawContext, workspaceDir, }) {
+async function summarizeConversationContextWithModel({ provider, credential, rawContext, workspaceDir, }) {
     const startedAt = Date.now();
     logger.info('PR conversation summarization started', {
         task: 'review',
@@ -261,9 +260,17 @@ async function summarizeConversationContextWithModel({ provider, apiKey, rawCont
         raw_chars: rawContext.length,
     });
     try {
+        const resolvedCredential = resolveReviewProviderCredential(credential);
+        if (!resolvedCredential) {
+            return null;
+        }
         const result = await invokePiPrompt({
             provider,
-            apiKey,
+            apiKey: resolvedCredential.apiKey,
+            ...(resolvedCredential.piProviderId
+                ? { piProviderId: resolvedCredential.piProviderId }
+                : {}),
+            ...(resolvedCredential.modelName ? { modelName: resolvedCredential.modelName } : {}),
             prompt: buildSummaryPrompt(rawContext),
             cwd: workspaceDir ?? WORKSPACE_DIR,
             timeoutMs: CONVERSATION_SUMMARY_TIMEOUT_MS,

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

@@ -1,11 +1,15 @@
 import { logger } from '../../../core/logging.js';
 import { invokePiPrompt } from '../../../core/pi.js';
 import { logPiProgressEvent } from '../../../core/pi-progress-logging.js';
+import { resolveReviewProviderCredential } from '../../../providers/credentials.js';
 import { extractJsonFromResponse } from '../../../providers/helpers.js';
 import { isDedupeResponse } from '../../../providers/schemas.js';
 const DEDUPE_TIMEOUT_MS = 5 * 60 * 1000;
 const DEDUPE_PROVIDER = 'gemini';
-const DEDUPE_MODEL_NAME = 'gemini-3-flash-preview';
+const DEDUPE_MODEL_BY_PI_PROVIDER = {
+    google: 'gemini-3-flash-preview',
+    openrouter: 'google/gemini-3-flash-preview',
+};
 const DEDUPE_THINKING_LEVEL = 'medium';
 const DEDUPE_MAX_ATTEMPTS = 2;
 const DEDUPE_RETRY_DELAY_MS = 1_000;
@@ -106,28 +110,31 @@ export function applyDedupeGroups(findings, groups) {
     });
     return findings.filter((finding) => !dropped.has(finding.id));
 }
-export async function dedupeMultiFocusFindings({ findings, availableModels, workspaceDir, geminiApiKey, }) {
+export async function dedupeMultiFocusFindings({ findings, availableModels, workspaceDir, geminiCredential, }) {
     if (findings.length <= 1) {
         return findings;
     }
     if (!availableModels.includes(DEDUPE_PROVIDER)) {
         logger.error('Multi-focus dedupe unavailable because Gemini is not enabled', {
             provider: DEDUPE_PROVIDER,
-            model: DEDUPE_MODEL_NAME,
+            model: DEDUPE_MODEL_BY_PI_PROVIDER.google,
         });
         throw new Error('Multi-focus dedupe requires Gemini to be enabled');
     }
-    if (!geminiApiKey) {
-        logger.error('Multi-focus dedupe unavailable because Gemini API key is unavailable', {
+    const credential = resolveReviewProviderCredential(geminiCredential);
+    if (!credential) {
+        logger.error('Multi-focus dedupe unavailable because Gemini review credential is unavailable', {
             provider: DEDUPE_PROVIDER,
-            model: DEDUPE_MODEL_NAME,
+            model: DEDUPE_MODEL_BY_PI_PROVIDER.google,
         });
-        throw new Error('Multi-focus dedupe requires a Gemini API key');
+        throw new Error('Multi-focus dedupe requires a Gemini review credential');
     }
+    const piProviderId = credential.piProviderId ?? 'google';
     const providerConfig = {
         provider: DEDUPE_PROVIDER,
-        apiKey: geminiApiKey,
-        modelName: DEDUPE_MODEL_NAME,
+        apiKey: credential.apiKey,
+        ...(credential.piProviderId ? { piProviderId: credential.piProviderId } : {}),
+        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;
@@ -135,6 +142,9 @@ export async function dedupeMultiFocusFindings({ findings, availableModels, work
             result = await invokePiPrompt({
                 provider: providerConfig.provider,
                 apiKey: providerConfig.apiKey,
+                ...(providerConfig.piProviderId
+                    ? { piProviderId: providerConfig.piProviderId }
+                    : {}),
                 prompt: buildDedupePrompt(findings),
                 cwd: workspaceDir,
                 timeoutMs: DEDUPE_TIMEOUT_MS,

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

@@ -1,20 +1,28 @@
 import { logger } from '../../../core/logging.js';
 import { convertFindingsToComments } from '../comment-mapper.js';
-import { buildFallbackSummary, summarizeCouncilReviews, withReviewSummaryGreeting, } from '../council/summary.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';
+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,
-        logEngine: 'multi_focus',
+        openRouterSessionId,
         onProgress,
     });
     if (!result) {
@@ -70,10 +78,10 @@ function routeLowPriorityFindings(findings, placement = 'summary') {
     }
     return { inlineFindings, summaryFindings };
 }
-function buildNoInlineSummaryWithNotes(prTitle, prAuthor, prAuthorGreetingName, excludePrAuthorFromSummary) {
+function buildNoInlineSummaryWithNotes(prTitle) {
     const safeTitle = prTitle.trim();
     const base = safeTitle ? `This PR updates ${safeTitle}.` : 'This PR updates the codebase.';
-    return withReviewSummaryGreeting(`${base} No inline issues were flagged.`, prAuthor, prAuthorGreetingName, excludePrAuthorFromSummary);
+    return `${base} No inline issues were flagged.`;
 }
 function collectReviewObservations(focusRuns) {
     const observations = [];
@@ -95,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();
@@ -116,34 +128,40 @@ 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, prAuthor, prAuthorGreetingName, resolvePrAuthorGreetingName, excludePrAuthorFromSummary, reviewObservations, summaryApiKey, 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 resolvedPrAuthorGreetingName = excludePrAuthorFromSummary === true
-        ? undefined
-        : (prAuthorGreetingName ?? (await resolvePrAuthorGreetingName?.()));
-    const synthesizedSummary = summaryApiKey == 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 summarizeCouncilReviews({
-            apiKey: summaryApiKey,
+        : await summarizeReviewFindings({
+            credential: summaryCredential,
             workspaceDir,
             prTitle,
             prBody,
-            prAuthor,
-            prAuthorGreetingName: resolvedPrAuthorGreetingName,
-            excludePrAuthorFromSummary,
             findings,
             reviewObservations,
+            fallbackModels: summaryFallbackModels,
         });
     const summaryWithoutNotes = synthesizedSummary ||
-        (comments.length === 0 && summaryFindings.length > 0
-            ? buildNoInlineSummaryWithNotes(prTitle, prAuthor, resolvedPrAuthorGreetingName, excludePrAuthorFromSummary)
+        (comments.length === 0 && hasReviewFindings
+            ? buildNoInlineSummaryWithNotes(prTitle)
             : buildFallbackSummary({
                 prTitle,
-                findings,
-                prAuthor,
-                prAuthorGreetingName: resolvedPrAuthorGreetingName,
-                excludePrAuthorFromSummary,
+                findings: inlineCommentFindings,
             }));
     return {
         summary: appendSummaryOnlyFindings(summaryWithoutNotes, summaryFindings),
@@ -155,10 +173,10 @@ async function buildMultiFocusReviewOutput({ inlineFindings, summaryFindings, li
         }),
     };
 }
-export async function runMultiFocusReviewEngine({ ctx, prompt, lineLookup, prTitle, prBody, prAuthor, prAuthorGreetingName, resolvePrAuthorGreetingName, excludePrAuthorFromSummary, lowPriorityFindingPlacement, standardsSection, onProgress, }) {
+export async function runMultiFocusReviewEngine({ ctx, prompt, lineLookup, prTitle, prBody, lowPriorityFindingPlacement, standardsSection, onProgress, }) {
     const apiKeys = getApiKeys(ctx);
     const availableModels = getAvailableModels(apiKeys);
-    const metricModels = availableModels.length > 0 ? [...availableModels] : [...ctx.councilModelsEnabled];
+    const metricModels = availableModels.length > 0 ? [...availableModels] : [...ctx.reviewModelsEnabled];
     if (availableModels.length === 0) {
         return {
             review: null,
@@ -168,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');
@@ -198,25 +217,32 @@ export async function runMultiFocusReviewEngine({ ctx, prompt, lineLookup, prTit
     }
     const allFindings = successfulRuns.flatMap((run) => run.findings);
     const reviewObservations = collectReviewObservations(successfulRuns);
-    const dedupedFindings = await dedupeMultiFocusFindings({
-        findings: allFindings,
-        availableModels,
-        workspaceDir: ctx.workspaceDir,
-        geminiApiKey: ctx.geminiApiKey,
-    });
+    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,
-        prAuthor,
-        prAuthorGreetingName,
-        resolvePrAuthorGreetingName,
-        excludePrAuthorFromSummary,
         reviewObservations,
-        summaryApiKey: 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

@@ -1,29 +1,23 @@
+import { getReviewProviderCredential, hasReviewProviderCredential, } from '../../../providers/credentials.js';
 import { getProvider } from '../../../providers/index.js';
-import { convertFindingsToComments } from '../comment-mapper.js';
-import { buildFallbackSummary, summarizeCouncilReviews, withReviewSummaryGreeting, } from '../council/summary.js';
-import { buildReviewOutputFindings } from '../finding-output.js';
 import { getReviewThinkingLevel } from '../thinking-level.js';
 export function getApiKeys(ctx) {
     const apiKeys = {};
-    if (ctx.councilModelsEnabled.includes('gemini')) {
-        apiKeys.gemini = ctx.geminiApiKey;
-    }
-    if (ctx.councilModelsEnabled.includes('openai')) {
-        apiKeys.openai = ctx.openaiApiKey;
-    }
-    if (ctx.councilModelsEnabled.includes('anthropic')) {
-        apiKeys.anthropic = ctx.anthropicApiKey;
+    for (const model of ctx.reviewModelsEnabled) {
+        apiKeys[model] = ctx.apiKeys[model];
     }
     return apiKeys;
 }
 export function getAvailableModels(apiKeys) {
     const models = [];
-    if (apiKeys.gemini)
+    if (hasReviewProviderCredential(apiKeys.gemini))
         models.push('gemini');
-    if (apiKeys.openai)
+    if (hasReviewProviderCredential(apiKeys.openai))
         models.push('openai');
-    if (apiKeys.anthropic)
-        models.push('anthropic');
+    if (hasReviewProviderCredential(apiKeys.deepseek))
+        models.push('deepseek');
+    if (hasReviewProviderCredential(apiKeys.zai))
+        models.push('zai');
     return models;
 }
 export function getProviderFailures(results) {
@@ -34,63 +28,23 @@ export function getProviderFailures(results) {
         error: result.error,
     }));
 }
-export async function requestModelReview({ model, prompt, apiKeys, workspaceDir, logEngine, onProgress, }) {
-    const apiKey = apiKeys[model];
-    if (!apiKey) {
+export async function requestModelReview({ model, prompt, apiKeys, workspaceDir, openRouterSessionId, onProgress, }) {
+    const credential = getReviewProviderCredential(apiKeys, model);
+    if (!credential) {
         return null;
     }
     const provider = getProvider(model);
     const config = {
-        apiKey,
+        ...credential,
         workspaceDir,
         thinkingLevel: getReviewThinkingLevel(model),
+        openRouterSessionId,
         onProgress,
     };
     try {
-        return await provider.review(prompt, config, logEngine ? { engine: logEngine } : undefined);
+        return await provider.review(prompt, config);
     }
     catch {
         return null;
     }
 }
-export async function buildReviewOutputFromFindings({ commentsSource, lineLookup, prTitle, prBody, prAuthor, prAuthorGreetingName, resolvePrAuthorGreetingName, excludePrAuthorFromSummary, summaryApiKey, workspaceDir, preferredSummary, reviewObservations, }) {
-    const comments = convertFindingsToComments(commentsSource, lineLookup);
-    const findings = Array.from(new Set(comments.map((comment) => comment.body.trim()).filter(Boolean)));
-    const preferredSummaryText = preferredSummary?.trim();
-    const hasPreferredSummary = Boolean(preferredSummaryText);
-    const resolvedPrAuthorGreetingName = excludePrAuthorFromSummary === true
-        ? undefined
-        : (prAuthorGreetingName ?? (await resolvePrAuthorGreetingName?.()));
-    const synthesizedSummary = hasPreferredSummary || summaryApiKey == null
-        ? null
-        : await summarizeCouncilReviews({
-            apiKey: summaryApiKey,
-            workspaceDir,
-            prTitle,
-            prBody,
-            prAuthor,
-            prAuthorGreetingName: resolvedPrAuthorGreetingName,
-            excludePrAuthorFromSummary,
-            findings,
-            reviewObservations,
-        });
-    const summary = preferredSummaryText ||
-        synthesizedSummary ||
-        buildFallbackSummary({
-            prTitle,
-            findings,
-            prAuthor,
-            prAuthorGreetingName: resolvedPrAuthorGreetingName,
-            excludePrAuthorFromSummary,
-        });
-    return {
-        summary: hasPreferredSummary
-            ? withReviewSummaryGreeting(summary, prAuthor, resolvedPrAuthorGreetingName, excludePrAuthorFromSummary)
-            : summary,
-        comments,
-        findings: buildReviewOutputFindings({
-            inlineFindings: commentsSource,
-            lineLookup,
-        }),
-    };
-}

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,24 +1,9 @@
-import { getLocalCustomPrompt, getLocalRepoConfig, parseCouncilModelsEnabled, resolveReviewEngine, } 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';
-import { loadDefaultReviewPromptTemplate } from './prompt.js';
 import { runSharedReview } from './runner.js';
 const LOCAL_REVIEW_PR_NUMBER = 0;
-function resolveLocalPromptTemplate(workspaceDir, promptFile) {
-    if (promptFile) {
-        const customPrompt = getLocalCustomPrompt({
-            workspaceDir,
-            path: promptFile,
-            logger,
-        });
-        if (customPrompt) {
-            return customPrompt;
-        }
-        logger.info('Local custom prompt not found, using default', { path: promptFile });
-    }
-    return loadDefaultReviewPromptTemplate();
-}
 export async function runLocalReview(input) {
     if (input.suppressLogs === true) {
         return await withLogsSuppressed(['info', 'warn', 'error'], async () => await runLocalReviewWithLogging(input));
@@ -41,13 +26,6 @@ async function runLocalReviewWithLogging(input) {
         source: input.source,
     });
     input.onProgress?.({ type: 'local_files_resolved', fileCount: files.length });
-    const repoConfig = getLocalRepoConfig({ workspaceDir: input.workspaceDir, logger });
-    const reviewEngine = resolveReviewEngine({
-        configuredEngine: repoConfig?.review?.engine,
-        envEngine: process.env.REVIEW_ENGINE,
-        logger,
-        repository: `${owner}/${repo}`,
-    });
     const reviewResult = await runSharedReview({
         owner,
         repo,
@@ -58,13 +36,8 @@ async function runLocalReviewWithLogging(input) {
         prBody: 'Local self-review before opening a pull request.',
         prAuthor: author,
         files,
-        reviewEngine,
-        promptTemplate: reviewEngine === 'council'
-            ? resolveLocalPromptTemplate(input.workspaceDir, repoConfig?.review?.prompt_file)
-            : undefined,
         apiKeys: input.apiKeys,
-        councilEnabled: repoConfig?.review?.council?.enabled !== false,
-        councilModelsEnabled: parseCouncilModelsEnabled(process.env.COUNCIL_MODELS_ENABLED),
+        reviewModelsEnabled: getDefaultReviewModels(),
         lowPriorityFindingPlacement: 'inline',
         workspaceDir: input.workspaceDir,
         onProgress: input.onProgress,