tutanus 0.12.0

package/dist/cli/diagnostic/processing-diagnostic.js

@@ -0,0 +1,1542 @@
+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;
+                        }
+                        throw new Error(messages.ExcecoesMensagens.exit1);
+                    }
+                }
+                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' ? '🔴' : nivel === 'aviso' ? '🟡' : '🔵';
+                    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