@silasfmartins/testhub 1.0.0

package/dist/src/testContext/UnifiedReportManager.js

@@ -0,0 +1,1206 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { StatementTracker } from '../hubdocs/StatementTracker.js';
+import { Logger } from '../utils/Logger.js';
+import { TestAnnotations } from './TestAnnotations.js';
+import { TestContext } from './TestContext.js';
+import { UnifiedHtmlGenerator } from './UnifiedHtmlGenerator.js';
+import { HTMLTemplate } from '../utils/HTMLTemplate.js';
+// 🔗 Import dinâmico do StatementTracker para evitar dependência circular
+const getStatementTrackerData = async () => {
+    try {
+        return StatementTracker.getReportData();
+    }
+    catch (error) {
+        return null;
+    }
+};
+/**
+ * Gerenciador unificado de relatórios para todos os tipos de teste
+ */
+export class UnifiedReportManager {
+    static inicioExecucao;
+    static fimExecucao;
+    static testes = [];
+    static contextoPorTeste = new Map();
+    static logsPorTeste = new Map();
+    static metadataPorTeste = new Map();
+    static duracoesPorTeste = new Map();
+    static ctToCnMap = new Map();
+    /**
+     * ✅ Dados globais estruturados
+     */
+    static dadosGlobais = {
+        totalTestes: 0,
+        testesPassados: 0,
+        testesFalharam: 0,
+        testes: {},
+    };
+    /**
+     * ✅ NOVO: Sistema de detecção automática
+     */
+    static autoDetectionActive = false;
+    static currentTestName = null;
+    static testStartTime = null;
+    static monitoringInterval = null;
+    /**
+     * Registra relacionamento entre CT (test.title) e CN (test.describe)
+     */
+    static registrarCtParaCn(ctName, cnName) {
+        if (!ctName || !cnName)
+            return;
+        UnifiedReportManager.ctToCnMap.set(ctName, cnName);
+    }
+    static obterCnRegistrado(ctName) {
+        if (!ctName)
+            return undefined;
+        return UnifiedReportManager.ctToCnMap.get(ctName);
+    }
+    static limparRegistroCt(ctName) {
+        if (!ctName)
+            return;
+        UnifiedReportManager.ctToCnMap.delete(ctName);
+    }
+    /**
+     * ❌ DESABILITADO: Auto-inicialização que causava registro duplicado
+     * O registro correto já é feito via TestAnnotations.Api/SSH/Banco/etc
+     */
+    static autoInit() {
+        if (!UnifiedReportManager.autoDetectionActive) {
+            UnifiedReportManager.autoDetectionActive = true;
+            // 🤖 FORÇA INICIALIZAÇÃO DO STATEMENT TRACKER
+            try {
+                import('../hubdocs/StatementTracker.js')
+                    .then(() => {
+                    // StatementTracker carregado e auto-inicializado
+                })
+                    .catch(() => {
+                    // Ignorar erro se não conseguir carregar
+                });
+            }
+            catch (error) {
+                // Ignorar erro de importação
+            }
+            // Configurar interceptação de erros automaticamente
+            UnifiedReportManager.configurarInterceptacaoErros();
+            // ❌ REMOVIDO: Monitoramento automático que registrava CT como teste
+            // this.iniciarMonitoramentoAutomatico()
+            // this.interceptarTestContext()
+        }
+    }
+    /**
+     * ✅ NOVO: Monitoramento automático de mudanças de teste
+     */
+    static iniciarMonitoramentoAutomatico() {
+        UnifiedReportManager.monitoringInterval = setInterval(() => {
+            try {
+                const testInfo = TestContext.getSafeTestInfo();
+                const currentTest = testInfo?.title || null;
+                // Detectar mudança de teste
+                if (currentTest &&
+                    currentTest !== UnifiedReportManager.currentTestName) {
+                    // Finalizar teste anterior se existir
+                    if (UnifiedReportManager.currentTestName) {
+                        UnifiedReportManager.finalizarTesteAutomatico(UnifiedReportManager.currentTestName);
+                    }
+                    // Iniciar novo teste
+                    UnifiedReportManager.iniciarTesteAutomatico(currentTest);
+                }
+                // Detectar fim de teste (quando não há mais TestInfo)
+                if (!currentTest && UnifiedReportManager.currentTestName) {
+                    UnifiedReportManager.finalizarTesteAutomatico(UnifiedReportManager.currentTestName);
+                }
+            }
+            catch (error) {
+                // Ignorar erros do monitoramento
+            }
+        }, 100); // Verificar a cada 100ms
+    }
+    /**
+     * ✅ NOVO: Interceptar TestContext para detectar mudanças automaticamente
+     */
+    static interceptarTestContext() {
+        try {
+            // ✅ CORRIGIDO: Verificar se TestContext está disponível antes de interceptar
+            if (typeof TestContext === 'undefined' || !TestContext) {
+                console.debug('TestContext ainda não está disponível para interceptação');
+                return;
+            }
+            // Interceptar o método setTestInfo do TestContext
+            const originalSetTestInfo = TestContext.setTestInfo;
+            if (originalSetTestInfo && typeof originalSetTestInfo === 'function') {
+                TestContext.setTestInfo = (testInfo) => {
+                    // Chamar método original
+                    originalSetTestInfo.call(TestContext, testInfo);
+                    // Detectar novo teste automaticamente
+                    if (testInfo?.title) {
+                        UnifiedReportManager.detectarNovoTeste(testInfo.title);
+                    }
+                };
+            }
+        }
+        catch (error) {
+            console.debug('Erro ao interceptar TestContext:', error);
+        }
+    }
+    /**
+     * ✅ NOVO: Detectar novo teste automaticamente
+     */
+    static detectarNovoTeste(testName) {
+        if (testName !== UnifiedReportManager.currentTestName) {
+            // Finalizar teste anterior se existir
+            if (UnifiedReportManager.currentTestName) {
+                UnifiedReportManager.finalizarTesteAutomatico(UnifiedReportManager.currentTestName);
+            }
+            // Iniciar novo teste
+            UnifiedReportManager.iniciarTesteAutomatico(testName);
+        }
+    }
+    /**
+     * ✅ NOVO: Iniciar teste automaticamente
+     */
+    static iniciarTesteAutomatico(testName) {
+        UnifiedReportManager.currentTestName = testName;
+        UnifiedReportManager.testStartTime = Date.now();
+        // Registrar teste automaticamente
+        UnifiedReportManager.registrarTeste(testName, 'Mixed'); // Detectar tipo depois
+        // ❌ REMOVIDO: NÃO chamar StatementTracker.setTestName() aqui!
+        // O nome correto (CN do test.describe) já foi setado em TestAnnotations.Api/SSH/Banco/etc
+        // Este testName aqui é o CT (test.title), não o CN!
+        // Iniciar execução se não iniciada
+        if (!UnifiedReportManager.inicioExecucao) {
+            UnifiedReportManager.registrarInicioExecucao();
+        }
+    }
+    /**
+     * ✅ NOVO: Finalizar teste automaticamente
+     */
+    static async finalizarTesteAutomatico(testName) {
+        // Detectar status baseado em logs
+        const logs = UnifiedReportManager.logsPorTeste.get(testName) || [];
+        const hasError = logs.some((log) => log.includes('❌') ||
+            log.includes('ERRO') ||
+            log.includes('Error') ||
+            log.includes('failed'));
+        const status = hasError ? 'failed' : 'passed';
+        // Marcar fim do teste
+        await UnifiedReportManager.marcarFimTeste(testName, status);
+        // Calcular duração
+        if (UnifiedReportManager.testStartTime) {
+            const duracao = Date.now() - UnifiedReportManager.testStartTime;
+            UnifiedReportManager.setTestDuration(testName, duracao);
+        }
+        // Reset
+        UnifiedReportManager.currentTestName = null;
+        UnifiedReportManager.testStartTime = null;
+    }
+    static setTestContext(testeName, contexto) {
+        UnifiedReportManager.contextoPorTeste.set(testeName, contexto);
+    }
+    static iniciarTeste(testeName, contexto) {
+        Logger.info(`🎯 Iniciando teste: ${testeName}`);
+        // ✅ IMPORTANTE: Registrar o teste no sistema
+        UnifiedReportManager.registrarTeste(testeName, contexto || 'Mixed');
+        // Definir teste atual
+        UnifiedReportManager.currentTestName = testeName;
+        // ✅ CRÍTICO: Informar StatementTracker sobre o nome do teste
+        try {
+            StatementTracker.setTestName(testeName);
+            Logger.success(`✅ Nome do teste "${testeName}" registrado no StatementTracker`);
+        }
+        catch (error) {
+            Logger.warning(`⚠️ Erro ao registrar nome no StatementTracker: ${error}`);
+        }
+        // Definir contexto se fornecido
+        if (contexto) {
+            UnifiedReportManager.contextoPorTeste.set(testeName, contexto);
+        }
+        // Inicializar estruturas de dados para o teste
+        if (!UnifiedReportManager.logsPorTeste.has(testeName)) {
+            UnifiedReportManager.logsPorTeste.set(testeName, []);
+        }
+        // Adicionar log inicial
+        UnifiedReportManager.adicionarLog(testeName, `🎯 INICIANDO: ${testeName}`);
+        // Marcar início do tempo
+        UnifiedReportManager.duracoesPorTeste.set(testeName, Date.now());
+        Logger.success(`✅ Teste ${testeName} inicializado no contexto ${contexto || 'Mixed'}`);
+    }
+    static registrarInicioExecucao() {
+        if (!UnifiedReportManager.inicioExecucao) {
+            UnifiedReportManager.inicioExecucao = new Date();
+            Logger.info(`⏱️  Início da execução unificada: ${UnifiedReportManager.inicioExecucao.toLocaleTimeString()}`);
+        }
+    }
+    /**
+     * Registra informações do ambiente CI (Azure Pipelines, GitHub Actions, etc)
+     * e as anexa como metadados globais para o relatório.
+     */
+    static registrarCIInfo() {
+        try {
+            const metadata = {};
+            // Azure Pipelines
+            if (process.env.AGENT_NAME || process.env.BUILD_REASON) {
+                metadata.ciProvider = 'azure-pipelines';
+                metadata.agentName = process.env.AGENT_NAME || null;
+                metadata.buildReason = process.env.BUILD_REASON || null; // Ex: 'Schedule', 'Manual'
+                metadata.requestedFor = process.env.BUILD_REQUESTEDFOR || process.env.BUILD_REQUESTEDFORID || null;
+                metadata.buildId = process.env.BUILD_BUILDID || null;
+                metadata.project = process.env.SYSTEM_TEAMPROJECT || null;
+                metadata.collectionUri = process.env.SYSTEM_COLLECTIONURI || null;
+                // Tentativa de descobrir email do usuário que requisitou
+                metadata.requestedForEmail = process.env.BUILD_REQUESTEDFOR || process.env.BUILD_REQUESTEDFOREMAIL || null;
+                metadata.isScheduled = (process.env.BUILD_REASON || '').toLowerCase() === 'schedule';
+            }
+            // GitHub Actions
+            if (process.env.GITHUB_ACTIONS) {
+                metadata.ciProvider = 'github-actions';
+                metadata.actor = process.env.GITHUB_ACTOR || null;
+                metadata.workflow = process.env.GITHUB_WORKFLOW || null;
+                metadata.runId = process.env.GITHUB_RUN_ID || null;
+                metadata.eventName = process.env.GITHUB_EVENT_NAME || null;
+                // GitHub schedule detection: eventName == 'schedule'
+                metadata.isScheduled = (process.env.GITHUB_EVENT_NAME || '').toLowerCase() === 'schedule';
+            }
+            // Fallbacks: tentar detectar e-mail do usuário a partir de variáveis comuns
+            if (!metadata.requestedForEmail) {
+                metadata.requestedForEmail = process.env.BUILD_REQUESTEDFOREMAIL || process.env.BUILD_REQUESTEDFOR || process.env.USER_EMAIL || null;
+            }
+            // Armazenar em dadosGlobais para anexar ao relatório final
+            ;
+            UnifiedReportManager.dadosGlobais.ciMetadata = metadata;
+            Logger.info(`🔗 CI metadata registrada: ${JSON.stringify(metadata)}`);
+        }
+        catch (error) {
+            Logger.warning(`⚠️ Não foi possível registrar CI info: ${error}`);
+        }
+    }
+    static registrarFimExecucao() {
+        UnifiedReportManager.fimExecucao = new Date();
+        if (UnifiedReportManager.inicioExecucao) {
+            const duration = (UnifiedReportManager.fimExecucao.getTime() -
+                UnifiedReportManager.inicioExecucao.getTime()) /
+                1000;
+            Logger.info(`⏱️  Execução unificada concluída em ${duration.toFixed(2)}s`);
+        }
+    }
+    /**
+     * ✅ NOVO: Registra explicitamente um teste no sistema
+     */
+    static registrarTeste(testName, contextType) {
+        if (!testName) {
+            Logger.warning('⚠️ Nome do teste vazio, ignorando registrarTeste');
+            return;
+        }
+        // ✅ CRÍTICO: Sempre criar entrada para o teste
+        UnifiedReportManager.dadosGlobais.testes[testName] = {
+            nome: testName,
+            tipo: contextType,
+            inicio: new Date(),
+            fim: null,
+            duracao: 0,
+            status: 'running',
+            logs: [],
+            screenshots: [],
+            dados: {},
+        };
+        // ✅ IMPORTANTE: Incrementar contador
+        UnifiedReportManager.dadosGlobais.totalTestes++;
+        // ✅ NOVO: Também criar entrada básica no array de testes para relatórios
+        const testeExistente = UnifiedReportManager.testes.find((t) => t.nome === testName);
+        if (!testeExistente) {
+            const novoTeste = {
+                nome: testName,
+                resultado: 'FAIL', // Assumir FAIL inicialmente, será atualizado
+                tipo: contextType,
+                duracao: 0,
+                logs: [],
+                timestamp: new Date(),
+                metadata: {},
+            };
+            UnifiedReportManager.testes.push(novoTeste);
+        }
+    }
+    /**
+     * 🆕 HELPER: Obter o nome correto do CN (test.describe) do TestInfo
+     */
+    static getCNNameFromTestInfo() {
+        const testInfo = TestContext.getSafeTestInfo();
+        // titlePath[0] = filename, titlePath[1] = CN (test.describe), titlePath[2] = CT (test)
+        return testInfo?.titlePath?.[1] || null;
+    }
+    /**
+     * ✅ NOVO: Marca explicitamente o fim de um teste
+     */
+    static async marcarFimTeste(testName, status, options = {}) {
+        const mappedCtName = options.ctName || testName;
+        const cnName = options.cnName ||
+            UnifiedReportManager.obterCnRegistrado(mappedCtName) ||
+            UnifiedReportManager.getCNNameFromTestInfo() ||
+            testName;
+        if (status === 'passed') {
+            await UnifiedReportManager.corrigirStatusCTsQuandoTestePassou(cnName, mappedCtName);
+        }
+        else if (status === 'failed') {
+            await UnifiedReportManager.corrigirStatusCTsQuandoTesteFalha(cnName, mappedCtName, options.errorMessage);
+        }
+        // Atualizar dadosGlobais
+        const testeGlobal = UnifiedReportManager.dadosGlobais.testes[testName];
+        if (testeGlobal) {
+            testeGlobal.fim = new Date();
+            testeGlobal.status = status;
+            // Calcular duração
+            if (testeGlobal.inicio) {
+                testeGlobal.duracao =
+                    (testeGlobal.fim.getTime() - testeGlobal.inicio.getTime()) / 1000;
+                // Atualizar também no Map de durações
+                UnifiedReportManager.duracoesPorTeste.set(testName, testeGlobal.duracao * 1000);
+            }
+            if (status === 'passed') {
+                UnifiedReportManager.dadosGlobais.testesPassados++;
+            }
+            else if (status === 'failed') {
+                UnifiedReportManager.dadosGlobais.testesFalharam++;
+            }
+        }
+        // Atualizar também o array de testes
+        const testeIndex = UnifiedReportManager.testes.findIndex((t) => t.nome === testName);
+        if (testeIndex >= 0) {
+            UnifiedReportManager.testes[testeIndex].resultado =
+                status === 'passed' ? 'PASS' : 'FAIL';
+            // Atualizar logs se existirem
+            const logs = UnifiedReportManager.logsPorTeste.get(testName) || [];
+            UnifiedReportManager.testes[testeIndex].logs = logs;
+            // Atualizar duração corretamente
+            UnifiedReportManager.testes[testeIndex].duracao =
+                testeGlobal?.duracao ?? 0;
+        }
+        UnifiedReportManager.limparRegistroCt(mappedCtName);
+        // Log de finalização
+        Logger.info(`🏁 Finalizado: ${testName} [${status.toUpperCase()}]`);
+    }
+    /**
+     * ✅ NOVO: Corrige status dos CTs quando teste PASSA
+     * Marca todos os CTs "running" do teste como "passed"
+     */
+    static async corrigirStatusCTsQuandoTestePassou(testName, ctName) {
+        try {
+            StatementTracker.finalizeRunningCTsAsPassed(testName, ctName);
+        }
+        catch (error) {
+            Logger.warning(`⚠️ Erro ao corrigir status dos CTs para teste ${testName}: ${error}`);
+        }
+    }
+    /**
+     * ✅ NOVO: Corrige status dos CTs quando teste FALHA
+     * Marca todos os CTs "running" do teste como "failed"
+     */
+    static async corrigirStatusCTsQuandoTesteFalha(testName, ctName, reason) {
+        try {
+            Logger.info(`🔧 Finalizando CTs "running" como "failed" para teste: ${testName}${ctName ? ` (CT: ${ctName})` : ''}`);
+            // Importar StatementTracker dinamicamente (ESModules)
+            StatementTracker.finalizeRunningCTsAsFailed(testName, reason || 'Teste falhou - finalizando CTs pendentes', ctName);
+            Logger.success(`✅ Status dos CTs corrigido para teste ${testName}`);
+        }
+        catch (error) {
+            Logger.warning(`⚠️ Erro ao corrigir status dos CTs para teste ${testName}: ${error}`);
+        }
+    }
+    static async coletarDadosDoTeste(testeName) {
+        const testInfo = TestContext.getSafeTestInfo();
+        // ✅ CORREÇÃO CRÍTICA: Buscar pelo CN (test.describe = titlePath[1]), não pelo CT (test.title)
+        // titlePath[0] = filename, titlePath[1] = CN (test.describe), titlePath[2] = CT (test)
+        const nomeDoCN = testeName || testInfo?.titlePath?.[1] || testInfo?.title;
+        if (!nomeDoCN)
+            return { cts: [], logs: [], screenshots: [] };
+        if (testInfo?.titlePath) {
+            Logger.info(`   📋 titlePath completo: ${testInfo.titlePath.join(' > ')}`);
+        }
+        const contexto = UnifiedReportManager.contextoPorTeste.get(nomeDoCN) || 'Mixed';
+        // 🔧 CORREÇÃO COMPLETA: Captura de logs de TODAS as fontes
+        let logs = [];
+        // ✅ FONTE 1: Logs do Map logsPorTeste
+        const logsDoMap = UnifiedReportManager.logsPorTeste.get(nomeDoCN) ?? [];
+        if (logsDoMap.length > 0) {
+            Logger.info(`📋 Encontrados ${logsDoMap.length} logs no Map`);
+            logs.push(...logsDoMap);
+        }
+        // ✅ FONTE 2: Logs dos dadosGlobais
+        const testeGlobal = UnifiedReportManager.dadosGlobais.testes[nomeDoCN];
+        if (testeGlobal?.logs && testeGlobal.logs.length > 0) {
+            Logger.info(`📋 Encontrados ${testeGlobal.logs.length} logs nos dadosGlobais`);
+            logs.push(...testeGlobal.logs);
+        }
+        // ✅ FONTE 3: Logs do buffer global do console
+        if (globalThis.consoleBuffer) {
+            const bufferLogs = globalThis.consoleBuffer
+                .filter((log) => log.testName === nomeDoCN ||
+                log.testName?.includes(nomeDoCN) ||
+                nomeDoCN.includes(log.testName || ''))
+                .map((log) => log.message);
+            if (bufferLogs.length > 0) {
+                Logger.info(`📋 Encontrados ${bufferLogs.length} logs no buffer do console`);
+                logs.push(...bufferLogs);
+            }
+        }
+        // ✅ FONTE 4: Logs do TestAnnotations (NOVO)
+        try {
+            const logsCapturados = TestAnnotations.getLogsCapturados();
+            if (logsCapturados && logsCapturados.length > 0) {
+                Logger.info(`📋 Encontrados ${logsCapturados.length} logs do TestAnnotations`);
+                logs.push(...logsCapturados);
+            }
+        }
+        catch (error) {
+            Logger.warning(`⚠️ Erro ao capturar logs do TestAnnotations: ${error}`);
+        }
+        // ✅ FONTE 5: Buscar logs por padrões similares de nome de teste
+        const nomeString = String(nomeDoCN || 'Unknown Test');
+        const nomesVariacoes = [
+            nomeString,
+            nomeString.replace(/[^\w\d]/g, ''),
+            nomeString.replace(/[^\w\d]/g, '_'),
+            nomeString.replace(/\s+/g, '_'),
+            nomeString.replace(/\s+/g, ''),
+        ];
+        for (const nomeVariacao of nomesVariacoes) {
+            const logsVariacao = UnifiedReportManager.logsPorTeste.get(nomeVariacao);
+            if (logsVariacao && logsVariacao.length > 0) {
+                Logger.info(`📋 Encontrados ${logsVariacao.length} logs para variação: ${nomeVariacao}`);
+                logs.push(...logsVariacao);
+            }
+        }
+        // 🔧 Remover duplicatas preservando ordem
+        logs = [...new Set(logs)];
+        // 🆕 Se ainda não temos logs, criar logs informativos básicos
+        if (logs.length === 0) {
+            logs = [
+                `🎯 Iniciando execução do teste: ${nomeDoCN}`,
+                `📋 Contexto detectado: ${contexto}`,
+                `🕐 Timestamp: ${new Date().toLocaleString('pt-BR')}`,
+                'ℹ️ ATENÇÃO: Logs reais não foram capturados automaticamente',
+                '💡 Para capturar logs, use: Logger.info(), console.log(), ou UnifiedReportManager.adicionarLog()',
+                `🔧 Debug: Total de variações testadas: ${nomesVariacoes.length}`,
+                `📊 Debug: Buffer do console disponível: ${globalThis.consoleBuffer ? 'SIM' : 'NÃO'}`,
+                `🎯 Debug: Nome do teste atual: ${UnifiedReportManager.currentTestName || 'NENHUM'}`,
+            ];
+        }
+        else {
+            Logger.success(`✅ Total de ${logs.length} logs coletados de todas as fontes`);
+            // 🆕 Adicionar logs informativos no início se não existirem
+            const logsComInfo = [
+                `🎯 Teste: ${nomeDoCN} (${contexto})`,
+                `🕐 Início: ${testeGlobal?.inicio ? new Date(testeGlobal.inicio).toLocaleString('pt-BR') : 'N/A'}`,
+                `📊 Total de logs capturados: ${logs.length}`,
+                '------- LOGS DE EXECUÇÃO -------',
+                ...logs,
+            ];
+            logs = logsComInfo;
+        }
+        const metadata = UnifiedReportManager.metadataPorTeste.get(nomeDoCN) || {};
+        // Buscar duração preferencialmente dos dadosGlobais
+        const duracao = testeGlobal?.duracao
+            ? testeGlobal.duracao
+            : (UnifiedReportManager.duracoesPorTeste.get(nomeDoCN) || 0) / 1000;
+        // Determina se há erros nos logs
+        const temErroLogs = logs.some((log) => log.includes('❌') ||
+            log.includes('FAILED') ||
+            log.includes('erro') ||
+            log.includes('falhou'));
+        // ✅ NOVO: Se o teste tem erro, corrigir CTs "running" antes de coletar
+        if (temErroLogs) {
+            Logger.info(`🔧 Teste com erro detectado nos logs, corrigindo CTs em execução: ${nomeDoCN}`);
+            await UnifiedReportManager.corrigirStatusCTsQuandoTesteFalha(nomeDoCN);
+            // Aguardar um pouco para permitir que as correções sejam aplicadas
+            await new Promise((resolve) => setTimeout(resolve, 100));
+        }
+        // 🆕 CRÍTICO: Aguardar que StatementTracker tenha dados prontos
+        try {
+            await StatementTracker.waitForDataReady();
+            Logger.success('✅ StatementTracker pronto para coleta de dados');
+        }
+        catch (error) {
+            Logger.warning(`⚠️ Erro ao aguardar dados do StatementTracker: ${error}`);
+        }
+        // 🔧 CORREÇÃO CRÍTICA: Busca direta e simples
+        const allExecutions = StatementTracker.getExecutions();
+        // 🆕 BUSCA SIMPLIFICADA: Pegar CTs do teste específico
+        let cts = [];
+        let totalCTs = 0;
+        let passedCTs = 0;
+        let failedCTs = 0;
+        let skippedCTs = 0;
+        // ✅ CORREÇÃO: Buscar pelo nome do CN (test.describe)
+        let testExecution = allExecutions.get(nomeDoCN);
+        // 🔍 DEBUG CRÍTICO: Ver todos os nomes registrados
+        for (const [key, value] of allExecutions.entries()) {
+            Logger.info(`  📋 "${key}" - ${value.totalCTs} CTs`);
+        }
+        // 🆘 FALLBACK: Se não encontrou exato, tentar busca parcial
+        if (!testExecution) {
+            // Tentar encontrar por semelhança
+            for (const [key, value] of allExecutions.entries()) {
+                if (key.includes(nomeDoCN) || nomeDoCN.includes(key)) {
+                    Logger.info(`🎯 [UnifiedReport] Encontrado por semelhança: "${key}" para "${nomeDoCN}"`);
+                    testExecution = value;
+                    break;
+                }
+            }
+            // Se ainda não encontrou, pegar qualquer um que tenha CTs
+            if (!testExecution) {
+                for (const [key, value] of allExecutions.entries()) {
+                    if (value.totalCTs > 0) {
+                        Logger.info(`🆘 [UnifiedReport] Usando primeiro teste com CTs: "${key}"`);
+                        testExecution = value;
+                        break;
+                    }
+                }
+            }
+        }
+        if (testExecution && testExecution.cts && testExecution.cts.length > 0) {
+            Logger.info(`🎯 Encontrado dados com ${testExecution.cts.length} CTs`); // ✅ CORREÇÃO: Iterar sobre os CTs do teste específico
+            cts = testExecution.cts.map((ct, index) => {
+                const rawName = ct.ctName || ct.name || '';
+                const derivedClass = ct.className ||
+                    rawName.split('.')[0] ||
+                    rawName.split('→')[0]?.trim() ||
+                    'Unknown';
+                const derivedMethod = ct.methodName ||
+                    rawName.split('.')[1] ||
+                    rawName.split('→')[1]?.trim() ||
+                    rawName ||
+                    'method';
+                const durationMs = typeof ct.duration === 'number'
+                    ? ct.duration
+                    : ct.endTime && ct.startTime
+                        ? ct.endTime - ct.startTime
+                        : 0;
+                return {
+                    ctId: ct.ctId ||
+                        ct.ctIdentifier ||
+                        `CT${(index + 1).toString().padStart(3, '0')}`,
+                    ctName: rawName || `CT ${index + 1}`,
+                    ctOrder: ct.ctOrder ?? index + 1,
+                    status: (ct.status || 'running'),
+                    duration: durationMs,
+                    timestamp: ct.startTime ? new Date(ct.startTime) : new Date(),
+                    startTime: ct.startTime ?? null,
+                    endTime: ct.endTime ?? (ct.startTime ? ct.startTime + durationMs : null),
+                    error: ct.error,
+                    className: derivedClass,
+                    methodName: derivedMethod,
+                    systemName: ct.systemName || testExecution.systemName || 'Unknown',
+                    statements: Array.isArray(ct.statements)
+                        ? ct.statements.map((stmt) => ({ ...stmt }))
+                        : [],
+                    executedActions: Array.isArray(ct.executedActions)
+                        ? ct.executedActions.map((action) => ({ ...action }))
+                        : [],
+                    logs: Array.isArray(ct.logs) ? [...ct.logs] : [],
+                };
+            });
+            // ✅ CORREÇÃO CRÍTICA: Sempre contar TODOS os CTs do array mapeado
+            // Não confiar apenas em testExecution.totalCTs pois pode estar desatualizado
+            // 🛡️ CRÍTICO: CTs "running" devem ser contados como "failed"
+            totalCTs = cts.length;
+            passedCTs = cts.filter((ct) => ct.status === 'passed').length;
+            failedCTs = cts.filter((ct) => ct.status === 'failed' || ct.status === 'running').length;
+            skippedCTs = cts.filter((ct) => ct.status === 'skipped').length;
+        }
+        else {
+            Logger.info(`⚠️ Nenhum CT encontrado para CN "${nomeDoCN}"`);
+            Logger.info(`📋 CNs disponíveis no StatementTracker: ${Array.from(allExecutions.keys()).join(', ')}`);
+            // 🔍 DEBUG: Verificar total de CNs e detalhes
+            for (const [testName, testData] of allExecutions.entries()) {
+                Logger.info(`  📋 Teste ${testName}: ${testData.totalCTs} CTs`);
+                Logger.info(`    ⚠️ Nenhum CT encontrado para ${testName}`);
+            }
+        }
+        // 🆕 CORREÇÃO CRÍTICA: Determinar resultado considerando tanto logs quanto CTs falhados
+        // 🛡️ IMPORTANTE: Se tem CT "failed" OU "running", o CN inteiro falhou
+        const temCTsFalhados = failedCTs > 0; // Já inclui running porque failedCTs conta running
+        const testeFalhou = temErroLogs || temCTsFalhados;
+        const resultado = {
+            nome: nomeDoCN,
+            resultado: testeFalhou ? 'FAIL' : 'PASS',
+            tipo: contexto,
+            duracao,
+            logs, // sempre array
+            timestamp: new Date(),
+            metadata,
+            // 🆕 Dados dos CTs
+            cts,
+            totalCTs,
+            passedCTs,
+            failedCTs,
+            skippedCTs,
+        };
+        // Remove teste existente e adiciona o atualizado
+        UnifiedReportManager.testes = UnifiedReportManager.testes.filter((t) => t.nome !== nomeDoCN);
+        UnifiedReportManager.testes.push(resultado);
+        // 🆕 Retornar os dados coletados
+        return {
+            cts,
+            logs,
+            screenshots: [], // TODO: implementar screenshots
+            totalCTs,
+            passedCTs,
+            failedCTs,
+            skippedCTs,
+        };
+    }
+    static adicionarLog(testeName, message) {
+        // 🔧 PROTEÇÃO CRÍTICA ANTI-LOOP: Evitar qualquer recursão
+        if (message.includes('[UNIFIED]') ||
+            message.includes('[LOG]') ||
+            message.includes('📝 Adicionando log para') ||
+            message.includes('AutoCore: Sistema') ||
+            message.includes('interceptação') ||
+            message.includes('interceptar') ||
+            UnifiedReportManager._addingLog) {
+            return; // Evitar re-processar logs já processados
+        }
+        // 🔧 MARCAR que estamos adicionando log para evitar recursão
+        ;
+        UnifiedReportManager._addingLog = true;
+        try {
+            // 🔧 CRÍTICO: NÃO usar console.log aqui - usar apenas estruturas internas
+            if (!UnifiedReportManager.logsPorTeste.has(testeName)) {
+                UnifiedReportManager.logsPorTeste.set(testeName, []);
+            }
+            UnifiedReportManager.logsPorTeste.get(testeName).push(message);
+            // ✅ NOVO: Adicionar log aos dadosGlobais também
+            if (UnifiedReportManager.dadosGlobais.testes[testeName]) {
+                UnifiedReportManager.dadosGlobais.testes[testeName].logs.push(message);
+            }
+            // ✅ NOVO: Adicionar também ao buffer global se não existir
+            if (globalThis.consoleBuffer) {
+                ;
+                globalThis.consoleBuffer.push({
+                    testName: testeName,
+                    message,
+                    timestamp: new Date().toISOString(),
+                    type: 'auto-added',
+                });
+            }
+        }
+        catch (error) {
+            // Evitar qualquer erro que possa causar loop
+        }
+        finally {
+            // 🔧 SEMPRE limpar flag
+            ;
+            UnifiedReportManager._addingLog = false;
+        }
+    }
+    static setTestMetadata(testeName, metadata) {
+        UnifiedReportManager.metadataPorTeste.set(testeName, metadata);
+    }
+    static setTestDuration(testeName, duracao) {
+        UnifiedReportManager.duracoesPorTeste.set(testeName, duracao);
+        // ✅ NOVO: Atualizar também nos dadosGlobais
+        if (UnifiedReportManager.dadosGlobais.testes[testeName]) {
+            UnifiedReportManager.dadosGlobais.testes[testeName].duracao =
+                duracao / 1000; // Converter para segundos
+        }
+    }
+    /**
+     * ✅ NOVO: Obter logs de um teste específico
+     */
+    static getTestLogs(testName) {
+        return UnifiedReportManager.logsPorTeste.get(testName) || [];
+    }
+    static async anexarRelatorioIndividual() {
+        const testInfo = TestContext.getSafeTestInfo();
+        if (!testInfo)
+            return;
+        const testeName = testInfo.title;
+        const testeAtual = UnifiedReportManager.testes.find((t) => t.nome === testeName);
+        if (!testeAtual) {
+            Logger.warning(`Teste ${testeName} não encontrado para relatório individual`);
+            return;
+        }
+        try {
+            const htmlBuffer = await UnifiedHtmlGenerator.generate([testeAtual], UnifiedReportManager.inicioExecucao || new Date(), UnifiedReportManager.fimExecucao || new Date(), true, testeName);
+            // Gerar nome de arquivo baseado no nome do teste
+            // Exemplo: CT003_Consultar_Cobertura.html
+            const safeTestName = testeName
+                .replace(/[^\w\d]+/g, '_')
+                .replace(/^_+|_+$/g, '');
+            const reportDir = path.join(process.cwd(), 'playwright-report');
+            if (!fs.existsSync(reportDir)) {
+                fs.mkdirSync(reportDir, { recursive: true });
+            }
+            const reportPath = path.join(reportDir, `${safeTestName}.html`);
+            fs.writeFileSync(reportPath, htmlBuffer);
+            // Anexar ao contexto do Playwright (útil para CI e UI)
+            await testInfo.attach(`${safeTestName}.html`, {
+                body: htmlBuffer,
+                contentType: 'text/html',
+            });
+            Logger.success(`📄 Relatório individual salvo e anexado: ${reportPath}`);
+        }
+        catch (error) {
+            Logger.error(`Erro ao gerar relatório individual para ${testeName}`, error);
+        }
+    }
+    /**
+     * ✅ CORRIGIDO: Anexa relatório geral unificado
+     */
+    static async anexarRelatorioGeral() {
+        try {
+            const testesRegistrados = Object.keys(UnifiedReportManager.dadosGlobais.testes);
+            Logger.info(`📊 Verificando testes registrados: ${testesRegistrados.length}`);
+            if (testesRegistrados.length === 0) {
+                Logger.info('⚠️ Nenhum teste registrado para relatório geral');
+                return;
+            }
+            // ✅ Gerar relatório mesmo com testes que falharam
+            Logger.info(`📋 Gerando relatório para ${testesRegistrados.length} teste(s)...`);
+            // 🆕 CRÍTICO: Buscar CNs reais do StatementTracker ao invés dos nomes dos testes
+            Logger.info('📊 Coletando dados dos CTs para todos os CNs...');
+            const allExecutions = StatementTracker.getExecutions();
+            const nomesDosCNs = Array.from(allExecutions.keys());
+            Logger.info(`📊 CNs detectados no StatementTracker: ${nomesDosCNs.join(', ')}`);
+            Logger.info(`📊 Testes registrados no UnifiedReportManager: ${testesRegistrados.join(', ')}`);
+            // 🔧 CORREÇÃO: Iterar sobre os CNs do StatementTracker, não sobre testesRegistrados
+            for (const nomeDoCN of nomesDosCNs) {
+                try {
+                    await UnifiedReportManager.coletarDadosDoTeste(nomeDoCN);
+                }
+                catch (error) {
+                    Logger.warning(`⚠️ Erro ao coletar dados do CN ${nomeDoCN}: ${error}`);
+                }
+            }
+            UnifiedReportManager.testes.forEach((teste, index) => {
+                if (teste.cts && teste.cts.length > 0) {
+                    teste.cts.forEach((ct, ctIndex) => {
+                        Logger.info(`    CT${ctIndex + 1}: ${ct.ctName} (${ct.status})`);
+                    });
+                }
+                else {
+                    Logger.info(`    ⚠️ Nenhum CT encontrado para ${teste.nome}`);
+                }
+            });
+            // ✅ NOVO: Gerar HTML do relatório geral
+            try {
+                const htmlBuffer = await UnifiedHtmlGenerator.generate(UnifiedReportManager.testes, UnifiedReportManager.inicioExecucao || new Date(), UnifiedReportManager.fimExecucao || new Date(), false, 'Relatório Geral');
+                // ✅ Salvar arquivo HTML
+                const reportDir = path.join(process.cwd(), 'playwright-report');
+                if (!fs.existsSync(reportDir)) {
+                    fs.mkdirSync(reportDir, { recursive: true });
+                }
+                const reportPath = path.join(reportDir, 'relatorio-geral-unificado.html');
+                fs.writeFileSync(reportPath, htmlBuffer);
+                Logger.info(`📁 Relatório geral salvo em: ${reportPath}`);
+            }
+            catch (error) {
+                Logger.error('❌ Erro ao gerar arquivo HTML do relatório', error);
+            }
+            // Logar os dados dos testes
+            testesRegistrados.forEach((testName) => {
+                const teste = UnifiedReportManager.dadosGlobais.testes[testName];
+                Logger.info(`  📄 ${testName}: ${teste.status} (${teste.tipo})`);
+            });
+            Logger.success('✅ Relatório geral gerado com sucesso!');
+        }
+        catch (error) {
+            Logger.error('❌ Erro ao gerar relatório geral', error);
+        }
+    }
+    /**
+     * 🔍 DEBUG: Método para acessar dados globais
+     */
+    static getDadosGlobais() {
+        return UnifiedReportManager.dadosGlobais;
+    }
+    /**
+     * ✅ ÚNICO: Método getMetrics unificado
+     */
+    static getMetrics() {
+        const testesPorTipo = {
+            API: 0,
+            Frontend: 0,
+            Mobile: 0,
+            SSH: 0,
+            Banco: 0,
+            Mixed: 0,
+            Scenarios: 0,
+        };
+        const resultadosPorTipo = {
+            API: { passou: 0, falhou: 0 },
+            Frontend: { passou: 0, falhou: 0 },
+            Mobile: { passou: 0, falhou: 0 },
+            SSH: { passou: 0, falhou: 0 },
+            Banco: { passou: 0, falhou: 0 },
+            Mixed: { passou: 0, falhou: 0 },
+            Scenarios: { passou: 0, falhou: 0 }, // Adicione esta linha
+        };
+        // ✅ USAR dadosGlobais como fonte única da verdade
+        Object.values(UnifiedReportManager.dadosGlobais.testes).forEach((teste) => {
+            testesPorTipo[teste.tipo]++;
+            if (teste.status === 'passed') {
+                resultadosPorTipo[teste.tipo].passou++;
+            }
+            else if (teste.status === 'failed') {
+                resultadosPorTipo[teste.tipo].falhou++;
+            }
+        });
+        const duracao = UnifiedReportManager.inicioExecucao && UnifiedReportManager.fimExecucao
+            ? (UnifiedReportManager.fimExecucao.getTime() -
+                UnifiedReportManager.inicioExecucao.getTime()) /
+                1000
+            : 0;
+        return {
+            totalTestes: UnifiedReportManager.dadosGlobais.totalTestes,
+            testesPorTipo,
+            resultadosPorTipo,
+            inicio: UnifiedReportManager.inicioExecucao,
+            fim: UnifiedReportManager.fimExecucao,
+            duracao,
+            testes: UnifiedReportManager.testes,
+        };
+    }
+    static reset() {
+        UnifiedReportManager.testes = [];
+        UnifiedReportManager.contextoPorTeste.clear();
+        UnifiedReportManager.logsPorTeste.clear();
+        UnifiedReportManager.metadataPorTeste.clear();
+        UnifiedReportManager.duracoesPorTeste.clear();
+        UnifiedReportManager.inicioExecucao = undefined;
+        UnifiedReportManager.fimExecucao = undefined;
+        // ✅ NOVO: Reset dadosGlobais
+        UnifiedReportManager.dadosGlobais = {
+            totalTestes: 0,
+            testesPassados: 0,
+            testesFalharam: 0,
+            testes: {},
+        };
+    }
+    static async finalizarTeste(testName, status) {
+        try {
+            // Se foi chamado com parâmetros, usar a versão específica
+            if (testName && status) {
+                await UnifiedReportManager.marcarFimTeste(testName, status);
+                return;
+            }
+            // 🆕 Finalizar todos os CTs pendentes antes de coletar dados
+            TestAnnotations.finalizarCTAtivo();
+            await UnifiedReportManager.coletarDadosDoTeste();
+            await UnifiedReportManager.anexarRelatorioIndividual();
+        }
+        catch (error) {
+            Logger.error('❌ Erro ao finalizar teste unificado', error);
+        }
+    }
+    /**
+     * ✅ NOVO: Interceptar e registrar erros de teste automaticamente
+     * @param testName Nome do teste
+     * @param error Erro capturado
+     */
+    static async registrarErroTeste(testName, error) {
+        const errorMessage = typeof error === 'string' ? error : error.message || error.toString();
+        Logger.info(`🔴 Erro registrado para ${testName}: ${errorMessage}`);
+        // Adicionar log do erro
+        UnifiedReportManager.adicionarLog(testName, `❌ ERRO: ${errorMessage}`);
+        // ✅ IMPORTANTE: Chamar corrigirStatusCTsQuandoTesteFalha imediatamente
+        await UnifiedReportManager.corrigirStatusCTsQuandoTesteFalha(testName);
+        // Marcar teste como falhado nos dados globais
+        if (UnifiedReportManager.dadosGlobais.testes[testName]) {
+            UnifiedReportManager.dadosGlobais.testes[testName].status = 'failed';
+            Logger.success(`✅ Status do teste ${testName} atualizado para 'failed'`);
+        }
+    }
+    /**
+     * ✅ NOVO: Configurar interceptação global de erros para testes AutoCore
+     */
+    static configurarInterceptacaoErros() {
+        const errorHandler = (error) => {
+            const errorMessage = error.message || error.toString();
+            // Usar teste atual do monitoramento automático
+            const testName = UnifiedReportManager.currentTestName;
+            if (testName &&
+                (errorMessage.includes('expect') ||
+                    errorMessage.includes('AssertionError') ||
+                    errorMessage.includes('Error:'))) {
+                Logger.info(`🤖 AutoCore: Erro detectado automaticamente no teste ${testName}`);
+                UnifiedReportManager.registrarErroTeste(testName, error).catch((err) => Logger.error('Erro ao registrar erro:', err));
+            }
+        };
+        // Adicionar handlers se ainda não existem
+        if (!process.listenerCount('uncaughtException')) {
+            process.on('uncaughtException', errorHandler);
+        }
+        if (!process.listenerCount('unhandledRejection')) {
+            process.on('unhandledRejection', (reason) => {
+                errorHandler(new Error(`Unhandled Rejection: ${reason}`));
+            });
+        }
+    }
+    /**
+     * ✅ NOVO: Interceptar logs do console para detectar ações automaticamente
+     */
+    static interceptarConsole() {
+        // 🆕 Criar buffer global para logs se não existir
+        if (!globalThis.consoleBuffer) {
+            ;
+            globalThis.consoleBuffer = [];
+        }
+        const originalLog = console.log;
+        const originalError = console.error;
+        const originalInfo = console.info;
+        const originalWarn = console.warn;
+        console.log = (...args) => {
+            const message = args.join(' ');
+            // 🔧 CRÍTICO: Evitar recursão infinita com proteções múltiplas
+            if (!(message.includes('📝 Adicionando log para') ||
+                message.includes('[UNIFIED]') ||
+                message.includes('interceptação') ||
+                message.includes('AutoCore: Sistema')) &&
+                UnifiedReportManager.currentTestName &&
+                !UnifiedReportManager._intercepting) {
+                ;
+                UnifiedReportManager._intercepting = true;
+                try {
+                    ;
+                    globalThis.consoleBuffer.push({
+                        testName: UnifiedReportManager.currentTestName,
+                        message,
+                        timestamp: new Date().toISOString(),
+                        type: 'log',
+                    });
+                    // 🔧 ADIÇÃO DIRETA SEM chamar adicionarLog para evitar loop
+                    if (!UnifiedReportManager.logsPorTeste.has(UnifiedReportManager.currentTestName)) {
+                        UnifiedReportManager.logsPorTeste.set(UnifiedReportManager.currentTestName, []);
+                    }
+                    UnifiedReportManager.logsPorTeste
+                        .get(UnifiedReportManager.currentTestName)
+                        .push(message);
+                }
+                finally {
+                    ;
+                    UnifiedReportManager._intercepting = false;
+                }
+            }
+            // Chamar console original
+            originalLog.apply(console, args);
+        };
+        console.info = (...args) => {
+            const message = args.join(' ');
+            if (UnifiedReportManager.currentTestName) {
+                ;
+                globalThis.consoleBuffer.push({
+                    testName: UnifiedReportManager.currentTestName,
+                    message: `ℹ️ ${message}`,
+                    timestamp: new Date().toISOString(),
+                    type: 'info',
+                });
+                // 🔧 EVITAR RECURSÃO: Não chamar adicionarLog que faz console.log
+                // this.adicionarLog(this.currentTestName, `ℹ️ ${message}`)
+            }
+            originalInfo.apply(console, args);
+        };
+        console.warn = (...args) => {
+            const message = args.join(' ');
+            if (UnifiedReportManager.currentTestName) {
+                ;
+                globalThis.consoleBuffer.push({
+                    testName: UnifiedReportManager.currentTestName,
+                    message: `⚠️ ${message}`,
+                    timestamp: new Date().toISOString(),
+                    type: 'warn',
+                });
+                // 🔧 EVITAR RECURSÃO: Não chamar adicionarLog que faz console.log
+                // this.adicionarLog(this.currentTestName, `⚠️ ${message}`)
+            }
+            originalWarn.apply(console, args);
+        };
+        console.error = (...args) => {
+            const message = args.join(' ');
+            // 🆕 Adicionar ao buffer global
+            if (UnifiedReportManager.currentTestName) {
+                ;
+                globalThis.consoleBuffer.push({
+                    testName: UnifiedReportManager.currentTestName,
+                    message: `❌ ERRO: ${message}`,
+                    timestamp: new Date().toISOString(),
+                    type: 'error',
+                });
+                // 🔧 EVITAR RECURSÃO: Não chamar adicionarLog que faz console.log
+                // this.adicionarLog(this.currentTestName, `❌ ERRO: ${message}`)
+                // Considerar como falha
+                setTimeout(() => {
+                    if (UnifiedReportManager.currentTestName) {
+                        UnifiedReportManager.registrarErroTeste(UnifiedReportManager.currentTestName, message).catch((err) => console.error('Erro ao registrar erro:', err));
+                    }
+                }, 10);
+            }
+            // Chamar console original
+            originalError.apply(console, args);
+        };
+    }
+    /**
+     * ✅ NOVO: Adiciona um CT ao teste
+     */
+    static adicionarCT(testName, ct) {
+        if (!(testName && ct)) {
+            Logger.warning('⚠️ Nome do teste ou CT vazio, ignorando adicionarCT');
+            return;
+        }
+        // Buscar o teste nos dados globais
+        const testeGlobal = UnifiedReportManager.dadosGlobais.testes[testName];
+        if (testeGlobal) {
+            if (!testeGlobal.cts) {
+                testeGlobal.cts = [];
+            }
+            testeGlobal.cts.push(ct);
+            Logger.info(`📋 CT adicionado ao teste ${testName}: ${ct.id || ct.descricao}`);
+        }
+        // Também adicionar ao array principal de testes
+        const testeArray = UnifiedReportManager.testes.find((t) => t.nome === testName);
+        if (testeArray) {
+            if (!testeArray.cts) {
+                testeArray.cts = [];
+            }
+            testeArray.cts.push(ct);
+        }
+    }
+    /**
+     * ✅ NOVO: Gera o relatório unificado final
+     */
+    static async gerarRelatorioUnificado() {
+        Logger.info('📊 Gerando relatório unificado...');
+        try {
+            // Coletar dados de todos os testes
+            const testesComDados = await Promise.all(UnifiedReportManager.testes.map(async (teste) => {
+                const dadosColetados = await UnifiedReportManager.coletarDadosDoTeste(teste.nome);
+                return {
+                    ...teste,
+                    cts: dadosColetados.cts || [],
+                    logs: dadosColetados.logs || [],
+                    screenshots: dadosColetados.screenshots || [],
+                };
+            }));
+            // 🆕 Buscar dados do StatementTracker
+            let ctData = null;
+            let allCNsData = {};
+            try {
+                ctData = await getStatementTrackerData();
+                const allExecutions = StatementTracker.getExecutions();
+                // 🔧 Converter Map para objeto plano (JSON serializable)
+                allCNsData = Object.fromEntries(allExecutions);
+                Logger.info(`📊 gerarRelatorioUnificado: ${Object.keys(allCNsData).length} CNs exportados para template`);
+            }
+            catch (error) {
+                Logger.warning(`⚠️ Erro ao buscar dados do StatementTracker: ${error}`);
+            }
+            // Preparar dados para o template
+            const dadosRelatorio = {
+                testes: testesComDados,
+                titulo: 'Relatório Unificado de Testes',
+                subtitulo: 'Resultados da execução de testes automatizados',
+                totalTestes: UnifiedReportManager.dadosGlobais.totalTestes,
+                testesPassaram: UnifiedReportManager.dadosGlobais.testesPassados,
+                testesFalharam: UnifiedReportManager.dadosGlobais.testesFalharam,
+                projectName: 'TestHUB',
+                environment: 'N/A',
+                executionDate: new Date().toLocaleString('pt-BR'),
+                autocoreVersion: 'v1.1.x',
+                // 🔗 INTEGRAÇÃO: Dados dos CTs detectados automaticamente
+                ctData,
+                allCNsData, // 🆕 Mapa completo de CNs → CTs → Statements → Actions
+                estatisticasPorTipo: {},
+                coresDosTipos: {
+                    API: '#3b82f6',
+                    Frontend: '#10b981',
+                    Mobile: '#f59e0b',
+                    SSH: '#ef4444',
+                    Banco: '#8b5cf6',
+                    Mixed: '#6b7280',
+                },
+                chartLabels: ['Passou', 'Falhou'],
+                chartData: [
+                    UnifiedReportManager.dadosGlobais.testesPassados,
+                    UnifiedReportManager.dadosGlobais.testesFalharam,
+                ],
+                chartColors: ['#22c55e', '#ef4444'],
+                barLabels: ['Testes'],
+                barData: [UnifiedReportManager.dadosGlobais.totalTestes],
+                pieLabels: ['Passou', 'Falhou'],
+                pieData: [
+                    UnifiedReportManager.dadosGlobais.testesPassados,
+                    UnifiedReportManager.dadosGlobais.testesFalharam,
+                ],
+                getIconePorTipo: (tipo) => {
+                    const icones = {
+                        API: '🌐',
+                        Frontend: '💻',
+                        Mobile: '📱',
+                        SSH: '🔐',
+                        Banco: '🗃️',
+                        Mixed: '🔄',
+                    };
+                    return icones[tipo] || '📋';
+                },
+                resumo: {
+                    totalTestes: UnifiedReportManager.dadosGlobais.totalTestes,
+                    testesPassados: UnifiedReportManager.dadosGlobais.testesPassados,
+                    testesFalharam: UnifiedReportManager.dadosGlobais.testesFalharam,
+                    duracaoTotal: UnifiedReportManager.calcularDuracaoTotal(),
+                    timestamp: new Date().toISOString(),
+                },
+                metadata: {
+                    inicio: UnifiedReportManager.inicioExecucao?.toISOString(),
+                    fim: UnifiedReportManager.fimExecucao?.toISOString(),
+                    contextos: UnifiedReportManager.getContextosUnicos(),
+                },
+            };
+            // Gerar HTML usando o template
+            const htmlTemplatePath = path.join(process.cwd(), 'src', 'utils', 'HTMLTemplate.js');
+            const htmlContent = HTMLTemplate(dadosRelatorio);
+            // Salvar arquivo
+            const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+            const nomeArquivo = `relatorio-unificado-${timestamp}.html`;
+            const caminhoCompleto = path.join(process.cwd(), 'docs', nomeArquivo);
+            // Garantir que o diretório existe
+            const dirDocs = path.dirname(caminhoCompleto);
+            if (!fs.existsSync(dirDocs)) {
+                fs.mkdirSync(dirDocs, { recursive: true });
+            }
+            fs.writeFileSync(caminhoCompleto, htmlContent, 'utf8');
+            Logger.info(`✅ Relatório unificado gerado: ${caminhoCompleto}`);
+            Logger.info(`📊 Resumo: ${dadosRelatorio.resumo.totalTestes} testes, ${dadosRelatorio.resumo.testesPassados} passaram, ${dadosRelatorio.resumo.testesFalharam} falharam`);
+            return caminhoCompleto;
+        }
+        catch (error) {
+            Logger.error('❌ Erro ao gerar relatório unificado:', error);
+            return '';
+        }
+    }
+    /**
+     * ✅ HELPER: Calcula duração total
+     */
+    static calcularDuracaoTotal() {
+        if (UnifiedReportManager.inicioExecucao &&
+            UnifiedReportManager.fimExecucao) {
+            const duracao = (UnifiedReportManager.fimExecucao.getTime() -
+                UnifiedReportManager.inicioExecucao.getTime()) /
+                1000;
+            return `${duracao.toFixed(2)}s`;
+        }
+        return '0s';
+    }
+    /**
+     * ✅ HELPER: Pega contextos únicos
+     */
+    static getContextosUnicos() {
+        const contextos = new Set();
+        UnifiedReportManager.testes.forEach((teste) => {
+            contextos.add(teste.tipo);
+        });
+        return Array.from(contextos);
+    }
+}
+// ✅ CRITICAL: Auto-inicialização quando módulo é carregado
+UnifiedReportManager['autoInit']();
+// ✅ IMPORTANTE: Interceptar console automaticamente
+UnifiedReportManager['interceptarConsole']();