import fs from 'node:fs';
import path from 'node:path';
import { detectarArquetipos } from '../../analysts/architects/index.js';
import { normalizarOcorrenciaParaJson } from './index.js';
import { traduzirRelatorioJson } from './exporters/index.js';
import { configurarFiltros, exibirBlocoFiltros, expandIncludes, listarAnalistas, processPatternGroups, processPatternListAchatado } from '../processing/index.js';
import { chalk, config, isInsideConfigDirectory, isInsideSrc, isInsideTestsDirectory } from '../../core/config/index.js';
import { executarInquisicao, iniciarInquisicao, registrarUltimasMetricas } from '../../core/execution/index.js';
import { messages } from '../../core/messages/index.js';
import { aplicarSupressaoOcorrencias } from '../../core/parsing/index.js';
import { scanSystemIntegrity } from '../../guardian/index.js';
import { emitirConselhoTutanus } from '../../reports/index.js';
import { dedupeOcorrencias, stringifyJsonEscaped } from '../../shared/data-processing/index.js';
import { asTecnicas, converterResultadoGuardian, IntegridadeStatus } from '../../types/index.js';
const { log, logGuardian, logRelatorio, logSistema, MENSAGENS_AUTOFIX, CliProcessamentoExtraMensagens } = messages;
let salvarEstado;
async function getSalvarEstado() {
    if (salvarEstado)
        return salvarEstado;
    const candidates = process.env.VITEST ? ['@shared/persistence/persistencia.js', '@shared/persistence/persistencia.ts'] : ['@shared/persistence/persistencia.js'];
    for (const caminho of candidates) {
        try {
            const mod = await import(caminho).catch(() => undefined);
            if (mod && typeof mod.salvarEstado === 'function') {
                salvarEstado = mod.salvarEstado;
                break;
            }
        }
        catch (err) {
            log.debug(`Erro em getSalvarEstado (importação dinâmica): ${err instanceof Error ? err.message : String(err)}`);
        }
    }
    if (!salvarEstado) {
        const mod = await import('../../shared/persistence/index.js');
        salvarEstado = mod.salvarEstado;
    }
    return salvarEstado;
}
export { configurarFiltros, getDefaultExcludes } from '../processing/index.js';
const DETECTAR_TEMPO_LIMITE_MS = process.env.VITEST ? 1000 : 30000;
async function detectarArquetiposComTimeout(ctx, baseDir, options) {
    try {
        const detectPromise = detectarArquetipos(ctx, baseDir, options).catch(erro => {
            if (config.DEV_MODE) {
                const msg = erro instanceof Error ? erro.message : String(erro);
                log.erro(`Falha detector arquetipos: ${msg}`);
            }
            return undefined;
        });
        const timeoutPromise = new Promise(resolve => setTimeout(() => resolve(undefined), DETECTAR_TEMPO_LIMITE_MS));
        return (await Promise.race([detectPromise, timeoutPromise]));
    }
    catch {
        return undefined;
    }
}
async function exportarPorNivel(ocorrenciasLimpas, dir, id, salvar) {
    const erros = ocorrenciasLimpas.filter(ocorrencia => ocorrencia.nivel === 'erro' || ocorrencia.tipo === 'PARSE_ERRO' || ocorrencia.nivel === 'critico');
    const avisos = ocorrenciasLimpas.filter(ocorrencia => ocorrencia.nivel === 'aviso' || ocorrencia.nivel === 'alto' || ocorrencia.nivel === 'media');
    const infos = ocorrenciasLimpas.filter(ocorrencia => ocorrencia.nivel === 'info' || ocorrencia.nivel === 'baixa' || !ocorrencia.nivel);
    if (erros.length > 0) {
        await salvar(path.join(dir, `erro-${id}.json`), {
            timestamp: new Date().toISOString(),
            total: erros.length,
            ocorrencias: erros,
        });
    }
    if (avisos.length > 0) {
        await salvar(path.join(dir, `aviso-${id}.json`), {
            timestamp: new Date().toISOString(),
            total: avisos.length,
            ocorrencias: avisos,
        });
    }
    if (infos.length > 0) {
        await salvar(path.join(dir, `info-${id}.json`), {
            timestamp: new Date().toISOString(),
            total: infos.length,
            ocorrencias: infos,
        });
    }
}
function computeLinguagens(fes) {
    const extensoes = {};
    let sem_ext = 0;
    for (const arquivo of fes || []) {
        const rel = arquivo.relPath || arquivo.fullCaminho || '';
        const base = rel.split(/[\\/]/).pop() || '';
        const idx = base.lastIndexOf('.');
        if (idx === -1) {
            sem_ext++;
        }
        else {
            const ext = base.slice(idx + 1) || 'sem_ext';
            extensoes[ext] = (extensoes[ext] || 0) + 1;
        }
    }
    return { total: (fes || []).length, extensoes: { ...extensoes, sem_ext } };
}
function limparOcorrencia(oc) {
    return {
        tipo: oc.tipo,
        nivel: oc.nivel,
        mensagem: oc.mensagem,
        relPath: oc.relPath,
        linha: oc.linha,
        coluna: oc.coluna,
        ...(oc.sugestao ? { sugestao: oc.sugestao } : {}),
    };
}
async function executarAutoFixInterno(opts, ocorrenciasFiltradas, fileEntriesComAst, baseDir, totalOcorrencias) {
    if (!opts.autoFix) {
        return { ocorrenciasFiltradas, totalOcorrencias: ocorrenciasFiltradas.length };
    }
    try {
        const { findQuickFixes, applyQuickFix } = await import('../../core/config/auto/index.js');
        const { getAutoFixConfig } = await import('../../core/config/auto/index.js');
        let autoCorrecaoMode = opts.autoCorrecaoMode || 'balanced';
        if (opts.autoFixConservative) {
            autoCorrecaoMode = 'conservative';
            opts.autoFix = true;
        }
        const autoCorrecaoConfiguracao = getAutoFixConfig(autoCorrecaoMode);
        if (autoCorrecaoMode === 'conservative') {
            log.info(MENSAGENS_AUTOFIX.logs.modoConservador);
        }
        else if (autoCorrecaoMode === 'aggressive') {
            log.aviso(messages.CliProcessamentoDiagnosticoMensagens.autoFixModoAgressivo);
        }
        const quickFixesDisponiveis = ocorrenciasFiltradas.filter(occ => occ.tipo === 'auto-fix-disponivel' || occ.tipo === 'QUICK_FIX_DISPONIVEL');
        if (quickFixesDisponiveis.length === 0) {
            logSistema.autoFixNenhumaCorrecao();
            return { ocorrenciasFiltradas, totalOcorrencias: ocorrenciasFiltradas.length };
        }
        logSistema.autoFixAplicando(autoCorrecaoMode);
        let arquivosCorrigidos = 0;
        let totalCorrecoes = 0;
        let correcoesPuladas = 0;
        const correcoesPorArquivo = new Map();
        for (const fix of quickFixesDisponiveis) {
            const arquivo = fix.relPath || fix.arquivo;
            if (!arquivo)
                continue;
            if (!correcoesPorArquivo.has(arquivo)) {
                correcoesPorArquivo.set(arquivo, []);
            }
            correcoesPorArquivo.get(arquivo)?.push(fix);
        }
        const maxFixesPerArquivo = autoCorrecaoConfiguracao?.maxFixesPerArquivo ?? Infinity;
        for (const [arquivo, _fixes] of correcoesPorArquivo) {
            try {
                const fileEntrada = fileEntriesComAst?.find(fe => fe.relPath === arquivo || fe.fullCaminho === arquivo);
                if (!fileEntrada || typeof fileEntrada.content !== 'string') {
                    logSistema.autoFixArquivoNaoEncontrado(arquivo);
                    continue;
                }
                let codigoCorrigido = fileEntrada.content;
                let corrigiuAlgo = false;
                let correcoesPorArquivoContagem = 0;
                const quickFixesEncontrados = findQuickFixes(codigoCorrigido, undefined, autoCorrecaoConfiguracao, arquivo);
                for (const quickCorrecao of quickFixesEncontrados) {
                    if (correcoesPorArquivoContagem >= maxFixesPerArquivo) {
                        correcoesPuladas += quickCorrecao.matches.length;
                        break;
                    }
                    for (const match of quickCorrecao.matches) {
                        try {
                            const novocodigo = applyQuickFix(codigoCorrigido, quickCorrecao, match);
                            if (novocodigo !== codigoCorrigido) {
                                codigoCorrigido = novocodigo;
                                corrigiuAlgo = true;
                                totalCorrecoes++;
                                correcoesPorArquivoContagem++;
                                if (config.VERBOSE) {
                                    logSistema.autoFixAplicada(quickCorrecao.title, quickCorrecao.confidence);
                                }
                            }
                        }
                        catch (err) {
                            logSistema.autoFixFalha(quickCorrecao.id, err instanceof Error ? err.message : String(err));
                        }
                        if (correcoesPorArquivoContagem >= maxFixesPerArquivo) {
                            break;
                        }
                    }
                }
                if (corrigiuAlgo) {
                    const { promises: fs } = await import('node:fs');
                    const caminhoCompleto = path.isAbsolute(arquivo) ? arquivo : path.join(baseDir, arquivo);
                    await fs.writeFile(caminhoCompleto, codigoCorrigido, 'utf-8');
                    arquivosCorrigidos++;
                    if (config.VERBOSE) {
                        logSistema.autoFixCorrigido(arquivo);
                    }
                }
            }
            catch (err) {
                log.erro(CliProcessamentoExtraMensagens.erroAplicarCorrecoes.replace('{erro}', err instanceof Error ? err.message : String(err)));
            }
        }
        if (arquivosCorrigidos > 0) {
            const estatisticas = [`${totalCorrecoes} correções aplicadas em ${arquivosCorrigidos} arquivo(s)`];
            if (correcoesPuladas > 0) {
                estatisticas.push(`${correcoesPuladas} correções puladas (limite por arquivo: ${maxFixesPerArquivo === Infinity ? '∞' : maxFixesPerArquivo})`);
            }
            if (autoCorrecaoMode === 'conservative') {
                estatisticas.push('modo conservador (alta confiança apenas)');
            }
            logSistema.autoFixEstatisticas(estatisticas);
            if (process.env.TUTANUS_ESLINT_VALIDATION !== '0' && autoCorrecaoConfiguracao.validateAfterFix) {
                try {
                    log.info(MENSAGENS_AUTOFIX.logs.validacaoEslint);
                    const { spawn } = await import('node:child_process');
                    const arquivosParaValidar = Array.from(correcoesPorArquivo.keys());
                    if (arquivosParaValidar.length > 0) {
                        const eslintArgs = ['--fix', ...arquivosParaValidar];
                        const proc = spawn('npx', ['eslint', ...eslintArgs], {
                            cwd: baseDir,
                            stdio: 'pipe'
                        });
                        let stdout = '';
                        let _stderr = '';
                        proc.stdout?.on('data', data => {
                            stdout += data;
                        });
                        proc.stderr?.on('data', data => {
                            _stderr += data;
                        });
                        const ESLINT_TIMEOUT_MS = 30_000;
                        await new Promise((resolve) => {
                            const timer = setTimeout(() => {
                                proc.kill();
                                resolve();
                            }, ESLINT_TIMEOUT_MS);
                            const done = () => {
                                clearTimeout(timer);
                                resolve();
                            };
                            proc.on('close', code => {
                                if (code === 0) {
                                    logSistema.autoFixESLintHarmonia();
                                }
                                else {
                                    if (config.VERBOSE && stdout) {
                                        logSistema.processamentoESLintOutput(stdout);
                                    }
                                    logSistema.autoFixESLintAjustes();
                                }
                                done();
                            });
                            proc.on('error', err => {
                                logSistema.autoFixESLintFalha(err.message);
                                done();
                            });
                        });
                    }
                }
                catch (err) {
                    log.aviso(`[AVISO]  Validação ESLint não executada: ${err instanceof Error ? err.message : String(err)}`);
                }
            }
        }
        else {
            logSistema.autoFixNenhumaAplicada();
        }
        const ocorrenciasSemQuickFixes = ocorrenciasFiltradas.filter(occ => occ.tipo !== 'auto-fix-disponivel' && occ.tipo !== 'QUICK_FIX_DISPONIVEL');
        return { ocorrenciasFiltradas: ocorrenciasSemQuickFixes, totalOcorrencias: ocorrenciasSemQuickFixes.length };
    }
    catch (err) {
        log.erro(`[ERRO] Falha ao executar auto-fix: ${err instanceof Error ? err.message : String(err)}`);
        return { ocorrenciasFiltradas, totalOcorrencias };
    }
}
export async function processarDiagnostico(opts) {
    if (opts.monorepo && !opts.paths?.length) {
        try {
            const { detectarMonorepo } = await import('../../analysts/detectors/index.js');
            const info = detectarMonorepo(process.cwd());
            if (info.isMonorepo && info.workspaces.length > 0) {
                const dirs = info.workspaces.map(w => w.dir);
                opts.paths = dirs;
                log.sucesso(`Monorepo detectado: ${info.workspaces.length} workspaces (${info.type})`);
            }
            else {
                log.aviso('Modo monorepo ativado mas nenhum workspace foi encontrado');
            }
        }
        catch (err) {
            log.aviso(`Falha ao detectar monorepo: ${err instanceof Error ? err.message : String(err)}`);
        }
    }
    const projectPaths = opts.paths?.filter(Boolean) ?? [];
    if (projectPaths.length > 0) {
        const resultados = [];
        let totalArquivos = 0;
        const metricasAnalistas = [];
        const analisarProjeto = async (projetoPath) => {
            const projetoNome = path.basename(projetoPath);
            const cwdAnterior = process.cwd();
            try {
                process.chdir(projetoPath);
                const subOpts = { ...opts, paths: undefined };
                const subResult = await processarDiagnosticoInterno(subOpts);
                if (subResult) {
                    const ocorr = subResult.resultadoFinal?.ocorrencias ?? [];
                    const tagged = ocorr.map(o => ({
                        ...o,
                        projeto: projetoNome,
                        mensagem: `[${projetoNome}] ${o.mensagem}`
                    }));
                    return { tagged, totalArquivos: subResult.resultadoFinal?.metricas?.totalArquivos ?? 0, analistas: subResult.resultadoFinal?.metricas?.analistas ?? [] };
                }
                return { tagged: [], totalArquivos: 0, analistas: [] };
            }
            catch (err) {
                log.aviso(`Falha ao analisar projeto ${projetoNome}: ${err instanceof Error ? err.message : String(err)}`);
                return { tagged: [], totalArquivos: 0, analistas: [] };
            }
            finally {
                process.chdir(cwdAnterior);
            }
        };
        const resultadosProjetos = await Promise.all(projectPaths.map(analisarProjeto));
        for (const r of resultadosProjetos) {
            resultados.push(...r.tagged);
            totalArquivos += r.totalArquivos;
            metricasAnalistas.push(...r.analistas);
        }
        if (opts.json) {
            const saidaJson = {
                meta: { multiProjeto: true, projetos: projectPaths.length, totalOcorrencias: resultados.length },
                totalArquivos,
                ocorrencias: resultados,
                metricas: { analistas: metricasAnalistas }
            };
            console.log(JSON.stringify(saidaJson, null, 2));
        }
        else {
            log.sucesso(`Análise multi-projeto concluída: ${projectPaths.length} projetos, ${resultados.length} ocorrências`);
        }
        return {
            totalOcorrencias: resultados.length,
            temErro: false,
            fileEntriesComAst: [],
            resultadoFinal: { ocorrencias: resultados, metricas: { totalArquivos, tempoTotal: 0, analistas: metricasAnalistas } }
        };
    }
    const resultado = await processarDiagnosticoInterno(opts);
    return resultado ?? {
        totalOcorrencias: 0,
        temErro: false,
        guardianResultado: undefined,
        fileEntriesComAst: [],
        resultadoFinal: {
            ocorrencias: [],
            metricas: { totalArquivos: 0, tempoTotal: 0, analistas: [] }
        }
    };
}
async function processarDiagnosticoInterno(opts) {
    const logExt = log;
    const optsDyn = opts;
    const configDyn = config;
    config.GUARDIAN_ENABLED = opts.guardianCheck ?? false;
    config.VERBOSE = opts.full ?? false;
    if (optsDyn.compact !== undefined) {
        config.COMPACT_MODE = Boolean(optsDyn.compact);
    }
    else {
        config.COMPACT_MODE = !opts.full;
    }
    if (opts.logNivel && ['erro', 'aviso', 'info', 'debug'].includes(opts.logNivel)) {
        config.LOG_LEVEL = opts.logNivel;
    }
    if (opts.stream) {
        config.REPORT_STREAM_ENABLED = true;
    }
    const includeGroupsRaw = processPatternGroups(opts.include);
    const includeGroupsExpanded = includeGroupsRaw.map(grupo => expandIncludes(grupo));
    const includeListFlat = includeGroupsExpanded.flat();
    const excludeList = processPatternListAchatado(opts.exclude);
    const incluiNodeModules = includeListFlat.some(caminho => /node_modules/.test(caminho));
    exibirBlocoFiltros(includeGroupsExpanded, includeListFlat, excludeList, incluiNodeModules);
    configurarFiltros(includeGroupsRaw, includeListFlat, excludeList, incluiNodeModules);
    const baseDir = process.cwd();
    let guardianResultado;
    let fileEntries = [];
    let totalOcorrencias = 0;
    let _jsonEmitted = false;
    if (opts.listarAnalistas && !opts.json) {
        await listarAnalistas();
    }
    try {
        if (opts.json) {
        }
        else if (!config.COMPACT_MODE) {
            logExt.fase?.('Iniciando diagnóstico completo');
        }
        else {
            logExt.fase?.('Diagnóstico (modo compacto)');
        }
        logExt.fase?.('Varredura');
        const leituraInicial = await iniciarInquisicao(baseDir, {
            incluirMetadados: false,
            skipExec: true
        });
        fileEntries = leituraInicial.fileEntries;
        if (opts.criarArquetipo) {
            try {
                const norm = (caminho) => caminho.replace(/\\/g, '/');
                const dirSet = new Set();
                const arquivosRaiz = [];
                for (const fe of fileEntries) {
                    const rel = norm(fe.relPath || fe.fullCaminho || '');
                    if (!rel)
                        continue;
                    if (!rel.includes('/')) {
                        arquivosRaiz.push(rel);
                    }
                    const parts = rel.split('/');
                    if (parts.length > 1) {
                        for (let indice = 1; indice < parts.length; indice++) {
                            const dirPath = parts.slice(0, indice).join('/');
                            if (dirPath)
                                dirSet.add(dirPath);
                        }
                    }
                }
                let nomeProjeto = path.basename(baseDir);
                try {
                    const pkg = fileEntries?.find(fe => /(^|[\\/])package\.json$/.test(fe.relPath || fe.fullCaminho));
                    if (pkg && typeof pkg.content === 'string' && pkg.content.trim()) {
                        const parsed = JSON.parse(pkg.content);
                        if (parsed && typeof parsed.name === 'string' && parsed.name.trim()) {
                            nomeProjeto = parsed.name.trim();
                        }
                    }
                    else {
                        const pkgCaminho = path.join(baseDir, 'package.json');
                        try {
                            const raw = await fs.promises.readFile(pkgCaminho, 'utf-8');
                            const parsed = JSON.parse(raw);
                            if (parsed && typeof parsed.name === 'string' && parsed.name.trim()) {
                                nomeProjeto = parsed.name.trim();
                            }
                        }
                        catch (err) {
                            log.debug(`Erro ao ler package.json (fallback): ${err instanceof Error ? err.message : String(err)}`);
                        }
                    }
                }
                catch (err) {
                    log.debug(`Erro ao obter nome do projeto do package.json: ${err instanceof Error ? err.message : String(err)}`);
                }
                const estruturaDetectada = Array.from(dirSet);
                const { criarTemplateArquetipoPersonalizado, salvarArquetipoPersonalizado } = await import('../../analysts/architects/index.js');
                const arquetipo = criarTemplateArquetipoPersonalizado(nomeProjeto, estruturaDetectada, arquivosRaiz, 'generico');
                if (opts.salvarArquetipo) {
                    await salvarArquetipoPersonalizado(arquetipo, baseDir);
                }
                else if (config.VERBOSE) {
                    log.info(messages.CliProcessamentoDiagnosticoMensagens.templateArquetipoPreview);
                }
            }
            catch (erro) {
                log.aviso(`Falha ao gerar/salvar arquétipo personalizado: ${erro instanceof Error ? erro.message : String(erro)}`);
            }
        }
        if (config.GUARDIAN_ENABLED) {
            logExt.fase?.('Verificando integridade do Tutanus');
            try {
                const resultado = await scanSystemIntegrity(fileEntries, {
                    suppressLogs: true
                });
                guardianResultado = resultado;
                switch (resultado.status) {
                    case IntegridadeStatus.Ok:
                        logGuardian.integridadeOk();
                        break;
                    case IntegridadeStatus.Criado:
                        logGuardian.baselineCriado();
                        break;
                    case IntegridadeStatus.Aceito:
                        logGuardian.baselineAceito();
                        break;
                    case IntegridadeStatus.AlteracoesDetectadas:
                        logGuardian.alteracoesDetectadas();
                        totalOcorrencias++;
                        break;
                }
            }
            catch (err) {
                logGuardian.bloqueado();
                if (config.GUARDIAN_ENFORCE_PROTECTION && typeof err === 'object' && err && 'detalhes' in err && Array.isArray(err.detalhes)) {
                    err.detalhes.forEach(diretorio => {
                        logGuardian.aviso(diretorio);
                    });
                    if (!process.env.VITEST) {
                        try {
                            process.exit(1);
                        }
                        catch (erro) {
                            throw erro;
                        }
                    }
                }
                else {
                    logGuardian.modoPermissivo();
                }
            }
        }
        if (config.SCAN_ONLY) {
            log.info(chalk.bold(`\n`));
            logGuardian.scanOnly(fileEntries.length);
            if (config.REPORT_EXPORT_ENABLED) {
                try {
                    const ts = new Date().toISOString().replace(/[:.]/g, '-');
                    const dir = typeof config.REPORT_OUTPUT_DIR === 'string' ? config.REPORT_OUTPUT_DIR : path.join(baseDir, 'reports');
                    const fs = await import('node:fs');
                    await fs.promises.mkdir(dir, {
                        recursive: true
                    });
                    const nome = `tutanus-scan-${ts}`;
                    const resumo = {
                        modo: 'scan-only',
                        totalArquivos: fileEntries.length,
                        timestamp: new Date().toISOString()
                    };
                    const salvar = await getSalvarEstado();
                    await salvar(path.join(dir, `${nome}.json`), resumo);
                    log.sucesso(messages.CliProcessamentoDiagnosticoMensagens.relatorioScanSalvo(dir));
                }
                catch (erro) {
                    const msg = messages.CliProcessamentoDiagnosticoMensagens.falhaExportarRelatorioScanOnly(erro instanceof Error ? erro.message : String(erro));
                    log.erro(msg);
                }
            }
            if (opts.json) {
                console.log(JSON.stringify({
                    modo: 'scan-only',
                    totalArquivos: fileEntries.length
                }));
            }
            if (!process.env.VITEST && !opts.json)
                process.exit(0);
            else if (!process.env.VITEST && opts.json)
                process.exitCode = 0;
            return {
                totalOcorrencias: 0,
                temErro: false,
                guardianResultado,
                fileEntriesComAst: [],
                resultadoFinal: {
                    ocorrencias: [],
                    metricas: {
                        totalArquivos: 0,
                        tempoTotal: 0,
                        analistas: []
                    }
                }
            };
        }
        const fastMode = Boolean(opts.fast);
        let fileEntriesComAst = fileEntries.map(entry => ({
            ...entry,
            ast: undefined
        }));
        if (fastMode) {
            const fmConfig = configDyn.fastMode;
            if (fmConfig?.conventions && typeof fmConfig.conventions === 'object') {
                Object.assign(config.conventions, fmConfig.conventions);
            }
            fileEntriesComAst = fileEntriesComAst.filter(fe => {
                const rel = fe.relPath || fe.fullCaminho || '';
                if (!rel)
                    return false;
                const isSrc = isInsideSrc(rel);
                const isTest = isInsideTestsDirectory(rel);
                const isConfig = isInsideConfigDirectory(rel);
                return isSrc && !isTest && !isConfig;
            });
        }
        const arquetiposResultado = await detectarArquetiposComTimeout({
            arquivos: fileEntriesComAst,
            baseDir
        }, baseDir, {
            quiet: opts.json
        });
        const registro = (await import('../../analysts/registry/index.js')).registroAnalistas;
        let tecnicas = asTecnicas(registro);
        if (fastMode) {
            const fmFastMode = configDyn.fastMode;
            const includeList = Array.isArray(fmFastMode?.analystsInclude) ? fmFastMode.analystsInclude : [];
            const excludeList = Array.isArray(fmFastMode?.analystsExclude) ? fmFastMode.analystsExclude : [];
            tecnicas = asTecnicas(registro.filter(arquivo => {
                const nomeRaw = arquivo.nome || '';
                const norm = (string) => string.toLowerCase().replace(/[^a-z0-9]+/g, '-');
                const nome = norm(nomeRaw);
                const matchIncluir = includeList.length ? includeList.some(node => {
                    const nn = norm(node);
                    return nome.includes(nn) || nomeRaw.toLowerCase().includes(node.toLowerCase());
                }) : true;
                const matchExcluir = excludeList.some(node => {
                    const nn = norm(node);
                    return nome.includes(nn) || nomeRaw.toLowerCase().includes(node.toLowerCase());
                });
                return matchIncluir && !matchExcluir;
            }));
        }
        logExt.fase?.('Executando analistas');
        try {
            const verifyCycles = Boolean(optsDyn.verifyCycles || configDyn.SPECIAL_VERIFY_CYCLES);
            configDyn.SPECIAL_VERIFY_CYCLES = verifyCycles;
        }
        catch (err) {
            log.debug(`Erro ao configurar flags especiais (verifyCycles): ${err instanceof Error ? err.message : String(err)}`);
        }
        const resultadoExecucao = await executarInquisicao(fileEntriesComAst, tecnicas, baseDir, converterResultadoGuardian(guardianResultado), {
            verbose: config.VERBOSE,
            compact: config.COMPACT_MODE,
            fast: opts.fast,
        });
        registrarUltimasMetricas(resultadoExecucao.metricas);
        let ocorrenciasFiltradas = dedupeOcorrencias(resultadoExecucao.ocorrencias || []);
        const trustCompiler = Boolean(optsDyn.trustCompiler || configDyn.SPECIAL_TRUST_COMPILER);
        if (trustCompiler) {
            try {
                fs.statSync(path.join(baseDir, 'tsconfig.json'));
                ocorrenciasFiltradas = ocorrenciasFiltradas.filter(ocorrencia => {
                    const regra = ocorrencia.tipo || '';
                    const cobertas = [/import.*nao.*usado/i, /tipo-inseguro.*unknown/i];
                    return !cobertas.some(raiz => raiz.test(regra));
                });
            }
            catch (err) {
                log.debug(`Erro em processarDiagnostico (trustCompiler): ${err instanceof Error ? err.message : String(err)}`);
            }
        }
        try {
            const byLoc = new Map();
            for (const ocorrencia of ocorrenciasFiltradas) {
                const key = `${ocorrencia.relPath || ''}:${ocorrencia.linha || 0}`;
                const tipo = ocorrencia.tipo || '';
                if (!byLoc.has(key))
                    byLoc.set(key, {
                        tipos: new Set(),
                        items: []
                    });
                const entry = byLoc.get(key);
                if (!entry)
                    continue;
                entry.tipos.add(tipo);
                entry.items.push(ocorrencia);
            }
            for (const [, entry] of byLoc) {
                const tipos = Array.from(entry.tipos);
                const hasTipoUnsafe = tipos.some(t => t.startsWith('tipo-inseguro'));
                const hasComplexity = tipos.some(t => /complexidade|funcoes-longas/i.test(t));
                if (hasTipoUnsafe && hasComplexity) {
                    for (const item of entry.items) {
                        const tipo = String(item.tipo || '');
                        if (tipo.startsWith('tipo-inseguro')) {
                            item.nivel = 'aviso';
                            item.mensagem = `${item.mensagem} | Conciliação: inferência e tipagem explícita em conflito; revisar caso`;
                        }
                    }
                }
            }
        }
        catch (err) {
            log.debug(`Erro em processarDiagnostico (conciliação analistas): ${err instanceof Error ? err.message : String(err)}`);
        }
        ocorrenciasFiltradas = aplicarSupressaoOcorrencias(ocorrenciasFiltradas, config);
        const totalOcorrenciasProcessadas = ocorrenciasFiltradas.length;
        if (opts.fix && !opts.autoFix) {
            opts.autoFix = true;
            logSistema.processamentoFixDetectada();
        }
        if (opts.fixSafe && !opts.autoFixConservative) {
            opts.autoFixConservative = true;
            opts.autoFix = true;
            log.info(MENSAGENS_AUTOFIX.flags.fixSafe);
        }
        const autoFixResult = await executarAutoFixInterno(opts, ocorrenciasFiltradas, fileEntriesComAst, baseDir, totalOcorrencias);
        ocorrenciasFiltradas = autoFixResult.ocorrenciasFiltradas;
        totalOcorrencias = autoFixResult.totalOcorrencias;
        const tiposOcorrencias = new Map();
        const nivelOcorrencias = new Map();
        ocorrenciasFiltradas.forEach(ocorrencia => {
            const tipo = ocorrencia.tipo || 'DESCONHECIDO';
            const nivel = ocorrencia.nivel || 'info';
            tiposOcorrencias.set(tipo, (tiposOcorrencias.get(tipo) || 0) + 1);
            nivelOcorrencias.set(nivel, (nivelOcorrencias.get(nivel) || 0) + 1);
        });
        if (tiposOcorrencias.size > 0 && !opts.json) {
            if (opts.executive) {
                try {
                    const criticos = nivelOcorrencias.get('erro') || 0;
                    const altos = nivelOcorrencias.get('alto') || 0;
                    const total = totalOcorrenciasProcessadas;
                    const arquivoContagem = new Map();
                    for (const oc of ocorrenciasFiltradas) {
                        const pathChave = (oc.relPath || oc.arquivo || 'desconhecido');
                        const nivel = oc.nivel || 'info';
                        if (nivel === 'erro' || nivel === 'alto') {
                            arquivoContagem.set(pathChave, (arquivoContagem.get(pathChave) || 0) + 1);
                        }
                    }
                    const topArquivos = Array.from(arquivoContagem.entries()).sort((arquivo, base) => base[1] - arquivo[1]).slice(0, 5);
                    const header = messages.CliProcessamentoDiagnosticoMensagens.resumoExecutivoHeader(total, criticos, altos);
                    if (typeof logExt.imprimirBloco === 'function') {
                        const linhas = [messages.CliProcessamentoDiagnosticoMensagens.resumoExecutivoCriticos(criticos), messages.CliProcessamentoDiagnosticoMensagens.resumoExecutivoAltos(altos), messages.CliProcessamentoDiagnosticoMensagens.linhaEmBranco, messages.CliProcessamentoDiagnosticoMensagens.resumoExecutivoTopArquivosErrosAltos, ...topArquivos.map(([arquivo, elem]) => messages.CliProcessamentoDiagnosticoMensagens.resumoExecutivoBulletTopArquivo(arquivo, elem)), messages.CliProcessamentoDiagnosticoMensagens.linhaEmBranco, messages.CliProcessamentoDiagnosticoMensagens.resumoExecutivoAcaoSugerida];
                        logExt.imprimirBloco(header, linhas);
                    }
                    else {
                        log.info(header);
                        if (topArquivos.length > 0) {
                            log.info(messages.CliProcessamentoDiagnosticoMensagens.resumoExecutivoTopArquivosErrosAltos);
                            topArquivos.forEach(([arquivo, elem]) => log.info(messages.CliProcessamentoDiagnosticoMensagens.resumoExecutivoBulletTopArquivo(arquivo, elem)));
                        }
                        log.info(messages.CliProcessamentoDiagnosticoMensagens.resumoExecutivoAcaoSugerida);
                    }
                }
                catch {
                }
            }
            else if (!config.VERBOSE && !config.DEV_MODE) {
                logSistema.processamentoResumoOcorrencias(totalOcorrenciasProcessadas);
                const topTipos = Array.from(tiposOcorrencias.entries()).sort((arquivo, base) => base[1] - arquivo[1]).slice(0, 10);
                console.log(messages.CliProcessamentoDiagnosticoMensagens.linhaEmBranco);
                console.log(messages.CliProcessamentoDiagnosticoMensagens.principaisTiposTitulo);
                topTipos.forEach(([tipo, count]) => {
                    console.log(messages.CliProcessamentoDiagnosticoMensagens.principaisTiposLinha(tipo, count));
                });
                try {
                    const arquivoContagem = new Map();
                    for (const oc of ocorrenciasFiltradas) {
                        const pathChave = (oc.relPath || oc.arquivo || 'desconhecido');
                        arquivoContagem.set(pathChave, (arquivoContagem.get(pathChave) || 0) + 1);
                    }
                    const topArquivos = Array.from(arquivoContagem.entries()).sort((arquivo, base) => base[1] - arquivo[1]).slice(0, 10);
                    if (topArquivos.length > 0) {
                        console.log(messages.CliProcessamentoDiagnosticoMensagens.linhaEmBranco);
                        console.log(messages.CliProcessamentoDiagnosticoMensagens.topArquivosTitulo);
                        topArquivos.forEach(([arquivo, elem]) => console.log(messages.CliProcessamentoDiagnosticoMensagens.topArquivosLinha(arquivo, elem)));
                    }
                }
                catch {
                }
                console.log(messages.CliProcessamentoDiagnosticoMensagens.linhaEmBranco);
                logSistema.processamentoDicasContextuais();
                const totalTodos = tiposOcorrencias.get('TODO_PENDENTE') || 0;
                const totalQuickFixes = (tiposOcorrencias.get('QUICK_FIX_DISPONIVEL') || 0) + (tiposOcorrencias.get('auto-fix-disponivel') || 0);
                const totalErros = nivelOcorrencias.get('erro') || 0;
                const totalAvisos = nivelOcorrencias.get('aviso') || 0;
                if (totalErros > 0) {
                    logSistema.processamentoErrosCriticos(totalErros);
                }
                if (totalAvisos > 0) {
                    logSistema.processamentoAvisosEncontrados(totalAvisos);
                }
                if (totalQuickFixes > 10) {
                    logSistema.processamentoQuickFixesMuitos(totalQuickFixes);
                    logSistema.processamentoQuickFixesComando();
                    logSistema.processamentoQuickFixesExecutar();
                }
                else if (totalQuickFixes > 0) {
                    logSistema.processamentoQuickFixesMuitos(totalQuickFixes);
                    logSistema.processamentoQuickFixesComando();
                    logSistema.processamentoQuickFixesExecutar();
                }
                if (totalTodos > 50) {
                    logSistema.processamentoTodosMuitos(totalTodos);
                }
                else if (totalTodos > 0) {
                    logSistema.processamentoTodosPoucos(totalTodos);
                }
                const MAX_OCORRENCIAS_WARN_THRESHOLD = 1000;
                if (totalOcorrenciasProcessadas > MAX_OCORRENCIAS_WARN_THRESHOLD) {
                    logSistema.processamentoMuitasOcorrencias();
                    logSistema.processamentoFiltrarPasta();
                }
                logSistema.processamentoUsarFull();
                logSistema.processamentoUsarJson();
                if (totalOcorrenciasProcessadas < 100) {
                    logSistema.processamentoProjetoLimpo();
                }
            }
            else {
                logSistema.processamentoDetalhamentoOcorrencias(totalOcorrenciasProcessadas);
                log.info(messages.CliProcessamentoDiagnosticoMensagens.porTipoTitulo);
                Array.from(tiposOcorrencias.entries()).sort((arquivo, base) => base[1] - arquivo[1]).forEach(([tipo, count]) => {
                    log.info(messages.CliProcessamentoDiagnosticoMensagens.porTipoLinha(tipo, count));
                });
                log.info(messages.CliProcessamentoDiagnosticoMensagens.porSeveridadeTitulo);
                Array.from(nivelOcorrencias.entries()).sort((arquivo, base) => base[1] - arquivo[1]).forEach(([nivel, count]) => {
                    const emoji = nivel === 'erro' ? '[RED]' : nivel === 'aviso' ? '[YELLOW]' : '[BLUE]';
                    log.info(messages.CliProcessamentoDiagnosticoMensagens.porSeveridadeLinha(emoji, nivel, count));
                });
                try {
                    const arquivosContagem = new Map();
                    for (const oc of ocorrenciasFiltradas) {
                        const key = (oc.relPath || oc.arquivo || 'desconhecido');
                        arquivosContagem.set(key, (arquivosContagem.get(key) || 0) + 1);
                    }
                    const topArquivosAll = Array.from(arquivosContagem.entries()).sort((arquivo, base) => base[1] - arquivo[1]).slice(0, 10);
                    if (topArquivosAll.length) {
                        if (typeof logExt.imprimirBloco === 'function') {
                            const linhas = [messages.CliProcessamentoDiagnosticoMensagens.topArquivosPorOcorrenciasTitulo, ...topArquivosAll.map(([arquivo, elem]) => messages.CliProcessamentoDiagnosticoMensagens.resumoExecutivoBulletTopArquivo(arquivo, elem))];
                            logExt.imprimirBloco(messages.CliProcessamentoDiagnosticoMensagens.arquivosMaisOcorrenciasTitulo, linhas);
                        }
                        else {
                            log.info(messages.CliProcessamentoDiagnosticoMensagens.topArquivosPorOcorrenciasTitulo);
                            topArquivosAll.forEach(([arquivo, elem]) => log.info(messages.CliProcessamentoDiagnosticoMensagens.resumoExecutivoBulletTopArquivo(arquivo, elem)));
                        }
                    }
                    const criticosOuAltos = [];
                    for (const oc of ocorrenciasFiltradas) {
                        const nivel = (oc.nivel || 'info').toString().toLowerCase();
                        if (nivel === 'erro' || nivel === 'alto') {
                            criticosOuAltos.push({
                                arquivo: oc.relPath || oc.arquivo || 'desconhecido',
                                tipo: oc.tipo || 'desconhecido',
                                nivel,
                                linha: typeof oc.linha === 'number' ? oc.linha : undefined,
                                coluna: typeof oc.coluna === 'number' ? oc.coluna : undefined
                            });
                        }
                    }
                    const ordemNivel = (node) => node === 'erro' ? 3 : node === 'alto' ? 2 : node === 'aviso' ? 1 : 0;
                    const topCriticos = criticosOuAltos.sort((arquivo, base) => ordemNivel(base.nivel) - ordemNivel(arquivo.nivel)).slice(0, 10);
                    if (topCriticos.length) {
                        if (typeof logExt.imprimirBloco === 'function') {
                            const linhas = topCriticos.map(elem => {
                                const pos = typeof elem.linha === 'number' ? `:${elem.linha}${typeof elem.coluna === 'number' ? `:${elem.coluna}` : ''}` : '';
                                return messages.CliProcessamentoDiagnosticoMensagens.topCriticosLinha(elem.nivel.toUpperCase(), elem.tipo, elem.arquivo, pos);
                            });
                            logExt.imprimirBloco(messages.CliProcessamentoDiagnosticoMensagens.topCriticosTitulo, linhas);
                        }
                        else {
                            log.info(messages.CliProcessamentoDiagnosticoMensagens.topCriticosTituloComDoisPontos);
                            topCriticos.forEach(elem => {
                                const pos = typeof elem.linha === 'number' ? `:${elem.linha}${typeof elem.coluna === 'number' ? `:${elem.coluna}` : ''}` : '';
                                log.info(messages.CliProcessamentoDiagnosticoMensagens.topCriticosLinha(elem.nivel.toUpperCase(), elem.tipo, elem.arquivo, pos));
                            });
                        }
                    }
                    const SAMPLE_MAX = 50;
                    const sample = ocorrenciasFiltradas.slice(0, SAMPLE_MAX).map(ocorrencia => `${ocorrencia.relPath}:${ocorrencia.linha ?? ''} [${ocorrencia.nivel ?? ''}] ${String(ocorrencia.mensagem ?? '').replace(/\n/g, ' ')}`);
                    if (sample.length) {
                        if (typeof logExt.imprimirBloco === 'function') {
                            logExt.imprimirBloco(messages.CliProcessamentoDiagnosticoMensagens.amostraBlocoTitulo(sample.length), sample.slice(0, 20));
                        }
                        else {
                            log.info(messages.CliProcessamentoDiagnosticoMensagens.amostraOcorrenciasTitulo);
                            sample.slice(0, 20).forEach(string => log.info(messages.CliProcessamentoDiagnosticoMensagens.amostraLinhaIndentada(string)));
                        }
                        if (ocorrenciasFiltradas.length > SAMPLE_MAX) {
                            log.info(messages.CliProcessamentoDiagnosticoMensagens.amostraMaisLinhas(SAMPLE_MAX, ocorrenciasFiltradas.length));
                        }
                    }
                }
                catch {
                }
            }
        }
        if (config.VERBOSE || config.DEV_MODE) {
            if (config.DEV_MODE && !opts.json && resultadoExecucao.metricas) {
                if (resultadoExecucao.metricas.analistas) {
                    const analistasComOcorrencias = resultadoExecucao.metricas.analistas.filter(arquivo => (arquivo.ocorrencias ?? 0) > 0);
                    logSistema.processamentoAnalistasProblemas(analistasComOcorrencias.length);
                    analistasComOcorrencias.forEach(analista => {
                        log.info(messages.CliProcessamentoDiagnosticoMensagens.analistaOcorrenciasLinha(analista.nome, analista.ocorrencias, analista.duracaoMs.toFixed(1)));
                    });
                }
            }
        }
        try {
            if (!opts.json && !config.SCAN_ONLY && totalOcorrencias === 0) {
                logRelatorio.repositorioImpecavel();
            }
        }
        catch (err) {
            log.debug(`Erro ao emitir log de repositório impecável: ${err instanceof Error ? err.message : String(err)}`);
        }
        if (process.env.VITEST && !opts.json) {
            log.info(messages.CliProcessamentoDiagnosticoMensagens.diagnosticoConcluido);
        }
        if (arquetiposResultado) {
            if (config.VERBOSE && arquetiposResultado.candidatos?.length > 0) {
                log.info(messages.CliProcessamentoDiagnosticoMensagens.arquetiposDetectados(arquetiposResultado.candidatos.length));
            }
            if (!config.VERBOSE && config.COMPACT_MODE && arquetiposResultado.candidatos?.length > 0) {
                const topCandidato = arquetiposResultado.candidatos[0];
                log.info(messages.CliProcessamentoDiagnosticoMensagens.arquetiposCompact(topCandidato.nome, topCandidato.confidence));
            }
            if (!config.VERBOSE && arquetiposResultado.candidatos?.length > 0) {
                log.info(messages.CliProcessamentoDiagnosticoMensagens.arquetiposCandidatosEncontrados(arquetiposResultado.candidatos.length));
            }
            if (config.VERBOSE && arquetiposResultado.candidatos?.length > 0) {
                const candidatoTop = arquetiposResultado.candidatos[0];
                log.info(messages.CliProcessamentoDiagnosticoMensagens.arquetiposCandidatosTitulo);
                for (const candidato of arquetiposResultado.candidatos.slice(0, 3)) {
                    log.info(messages.CliProcessamentoDiagnosticoMensagens.arquetiposCandidatoLinha(candidato.nome, candidato.confidence));
                }
                if (candidatoTop.planoSugestao) {
                    const plano = candidatoTop.planoSugestao;
                    if (plano.mover && plano.mover.length > 0) {
                        log.info(messages.CliProcessamentoDiagnosticoMensagens.planoSugestaoMove(plano.mover.length));
                    }
                    else {
                        log.info(messages.CliProcessamentoDiagnosticoMensagens.planoSugestaoNenhumMove);
                    }
                    if (plano.conflitos && plano.conflitos.length > 0) {
                        log.info(messages.CliProcessamentoDiagnosticoMensagens.conflitos(plano.conflitos.length));
                    }
                }
                if (candidatoTop.anomalias && candidatoTop.anomalias.length > 0) {
                    const tituloAnomalias = messages.CliProcessamentoDiagnosticoMensagens.anomaliasTitulo;
                    const linhasAnomalias = [];
                    for (const anomalia of candidatoTop.anomalias.slice(0, 8)) {
                        linhasAnomalias.push(messages.CliProcessamentoDiagnosticoMensagens.anomaliaLinha(anomalia.path, anomalia.motivo));
                    }
                    if (candidatoTop.anomalias.length > 8) {
                        linhasAnomalias.push(messages.CliProcessamentoDiagnosticoMensagens.anomaliasMais(candidatoTop.anomalias.length - 8));
                    }
                    if (typeof logExt.imprimirBloco === 'function') {
                        logExt.imprimirBloco(tituloAnomalias, linhasAnomalias);
                    }
                    else {
                        log.info(messages.CliProcessamentoDiagnosticoMensagens.anomaliasTituloComDoisPontos);
                        for (const linha of linhasAnomalias) {
                            log.info(messages.CliProcessamentoDiagnosticoMensagens.amostraLinhaIndentada(linha));
                        }
                    }
                    if (candidatoTop.anomalias.length > 8) {
                        log.aviso(messages.CliProcessamentoDiagnosticoMensagens.anomaliasOcultasAviso(candidatoTop.anomalias.length - 8));
                    }
                }
                if (arquetiposResultado.drift) {
                    const drift = arquetiposResultado.drift;
                    if (drift.alterouArquetipo) {
                        log.info(messages.CliProcessamentoDiagnosticoMensagens.driftAlterou(drift.anterior, drift.atual));
                    }
                    else {
                        log.info(messages.CliProcessamentoDiagnosticoMensagens.driftMantido(drift.atual));
                    }
                    if (drift.arquivosRaizNovos && drift.arquivosRaizNovos.length > 0) {
                        const novosStr = drift.arquivosRaizNovos.length > 3 ? `${drift.arquivosRaizNovos.slice(0, 3).join(', ')}...` : drift.arquivosRaizNovos.join(', ');
                        log.info(messages.CliProcessamentoDiagnosticoMensagens.driftNovos(novosStr));
                    }
                    if (drift.arquivosRaizRemovidos && drift.arquivosRaizRemovidos.length > 0) {
                        const removidosStr = drift.arquivosRaizRemovidos.length > 3 ? `${drift.arquivosRaizRemovidos.slice(0, 3).join(', ')}...` : drift.arquivosRaizRemovidos.join(', ');
                        log.info(messages.CliProcessamentoDiagnosticoMensagens.driftRemovidos(removidosStr));
                    }
                }
            }
            else if (config.VERBOSE) {
                const candidatosContagem = arquetiposResultado ? arquetiposResultado.candidatos?.length || 0 : 0;
                log.info(`DEBUG: arquetiposResultado=${!!arquetiposResultado}, candidatos=${candidatosContagem}`);
            }
            if (!opts.json && arquetiposResultado && (arquetiposResultado.baseline || arquetiposResultado.drift)) {
                const linhasEstrutura = [];
                if (arquetiposResultado.baseline) {
                    const baseline = arquetiposResultado.baseline;
                    linhasEstrutura.push(messages.CliProcessamentoDiagnosticoMensagens.baselineArquetipo(baseline.arquetipo, baseline.confidence));
                    linhasEstrutura.push(messages.CliProcessamentoDiagnosticoMensagens.baselineCriadoEm(new Date(baseline.timestamp).toLocaleString('pt-BR')));
                }
                else {
                    log.aviso(messages.CliProcessamentoDiagnosticoMensagens.baselineDesconhecidoAviso);
                    linhasEstrutura.push(messages.CliProcessamentoDiagnosticoMensagens.baselineArquetipoDesconhecido);
                }
                if (arquetiposResultado.drift) {
                    const drift = arquetiposResultado.drift;
                    if (drift.alterouArquetipo) {
                        linhasEstrutura.push(messages.CliProcessamentoDiagnosticoMensagens.driftDetectado(drift.anterior, drift.atual));
                    }
                    else {
                        linhasEstrutura.push(messages.CliProcessamentoDiagnosticoMensagens.arquetipoMantido(drift.atual));
                    }
                    if (drift.arquivosRaizNovos && drift.arquivosRaizNovos.length > 0) {
                        linhasEstrutura.push(messages.CliProcessamentoDiagnosticoMensagens.novosArquivosRaiz(drift.arquivosRaizNovos.join(', ')));
                    }
                    if (drift.arquivosRaizRemovidos && drift.arquivosRaizRemovidos.length > 0) {
                        linhasEstrutura.push(messages.CliProcessamentoDiagnosticoMensagens.arquivosRemovidosRaiz(drift.arquivosRaizRemovidos.join(', ')));
                    }
                }
                if (arquetiposResultado.candidatos && arquetiposResultado.candidatos.length > 0) {
                    const top = arquetiposResultado.candidatos[0];
                    linhasEstrutura.push(messages.CliProcessamentoDiagnosticoMensagens.candidatoPrincipal(top.nome, top.confidence));
                }
                const tituloEstrutura = messages.CliProcessamentoDiagnosticoMensagens.resumoEstruturaTitulo;
                if (typeof logExt.imprimirBloco === 'function') {
                    let larguraEstrutura;
                    if (typeof logExt.calcularLargura === 'function') {
                        larguraEstrutura = logExt.calcularLargura(tituloEstrutura, linhasEstrutura, config.COMPACT_MODE ? 84 : 96);
                        if (typeof larguraEstrutura !== 'number' || isNaN(larguraEstrutura)) {
                            larguraEstrutura = config.COMPACT_MODE ? 84 : 96;
                        }
                    }
                    else {
                        larguraEstrutura = config.COMPACT_MODE ? 84 : 96;
                    }
                    logExt.imprimirBloco(tituloEstrutura, linhasEstrutura, undefined, larguraEstrutura);
                }
            }
            if (config.DEV_MODE) {
                logExt.debug?.(messages.CliProcessamentoDiagnosticoMensagens.debugAboutToEmitJson(JSON.stringify(opts)));
            }
            if (opts.json) {
                const ocorrenciasOriginais = ocorrenciasFiltradas;
                const todosPorArquivo = new Map();
                const naoTodos = [];
                for (const ocorrencia of ocorrenciasOriginais) {
                    if (ocorrencia.tipo === 'TODO_PENDENTE') {
                        const relPath = ocorrencia.relPath || 'desconhecido';
                        if (!todosPorArquivo.has(relPath)) {
                            todosPorArquivo.set(relPath, []);
                        }
                        const todosArray = todosPorArquivo.get(relPath);
                        if (todosArray) {
                            todosArray.push(ocorrencia);
                        }
                    }
                    else {
                        naoTodos.push(ocorrencia);
                    }
                }
                const todosAgregados = [];
                for (const [, todos] of todosPorArquivo) {
                    if (todos.length === 1) {
                        todosAgregados.push(todos[0]);
                    }
                    else if (todos.length > 1) {
                        const primeira = todos[0];
                        const mensagemAgregada = messages.CliProcessamentoDiagnosticoMensagens.todosPendentesEncontrados(todos.length);
                        todosAgregados.push({
                            ...primeira,
                            mensagem: mensagemAgregada,
                            linha: Math.min(...todos.map(textoTitulo => textoTitulo.linha || 0))
                        });
                    }
                }
                let todasOcorrencias = [...naoTodos, ...todosAgregados];
                todasOcorrencias = dedupeOcorrencias(todasOcorrencias);
                const ocorrenciasParaJson = todasOcorrencias.map(ocorrencia => normalizarOcorrenciaParaJson(ocorrencia)).filter(ocorrencia => {
                    const nivel = (ocorrencia.nivel || 'info');
                    return nivel === 'erro' || ocorrencia.tipo === 'PARSE_ERRO';
                });
                const totalOcorrenciasJson = ocorrenciasParaJson.length;
                const tiposOcorrencias = {};
                const parseErros = {
                    totalOriginais: 0,
                    totalExibidos: 0,
                    agregados: 0
                };
                for (const ocorrencia of ocorrenciasParaJson) {
                    const tipo = ocorrencia.tipo || 'desconhecido';
                    tiposOcorrencias[tipo] = (tiposOcorrencias[tipo] || 0) + 1;
                    if (tipo === 'PARSE_ERRO') {
                        parseErros.totalOriginais++;
                        parseErros.totalExibidos++;
                    }
                }
                const globalThisExt = globalThis;
                const parseErrosGlobais = globalThisExt.__TUTANUS_PARSE_ERROS__ || [];
                const parseErrosOriginais = globalThisExt.__TUTANUS_PARSE_ERROS_ORIGINAIS__ || 0;
                if (parseErrosGlobais.length > 0 || parseErrosOriginais > 0) {
                    parseErros.totalOriginais = Math.max(parseErros.totalOriginais, parseErrosOriginais);
                    if (parseErrosGlobais.length > 0) {
                        parseErros.totalExibidos = Math.min(parseErros.totalOriginais, parseErrosGlobais.length);
                    }
                    if (parseErrosOriginais > 0) {
                        totalOcorrencias = Math.max(totalOcorrencias, parseErrosOriginais);
                    }
                }
                parseErros.agregados = Math.max(0, parseErros.totalOriginais - parseErros.totalExibidos);
                let status = 'ok';
                if (totalOcorrenciasJson > 0) {
                    status = 'problemas';
                    if (parseErros.totalOriginais > 0 && config.PARSE_ERRO_FALHA) {
                        status = 'erro';
                    }
                }
                const saidaJson = {
                    status: status,
                    totalOcorrencias: totalOcorrenciasJson,
                    guardian: guardianResultado ? 'verificado' : 'nao-verificado',
                    tiposOcorrencias,
                    parseErros,
                    ocorrencias: ocorrenciasParaJson,
                    linguagens: {
                        total: 0,
                        extensoes: {}
                    }
                };
                if (arquetiposResultado) {
                    saidaJson.estruturaIdentificada = {
                        melhores: arquetiposResultado.candidatos || [],
                        baseline: arquetiposResultado.baseline || null,
                        drift: arquetiposResultado.drift || {
                            alterouArquetipo: false,
                            deltaConfidence: 0,
                            arquivosRaizNovos: [],
                            arquivosRaizRemovidos: []
                        }
                    };
                }
                const linguagensFinal = computeLinguagens(fileEntriesComAst || fileEntries);
                saidaJson.linguagens = linguagensFinal;
                try {
                    const schemaMeta = {
                        schemaVersion: '1.0.0',
                        tutanusVersion: '0.0.0',
                        timestamp: new Date().toISOString()
                    };
                    const saidaComMeta = {
                        ...schemaMeta,
                        ...saidaJson
                    };
                    const asciiOnly = Boolean(opts && opts.jsonAscii || false);
                    let jsonOutput = stringifyJsonEscaped(saidaComMeta, 2, {
                        asciiOnly
                    });
                    jsonOutput = traduzirRelatorioJson(jsonOutput);
                    console.log(jsonOutput);
                    _jsonEmitted = true;
                }
                catch (erro) {
                    console.error(messages.CliProcessamentoDiagnosticoMensagens.errorGeneratingJson, erro);
                    console.log(messages.CliProcessamentoDiagnosticoMensagens.fallbackJson, JSON.stringify(saidaJson));
                    _jsonEmitted = true;
                }
                if (!process.env.VITEST) {
                    const erros = (nivelOcorrencias.get('erro') || 0);
                    const exitCode = parseErros.totalOriginais > 0 && config.PARSE_ERRO_FALHA ? 2 : erros > 0 ? 1 : 0;
                    process.exit(exitCode);
                }
            }
            if (!opts.json && !config.SCAN_ONLY) {
                if (totalOcorrencias > 0 && ocorrenciasFiltradas) {
                    if (opts.executive) {
                        const { gerarResumoExecutivo } = await import('../../reports/index.js');
                        const resumoExec = gerarResumoExecutivo(ocorrenciasFiltradas);
                        if (resumoExec.detalhes.length > 0) {
                            const linhasExec = resumoExec.detalhes.map(problema => `${problema.icone} ${problema.titulo.padEnd(25)} ${problema.quantidade.toString().padStart(6)}`);
                            const tituloExec = messages.CliProcessamentoDiagnosticoMensagens.resumoExecutivoTitulo(resumoExec.problemasCriticos + resumoExec.problemasAltos);
                            const cabecalhoExec = [`${messages.CliProcessamentoDiagnosticoMensagens.cabecalhoExecProblema.padEnd(30)}${messages.CliProcessamentoDiagnosticoMensagens.cabecalhoExecQtd.padStart(6)}`];
                            if ('imprimirBloco' in log && typeof log.imprimirBloco === 'function') {
                                log.imprimirBloco(tituloExec, [...cabecalhoExec, ...linhasExec]);
                            }
                            console.log(messages.CliProcessamentoDiagnosticoMensagens.dicaUseFull(totalOcorrencias));
                        }
                        else {
                            console.log(messages.CliProcessamentoDiagnosticoMensagens.projetoBomEstado(totalOcorrencias));
                            if (resumoExec.quickFixes > 0) {
                                console.log(messages.CliProcessamentoDiagnosticoMensagens.quickFixesDisponiveis(resumoExec.quickFixes));
                            }
                        }
                    }
                    else {
                        const tiposResumo = {};
                        for (const ocorrencia of ocorrenciasFiltradas) {
                            const tipo = ocorrencia.tipo || 'desconhecido';
                            tiposResumo[tipo] = (tiposResumo[tipo] || 0) + 1;
                        }
                        const linhasResumo = Object.entries(tiposResumo).map(([tipo, qtd]) => `${tipo.padEnd(20)} ${qtd.toString().padStart(8)}`);
                        const tituloResumo = messages.CliProcessamentoDiagnosticoMensagens.resumoTiposTitulo;
                        const cabecalho = [`${messages.CliProcessamentoDiagnosticoMensagens.cabecalhoResumoTipo.padEnd(20)}${messages.CliProcessamentoDiagnosticoMensagens.cabecalhoResumoQuantidade.padStart(8)}`];
                        if ('imprimirBloco' in log && typeof log.imprimirBloco === 'function') {
                            log.imprimirBloco(tituloResumo, [...cabecalho, ...linhasResumo]);
                        }
                    }
                }
                if (!config.COMPACT_MODE && !process.env.__TUTANUS_TUDO_PRONTO_EMITIDO) {
                    log.info(messages.CliProcessamentoDiagnosticoMensagens.tudoPronto);
                    process.env['__TUTANUS_TUDO_PRONTO_EMITIDO'] = '1';
                }
                if (process.env.VITEST) {
                    log.info(messages.CliProcessamentoDiagnosticoMensagens.diagnosticoConcluido);
                }
            }
        }
        if (!opts.json && !config.SCAN_ONLY) {
            logExt.fase?.('Gerando relatórios');
            try {
                const contextoConselho = {
                    hora: new Date().getHours(),
                    arquivosParaCorrigir: totalOcorrencias,
                    arquivosParaPodar: 0,
                    totalOcorrenciasAnaliticas: totalOcorrencias,
                    integridadeGuardian: guardianResultado?.status || 'nao-verificado'
                };
                emitirConselhoTutanus(contextoConselho);
                if (config.REPORT_EXPORT_ENABLED) {
                    try {
                        const dir = typeof config.REPORT_OUTPUT_DIR === 'string' ? config.REPORT_OUTPUT_DIR : path.join(baseDir, 'reports');
                        fs.mkdirSync(dir, {
                            recursive: true
                        });
                        const arquivosNoDir = fs.readdirSync(dir);
                        const obterProximoId = () => {
                            const ids = arquivosNoDir.filter(arquivo => arquivo.endsWith('.json')).map(arquivo => {
                                const match = arquivo.match(/-(\d+)\.json$/);
                                return match ? parseInt(match[1], 10) : 0;
                            });
                            const maxId = Math.max(0, ...ids);
                            return (maxId + 1).toString().padStart(3, '0');
                        };
                        const id = obterProximoId();
                        const salvar = await getSalvarEstado();
                        const metricasOriginais = resultadoExecucao.metricas;
                        const analistasAgregados = {};
                        for (const arquivo of metricasOriginais?.analistas || []) {
                            const nome = arquivo.nome || 'desconhecido';
                            if (!analistasAgregados[nome]) {
                                analistasAgregados[nome] = {
                                    duracaoMs: 0,
                                    ocorrencias: 0,
                                    execucoes: 0
                                };
                            }
                            analistasAgregados[nome].duracaoMs += arquivo.duracaoMs || 0;
                            analistasAgregados[nome].ocorrencias += arquivo.ocorrencias || 0;
                            analistasAgregados[nome].execucoes += 1;
                        }
                        const analistasResumidos = Object.entries(analistasAgregados).map(([nome, dados]) => ({
                            nome,
                            duracaoTotalMs: Math.round(dados.duracaoMs * 100) / 100,
                            ocorrenciasTotal: dados.ocorrencias,
                            execucoes: dados.execucoes
                        })).sort((arquivo, base) => base.ocorrenciasTotal - arquivo.ocorrenciasTotal);
                        const relatorioMetricas = {
                            timestamp: new Date().toISOString(),
                            metricas: {
                                totalArquivos: metricasOriginais?.totalArquivos,
                                tempoParsingMs: metricasOriginais?.tempoParsingMs,
                                tempoAnaliseMs: metricasOriginais?.tempoAnaliseMs,
                                cacheAstHits: metricasOriginais?.cacheAstHits,
                                cacheAstMiss: metricasOriginais?.cacheAstMiss,
                                analistas: analistasResumidos
                            }
                        };
                        await salvar(path.join(dir, `metricas-${id}.json`), relatorioMetricas);
                        const todasOcorrencias = dedupeOcorrencias(resultadoExecucao.ocorrencias || []);
                        const ocorrenciasLimpas = todasOcorrencias.map(oc => limparOcorrencia(oc));
                        const usarStream = config.REPORT_STREAM_ENABLED && ocorrenciasLimpas.length >= config.REPORT_STREAM_AUTO_THRESHOLD;
                        if (usarStream) {
                            try {
                                const { RelatorioStream } = await import('../../reports/index.js');
                                const stream = new RelatorioStream({
                                    outputDir: dir,
                                    prefix: `tutanus-stream-${id}`,
                                    maxOcorrenciasPerShard: config.REPORT_STREAM_MAX_OCCURRENCES_PER_SHARD,
                                    maxBytesPerShard: config.REPORT_STREAM_MAX_BYTES_PER_SHARD,
                                    compress: config.REPORT_STREAM_COMPRESS,
                                });
                                const TAMANHO_LOTE = 500;
                                for (let i = 0; i < ocorrenciasLimpas.length; i += TAMANHO_LOTE) {
                                    const lote = ocorrenciasLimpas.slice(i, i + TAMANHO_LOTE);
                                    stream.writeBatch(lote);
                                }
                                const { manifest, manifestFile } = await stream.end({
                                    projectDir: baseDir,
                                    timestamp: new Date().toISOString(),
                                    totalArquivos: resultadoExecucao.totalArquivos,
                                    totalOcorrencias: ocorrenciasLimpas.length,
                                });
                                log.sucesso(`Relatório streaming salvo: ${manifestFile} (${manifest.totalShards} shards, ${manifest.totalOcorrencias} ocorrências)`);
                            }
                            catch (streamErr) {
                                log.aviso(`Streaming de relatório falhou, usando export padrão: ${streamErr.message}`);
                                await exportarPorNivel(ocorrenciasLimpas, dir, id, salvar);
                            }
                        }
                        else {
                            await exportarPorNivel(ocorrenciasLimpas, dir, id, salvar);
                        }
                        try {
                            const { OperarioEstrutura } = await import('../../analysts/strategists/index.js');
                            const { plano: planoOrg, origem: origemOrg } = await OperarioEstrutura.planejar(baseDir, fileEntriesComAst, {
                                preferEstrategista: true,
                            });
                            if (planoOrg && planoOrg.mover && planoOrg.mover.length > 0) {
                                const sugestoes = planoOrg.mover.map(m => ({
                                    tipo: 'organizacao',
                                    origem: origemOrg,
                                    arquivo: m.de,
                                    destinoSugerido: m.para,
                                    mensagem: `Sugestão: mover ${m.de} para ${m.para}`,
                                }));
                                await salvar(path.join(dir, `sugestoes-${id}.json`), {
                                    timestamp: new Date().toISOString(),
                                    total: sugestoes.length,
                                    sugestoes,
                                });
                            }
                        }
                        catch (erro) {
                            log.debug(`Erro ao gerar sugestões de organização: ${erro instanceof Error ? erro.message : String(erro)}`);
                        }
                        log.sucesso(messages.CliProcessamentoDiagnosticoMensagens.relatoriosExportadosPara(dir));
                    }
                    catch (erro) {
                        log.erro(messages.CliProcessamentoDiagnosticoMensagens.falhaExportarRelatorios(erro instanceof Error ? erro.message : String(erro)));
                    }
                }
            }
            catch (erro) {
                log.erro(messages.CliProcessamentoDiagnosticoMensagens.falhaExportarRelatorios(erro.message));
            }
        }
        if (!opts.json && !config.SCAN_ONLY) {
            try {
                if (totalOcorrencias > 0 && resultadoExecucao && ocorrenciasFiltradas) {
                    const tiposResumo = {};
                    for (const ocorrencia of ocorrenciasFiltradas) {
                        const tipo = ocorrencia.tipo || 'desconhecido';
                        tiposResumo[tipo] = (tiposResumo[tipo] || 0) + 1;
                    }
                    const linhasResumo = Object.entries(tiposResumo).map(([tipo, qtd]) => `${tipo.padEnd(20)} ${qtd.toString().padStart(8)}`);
                    const tituloResumo = messages.CliProcessamentoDiagnosticoMensagens.resumoTiposTitulo;
                    const cabecalho = [`${messages.CliProcessamentoDiagnosticoMensagens.cabecalhoResumoTipo.padEnd(20)}${messages.CliProcessamentoDiagnosticoMensagens.cabecalhoResumoQuantidade.padStart(8)}`];
                    if ('imprimirBloco' in log && typeof log.imprimirBloco === 'function') {
                        log.imprimirBloco(tituloResumo, [...cabecalho, ...linhasResumo]);
                    }
                }
                if (!config.COMPACT_MODE && !process.env.__TUTANUS_TUDO_PRONTO_EMITIDO) {
                    log.info(messages.CliProcessamentoDiagnosticoMensagens.tudoPronto);
                    process.env['__TUTANUS_TUDO_PRONTO_EMITIDO'] = '1';
                }
            }
            catch { }
        }
        if (opts.json) {
            const ocorrenciasOriginais = dedupeOcorrencias(resultadoExecucao.ocorrencias || []);
            const todosPorArquivo = new Map();
            const naoTodos = [];
            for (const ocorrencia of ocorrenciasOriginais) {
                if (ocorrencia.tipo === 'TODO_PENDENTE') {
                    const relPath = ocorrencia.relPath || 'desconhecido';
                    if (!todosPorArquivo.has(relPath))
                        todosPorArquivo.set(relPath, []);
                    const ocorrenciasArquivo = todosPorArquivo.get(relPath);
                    if (ocorrenciasArquivo)
                        ocorrenciasArquivo.push(ocorrencia);
                }
                else {
                    naoTodos.push(ocorrencia);
                }
            }
            try {
                if (!opts.json && !config.SCAN_ONLY && totalOcorrencias === 0) {
                    logRelatorio.repositorioImpecavel();
                }
            }
            catch { }
            const todosAgregados = [];
            for (const [, todos] of todosPorArquivo) {
                if (todos.length === 1)
                    todosAgregados.push(todos[0]);
                else if (todos.length > 1) {
                    const primeira = todos[0];
                    const mensagemAgregada = messages.CliProcessamentoDiagnosticoMensagens.todosPendentesEncontrados(todos.length);
                    todosAgregados.push({
                        ...primeira,
                        mensagem: mensagemAgregada,
                        linha: Math.min(...todos.map(textoTitulo => textoTitulo.linha || 0))
                    });
                }
            }
            let todasOcorrencias = [...naoTodos, ...todosAgregados];
            todasOcorrencias = dedupeOcorrencias(todasOcorrencias);
            const ocorrenciasParaJson = todasOcorrencias.filter(ocorrencia => {
                const nivel = (ocorrencia.nivel || 'info');
                return nivel === 'erro' || ocorrencia.tipo === 'PARSE_ERRO';
            });
            const tiposOcorrencias = {};
            const parseErros = {
                totalOriginais: 0,
                totalExibidos: 0,
                agregados: 0
            };
            for (const ocorrencia of ocorrenciasParaJson) {
                const tipo = ocorrencia.tipo || 'desconhecido';
                tiposOcorrencias[tipo] = (tiposOcorrencias[tipo] || 0) + 1;
                if (tipo === 'PARSE_ERRO') {
                    parseErros.totalOriginais++;
                    parseErros.totalExibidos++;
                }
            }
            const globalThisExt = globalThis;
            const parseErrosGlobais = globalThisExt.__TUTANUS_PARSE_ERROS__ || [];
            const parseErrosOriginais = globalThisExt.__TUTANUS_PARSE_ERROS_ORIGINAIS__ || 0;
            if (parseErrosGlobais.length > 0 || parseErrosOriginais > 0) {
                parseErros.totalOriginais = Math.max(parseErros.totalOriginais, parseErrosOriginais);
                if (parseErrosGlobais.length > 0) {
                    parseErros.totalExibidos = Math.min(parseErros.totalOriginais, parseErrosGlobais.length);
                }
                if (parseErrosOriginais > 0) {
                    totalOcorrencias = Math.max(totalOcorrencias, parseErrosOriginais);
                }
            }
            parseErros.agregados = Math.max(0, parseErros.totalOriginais - parseErros.totalExibidos);
            let status = 'ok';
            if (ocorrenciasParaJson.length > 0) {
                status = 'problemas';
                if (parseErros.totalOriginais > 0 && config.PARSE_ERRO_FALHA)
                    status = 'erro';
            }
            const saidaJson = {
                status: status,
                totalOcorrencias: ocorrenciasParaJson.length,
                guardian: guardianResultado ? 'verificado' : 'nao-verificado',
                tiposOcorrencias,
                parseErros,
                ocorrencias: ocorrenciasParaJson,
                linguagens: {
                    total: 0,
                    extensoes: {}
                }
            };
            const linguagensFinal = computeLinguagens(fileEntriesComAst || fileEntries);
            saidaJson.linguagens = linguagensFinal;
            if (!_jsonEmitted) {
                try {
                    let pkgVersion = '0.0.0';
                    try {
                        const pkgRaw = await fs.promises.readFile(path.join(process.cwd(), 'package.json'), 'utf-8');
                        const pkgObj = JSON.parse(pkgRaw);
                        if (pkgObj && typeof pkgObj.version === 'string')
                            pkgVersion = pkgObj.version;
                    }
                    catch { }
                    const schemaMeta = {
                        schemaVersion: '1.0.0',
                        tutanusVersion: pkgVersion,
                        timestamp: new Date().toISOString()
                    };
                    const saidaComMeta = {
                        ...schemaMeta,
                        ...saidaJson
                    };
                    const asciiOnly = Boolean(opts && opts.jsonAscii || false);
                    let jsonOutput = stringifyJsonEscaped(saidaComMeta, 2, {
                        asciiOnly
                    });
                    jsonOutput = traduzirRelatorioJson(jsonOutput);
                    console.log(jsonOutput);
                    if (config.REPORT_EXPORT_ENABLED) {
                        try {
                            const dir = typeof config.REPORT_OUTPUT_DIR === 'string' ? config.REPORT_OUTPUT_DIR : path.join(baseDir, 'reports');
                            fs.mkdirSync(dir, {
                                recursive: true
                            });
                            const arquivosNoDir = fs.readdirSync(dir);
                            const ids = arquivosNoDir.filter(arquivo => arquivo.endsWith('.json')).map(arquivo => {
                                const match = arquivo.match(/-(\d+)\.json$/);
                                return match ? parseInt(match[1], 10) : 0;
                            });
                            const maxId = Math.max(0, ...ids);
                            const id = (maxId + 1).toString().padStart(3, '0');
                            const caminhoArquivo = path.join(dir, `tutanus-diagnostico-${id}.json`);
                            fs.writeFileSync(caminhoArquivo, jsonOutput, 'utf-8');
                            log.sucesso(messages.CliProcessamentoDiagnosticoMensagens.relatoriosExportadosPara(dir));
                        }
                        catch (erro) {
                            log.erro(messages.CliProcessamentoDiagnosticoMensagens.falhaSalvarRelatorioJson(erro instanceof Error ? erro.message : String(erro)));
                        }
                    }
                }
                catch (erro) {
                    console.error(messages.CliProcessamentoDiagnosticoMensagens.errorGeneratingJson, erro);
                    console.log(messages.CliProcessamentoDiagnosticoMensagens.fallbackJson, JSON.stringify(saidaJson));
                }
            }
            if (!process.env.VITEST) {
                const erros = (nivelOcorrencias.get('erro') || 0);
                const exitCode = parseErros.totalOriginais > 0 && config.PARSE_ERRO_FALHA ? 2 : erros > 0 ? 1 : 0;
                process.exit(exitCode);
            }
        }
    }
    catch (error) {
        try {
            if (error && typeof error === 'object' && 'message' in error && typeof error.message === 'string' && String(error.message).startsWith('exit:')) {
                throw error;
            }
        }
        catch (re) {
            throw re;
        }
        const errMsg = typeof error === 'string' ? error : error instanceof Error ? error.message : (() => {
            try {
                return JSON.stringify(error);
            }
            catch {
                return String(error);
            }
        })();
        log.erro(messages.CliProcessamentoDiagnosticoMensagens.erroFatalDiagnostico(errMsg));
        if (config.DEV_MODE) {
            console.error(error);
        }
        return {
            totalOcorrencias: 1,
            temErro: true,
            guardianResultado,
            fileEntriesComAst: [],
            resultadoFinal: {
                ocorrencias: [],
                metricas: {
                    totalArquivos: 0,
                    tempoTotal: 0,
                    analistas: []
                }
            }
        };
    }
    try {
        if (!opts.json && !config.SCAN_ONLY && totalOcorrencias === 0) {
            logRelatorio.repositorioImpecavel();
        }
    }
    catch { }
    return {
        totalOcorrencias: totalOcorrencias || 0,
        temErro: false,
        guardianResultado,
        fileEntriesComAst: [],
        resultadoFinal: {
            ocorrencias: [],
            metricas: {
                totalArquivos: 0,
                tempoTotal: 0,
                analistas: []
            }
        }
    };
}
//# sourceMappingURL=processing-diagnostic.js.map