@doist/doistbot-cli 1.0.4 → 1.0.6

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

@@ -1,7 +1,14 @@
 import { logger } from '../../core/logging.js';
-import { invokePiPrompt } from '../../core/pi.js';
+import { DEFAULT_OPENROUTER_MODELS, DEFAULT_PI_MODELS, invokePiPrompt, PI_PROVIDER_BY_DOISTBOT_PROVIDER, } from '../../core/pi.js';
 import { WORKSPACE_DIR } from '../../core/shared.js';
+import { resolveReviewProviderCredential } from '../../providers/credentials.js';
+import { extractJsonCandidatesFromResponse } from '../../providers/helpers.js';
 const REVIEW_SUMMARY_TIMEOUT_MS = 5 * 60 * 1000;
+const REVIEW_SUMMARY_THINKING_LEVEL = 'medium';
+const GEMINI_FLASH_SUMMARY_MODEL_BY_PI_PROVIDER = {
+    google: 'gemini-3-flash-preview',
+    openrouter: 'google/gemini-3-flash-preview',
+};
 const DIFF_SIDE = {
     LEFT: 'LEFT',
     RIGHT: 'RIGHT',
@@ -9,45 +16,194 @@ const DIFF_SIDE = {
 function getWorkspaceDir() {
     return WORKSPACE_DIR;
 }
-export async function requestReviewSummary({ apiKey, prompt, workspaceDir, }) {
+function getReviewSummaryModelNameForLog({ provider, piProviderId, modelName, }) {
+    if (modelName) {
+        return modelName;
+    }
+    const resolvedPiProviderId = piProviderId ?? PI_PROVIDER_BY_DOISTBOT_PROVIDER[provider];
+    return ((resolvedPiProviderId === 'openrouter' ? DEFAULT_OPENROUTER_MODELS[provider] : undefined) ??
+        DEFAULT_PI_MODELS[provider]);
+}
+export function buildGeminiFlashReviewSummaryModel(credential) {
+    if (credential === undefined) {
+        return undefined;
+    }
+    const resolvedCredential = resolveReviewProviderCredential(credential);
+    if (!resolvedCredential) {
+        return undefined;
+    }
+    const piProviderId = resolvedCredential.piProviderId ?? 'google';
+    const modelName = GEMINI_FLASH_SUMMARY_MODEL_BY_PI_PROVIDER[piProviderId] ??
+        GEMINI_FLASH_SUMMARY_MODEL_BY_PI_PROVIDER.google;
+    return {
+        provider: 'gemini',
+        credential,
+        modelName,
+    };
+}
+function failedReviewSummaryRequest({ reason, error, timedOut, durationMs, outputChars, }) {
+    return {
+        status: 'failed',
+        reason,
+        ...(error ? { error } : {}),
+        ...(timedOut !== undefined ? { timedOut } : {}),
+        ...(durationMs !== undefined ? { durationMs } : {}),
+        ...(outputChars !== undefined ? { outputChars } : {}),
+    };
+}
+function getRequestFailureReason(result) {
+    if (result.timedOut) {
+        return 'timeout';
+    }
+    return result.error.toLowerCase().includes('did not produce an assistant response')
+        ? 'no_assistant_response'
+        : 'request_failed';
+}
+export async function requestReviewSummary({ credential, provider = 'zai', modelName, prompt, workspaceDir, }) {
     try {
+        const resolvedCredential = resolveReviewProviderCredential(credential);
+        if (!resolvedCredential) {
+            return failedReviewSummaryRequest({ reason: 'missing_credential' });
+        }
+        const resolvedModelName = modelName ?? resolvedCredential.modelName;
+        const logModelName = getReviewSummaryModelNameForLog({
+            provider,
+            piProviderId: resolvedCredential.piProviderId,
+            modelName: resolvedModelName,
+        });
+        logger.info('Review summary model request', {
+            provider,
+            modelName: logModelName,
+            promptLength: prompt.length,
+            timeoutMs: REVIEW_SUMMARY_TIMEOUT_MS,
+            thinkingLevel: REVIEW_SUMMARY_THINKING_LEVEL,
+        });
         const result = await invokePiPrompt({
-            provider: 'gemini',
-            apiKey,
+            provider,
+            apiKey: resolvedCredential.apiKey,
+            ...(resolvedCredential.piProviderId
+                ? { piProviderId: resolvedCredential.piProviderId }
+                : {}),
+            ...(resolvedModelName ? { modelName: resolvedModelName } : {}),
             prompt,
             cwd: workspaceDir ?? getWorkspaceDir(),
             timeoutMs: REVIEW_SUMMARY_TIMEOUT_MS,
             capabilityPreset: 'read-only',
+            thinkingLevel: REVIEW_SUMMARY_THINKING_LEVEL,
         });
         if (!result.ok) {
+            const reason = getRequestFailureReason(result);
             logger.warn('Review summary model request failed', {
+                reason,
+                provider,
+                modelName: logModelName,
+                error: result.error,
+                timedOut: result.timedOut,
+                durationMs: result.durationMs,
+                promptLength: prompt.length,
+            });
+            return failedReviewSummaryRequest({
+                reason,
                 error: result.error,
                 timedOut: result.timedOut,
+                durationMs: result.durationMs,
             });
-            return null;
         }
         const output = result.output;
         if (!output?.trim()) {
-            return null;
+            return failedReviewSummaryRequest({
+                reason: 'empty_output',
+                durationMs: result.durationMs,
+                outputChars: output?.length ?? 0,
+            });
+        }
+        const jsonCandidates = extractJsonCandidatesFromResponse(output);
+        if (jsonCandidates.length === 0) {
+            logger.warn('Review summary model output missing JSON', {
+                provider,
+                modelName: logModelName,
+                durationMs: result.durationMs,
+                outputChars: output.length,
+            });
+            return failedReviewSummaryRequest({
+                reason: 'missing_json',
+                durationMs: result.durationMs,
+                outputChars: output.length,
+            });
+        }
+        let parsed;
+        let parsedSuccessfully = false;
+        let parseError;
+        for (const jsonCandidate of jsonCandidates) {
+            try {
+                parsed = JSON.parse(jsonCandidate);
+                parsedSuccessfully = true;
+                break;
+            }
+            catch (error) {
+                parseError = error;
+            }
+        }
+        if (!parsedSuccessfully) {
+            logger.warn('Review summary model output contained invalid JSON', {
+                provider,
+                modelName: logModelName,
+                error: parseError instanceof Error ? parseError.message : String(parseError),
+                durationMs: result.durationMs,
+                outputChars: output.length,
+            });
+            return failedReviewSummaryRequest({
+                reason: 'invalid_json',
+                error: parseError instanceof Error ? parseError.message : String(parseError),
+                durationMs: result.durationMs,
+                outputChars: output.length,
+            });
         }
-        const start = output.indexOf('{');
-        const end = output.lastIndexOf('}');
-        if (start === -1 || end === -1 || end <= start) {
-            logger.warn('Review summary model output missing JSON delimiters');
-            return null;
+        if (!parsed || typeof parsed !== 'object') {
+            return failedReviewSummaryRequest({
+                reason: 'invalid_schema',
+                durationMs: result.durationMs,
+                outputChars: output.length,
+            });
+        }
+        const summaryResult = parsed;
+        if (typeof summaryResult.summary !== 'string') {
+            return failedReviewSummaryRequest({
+                reason: 'invalid_schema',
+                durationMs: result.durationMs,
+                outputChars: output.length,
+            });
+        }
+        if (!summaryResult.summary.trim()) {
+            return failedReviewSummaryRequest({
+                reason: 'empty_summary',
+                durationMs: result.durationMs,
+                outputChars: output.length,
+            });
         }
-        const jsonText = output.slice(start, end + 1);
-        const parsed = JSON.parse(jsonText);
+        logger.info('Review summary model response', {
+            provider,
+            modelName: logModelName,
+            durationMs: result.durationMs,
+            outputChars: output.length,
+            summaryChars: summaryResult.summary.trim().length,
+        });
         return {
-            summary: typeof parsed.summary === 'string' ? parsed.summary : '',
-            comments: Array.isArray(parsed.comments) ? parsed.comments : [],
+            status: 'succeeded',
+            summary: summaryResult.summary,
+            comments: Array.isArray(summaryResult.comments) ? summaryResult.comments : [],
+            durationMs: result.durationMs,
+            outputChars: output.length,
         };
     }
     catch (error) {
         logger.error('Review summary model request or parsing failed', {
             error: error instanceof Error ? error.message : String(error),
         });
-        return null;
+        return failedReviewSummaryRequest({
+            reason: 'request_failed',
+            error: error instanceof Error ? error.message : String(error),
+        });
     }
 }
 export function sanitizeInlineComments(comments, lineLookup) {

package/sandbox/dist/tasks/review/thinking-level.js

@@ -1,10 +1,12 @@
 export function getReviewThinkingLevel(model) {
     switch (model) {
+        case 'deepseek':
+            return 'high';
         case 'openai':
             return 'high';
+        case 'zai':
+            return 'high';
         case 'gemini':
             return 'high';
-        case 'anthropic':
-            return 'xhigh';
     }
 }

package/sandbox/node_modules/doistbot-repo-config/dist/index.d.ts

@@ -1,21 +1,14 @@
 import type { Logger } from 'doistbot-logging';
 import type { Octokit } from 'octokit';
 export declare const CONFIG_FILE_PATH = ".github/doistbot.yml";
-export declare const DEFAULT_COUNCIL_MODELS: readonly ["gemini", "openai"];
-type ParseCouncilModelsEnabledOptions = {
-    defaultModels?: readonly string[];
-};
+export declare const DEFAULT_REVIEW_MODELS: readonly ["gemini", "openai", "deepseek", "zai"];
+export type DefaultReviewModel = (typeof DEFAULT_REVIEW_MODELS)[number];
 export type RepoConfig = {
     review?: {
         skip_forks?: boolean;
         skip_drafts?: boolean;
         skip_title_pattern?: string;
         skip_branch_pattern?: string;
-        prompt_file?: string;
-        engine?: 'council' | 'multi_focus';
-        council?: {
-            enabled: boolean;
-        };
         /**
          * @deprecated Ignored as of #274. Doistbot now posts a GitHub Check
          * Run for every `/review` (always-on; no opt-in) when `HEAD_SHA` is
@@ -53,17 +46,6 @@ export declare function getLocalRepoConfig({ workspaceDir, logger, }: {
     workspaceDir: string;
     logger: Logger;
 }): RepoConfig | null;
-/**
- * Fetches a custom prompt file from the repository.
- * Returns null if the file doesn't exist.
- */
-export declare function getCustomPrompt({ octokit, owner, repo, path, ref, logger, }: FetchFileParams): Promise<string | null>;
-export declare function getLocalCustomPrompt({ workspaceDir, path: promptPath, logger, }: {
-    workspaceDir: string;
-    path: string;
-    logger: Logger;
-}): string | null;
-export declare function parseCouncilModelsEnabled(raw: string | undefined, { defaultModels }?: ParseCouncilModelsEnabledOptions): string[];
-export declare function getDefaultCouncilModels(): string[];
-export type { ReviewEngine } from './review-engine.js';
-export { DEFAULT_REVIEW_ENGINE, parseReviewEngine, resolveReviewEngine } from './review-engine.js';
+export declare function getDefaultReviewModels(): DefaultReviewModel[];
+export declare function parseReviewModelsEnabled(value: string | undefined): string[];
+export {};

package/sandbox/node_modules/doistbot-repo-config/dist/index.js

@@ -2,19 +2,10 @@ import fs from 'fs';
 import path from 'path';
 import { load as yamlLoad } from 'js-yaml';
 export const CONFIG_FILE_PATH = '.github/doistbot.yml';
-export const DEFAULT_COUNCIL_MODELS = ['gemini', 'openai'];
+export const DEFAULT_REVIEW_MODELS = ['gemini', 'openai', 'deepseek', 'zai'];
 function parseRepoConfigContent(content) {
     return yamlLoad(content);
 }
-function resolveWorkspacePath(workspaceDir, repoPath) {
-    const root = path.resolve(workspaceDir);
-    const resolved = path.resolve(root, repoPath);
-    const relative = path.relative(root, resolved);
-    if (relative.startsWith('..') || path.isAbsolute(relative)) {
-        return null;
-    }
-    return resolved;
-}
 async function fetchFileContent({ octokit, owner, repo, path, ref, logger, }) {
     const params = {
         owner,
@@ -99,80 +90,13 @@ export function getLocalRepoConfig({ workspaceDir, logger, }) {
         return null;
     }
 }
-/**
- * Fetches a custom prompt file from the repository.
- * Returns null if the file doesn't exist.
- */
-export async function getCustomPrompt({ octokit, owner, repo, path, ref, logger, }) {
-    let content;
-    try {
-        content = await fetchFileContent({ octokit, owner, repo, path, ref, logger });
-    }
-    catch (error) {
-        logger.warn('Error fetching custom prompt', {
-            component: 'repo-config',
-            repository: `${owner}/${repo}`,
-            path,
-            error: error instanceof Error ? error.message : String(error),
-        });
-        return null;
-    }
-    if (content !== null) {
-        logger.info('Loaded custom prompt', {
-            component: 'repo-config',
-            repository: `${owner}/${repo}`,
-            path,
-        });
-    }
-    return content;
-}
-export function getLocalCustomPrompt({ workspaceDir, path: promptPath, logger, }) {
-    const resolvedPath = resolveWorkspacePath(workspaceDir, promptPath);
-    if (resolvedPath === null) {
-        logger.warn('Custom prompt path escapes workspace', {
-            component: 'repo-config',
-            path: promptPath,
-        });
-        return null;
-    }
-    if (!fs.existsSync(resolvedPath)) {
-        return null;
-    }
-    try {
-        const content = fs.readFileSync(resolvedPath, 'utf8');
-        logger.info('Loaded local custom prompt', {
-            component: 'repo-config',
-            path: promptPath,
-        });
-        return content;
-    }
-    catch (error) {
-        logger.warn('Failed to load local custom prompt', {
-            component: 'repo-config',
-            path: promptPath,
-            error: error instanceof Error ? error.message : String(error),
-        });
-        return null;
-    }
-}
-export function parseCouncilModelsEnabled(raw, { defaultModels = DEFAULT_COUNCIL_MODELS } = {}) {
-    if (!raw?.trim()) {
-        return [...defaultModels];
-    }
-    const allowedModels = new Set(DEFAULT_COUNCIL_MODELS);
-    const models = [];
-    for (const token of raw.split(',')) {
-        const model = token.trim().toLowerCase();
-        if (!model || !allowedModels.has(model)) {
-            continue;
-        }
-        if (!models.includes(model)) {
-            models.push(model);
-        }
-    }
-    return models.length > 0 ? models : [...defaultModels];
+export function getDefaultReviewModels() {
+    return [...DEFAULT_REVIEW_MODELS];
 }
-export function getDefaultCouncilModels() {
-    return [...DEFAULT_COUNCIL_MODELS];
+export function parseReviewModelsEnabled(value) {
+    const models = value
+        ?.split(',')
+        .map((model) => model.trim())
+        .filter(Boolean) ?? [];
+    return models.length > 0 ? [...new Set(models)] : getDefaultReviewModels();
 }
-export { DEFAULT_REVIEW_ENGINE, parseReviewEngine, resolveReviewEngine } from './review-engine.js';

package/sandbox/_node_modules/doistbot-repo-config/dist/review-engine.d.ts

@@ -1,11 +0,0 @@
-export declare const DEFAULT_REVIEW_ENGINE: "multi_focus";
-export type ReviewEngine = 'council' | 'multi_focus';
-export declare function parseReviewEngine(raw: unknown): ReviewEngine | null;
-export declare function resolveReviewEngine({ configuredEngine, envEngine, logger, repository, }: {
-    configuredEngine?: unknown;
-    envEngine?: unknown;
-    logger?: {
-        warn: (message: string, context?: Record<string, unknown>) => void;
-    };
-    repository?: string;
-}): ReviewEngine;

package/sandbox/_node_modules/doistbot-repo-config/dist/review-engine.js

@@ -1,41 +0,0 @@
-export const DEFAULT_REVIEW_ENGINE = 'multi_focus';
-function isReviewEngine(value) {
-    return value === 'council' || value === 'multi_focus';
-}
-export function parseReviewEngine(raw) {
-    if (typeof raw !== 'string') {
-        return null;
-    }
-    const normalized = raw.trim().toLowerCase();
-    if (!normalized) {
-        return null;
-    }
-    return isReviewEngine(normalized) ? normalized : null;
-}
-export function resolveReviewEngine({ configuredEngine, envEngine, logger, repository, }) {
-    const configured = parseReviewEngine(configuredEngine);
-    if (configured) {
-        return configured;
-    }
-    if (configuredEngine != null) {
-        logger?.warn('Invalid configured review engine, checking environment override next', {
-            component: 'review-engine',
-            repository,
-            configured_engine: configuredEngine,
-            next_source: 'env',
-        });
-    }
-    const fromEnv = parseReviewEngine(envEngine);
-    if (fromEnv) {
-        return fromEnv;
-    }
-    if (envEngine != null) {
-        logger?.warn('Invalid env review engine, falling back', {
-            component: 'review-engine',
-            repository,
-            env_engine: envEngine,
-            fallback: DEFAULT_REVIEW_ENGINE,
-        });
-    }
-    return DEFAULT_REVIEW_ENGINE;
-}

package/sandbox/dist/providers/anthropic.js

@@ -1,30 +0,0 @@
-/**
- * Anthropic provider for the multi-model code review system.
- * Uses the Pi harness instead of the Claude CLI.
- */
-import { DEFAULT_PI_MODELS } from '../core/pi.js';
-import { resolveProviderTimeoutMs } from './config.js';
-import { extractJsonFromResponse } from './helpers.js';
-import { runPiReviewProvider } from './pi-review.js';
-export class AnthropicProvider {
-    name = 'anthropic';
-    async review(prompt, config, logOptions) {
-        return await runPiReviewProvider({
-            provider: this.name,
-            modelName: config.modelName ?? DEFAULT_PI_MODELS.anthropic,
-            prompt,
-            config: {
-                ...config,
-                timeout: resolveProviderTimeoutMs(config.timeout),
-            },
-            prompts: config.jsonSchema
-                ? [
-                    prompt,
-                    `${prompt}\n\nReturn only JSON that matches the provided schema. Do not include analysis text.`,
-                ]
-                : [prompt],
-            parseOutput: (output) => JSON.parse(extractJsonFromResponse(output)),
-            logOptions,
-        });
-    }
-}

package/sandbox/dist/tasks/review/author-format.js

@@ -1,14 +0,0 @@
-export const REVIEW_AUTHOR_EMAIL_PATTERN = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-export function normalizePrAuthor(prAuthor) {
-    return (prAuthor ?? '').trim().replace(/^@+/, '');
-}
-export function formatPrAuthorForGreeting(prAuthor) {
-    const normalizedAuthor = normalizePrAuthor(prAuthor);
-    if (!normalizedAuthor || normalizedAuthor.toLowerCase() === 'unknown') {
-        return null;
-    }
-    if (REVIEW_AUTHOR_EMAIL_PATTERN.test(normalizedAuthor)) {
-        return null;
-    }
-    return normalizedAuthor;
-}

package/sandbox/dist/tasks/review/author-profile.js

@@ -1,67 +0,0 @@
-import { isKnownAutomationLogin } from '../../core/bot-logins.js';
-import { logger } from '../../core/logging.js';
-import { formatPrAuthorForGreeting, REVIEW_AUTHOR_EMAIL_PATTERN } from './author-format.js';
-const URL_PATTERN = /^https?:\/\//i;
-const UNSAFE_GREETING_CHARS = new Set([
-    '@',
-    '<',
-    '>',
-    '{',
-    '}',
-    '[',
-    ']',
-    '(',
-    ')',
-    '`',
-    '*',
-    '_',
-    '#',
-    '|',
-    '\\',
-]);
-const MAX_GREETING_NAME_CHARS = 40;
-function hasUnsafeGreetingChar(value) {
-    return Array.from(value).some((char) => UNSAFE_GREETING_CHARS.has(char));
-}
-export function shouldExcludePrAuthorFromReviewSummary(login) {
-    const normalizedLogin = login?.trim().toLowerCase();
-    return isKnownAutomationLogin(normalizedLogin);
-}
-export function extractFirstNameFromProfileName(profileName) {
-    const normalized = profileName?.replace(/\s+/g, ' ').trim() ?? '';
-    if (!normalized) {
-        return null;
-    }
-    const firstToken = normalized.split(' ')[0]?.replace(/[.,;:!]+$/g, '') ?? '';
-    if (!firstToken ||
-        firstToken.length > MAX_GREETING_NAME_CHARS ||
-        REVIEW_AUTHOR_EMAIL_PATTERN.test(firstToken) ||
-        URL_PATTERN.test(firstToken) ||
-        hasUnsafeGreetingChar(firstToken) ||
-        !/\p{L}/u.test(firstToken)) {
-        return null;
-    }
-    return firstToken;
-}
-export async function resolvePrAuthorGreetingName({ octokit, login, }) {
-    const normalizedLogin = formatPrAuthorForGreeting(login);
-    if (!normalizedLogin || shouldExcludePrAuthorFromReviewSummary(normalizedLogin)) {
-        return undefined;
-    }
-    try {
-        const response = await octokit.rest.users.getByUsername({ username: normalizedLogin });
-        const greetingName = extractFirstNameFromProfileName(response.data.name);
-        if (!greetingName) {
-            logger.info('PR author GitHub profile name unavailable for greeting', {
-                profile_name_available: Boolean(response.data.name?.trim()),
-            });
-        }
-        return greetingName ?? undefined;
-    }
-    catch (error) {
-        logger.warn('Failed to resolve PR author GitHub profile name', {
-            error: error instanceof Error ? error.message : String(error),
-        });
-        return undefined;
-    }
-}

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

@@ -1,104 +0,0 @@
-/**
- * Normalizer module for deduplicating findings across multiple models.
- * Groups similar findings together based on location and content similarity.
- */
-import { randomUUID } from 'crypto';
-import { logger } from '../../../core/logging.js';
-const FUZZY_LINE_TOLERANCE = 3; // Consider findings within +-3 lines as potentially related
-/**
- * Creates a location key for exact matching.
- */
-function getLocationKey(finding) {
-    return `${finding.path}:${finding.line}:${finding.side}`;
-}
-/**
- * Creates location keys for fuzzy matching (within tolerance).
- */
-function getFuzzyLocationKeys(finding) {
-    const keys = [];
-    for (let offset = -FUZZY_LINE_TOLERANCE; offset <= FUZZY_LINE_TOLERANCE; offset++) {
-        const fuzzyLine = finding.line + offset;
-        if (fuzzyLine > 0) {
-            keys.push(`${finding.path}:${fuzzyLine}:${finding.side}`);
-        }
-    }
-    return keys;
-}
-/**
- * Normalizes and deduplicates findings from multiple model results.
- * Findings are grouped by:
- * 1. Exact location match (path:line:side)
- * 2. Fuzzy location match (same path, within +-3 lines, same side)
- */
-export function normalizeFindings(allFindings) {
-    if (allFindings.length === 0) {
-        return [];
-    }
-    const groups = [];
-    const findingToGroup = new Map(); // finding.id -> group
-    const locationToGroup = new Map(); // location -> group
-    for (const finding of allFindings) {
-        const exactKey = getLocationKey(finding);
-        // Check for exact match first
-        const existingGroup = locationToGroup.get(exactKey);
-        if (existingGroup) {
-            existingGroup.relatedFindings.push(finding);
-            if (!existingGroup.sourceModels.includes(finding.sourceModel)) {
-                existingGroup.sourceModels.push(finding.sourceModel);
-            }
-            findingToGroup.set(finding.id, existingGroup);
-            continue;
-        }
-        // Check for fuzzy match
-        const fuzzyKeys = getFuzzyLocationKeys(finding);
-        let fuzzyMatchGroup;
-        for (const fuzzyKey of fuzzyKeys) {
-            const group = locationToGroup.get(fuzzyKey);
-            if (group) {
-                // Only fuzzy match if it's from a different model
-                if (group.primaryFinding.sourceModel !== finding.sourceModel) {
-                    fuzzyMatchGroup = group;
-                    break;
-                }
-            }
-        }
-        if (fuzzyMatchGroup) {
-            fuzzyMatchGroup.relatedFindings.push(finding);
-            if (!fuzzyMatchGroup.sourceModels.includes(finding.sourceModel)) {
-                fuzzyMatchGroup.sourceModels.push(finding.sourceModel);
-            }
-            findingToGroup.set(finding.id, fuzzyMatchGroup);
-            // Also register this finding's exact location to the group
-            locationToGroup.set(exactKey, fuzzyMatchGroup);
-            continue;
-        }
-        // No match found, create a new group
-        const newGroup = {
-            id: randomUUID(),
-            primaryFinding: finding,
-            relatedFindings: [],
-            sourceModels: [finding.sourceModel],
-        };
-        groups.push(newGroup);
-        findingToGroup.set(finding.id, newGroup);
-        locationToGroup.set(exactKey, newGroup);
-    }
-    logger.info('Normalized council findings', {
-        originalCount: allFindings.length,
-        deduplicatedCount: groups.length,
-        groups,
-    });
-    return groups;
-}
-/**
- * Gets all findings from a group (primary + related).
- */
-export function getAllFindingsFromGroup(group) {
-    return [group.primaryFinding, ...group.relatedFindings];
-}
-/**
- * Gets the number of unique models that found something in this group.
- */
-export function getModelCountForGroup(group) {
-    return group.sourceModels.length;
-}