@silasfmartins/testhub 1.0.0

package/dist/src/hubdocs/StatementTracker.js

@@ -0,0 +1,2419 @@
+/**
+ * 🎯 INTERCEPTADOR AUTOMÁTICO DE STATEMENTS
+ * Sistema 100% automático - detecta tudo pelos logs existentes
+ * Integrado com ExecutionTracker e relatórios HTML
+ * @version 3.1.0 - PERSISTÊNCIA AUTOMÁTICA ANTI-PERDA
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { Logger } from '../utils/Logger.js';
+/**
+ * 📊 RASTREADOR AUTOMÁTICO DE CTs
+ * ZERO CONFIGURAÇÃO - DETECÇÃO AUTOMÁTICA + INTEGRAÇÃO COM RELATÓRIOS
+ */
+export class StatementTracker {
+    /**
+     * 🛑 Flag global para indicar que algum CT falhou com stopOnFailure ativo
+     * Quando true, todos os próximos CTs devem ser pulados
+     */
+    static hasFailedWithStopOnFailure = false;
+    /**
+     * 🔒 Controle de duplicação de logs - evita logs repetidos
+     */
+    static lastLoggedCT = null;
+    static lastLoggedRequest = null;
+    static lastRequestTimestamp = 0;
+    static ctLogStreams = new Map();
+    /**
+     * ✅ CORRIGIDO: Criar CT automaticamente se não existir - VERSÃO ROBUSTA
+     * Um CT é criado por test(), não por statement!
+     * 🔧 FIX: Verificar se já existe CT com o MESMO NOME, não apenas status='running'
+     * ✅ AGORA COM FALLBACKS ROBUSTOS PARA PROJETOS CONSUMIDORES
+     */
+    static ensureCTCreated() {
+        const testName = StatementTracker.getCurrentTestName();
+        const testData = StatementTracker.executions.get(testName);
+        // ✅ PROTEÇÃO CRÍTICA #1: Se já existe um CT "running", NÃO criar outro
+        // Isso evita criar CTs duplicados quando statements executam
+        if (testData && testData.cts.length > 0) {
+            const runningCT = testData.cts.find((ct) => ct.status === 'running');
+            if (runningCT) {
+                // CT running já existe, não fazer nada
+                return;
+            }
+        }
+        // Pegar nome do CT atual (test()) com fallbacks robustos
+        let ctName = StatementTracker.getCurrentCTName();
+        // 🆘 FALLBACK 1: Se não conseguiu pegar CT do TestContext, usar teste como CT
+        if (!ctName) {
+            ctName = testName;
+        }
+        // 🆘 FALLBACK 2: Se o ctName ainda for vago, criar um nome único
+        if (!ctName || ctName === 'Unknown Test') {
+            ctName = `CT_${Date.now()}`; // CT único baseado em timestamp
+        }
+        // 🆘 FALLBACK 3: Se ctName é igual ao testName, criar um CT específico
+        if (ctName === testName) {
+            ctName = `${testName}_CT_Principal`;
+        }
+        // ✅ PROTEÇÃO #2: Verificar se já existe CT com este NOME, não apenas status
+        // Um test() deve ter apenas 1 CT, mesmo que falhe no meio
+        if (testData && testData.cts.length > 0 && ctName) {
+            const existingCT = testData.cts.find((ct) => ct.name === ctName);
+            if (existingCT) {
+                // CT já existe, não criar outro!
+                return;
+            }
+        }
+        if (ctName) {
+            StatementTracker.startCT(ctName);
+            StatementTracker.ctAutoCreated = true;
+        }
+        else {
+            // 🚨 FORÇA CRIAÇÃO DE CT COMO ÚLTIMO RECURSO
+            const forcedCTName = `CT_FORCED_${Date.now()}`;
+            StatementTracker.startCT(forcedCTName);
+            StatementTracker.ctAutoCreated = true;
+        }
+    }
+    /**
+     * 🎯 MÉTODO AUXILIAR: Detectar CT via análise de contexto de execução
+     * Para projetos consumidores onde TestContext pode não estar disponível
+     */
+    static detectCTFromExecutionContext() {
+        try {
+            // Capturar stack trace atual
+            const error = new Error();
+            const stack = error.stack;
+            if (!stack)
+                return null;
+            // Padrões comuns de nomes de CT em projetos
+            const ctPatterns = [
+                // Padrões específicos
+                /CT\d+[_\s-].*?(?=\s|"|'|`|\n|$)/gi,
+                /test\(["`']([^"`']+)["`']/gi,
+                /describe\(["`'].*?["`'].*?test\(["`']([^"`']+)["`']/gi,
+                // Padrões de método que executam testes
+                /(?:executar|execute|run|test)([A-Z][a-zA-Z0-9_]+)/gi,
+                // Padrões SSH específicos
+                /(?:Consumo|Voz|Dados|SMS|Internet|Teste)[_\s-].*?(?=\s|"|'|`|\n|$)/gi,
+            ];
+            for (const pattern of ctPatterns) {
+                pattern.lastIndex = 0; // Reset regex
+                const matches = Array.from(stack.matchAll(pattern));
+                for (const match of matches) {
+                    const potentialCT = match[1] || match[0];
+                    if (potentialCT &&
+                        potentialCT.length > 3 &&
+                        potentialCT.length < 100) {
+                        const cleanCT = potentialCT.trim().replace(/["`']/g, '');
+                        return cleanCT;
+                    }
+                }
+            }
+            // Fallback: procurar por qualquer string que pareça um nome de teste
+            const lines = stack.split('\n');
+            for (const line of lines) {
+                if (line.includes('.spec.ts') || line.includes('test')) {
+                    // Extrair nome do arquivo como possível CT
+                    const fileMatch = line.match(/([^/\\]+)\.spec\.ts/);
+                    if (fileMatch) {
+                        const fileName = fileMatch[1];
+                        return fileName;
+                    }
+                }
+            }
+        }
+        catch (_error) {
+            // Silenciosamente ignorar erros
+        }
+        return null;
+    }
+    static getCTStreamKey(testName, ctName) {
+        const safeTest = testName || 'Unknown Test';
+        const safeCT = ctName || 'Unknown CT';
+        return `${safeTest}::${safeCT}`;
+    }
+    static startCTLogStream(testName, ctName) {
+        try {
+            const TerminalLogCapture = globalThis.TerminalLogCapture;
+            if (!TerminalLogCapture ||
+                typeof TerminalLogCapture.addListener !== 'function') {
+                return;
+            }
+            const key = StatementTracker.getCTStreamKey(testName, ctName);
+            if (StatementTracker.ctLogStreams.has(key)) {
+                return;
+            }
+            const listenerId = `${key}-${Date.now()}-${Math.random()
+                .toString(36)
+                .slice(2)}`;
+            const buffer = [];
+            const listener = (log) => {
+                if (!log || !log.message) {
+                    return;
+                }
+                const level = (log.level || 'LOG').toUpperCase();
+                buffer.push(`[${level}] ${log.message}`);
+            };
+            TerminalLogCapture.addListener(listenerId, listener);
+            StatementTracker.ctLogStreams.set(key, {
+                listenerId,
+                logs: buffer,
+            });
+        }
+        catch {
+            // Ignorar se captura em tempo real não estiver disponível
+        }
+    }
+    static stopCTLogStream(testName, ctName) {
+        const key = StatementTracker.getCTStreamKey(testName, ctName);
+        const streamInfo = StatementTracker.ctLogStreams.get(key);
+        if (!streamInfo) {
+            return null;
+        }
+        StatementTracker.ctLogStreams.delete(key);
+        try {
+            const TerminalLogCapture = globalThis.TerminalLogCapture;
+            if (TerminalLogCapture &&
+                typeof TerminalLogCapture.removeListener === 'function') {
+                TerminalLogCapture.removeListener(streamInfo.listenerId);
+            }
+        }
+        catch {
+            // Ignorar erros ao remover listener
+        }
+        return streamInfo.logs.length > 0 ? [...streamInfo.logs] : null;
+    }
+    /**
+     * 🚫 PADRÕES DE LOGS INTERNOS QUE NÃO DEVEM SER ENVIADOS PARA O TESTHUB
+     * Estes são logs do próprio framework, não logs úteis do teste
+     */
+    static INTERNAL_LOG_PATTERNS = [
+        // Logs do próprio StatementTracker
+        /^\[CT-LOGS\]/,
+        /^📋 \[CT-LOGS\]/,
+        /^\[forceLoadFromFile\]/,
+        /^🔄 \[forceLoadFromFile\]/,
+        /^Carregando dados de \d+ arquivos/,
+        /^📁 Arquivos de logs encontrados:/,
+        // Logs aninhados (já processados)
+        /^\s*\[LOG\]/,
+        /^\s{2,}\[LOG\]/,
+        // Logs de debug internos
+        /^🔍 Analisando \d+ candidatos/,
+        /^❌ Erro ao ler/,
+        /^❌ Erro ao listar/,
+        // Logs de sistema do Playwright
+        /^\s*\d+\s+tests\\/,
+        /^\s*\d+\s+C:\\/,
+        /^ℹ️\s+\d+\s+C:\\/,
+        /^ℹ️\s+\d+\s+tests\\/,
+        // Logs de registro de teste (duplicados)
+        /^🏷️\s+Teste registrado:/,
+        // Logs do dotenv
+        /^\[dotenv@/,
+        // Logs de stop-on-failure (contexto, não conteúdo)
+        /^🛑 \[STOP-ON-FAILURE\] ATIVADO/,
+        // Logs de AutoIntercept
+        /^🔄 \[AutoIntercept\]/,
+    ];
+    /**
+     * 🔍 Verifica se um log é interno do framework e deve ser filtrado
+     */
+    static isInternalLog(message) {
+        if (!message || typeof message !== 'string')
+            return true;
+        const trimmed = message.trim();
+        // Filtrar logs vazios
+        if (trimmed.length === 0)
+            return true;
+        // Filtrar logs que começam com [LOG] (já aninhados)
+        if (trimmed.startsWith('[LOG]'))
+            return true;
+        // Verificar contra padrões internos
+        for (const pattern of StatementTracker.INTERNAL_LOG_PATTERNS) {
+            if (pattern.test(trimmed))
+                return true;
+        }
+        return false;
+    }
+    static hydrateCTLogs(ct, testName, ctNameOverride) {
+        const ctName = ctNameOverride || ct.name || 'Unknown CT';
+        // 🔧 ROBUSTO: Estratégia que funciona para single E multi-worker
+        const currentGlobalIndex = StatementTracker.getCurrentGlobalLogIndex();
+        const startIndex = Math.max(0, ct.logStartIndex ?? 0);
+        // 🆕 Converter timestamps para comparação
+        const ctStartTime = ct.startTime;
+        const ctEndTime = ct.endTime || Date.now();
+        // ========================================
+        // 🎯 ESTRATÉGIA UNIFICADA (UNION STRATEGY)
+        // Combina logs por Nome do CT E por Timestamp para garantir completude
+        // ========================================
+        let allCandidates = [];
+        // 1️⃣ COLETAR TODOS OS LOGS DISPONÍVEIS (Memória + Arquivos)
+        try {
+            const TerminalLogCapture = globalThis.TerminalLogCapture;
+            // Tentar pegar logs combinados (memória + arquivo compartilhado)
+            if (TerminalLogCapture && typeof TerminalLogCapture.getAllLogsCombined === 'function') {
+                allCandidates = TerminalLogCapture.getAllLogsCombined();
+            }
+            // Fallback: pegar logs da memória local
+            else if (TerminalLogCapture && typeof TerminalLogCapture.getAllLogs === 'function') {
+                allCandidates = TerminalLogCapture.getAllLogs();
+            }
+        }
+        catch {
+            // Ignorar erros de acesso ao TerminalLogCapture
+        }
+        // 2️⃣ SE NÃO TEM LOGS, TENTAR LER DIRETAMENTE DOS ARQUIVOS (Fallback Multi-worker)
+        if (allCandidates.length === 0) {
+            try {
+                const dir = path.resolve(process.cwd(), '.rbqa');
+                if (fs.existsSync(dir)) {
+                    const files = fs.readdirSync(dir).filter(f => f.startsWith('captured-logs-') && f.endsWith('.json'));
+                    for (const file of files) {
+                        try {
+                            const content = fs.readFileSync(path.join(dir, file), 'utf8');
+                            const data = JSON.parse(content);
+                            if (Array.isArray(data.logs)) {
+                                allCandidates = allCandidates.concat(data.logs);
+                            }
+                        }
+                        catch {
+                            // Silenciosamente ignorar erros de leitura
+                        }
+                    }
+                }
+            }
+            catch {
+                // Silenciosamente ignorar erros de listagem
+            }
+        }
+        // 3️⃣ FILTRAR E UNIFICAR LOGS
+        if (allCandidates.length > 0) {
+            const filteredLogs = allCandidates.filter((log) => {
+                // 🚫 PRIMEIRO: Filtrar logs internos do framework
+                if (log.message && StatementTracker.isInternalLog(log.message)) {
+                    return false;
+                }
+                // 🚫 SEGUNDO: Filtrar logs que pertencem a OUTROS CTs (não este)
+                if (log.ctName && log.ctName !== ctName) {
+                    // Se o log tem ctName definido e é de outro CT, excluir
+                    return false;
+                }
+                // A. Match por CT Name (Alta Precisão)
+                if (log.ctName === ctName)
+                    return true;
+                // B. Match por mensagem contendo o nome do CT
+                if (log.message && typeof log.message === 'string' && log.message.includes(ctName)) {
+                    // Mas excluir se for log de processamento de outro CT
+                    if (log.message.includes('[CT-LOGS]'))
+                        return false;
+                    return true;
+                }
+                // C. Match por Timestamp (com margem reduzida para evitar contaminar)
+                if (log.timestamp) {
+                    const logTime = new Date(log.timestamp).getTime();
+                    // 🔧 REDUZIDO: Margem de 1000ms (1s) para evitar contaminar logs de outros CTs
+                    const margin = 1000;
+                    const inRange = logTime >= (ctStartTime - margin) && logTime <= (ctEndTime + margin);
+                    return inRange;
+                }
+                return false;
+            });
+            if (filteredLogs.length > 0) {
+                // Deduplicar logs (usando índice ou timestamp+mensagem)
+                const uniqueLogsMap = new Map();
+                for (const log of filteredLogs) {
+                    const key = log.index !== undefined ? `idx_${log.index}` : `${log.timestamp}_${log.message}`;
+                    if (!uniqueLogsMap.has(key)) {
+                        uniqueLogsMap.set(key, log);
+                    }
+                }
+                const uniqueLogs = Array.from(uniqueLogsMap.values());
+                // Ordenar por índice ou timestamp
+                uniqueLogs.sort((a, b) => {
+                    if (a.index !== undefined && b.index !== undefined)
+                        return a.index - b.index;
+                    return new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime();
+                });
+                // 🎯 LIMPAR MENSAGENS: Remover prefixo [LOG] se já existir
+                ct.logs = uniqueLogs.map((log) => {
+                    let message = log.message || '';
+                    // Remover prefixos [LOG] aninhados
+                    message = message.replace(/^\s*\[LOG\]\s*/g, '');
+                    return message.trim();
+                }).filter((msg) => msg.length > 0); // Remover mensagens vazias
+                ct.logEndIndex = currentGlobalIndex;
+                return;
+            }
+        }
+        // 4️⃣ FALLBACK SINTÉTICO: Se ainda não achou nada
+        ct.logs = StatementTracker.buildFallbackLogs(ctName, testName, ct.duration, ct.status, ct.error, ct);
+        ct.logEndIndex = currentGlobalIndex || startIndex;
+    }
+    /**
+     * ✅ CORRIGIDO: Pegar nome do CT atual (test()) - VERSÃO ROBUSTA COM MÚLTIPLOS FALLBACKS
+     * ES MODULES PURO + COMPATIBILIDADE TOTAL COM PROJETOS CONSUMIDORES
+     */
+    static getCurrentCTName() {
+        try {
+            // 🎯 MÉTODO 1: TestContext global (mais confiável)
+            const TestContext = globalThis.__TEST_CONTEXT__;
+            if (TestContext) {
+                const testInfo = TestContext?.getSafeTestInfo?.();
+                if (testInfo?.title) {
+                    return testInfo.title;
+                }
+            }
+            // 🎯 MÉTODO 2: Usar CT setado manualmente (se disponível)
+            if (StatementTracker.currentCTName) {
+                return StatementTracker.currentCTName;
+            }
+            // 🎯 MÉTODO 4: Análise de stack trace (último recurso)
+            const stackTrace = new Error().stack;
+            if (stackTrace) {
+                // Procurar por padrões de CT/test em métodos chamadores
+                const ctPatterns = [
+                    /CT\d+[_\s-]?[^"\s)]+/i,
+                    /test[_\s-]?[^"\s)]+/i,
+                    /caso[_\s-]?de[_\s-]?teste[_\s-]?[^"\s)]+/i,
+                ];
+                for (const pattern of ctPatterns) {
+                    const match = stackTrace.match(pattern);
+                    if (match) {
+                        const ctName = match[0].trim();
+                        return ctName;
+                    }
+                }
+            }
+            // 🎯 MÉTODO 4: Análise de stack trace (último recurso)
+            const stackCT = StatementTracker.detectCTFromExecutionContext();
+            if (stackCT) {
+                return stackCT;
+            }
+        }
+        catch (_error) {
+            // Silenciosamente ignorar
+        }
+        // 🎯 MÉTODO 5: Fallback final - usar nome do teste como CT
+        const currentTest = StatementTracker.getCurrentTestName();
+        if (currentTest && currentTest !== 'Unknown Test') {
+            return currentTest;
+        }
+        return null;
+    }
+    /**
+     * ✅ CORRIGIDO: Registrar início de um Statement (método)
+     * 🔧 FIX: Buscar CT pelo NOME, não pelo último índice
+     * 🆕 AGORA COM CRIAÇÃO AUTOMÁTICA DE CT SE NÃO EXISTIR
+     */
+    static startStatement(className, methodName) {
+        const testName = StatementTracker.getCurrentTestName();
+        // 🔧 CORREÇÃO: Pegar nome do CT atual PRIMEIRO
+        const ctName = StatementTracker.getCurrentCTName();
+        // 🆕 CRÍTICO: Garantir que existe estrutura de teste
+        if (!StatementTracker.executions.has(testName)) {
+            StatementTracker.executions.set(testName, {
+                testName,
+                cts: [],
+                totalDuration: 0,
+                totalCTs: 0,
+                passedCTs: 0,
+                failedCTs: 0,
+            });
+        }
+        const testData = StatementTracker.executions.get(testName);
+        // 🔧 CORREÇÃO CRÍTICA: Buscar CT pelo nome do test() atual
+        let currentCT = testData.cts.find((ct) => ct.name === ctName);
+        // ✅ SE CT NÃO EXISTE, CRIAR AUTOMATICAMENTE
+        if (!currentCT && ctName) {
+            StatementTracker.startCT(ctName);
+            // Buscar novamente após criação
+            currentCT = testData.cts.find((ct) => ct.name === ctName);
+        }
+        // Se ainda não encontrou CT, erro crítico
+        if (!currentCT) {
+            Logger.error(`❌ [StatementTracker] FALHA CRÍTICA: Não foi possível criar/encontrar CT "${ctName}" para statement ${className}.${methodName}`);
+            return Date.now();
+        }
+        // ✅ Criar e registrar statement no CT correto
+        const statement = {
+            name: `${className}.${methodName}`,
+            className,
+            methodName,
+            startTime: Date.now(),
+            status: 'running',
+        };
+        currentCT.statements.push(statement);
+        return statement.startTime;
+    }
+    /**
+     * ✅ CORRIGIDO: Registrar fim de um Statement
+     * 🔧 FIX: Buscar CT pelo NOME, não pelo último índice
+     */
+    static finishStatement(timestamp, success, error) {
+        const testName = StatementTracker.getCurrentTestName();
+        const testData = StatementTracker.executions.get(testName);
+        if (!testData || testData.cts.length === 0) {
+            return;
+        }
+        // 🔧 CORREÇÃO: Buscar CT pelo nome do test() atual
+        const ctName = StatementTracker.getCurrentCTName();
+        const currentCT = testData.cts.find((ct) => ct.name === ctName);
+        if (!currentCT || currentCT.statements.length === 0) {
+            return;
+        }
+        const lastStatement = currentCT.statements.at(-1);
+        if (lastStatement && lastStatement.status === 'running') {
+            lastStatement.endTime = Date.now();
+            lastStatement.duration = lastStatement.endTime - lastStatement.startTime;
+            lastStatement.status = success ? 'passed' : 'failed';
+            if (error)
+                lastStatement.error = error;
+            // 💾 AUTO-SAVE: Salvar dados após cada Statement para evitar perda de dados
+            StatementTracker.saveDataToFile();
+        }
+    }
+    static waitForDataReady() {
+        return Promise.resolve();
+    }
+    /**
+     * ✅ NOVO: Finalizar e persistir todos os dados
+     * Salva ct-execution-data.json com dados completos
+     */
+    static async finalize() {
+        try {
+            // ✅ Finalizar CTs que ainda estão "running" antes de persistir os dados
+            for (const [testName, data] of StatementTracker.executions.entries()) {
+                const hasRunningCts = Array.isArray(data.cts)
+                    ? data.cts.some((ct) => ct.status === 'running')
+                    : false;
+                if (hasRunningCts) {
+                    Logger.warning(`⚠️ [StatementTracker] Finalizando CTs pendentes do teste "${testName}" antes do teardown`);
+                    StatementTracker.finalizeRunningCTsAsFailed(testName, 'Execução finalizada - CT não foi concluído automaticamente');
+                }
+                // Garantir que as métricas estejam atualizadas para cada teste
+                StatementTracker.recomputeTestStats(data);
+            }
+            // Salvar dados finais em arquivo
+            StatementTracker.saveDataToFile();
+            // ✅ NOVO: Copiar também para pasta docs/ para acesso dos relatórios HTML
+            const sourceFilePath = StatementTracker.getDataFilePath();
+            const docsPath = path.resolve(process.cwd(), 'docs', 'ct-execution-data.json');
+            if (fs.existsSync(sourceFilePath)) {
+                const docsDir = path.dirname(docsPath);
+                if (!fs.existsSync(docsDir)) {
+                    fs.mkdirSync(docsDir, { recursive: true });
+                }
+                fs.copyFileSync(sourceFilePath, docsPath);
+            }
+            const stats = StatementTracker.getStats();
+        }
+        catch (error) {
+            Logger.warning(`⚠️ [StatementTracker] Erro ao finalizar: ${error}`);
+        }
+        return Promise.resolve();
+    }
+    // 🔗 SINGLETON GLOBAL COM PERSISTÊNCIA AUTOMÁTICA
+    static get executions() {
+        if (globalThis.__SIMPLE_STATEMENT_EXECUTIONS__) {
+            const size = globalThis.__SIMPLE_STATEMENT_EXECUTIONS__.size;
+            if (size > 0) {
+            }
+        }
+        else {
+            ;
+            globalThis.__SIMPLE_STATEMENT_EXECUTIONS__ = new Map();
+            // 🆕 RECUPERAR DADOS AUTOMATICAMENTE
+            StatementTracker.loadDataFromFile();
+        }
+        return globalThis.__SIMPLE_STATEMENT_EXECUTIONS__;
+    }
+    static get currentTest() {
+        if (!globalThis.__SIMPLE_STATEMENT_CURRENT_TEST__) {
+            ;
+            globalThis.__SIMPLE_STATEMENT_CURRENT_TEST__ = 'Unknown Test';
+        }
+        return globalThis.__SIMPLE_STATEMENT_CURRENT_TEST__;
+    }
+    static set currentTest(value) {
+        ;
+        globalThis.__SIMPLE_STATEMENT_CURRENT_TEST__ = value;
+    }
+    static get ctCounter() {
+        if (!globalThis.__SIMPLE_STATEMENT_CT_COUNTER__) {
+            ;
+            globalThis.__SIMPLE_STATEMENT_CT_COUNTER__ = 0;
+        }
+        return globalThis.__SIMPLE_STATEMENT_CT_COUNTER__;
+    }
+    static set ctCounter(value) {
+        ;
+        globalThis.__SIMPLE_STATEMENT_CT_COUNTER__ = value;
+    }
+    static get currentCTName() {
+        return globalThis.__SIMPLE_STATEMENT_CURRENT_CT_NAME__ || null;
+    }
+    static set currentCTName(value) {
+        ;
+        globalThis.__SIMPLE_STATEMENT_CURRENT_CT_NAME__ = value;
+    }
+    static get ctAutoCreated() {
+        return globalThis.__SIMPLE_STATEMENT_CT_AUTO_CREATED__;
+    }
+    static set ctAutoCreated(value) {
+        ;
+        globalThis.__SIMPLE_STATEMENT_CT_AUTO_CREATED__ = value;
+    }
+    /**
+     * 🆕 Define o sistema atual (chamado por TestAnnotations.setSystem)
+     */
+    static setCurrentSystem(systemName) {
+        try {
+            // ✅ SEMPRE armazenar no globalThis para próximos CTs
+            ;
+            globalThis.__SIMPLE_STATEMENT_CURRENT_SYSTEM__ = systemName;
+            const testName = StatementTracker.getCurrentTestName();
+            const testData = StatementTracker.executions.get(testName);
+            if (testData) {
+                // ✅ CORRIGIDO: Pegar o CT mais recente em execução (último iniciado)
+                // Isso resolve o problema de múltiplos CTs simultâneos
+                const runningCT = testData.cts
+                    .filter((ct) => ct.status === 'running')
+                    .sort((a, b) => b.startTime - a.startTime)[0]; // Mais recente primeiro
+                if (runningCT) {
+                    runningCT.systemName = systemName;
+                }
+                else {
+                    Logger.warning(`⚠️ [setCurrentSystem] Nenhum CT em execução - sistema "${systemName}" armazenado para próximo CT`);
+                }
+            }
+            else {
+                Logger.warning(`⚠️ [setCurrentSystem] Teste não encontrado - sistema "${systemName}" armazenado para próximo CT`);
+            }
+        }
+        catch (error) {
+            Logger.warning(`⚠️ [StatementTracker] Erro ao aplicar sistema no CT atual: ${String(error)}`);
+            globalThis.__SIMPLE_STATEMENT_CURRENT_SYSTEM__ = systemName;
+        }
+    }
+    /**
+     * 🆕 Obtém o sistema atual
+     */
+    static getCurrentSystem() {
+        return globalThis.__SIMPLE_STATEMENT_CURRENT_SYSTEM__;
+    }
+    /**
+     * � Obtém referência segura dos logs capturados globalmente
+     */
+    /**
+     * 🆕 Obtém o sistema do CT em execução (público para uso externo)
+     * Retorna o sistema configurado via setSystem() para o CT atual
+     * @returns {string | null} Nome do sistema ou null se não configurado
+     */
+    static getCurrentCTSystem() {
+        try {
+            const testName = StatementTracker.getCurrentTestName();
+            if (!testName) {
+                return null;
+            }
+            const testData = StatementTracker.executions.get(testName);
+            if (!testData) {
+                return null;
+            }
+            // ✅ CORRIGIDO: Buscar CT mais recente em execução (último iniciado)
+            const runningCT = testData.cts
+                .filter((ct) => ct.status === 'running')
+                .sort((a, b) => b.startTime - a.startTime)[0]; // Mais recente primeiro
+            if (runningCT &&
+                runningCT.systemName &&
+                runningCT.systemName !== 'Unknown') {
+                return runningCT.systemName;
+            }
+            return null;
+        }
+        catch (error) {
+            Logger.warning(`⚠️ [StatementTracker.getCurrentCTSystem] Erro ao obter sistema do CT: ${String(error)}`);
+            return null;
+        }
+    }
+    /**
+     * 📝 Obtém logs globais normalizados (com índice + nível)
+     * 🔧 ATUALIZADO: Trabalha com índices globais para permitir fatiamento preciso por CT
+     */
+    static getGlobalLogs() {
+        const fromCapture = StatementTracker.gatherLogsFromTerminalCapture();
+        if (fromCapture.length > 0) {
+            return fromCapture;
+        }
+        const fromSharedFile = StatementTracker.gatherLogsFromSharedFile();
+        if (fromSharedFile.length > 0) {
+            return fromSharedFile;
+        }
+        return StatementTracker.gatherLegacyLogs();
+    }
+    static gatherLogsFromTerminalCapture() {
+        try {
+            const TerminalLogCapture = globalThis.TerminalLogCapture;
+            if (TerminalLogCapture &&
+                typeof TerminalLogCapture.getAllLogs === 'function') {
+                const capturedLogs = TerminalLogCapture.getAllLogs();
+                if (Array.isArray(capturedLogs) && capturedLogs.length > 0) {
+                    return StatementTracker.normalizeLogs(capturedLogs);
+                }
+            }
+        }
+        catch {
+            // Ignorar e tentar próximo fallback
+        }
+        return [];
+    }
+    static gatherLogsFromSharedFile() {
+        const sharedLogsPath = path.resolve(process.cwd(), '.rbqa', 'captured-logs.json');
+        if (!fs.existsSync(sharedLogsPath)) {
+            return [];
+        }
+        try {
+            const data = JSON.parse(fs.readFileSync(sharedLogsPath, 'utf8'));
+            if (Array.isArray(data.logs) && data.logs.length > 0) {
+                // Ordenar por índice para garantir consistência
+                const sortedLogs = [...data.logs].sort((a, b) => (a.index || 0) - (b.index || 0));
+                return StatementTracker.normalizeLogs(sortedLogs);
+            }
+        }
+        catch {
+            // Arquivo pode estar em uso por outro worker - ignorar
+        }
+        return [];
+    }
+    static gatherLegacyLogs() {
+        const aggregated = [];
+        const directLogs = globalThis.logsCapturados;
+        if (Array.isArray(directLogs) && directLogs.length > 0) {
+            aggregated.push(...StatementTracker.normalizeLogs(directLogs));
+        }
+        const fallbackLogs = globalThis.__AUTOCORE_LOGS_CAPTURADOS__;
+        if (Array.isArray(fallbackLogs) && fallbackLogs.length > 0) {
+            aggregated.push(...StatementTracker.normalizeLogs(fallbackLogs));
+        }
+        return aggregated.sort((a, b) => a.index - b.index);
+    }
+    static normalizeLogs(rawLogs) {
+        const normalized = [];
+        for (const rawLog of rawLogs) {
+            const previousIndex = normalized.length > 0 ? normalized[normalized.length - 1].index : 0;
+            const fallbackIndex = previousIndex + 1;
+            const normalizedEntry = StatementTracker.normalizeSingleLog(rawLog, fallbackIndex);
+            if (normalizedEntry) {
+                normalized.push(normalizedEntry);
+            }
+        }
+        return normalized.sort((a, b) => a.index - b.index);
+    }
+    static normalizeSingleLog(rawLog, fallbackIndex) {
+        if (rawLog === null || typeof rawLog === 'undefined') {
+            return null;
+        }
+        const indexCandidate = typeof rawLog?.index === 'number'
+            ? rawLog.index
+            : typeof rawLog?.globalIndex === 'number'
+                ? rawLog.globalIndex
+                : fallbackIndex;
+        const rawLevel = typeof rawLog?.level === 'string'
+            ? rawLog.level
+            : typeof rawLog?.type === 'string'
+                ? rawLog.type
+                : typeof rawLog?.severity === 'string'
+                    ? rawLog.severity
+                    : 'LOG';
+        let message;
+        if (typeof rawLog?.message === 'string') {
+            message = rawLog.message;
+        }
+        else if (typeof rawLog === 'string') {
+            message = rawLog;
+        }
+        else if (rawLog?.message !== undefined) {
+            try {
+                message = JSON.stringify(rawLog.message);
+            }
+            catch {
+                message = String(rawLog.message);
+            }
+        }
+        else {
+            try {
+                message = JSON.stringify(rawLog);
+            }
+            catch {
+                message = String(rawLog);
+            }
+        }
+        return {
+            index: indexCandidate,
+            level: rawLevel.toUpperCase(),
+            message,
+        };
+    }
+    static formatLogEntry(log) {
+        return `[${log.level}] ${log.message}`;
+    }
+    static captureLogsBetweenIndices(startIndex, endIndex, cachedLogs) {
+        const logs = cachedLogs ?? StatementTracker.getGlobalLogs();
+        if (logs.length === 0) {
+            return [];
+        }
+        const filtered = logs.filter((log) => {
+            const afterStart = log.index > startIndex;
+            const beforeEnd = typeof endIndex === 'number' ? log.index <= endIndex : true;
+            return afterStart && beforeEnd;
+        });
+        return filtered.map((log) => StatementTracker.formatLogEntry(log));
+    }
+    static getLogsFromTestScope(testName) {
+        try {
+            const TerminalLogCapture = globalThis.TerminalLogCapture;
+            if (TerminalLogCapture &&
+                typeof TerminalLogCapture.getLogsForTest === 'function') {
+                const candidateName = testName || StatementTracker.currentTest || 'Unknown Test';
+                const testLogs = TerminalLogCapture.getLogsForTest(candidateName);
+                if (Array.isArray(testLogs) && testLogs.length > 0) {
+                    return testLogs.map((log) => `[${log.level?.toUpperCase() || 'LOG'}] ${log.message}`);
+                }
+            }
+        }
+        catch {
+            // Ignorar fallbacks silenciosamente
+        }
+        return [];
+    }
+    static buildFallbackLogs(ctName, testName, duration, status, error, ct) {
+        const fallbackLogs = [];
+        // 🆕 ESTRATÉGIA 1: Buscar logs REAIS do terminal pelo TIMESTAMP do CT
+        if (ct && ct.startTime && ct.endTime) {
+            try {
+                // Tentar buscar do arquivo compartilhado (funciona em single E multi-worker)
+                const sharedLogsPath = path.resolve(process.cwd(), '.rbqa', 'captured-logs.json');
+                if (fs.existsSync(sharedLogsPath)) {
+                    const data = JSON.parse(fs.readFileSync(sharedLogsPath, 'utf8'));
+                    if (Array.isArray(data.logs) && data.logs.length > 0) {
+                        // Filtrar logs pelo timestamp do CT (com margem de 500ms)
+                        const ctStart = ct.startTime - 500;
+                        const ctEnd = ct.endTime + 500;
+                        const logsInRange = data.logs.filter((log) => {
+                            if (!log.timestamp)
+                                return false;
+                            // 🚫 Filtrar logs internos do framework
+                            if (log.message && StatementTracker.isInternalLog(log.message))
+                                return false;
+                            const logTime = new Date(log.timestamp).getTime();
+                            return logTime >= ctStart && logTime <= ctEnd;
+                        });
+                        if (logsInRange.length > 0) {
+                            for (const log of logsInRange) {
+                                // ✅ CORRIGIDO: Apenas a mensagem, sem prefixo [LOG]
+                                const message = (log.message || '').replace(/^\s*\[LOG\]\s*/g, '').trim();
+                                if (message)
+                                    fallbackLogs.push(message);
+                            }
+                            return fallbackLogs;
+                        }
+                    }
+                }
+            }
+            catch {
+                // Ignorar erros de leitura
+            }
+            // 🆕 ESTRATÉGIA 2: Buscar da memória local (TerminalLogCapture)
+            try {
+                const TerminalLogCapture = globalThis.TerminalLogCapture;
+                if (TerminalLogCapture) {
+                    // Tentar getAllLogsCombined primeiro
+                    const getAllLogs = TerminalLogCapture.getAllLogsCombined || TerminalLogCapture.getAllLogs;
+                    if (typeof getAllLogs === 'function') {
+                        const allLogs = getAllLogs.call(TerminalLogCapture);
+                        if (Array.isArray(allLogs) && allLogs.length > 0) {
+                            const ctStart = ct.startTime - 500;
+                            const ctEnd = ct.endTime + 500;
+                            const logsInRange = allLogs.filter((log) => {
+                                if (!log.timestamp)
+                                    return false;
+                                // 🚫 Filtrar logs internos do framework
+                                if (log.message && StatementTracker.isInternalLog(log.message))
+                                    return false;
+                                const logTime = new Date(log.timestamp).getTime();
+                                return logTime >= ctStart && logTime <= ctEnd;
+                            });
+                            if (logsInRange.length > 0) {
+                                for (const log of logsInRange) {
+                                    // ✅ CORRIGIDO: Apenas a mensagem, sem prefixo [LOG]
+                                    const message = (log.message || '').replace(/^\s*\[LOG\]\s*/g, '').trim();
+                                    if (message)
+                                        fallbackLogs.push(message);
+                                }
+                                return fallbackLogs;
+                            }
+                        }
+                    }
+                }
+            }
+            catch {
+                // Ignorar
+            }
+        }
+        // 🆕 ESTRATÉGIA 3: Logs sintéticos (último recurso)
+        // ✅ CORRIGIDO: Logs sem prefixo [LOG] para evitar duplicação
+        fallbackLogs.push(`🚀 [CT-START] === INICIANDO NOVO CT ===`);
+        fallbackLogs.push(`   🎯 CT Name: "${ctName}"`);
+        fallbackLogs.push(`   📋 Test Name: "${testName}"`);
+        fallbackLogs.push(`🚀 [CT-START] === CT CRIADO ===`);
+        // Se temos referência ao CT, incluir logs dos statements e actions
+        if (ct) {
+            // Adicionar logs dos statements executados
+            if (ct.statements && ct.statements.length > 0) {
+                fallbackLogs.push(`📝 === STATEMENTS EXECUTADOS ===`);
+                for (const stmt of ct.statements) {
+                    const stmtStatus = stmt.status === 'passed' ? '✅' : stmt.status === 'failed' ? '❌' : '⏳';
+                    fallbackLogs.push(`${stmtStatus} ${stmt.className}.${stmt.methodName} (${stmt.duration || 0}ms)`);
+                    if (stmt.error) {
+                        fallbackLogs.push(`   ❌ Erro: ${stmt.error}`);
+                    }
+                }
+            }
+            // Adicionar logs das actions executadas
+            if (ct.executedActions && ct.executedActions.length > 0) {
+                fallbackLogs.push(`🎬 === ACTIONS EXECUTADAS ===`);
+                for (const action of ct.executedActions) {
+                    const actionStatus = action.success ? '✅' : '❌';
+                    fallbackLogs.push(`${actionStatus} [${action.type}] ${action.description} (${action.duration || 0}ms)`);
+                    if (!action.success && action.details) {
+                        fallbackLogs.push(`   ❌ Detalhes: ${JSON.stringify(action.details)}`);
+                    }
+                }
+            }
+            // Adicionar logs das actions (formato antigo)
+            if (ct.actions && ct.actions.length > 0 && (!ct.executedActions || ct.executedActions.length === 0)) {
+                fallbackLogs.push(`🎬 === ACTIONS ===`);
+                for (const action of ct.actions) {
+                    fallbackLogs.push(`▸ ${action}`);
+                }
+            }
+        }
+        // Status final
+        fallbackLogs.push(`📊 CT "${ctName}" executado com status: ${status || 'unknown'}`);
+        fallbackLogs.push(`⏱️ Duração: ${duration ?? 0}ms`);
+        if (error) {
+            fallbackLogs.push(`❌ Erro: ${error}`);
+        }
+        fallbackLogs.push(`🏁 [CT-END] === CT FINALIZADO ===`);
+        return fallbackLogs;
+    }
+    static getCurrentGlobalLogIndex() {
+        try {
+            const TerminalLogCapture = globalThis.TerminalLogCapture;
+            if (TerminalLogCapture) {
+                if (typeof TerminalLogCapture.getCurrentGlobalIndex === 'function') {
+                    return TerminalLogCapture.getCurrentGlobalIndex();
+                }
+                if (typeof TerminalLogCapture.getSharedGlobalIndex === 'function') {
+                    const sharedIndex = TerminalLogCapture.getSharedGlobalIndex();
+                    if (typeof sharedIndex === 'number') {
+                        return sharedIndex;
+                    }
+                }
+                if (typeof TerminalLogCapture.getAllLogs === 'function') {
+                    const allLogs = TerminalLogCapture.getAllLogs();
+                    if (Array.isArray(allLogs) && allLogs.length > 0) {
+                        const lastLog = allLogs[allLogs.length - 1];
+                        if (lastLog && typeof lastLog.index === 'number') {
+                            return lastLog.index;
+                        }
+                        return allLogs.length;
+                    }
+                }
+            }
+        }
+        catch {
+            // Ignorar e usar fallback de arquivo
+        }
+        try {
+            const sharedLogsPath = path.resolve(process.cwd(), '.rbqa', 'captured-logs.json');
+            if (fs.existsSync(sharedLogsPath)) {
+                const data = JSON.parse(fs.readFileSync(sharedLogsPath, 'utf8'));
+                if (typeof data.globalIndex === 'number') {
+                    return data.globalIndex;
+                }
+                if (Array.isArray(data.logs) && data.logs.length > 0) {
+                    const sorted = [...data.logs].sort((a, b) => (a.index || 0) - (b.index || 0));
+                    const lastEntry = sorted[sorted.length - 1];
+                    if (lastEntry && typeof lastEntry.index === 'number') {
+                        return lastEntry.index;
+                    }
+                    return sorted.length;
+                }
+            }
+        }
+        catch {
+            // Ignorar
+        }
+        return 0;
+    }
+    /**
+     * 📊 Recalcula estatísticas derivadas com base nos CTs registrados
+     */
+    static recomputeTestStats(data) {
+        const cts = Array.isArray(data.cts) ? data.cts : [];
+        data.totalCTs = cts.length;
+        data.passedCTs = cts.filter((ct) => ct.status === 'passed').length;
+        data.failedCTs = cts.filter((ct) => ct.status === 'failed').length;
+        let totalDuration = 0;
+        for (const ct of cts) {
+            if (typeof ct.duration === 'number') {
+                totalDuration += ct.duration;
+            }
+            else if (ct.endTime) {
+                totalDuration += ct.endTime - ct.startTime;
+            }
+        }
+        data.totalDuration = totalDuration;
+    }
+    /**
+     * ��🔄 Obtém caminho do arquivo de persistência
+     */
+    static getDataFilePath() {
+        // 🆕 Usar arquivo separado por worker para evitar conflitos de escrita (ENOENT)
+        const workerIndex = process.env.TEST_WORKER_INDEX;
+        if (workerIndex !== undefined) {
+            return path.resolve(process.cwd(), '.rbqa', `ct-execution-data-${workerIndex}.json`);
+        }
+        return path.resolve(process.cwd(), '.rbqa', 'ct-execution-data.json');
+    }
+    /**
+     * ⏱️ Formatar duração em formato legível
+     */
+    static formatDuration(milliseconds) {
+        if (!milliseconds || milliseconds === 0)
+            return '0ms';
+        const seconds = Math.floor(milliseconds / 1000);
+        const minutes = Math.floor(seconds / 60);
+        const hours = Math.floor(minutes / 60);
+        if (hours > 0) {
+            const remainingMinutes = minutes % 60;
+            const remainingSeconds = seconds % 60;
+            return `${hours}h ${remainingMinutes}m ${remainingSeconds}s`;
+        }
+        if (minutes > 0) {
+            const remainingSeconds = seconds % 60;
+            return `${minutes}m ${remainingSeconds}s`;
+        }
+        if (seconds > 0) {
+            const remainingMs = milliseconds % 1000;
+            return `${seconds}s ${remainingMs}ms`;
+        }
+        return `${milliseconds}ms`;
+    }
+    /**
+     * 💾 Salva dados automaticamente no arquivo
+     * 🛡️ CORRIGIDO: Mescla com dados existentes antes de salvar (multi-worker safe)
+     */
+    static saveDataToFile() {
+        try {
+            const filePath = StatementTracker.getDataFilePath();
+            const dir = path.dirname(filePath);
+            // Garantir que diretório existe
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+            // 🔄 PASSO 1: Carregar dados existentes do arquivo
+            let existingData = { tests: [] };
+            if (fs.existsSync(filePath)) {
+                try {
+                    const fileContent = fs.readFileSync(filePath, 'utf8');
+                    if (fileContent && fileContent.trim().length > 0) {
+                        existingData = JSON.parse(fileContent);
+                    }
+                }
+                catch (parseError) {
+                    Logger.warning(`⚠️ [SAVE] Erro ao ler arquivo existente, será sobrescrito: ${parseError}`);
+                }
+            }
+            // 🔄 PASSO 2: Criar mapa de CTs existentes por testName
+            const existingTestsMap = new Map();
+            const existingCTsByTest = new Map();
+            if (existingData.tests && Array.isArray(existingData.tests)) {
+                for (const testData of existingData.tests) {
+                    existingTestsMap.set(testData.testName, testData);
+                    const ctMap = new Map();
+                    for (const ct of testData.cts || []) {
+                        ctMap.set(ct.name, ct);
+                    }
+                    existingCTsByTest.set(testData.testName, ctMap);
+                }
+            }
+            const executionsSize = StatementTracker.executions.size;
+            // 🔄 PASSO 3: Mesclar dados da memória com dados do arquivo
+            const mergedTests = new Map();
+            // Processar testes da memória
+            for (const [testName, data] of StatementTracker.executions.entries()) {
+                StatementTracker.recomputeTestStats(data);
+                const existingTest = existingTestsMap.get(testName);
+                const existingCTMap = existingCTsByTest.get(testName) || new Map();
+                // Mesclar CTs
+                const mergedCTMap = new Map(existingCTMap);
+                for (const ct of data.cts) {
+                    // ✅ CORREÇÃO: Só hidratar logs se o CT estiver FINALIZADO (não running)
+                    // Isso evita que logs incompletos/sintéticos sejam gerados durante o startCT
+                    if (ct.status !== 'running' && (!ct.logs || ct.logs.length === 0)) {
+                        StatementTracker.hydrateCTLogs(ct, testName);
+                    }
+                    // ✅ PROTEÇÃO CRÍTICA: NÃO recalcular status de CTs já finalizados
+                    // Se o CT já tem status passed/failed/skipped, foi explicitamente finalizado pelo CustomReporter
+                    // Apenas processar CTs com status 'running'
+                    let computedStatus = ct.status;
+                    let computedError = ct.error;
+                    if (ct.status === 'running') {
+                        // Só aqui fazemos análise de statements para determinar status
+                        const statements = Array.isArray(ct.statements) ? ct.statements : [];
+                        const hasFailedStatement = statements.some((stmt) => stmt.status === 'failed');
+                        const hasRunningStatement = statements.some((stmt) => stmt.status === 'running');
+                        const hasAnyStatement = statements.length > 0;
+                        const ctHasExplicitEnd = typeof ct.endTime === 'number';
+                        if (hasFailedStatement) {
+                            computedStatus = 'failed';
+                            computedError =
+                                computedError ||
+                                    statements.find((stmt) => stmt.status === 'failed')?.error ||
+                                    'Statement falhou';
+                        }
+                        else if (!hasRunningStatement && hasAnyStatement) {
+                            computedStatus = 'passed';
+                            computedError = undefined;
+                        }
+                        else if (ctHasExplicitEnd) {
+                            computedStatus = 'failed';
+                            computedError =
+                                computedError ||
+                                    (hasAnyStatement
+                                        ? 'CT finalizado com estado indefinido'
+                                        : 'CT finalizado sem statements executadas');
+                        }
+                    }
+                    // ✅ PROTEÇÃO: Só calcular endTime/duration se CT ainda está running
+                    // CTs finalizados já têm esses valores corretos do CustomReporter
+                    let finalEndTime = ct.endTime;
+                    let finalDuration = ct.duration;
+                    if (ct.status === 'running') {
+                        // Só para CTs running, tentar inferir endTime/duration dos statements
+                        const statements = Array.isArray(ct.statements) ? ct.statements : [];
+                        const statementEndTimes = statements
+                            .map((stmt) => stmt.endTime)
+                            .filter((value) => typeof value === 'number');
+                        const latestStatementEnd = statementEndTimes.length > 0
+                            ? Math.max(...statementEndTimes)
+                            : undefined;
+                        if (computedStatus !== 'running') {
+                            if (!finalEndTime && latestStatementEnd) {
+                                finalEndTime = latestStatementEnd;
+                            }
+                            if (!finalEndTime &&
+                                typeof ct.duration === 'number' &&
+                                ct.duration > 0) {
+                                finalEndTime = ct.startTime + ct.duration;
+                            }
+                            if (!finalEndTime) {
+                                finalEndTime = ct.startTime;
+                            }
+                            if (typeof finalDuration !== 'number') {
+                                finalDuration =
+                                    finalEndTime !== undefined
+                                        ? Math.max(0, finalEndTime - ct.startTime)
+                                        : 0;
+                            }
+                        }
+                        else if (typeof finalDuration !== 'number') {
+                            finalDuration = 0;
+                        }
+                        ct.status = computedStatus;
+                        ct.error = computedStatus === 'passed' ? undefined : computedError;
+                        ct.endTime = finalEndTime;
+                        ct.duration = finalDuration;
+                    }
+                    // Se não é running, manter valores originais (já finalizados)
+                    const durationFormatted = StatementTracker.formatDuration(ct.duration);
+                    const ctData = {
+                        name: ct.name,
+                        systemName: ct.systemName,
+                        status: ct.status,
+                        startTime: ct.startTime,
+                        startTimeFormatted: new Date(ct.startTime).toISOString(),
+                        endTime: ct.endTime,
+                        endTimeFormatted: ct.endTime
+                            ? new Date(ct.endTime).toISOString()
+                            : undefined,
+                        duration: ct.duration,
+                        durationFormatted,
+                        error: ct.error,
+                        actions: ct.actions || [],
+                        executedActions: ct.executedActions || [],
+                        statements: ct.statements || [],
+                        logs: ct.logs || [],
+                    };
+                    mergedCTMap.set(ct.name, ctData);
+                }
+                const mergedCTs = Array.from(mergedCTMap.values());
+                // ❌ REMOVIDO: Log de debug que listava todos os CTs
+                // Calcular estatísticas do teste mesclado
+                const testStartTime = mergedCTs.length > 0
+                    ? Math.min(...mergedCTs.map((ct) => ct.startTime))
+                    : Date.now();
+                const testEndTime = mergedCTs.length > 0 && mergedCTs.some((ct) => ct.endTime)
+                    ? Math.max(...mergedCTs
+                        .filter((ct) => ct.endTime)
+                        .map((ct) => ct.endTime))
+                    : undefined;
+                // ✅ CORREÇÃO CRÍTICA: CTs "running" devem ser contados como "failed"
+                const passedCTs = mergedCTs.filter((ct) => ct.status === 'passed').length;
+                const failedCTs = mergedCTs.filter((ct) => ct.status === 'failed' || ct.status === 'running').length;
+                const skippedCTs = mergedCTs.filter((ct) => ct.status === 'skipped').length;
+                const totalDuration = mergedCTs.reduce((sum, ct) => sum + (ct.duration || 0), 0);
+                mergedTests.set(testName, {
+                    testName,
+                    startTime: testStartTime,
+                    startTimeFormatted: new Date(testStartTime).toISOString(),
+                    endTime: testEndTime,
+                    endTimeFormatted: testEndTime
+                        ? new Date(testEndTime).toISOString()
+                        : undefined,
+                    totalCTs: mergedCTs.length,
+                    passedCTs,
+                    failedCTs,
+                    skippedCTs,
+                    duration: totalDuration,
+                    durationFormatted: StatementTracker.formatDuration(totalDuration),
+                    cts: mergedCTs,
+                });
+            }
+            // Adicionar testes que estão apenas no arquivo (não na memória)
+            for (const [testName, testData] of existingTestsMap.entries()) {
+                if (!mergedTests.has(testName)) {
+                    Logger.info(`   📂 Preservando "${testName}" do arquivo (não está na memória)`);
+                    mergedTests.set(testName, testData);
+                }
+            }
+            // 🆕 Calcular estatísticas globais
+            const allCTs = Array.from(mergedTests.values()).flatMap((t) => t.cts || []);
+            // ✅ CORREÇÃO CRÍTICA: CTs "running" devem ser contados como "failed"
+            const stats = {
+                totalCTs: allCTs.length,
+                passedCTs: allCTs.filter((ct) => ct.status === 'passed').length,
+                failedCTs: allCTs.filter((ct) => ct.status === 'failed' || ct.status === 'running').length,
+                skippedCTs: allCTs.filter((ct) => ct.status === 'skipped').length,
+                totalDuration: allCTs.reduce((sum, ct) => sum + (ct.duration || 0), 0),
+            };
+            const exportData = {
+                timestamp: new Date().toISOString(),
+                totalCTs: stats.totalCTs,
+                passedCTs: stats.passedCTs,
+                failedCTs: stats.failedCTs,
+                skippedCTs: stats.skippedCTs,
+                totalDuration: stats.totalDuration,
+                totalDurationFormatted: StatementTracker.formatDuration(stats.totalDuration),
+                // 🛑 PERSISTIR FLAG DE STOP-ON-FAILURE para compartilhar entre processos/workers
+                stopOnFailureTriggered: StatementTracker.hasFailedWithStopOnFailure,
+                tests: Array.from(mergedTests.values()),
+            };
+            // 🔄 PASSO 4: Salvar com proteção atômica (temp file + rename)
+            const tempFilePath = `${filePath}.tmp`;
+            fs.writeFileSync(tempFilePath, JSON.stringify(exportData, null, 2), 'utf8');
+            // Move atômico (renomear substitui o arquivo antigo)
+            // ✅ CORREÇÃO: Verificar se arquivo existe antes de deletar
+            try {
+                if (fs.existsSync(filePath)) {
+                    fs.unlinkSync(filePath);
+                }
+                fs.renameSync(tempFilePath, filePath);
+            }
+            catch (renameError) {
+                // Se rename falhar, tentar salvar direto (fallback)
+                Logger.warning(`⚠️ [SAVE] Rename falhou, salvando direto: ${renameError}`);
+                fs.copyFileSync(tempFilePath, filePath);
+                fs.unlinkSync(tempFilePath);
+            }
+        }
+        catch (error) {
+            Logger.error('❌ [AUTO-SAVE] Erro ao salvar dados:', error);
+        }
+    }
+    /**
+     * 🔄 FORÇA CARREGAMENTO DOS DADOS DO ARQUIVO
+     * Usado pelo CustomReporter que roda em processo separado dos testes
+     * Garante que os CTs criados pelos testes estejam disponíveis no Reporter
+     * 🆕 AGORA SUPORTA MÚLTIPLOS ARQUIVOS DE WORKERS
+     */
+    static forceLoadFromFile() {
+        const dir = path.resolve(process.cwd(), '.rbqa');
+        if (!fs.existsSync(dir)) {
+            return;
+        }
+        try {
+            // Encontrar todos os arquivos de dados (principal + workers)
+            const files = fs.readdirSync(dir).filter(f => f.startsWith('ct-execution-data') && f.endsWith('.json'));
+            if (files.length === 0) {
+                Logger.warning('⚠️ [forceLoadFromFile] Nenhum arquivo de dados encontrado');
+                return;
+            }
+            for (const file of files) {
+                const filePath = path.join(dir, file);
+                try {
+                    const fileContent = fs.readFileSync(filePath, 'utf8');
+                    if (!fileContent || fileContent.trim().length === 0)
+                        continue;
+                    const data = JSON.parse(fileContent);
+                    // 🛑 CARREGAR FLAG DE STOP-ON-FAILURE
+                    if (data.stopOnFailureTriggered === true) {
+                        StatementTracker.hasFailedWithStopOnFailure = true;
+                    }
+                    if (!data.tests || !Array.isArray(data.tests))
+                        continue;
+                    for (const testData of data.tests) {
+                        const existingData = StatementTracker.executions.get(testData.testName);
+                        if (existingData) {
+                            // 🔄 MESCLAR CTs
+                            const existingCTNames = new Set(existingData.cts.map(ct => ct.name));
+                            const newCTs = (testData.cts || []).filter((ct) => !existingCTNames.has(ct.name));
+                            if (newCTs.length > 0) {
+                                existingData.cts.push(...newCTs);
+                                existingData.totalCTs = existingData.cts.length;
+                                // Recalcular stats
+                                existingData.passedCTs = existingData.cts.filter(ct => ct.status === 'passed').length;
+                                existingData.failedCTs = existingData.cts.filter(ct => ct.status === 'failed').length;
+                            }
+                        }
+                        else {
+                            const executionData = {
+                                testName: testData.testName,
+                                cts: testData.cts || [],
+                                totalDuration: testData.duration || 0,
+                                totalCTs: testData.totalCTs || 0,
+                                passedCTs: testData.passedCTs || 0,
+                                failedCTs: testData.failedCTs || 0,
+                            };
+                            StatementTracker.executions.set(testData.testName, executionData);
+                        }
+                    }
+                }
+                catch (err) {
+                    Logger.warning(`⚠️ [forceLoadFromFile] Erro ao ler ${file}: ${err}`);
+                }
+            }
+        }
+        catch (error) {
+            Logger.error('❌ [forceLoadFromFile] Erro geral:', error);
+        }
+    }
+    /**
+     * 📂 Carrega dados do arquivo de persistência
+     */
+    static loadDataFromFile() {
+        try {
+            const filePath = StatementTracker.getDataFilePath();
+            if (!fs.existsSync(filePath)) {
+                return;
+            }
+            const fileContent = fs.readFileSync(filePath, 'utf8');
+            // ✅ PROTEÇÃO: Verificar se arquivo não está vazio ou corrompido
+            if (!fileContent || fileContent.trim().length === 0) {
+                Logger.warning('⚠️ [LOAD] Arquivo vazio, ignorando');
+                return;
+            }
+            // ✅ PROTEÇÃO: Verificar se é JSON válido
+            let data;
+            try {
+                data = JSON.parse(fileContent);
+            }
+            catch (parseError) {
+                Logger.error('❌ [LOAD] Erro ao fazer parse do JSON, arquivo pode estar corrompido');
+                Logger.error(`📄 Conteúdo: ${fileContent.substring(0, 200)}...`);
+                return;
+            }
+            if (data.tests && Array.isArray(data.tests)) {
+                for (const testData of data.tests) {
+                    // 🔄 MESCLAR dados em vez de sobrescrever
+                    const existingData = StatementTracker.executions.get(testData.testName);
+                    if (existingData) {
+                        // ✅ JÁ EXISTE - Mesclar CTs
+                        Logger.info(`   🔄 [LOAD] Mesclando dados para "${testData.testName}"`);
+                        Logger.info(`      📊 Existente: ${existingData.cts.length} CTs`);
+                        Logger.info(`      📊 Arquivo: ${(testData.cts || []).length} CTs`);
+                        // Mesclar CTs por nome (evitar duplicatas)
+                        const existingCTNames = new Set(existingData.cts.map((ct) => ct.name));
+                        const newCTs = (testData.cts || []).filter((ct) => !existingCTNames.has(ct.name));
+                        existingData.cts.push(...newCTs);
+                        existingData.totalCTs = existingData.cts.length;
+                        existingData.passedCTs = existingData.cts.filter((ct) => ct.status === 'passed').length;
+                        existingData.failedCTs = existingData.cts.filter((ct) => ct.status === 'failed').length;
+                        Logger.info(`      ✅ [LOAD] Mesclado: ${existingData.cts.length} CTs total`);
+                    }
+                    else {
+                        // ✅ NÃO EXISTE - Criar novo
+                        const executionData = {
+                            testName: testData.testName,
+                            cts: testData.cts || [],
+                            totalDuration: testData.duration || 0,
+                            totalCTs: testData.totalCTs || 0,
+                            passedCTs: testData.passedCTs || 0,
+                            failedCTs: testData.failedCTs || 0,
+                        };
+                        StatementTracker.executions.set(testData.testName, executionData);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            Logger.error('❌ [LOAD] Erro ao carregar dados:', error);
+        }
+    }
+    /**
+     * 🚫 LISTA DE MÉTODOS QUE NÃO SÃO CTs
+     * Métodos de validação, assertions e utilitários não devem ser tratados como CTs
+     * ✅ CORRIGIDO: Incluir métodos do BancoActions que são AÇÕES, não CTs
+     * 🎯 NOVO: Lista de métodos que são apenas ações internas, não CTs completos
+     *
+     * ⚠️ IMPORTANTE: Métodos como validateCep, processOrder são CTs REAIS!
+     * Apenas métodos auxiliares como assert, log, setup devem estar aqui.
+     */
+    static NON_CT_METHODS = [
+        // ⚠️ REMOVIDO 'validar' e 'validate' - estes PODEM ser CTs reais
+        'assert',
+        'check',
+        'verify',
+        'expect',
+        'should',
+        'wait',
+        'sleep',
+        'delay',
+        'log',
+        'print',
+        'debug',
+        'setup',
+        'teardown',
+        'before',
+        'after',
+        'init',
+        'cleanup',
+        'helper',
+        'util',
+        'constructor',
+        'toString',
+        'valueOf',
+        'hasOwnProperty',
+    ];
+    /**
+     * 🎯 LISTA DE MÉTODOS QUE SÃO APENAS AÇÕES INTERNAS (NÃO CTs)
+     * Estes métodos são chamados DENTRO de um CT real, mas não são CTs por si só
+     */
+    static INTERNAL_ACTION_METHODS = [
+        // ✅ BANCO: Métodos do BancoActions que são AÇÕES internas
+        'select',
+        'executequery',
+        'executarquery',
+        'execute',
+        'executar',
+        'insert',
+        'update',
+        'delete',
+        'commit',
+        'rollback',
+        'connect',
+        'disconnect',
+        'close',
+        // ✅ API: Métodos de API que são ações internas
+        'get',
+        'post',
+        'put',
+        'patch',
+        'delete',
+        'request',
+        // ✅ UI: Métodos de UI que são ações internas
+        'click',
+        'type',
+        'fill',
+        'select',
+        'hover',
+        'scroll',
+        'waitfor',
+        'screenshot',
+        // ✅ MOBILE: Métodos de Mobile que são ações internas
+        'tap',
+        'swipe',
+        'scroll',
+        'pinch',
+        'zoom',
+        'rotate',
+        // ✅ SSH: Métodos de SSH que são ações internas
+        'execute',
+        'upload',
+        'download',
+        'connect',
+        'disconnect',
+    ];
+    /**
+     * 🔍 VERIFICA SE MÉTODO É UM CT OU AÇÃO INTERNA
+     * ✅ NOVA LÓGICA: CT real vs Ação interna
+     *
+     * Um CT REAL é um método da classe Statement que:
+     * 1. Não está na lista NON_CT_METHODS (utilitários)
+     * 2. Não está na lista INTERNAL_ACTION_METHODS (ações como select, execute, click, etc.)
+     * 3. Não é método privado (_method)
+     * 4. É o método PRINCIPAL da classe (como validateCep, processOrder, etc.)
+     */
+    static isValidCTMethod(methodName) {
+        const lowerMethodName = methodName.toLowerCase();
+        // 1️⃣ Ignorar métodos utilitários e de sistema (comparação EXATA)
+        if (StatementTracker.NON_CT_METHODS.includes(lowerMethodName)) {
+            return false;
+        }
+        // 2️⃣ NOVO: Ignorar métodos que são apenas ações internas (comparação EXATA)
+        if (StatementTracker.INTERNAL_ACTION_METHODS.includes(lowerMethodName)) {
+            return false;
+        }
+        // 3️⃣ Ignorar métodos privados (começam com _)
+        if (methodName.startsWith('_')) {
+            return false;
+        }
+        // 4️⃣ NOVO: Ignorar getters/setters (começam com get/set)
+        if (methodName.startsWith('get') || methodName.startsWith('set')) {
+            return false;
+        }
+        // 5️⃣ NOVO: Ignorar apenas métodos que são claramente utilitários (começam com prefixo)
+        const utilityPrefixes = [
+            'assert',
+            'check',
+            'verify',
+            'log',
+            'debug',
+            'setup',
+            'teardown',
+        ];
+        for (const prefix of utilityPrefixes) {
+            if (lowerMethodName.startsWith(prefix)) {
+                return false;
+            }
+        }
+        // ✅ MÉTODO VÁLIDO: É um CT real!
+        return true;
+    }
+    /**
+     * 🎯 INTERCEPTAR CLASSE AUTOMATICAMENTE
+     * ✅ CORRIGIDO: Apenas interceptar classes Statement, não Actions
+     */
+    static interceptStatement(StatementClass) {
+        const className = StatementClass.name;
+        // 🚫 FILTRO CRÍTICO: Não interceptar classes que são Actions (BancoActions, WebActions, etc.)
+        if (className.endsWith('Actions') ||
+            className.endsWith('Helper') ||
+            className.endsWith('Manager')) {
+            return StatementClass; // Retornar classe original sem interceptação
+        }
+        // 🚫 FILTRO: Não interceptar classes específicas do sistema
+        const systemClasses = [
+            'TestContext',
+            'Logger',
+            'AutoDocs',
+            'UnifiedReportManager',
+            'EnviromentHelper',
+        ];
+        if (systemClasses.includes(className)) {
+            return StatementClass;
+        }
+        return new Proxy(StatementClass, {
+            construct(target) {
+                const instance = new target();
+                const prototype = target.prototype;
+                for (const methodName of Object.getOwnPropertyNames(prototype)) {
+                    if (methodName !== 'constructor' &&
+                        typeof instance[methodName] === 'function') {
+                        const originalMethod = instance[methodName];
+                        // ✅ FILTRAR: Só interceptar métodos que são CTs de verdade
+                        if (!StatementTracker.isValidCTMethod(methodName)) {
+                            continue;
+                        }
+                        ;
+                        instance[methodName] = async function (...methodArgs) {
+                            const statementName = `${className}.${methodName}`;
+                            // ✅ NOVO: Cada método Statement = 1 CT individual
+                            const ctName = `CT - ${statementName}`;
+                            // Iniciar CT específico para este método
+                            StatementTracker.startCT(ctName);
+                            // Registrar statement dentro do CT
+                            StatementTracker.startStatement(className, methodName);
+                            const startTime = Date.now();
+                            try {
+                                const result = await originalMethod.apply(this, methodArgs);
+                                const endTime = Date.now();
+                                // Finalizar statement como sucesso
+                                StatementTracker.finishStatement(endTime, true);
+                                // Finalizar CT como sucesso
+                                StatementTracker.endCT(ctName, true);
+                                return result;
+                            }
+                            catch (error) {
+                                const endTime = Date.now();
+                                const errorMessage = error instanceof Error ? error.message : String(error);
+                                // Finalizar statement como falha
+                                StatementTracker.finishStatement(endTime, false, errorMessage);
+                                // Finalizar CT como falha
+                                StatementTracker.endCT(ctName, false, errorMessage);
+                                throw error;
+                            }
+                        };
+                    }
+                }
+                return instance;
+            },
+        });
+    }
+    /**
+     * 🚀 INICIAR CT (CASO DE TESTE) AUTOMATICAMENTE
+     */
+    static startCT(ctName) {
+        // 🛑 CARREGAR FLAG DO ARQUIVO PRIMEIRO (para compartilhar entre processos/workers)
+        StatementTracker.loadStopOnFailureFlagFromFile();
+        // 🛑 VERIFICAR SE JÁ HOUVE FALHA COM STOP-ON-FAILURE
+        if (StatementTracker.hasAnyTestFailedWithStopOnFailure()) {
+            const errorMsg = `🛑 [STOP-ON-FAILURE] CT "${ctName}" pulado - um CT anterior falhou.`;
+            Logger.error(`\n${errorMsg}`);
+            throw new Error(errorMsg);
+        }
+        const testName = StatementTracker.getCurrentTestName();
+        if (!StatementTracker.executions.has(testName)) {
+            StatementTracker.executions.set(testName, {
+                testName,
+                cts: [],
+                totalDuration: 0,
+                totalCTs: 0,
+                passedCTs: 0,
+                failedCTs: 0,
+            });
+        }
+        const testData = StatementTracker.executions.get(testName);
+        // 🔍 VERIFICAÇÃO DE DUPLICATA ANTES DE CRIAR
+        const existingCT = testData.cts.find((ct) => ct.name === ctName);
+        if (existingCT) {
+            // CT já existe, não criar duplicata
+            return;
+        }
+        StatementTracker.ctCounter++;
+        StatementTracker.currentCTName = ctName;
+        // 🆕 Definir CT atual no TerminalLogCapture para filtragem precisa
+        try {
+            const TerminalLogCapture = globalThis.TerminalLogCapture;
+            if (TerminalLogCapture && typeof TerminalLogCapture.setCurrentCT === 'function') {
+                TerminalLogCapture.setCurrentCT(ctName);
+            }
+        }
+        catch {
+            // Ignorar se TerminalLogCapture não estiver disponível
+        }
+        // 🧹 NOVO: Limpar cache de contextos do ApiActions para novo CT
+        try {
+            import('../api/ApiActions.js')
+                .then(({ ApiActions }) => {
+                return ApiActions.clearContextCache();
+            })
+                .catch(() => {
+                // Silenciosamente ignorar se ApiActions não estiver disponível
+            });
+        }
+        catch {
+            // Silenciosamente ignorar
+        }
+        // 🔧 Capturar sistema configurado do globalThis (definido por TestAnnotations.setSystem)
+        const capturedSystem = StatementTracker.getCurrentSystem();
+        const logStartIndex = StatementTracker.getCurrentGlobalLogIndex();
+        const ct = {
+            name: ctName,
+            startTime: Date.now(),
+            status: 'running',
+            systemName: 'Unknown',
+            statements: [], // ✅ CORRETO: Array para armazenar statements
+            actions: [],
+            executedActions: [],
+            logs: [], // Logs serão associados no final do CT
+            logStartIndex, // 📍 Marca onde este CT começa nos logs globais (ANTES dos logs de CT-START)
+        };
+        testData.cts.push(ct);
+        testData.totalCTs++;
+        StatementTracker.startCTLogStream(testName, ctName);
+        globalThis.__SIMPLE_STATEMENT_CURRENT_SYSTEM__ = undefined;
+        // 🔒 PROTEÇÃO ANTI-DUPLICAÇÃO: Só logar se é um CT diferente do último
+        // ✅ IMPORTANTE: Estes logs são impressos DEPOIS de capturar logStartIndex,
+        // mas serão incluídos na captura pois logStartIndex foi capturado ANTES
+        if (StatementTracker.lastLoggedCT !== ctName) {
+            StatementTracker.lastLoggedCT = ctName;
+            Logger.info('\n🚀 [CT-START] === INICIANDO NOVO CT ===');
+            Logger.info(`   🎯 CT Name: "${ctName}"`);
+            Logger.info(`   📋 Test Name: "${testName}"`);
+            Logger.info(`   🔢 CT #${testData.totalCTs}`);
+            Logger.info(`   📊 Total de CTs no teste: ${testData.cts.length}`);
+            Logger.info('🚀 [CT-START] === CT CRIADO ===\n');
+        }
+        // 💾 Auto-save após iniciar CT
+        StatementTracker.saveDataToFile();
+    }
+    /**
+     * 🏁 FINALIZAR CT (CASO DE TESTE) AUTOMATICAMENTE
+     */
+    static endCT(ctName, success, errorMessage) {
+        const testName = StatementTracker.getCurrentTestName();
+        const testData = StatementTracker.executions.get(testName);
+        if (!testData) {
+            Logger.warning(`⚠️ [CT] Teste "${testName}" não encontrado ao finalizar CT: ${ctName}`);
+            return;
+        }
+        const ct = testData.cts.find((c) => c.name === ctName && c.status === 'running');
+        if (!ct) {
+            Logger.warning(`⚠️ [CT] CT "${ctName}" não encontrado ou já finalizado`);
+            Logger.info(`   📋 CTs disponíveis: ${testData.cts.map((c) => `${c.name}(${c.status})`).join(', ')}`);
+            return;
+        }
+        // ✅ SALVAR ENDTIME E STATUS
+        ct.endTime = Date.now();
+        ct.duration = ct.endTime - ct.startTime;
+        ct.status = success ? 'passed' : 'failed';
+        if (errorMessage)
+            ct.error = errorMessage;
+        StatementTracker.hydrateCTLogs(ct, testName, ctName);
+        testData.totalDuration += ct.duration;
+        if (success)
+            testData.passedCTs++;
+        else
+            testData.failedCTs++;
+        StatementTracker.currentCTName = null;
+        // 🆕 Limpar CT atual no TerminalLogCapture
+        try {
+            const TerminalLogCapture = globalThis.TerminalLogCapture;
+            if (TerminalLogCapture && typeof TerminalLogCapture.clearCurrentCT === 'function') {
+                TerminalLogCapture.clearCurrentCT();
+            }
+        }
+        catch {
+            // Ignorar se TerminalLogCapture não estiver disponível
+        }
+        // 💾 CRÍTICO: Auto-save após finalizar CT
+        StatementTracker.saveDataToFile();
+        // 🛑 STOP ON FAILURE: Se o CT falhou e stopOnFailure está ativo, marcar flag e lançar erro
+        if (!success) {
+            const stopOnFailure = StatementTracker.isStopOnFailureEnabled();
+            if (stopOnFailure) {
+                // Marcar flag global para impedir próximos CTs
+                StatementTracker.markFailedWithStopOnFailure();
+                const errorMsg = `🛑 [STOP-ON-FAILURE] CT "${ctName}" falhou. Execução interrompida.`;
+                Logger.error(`\n${errorMsg}`);
+                // Lançar erro para interromper execução dos próximos CTs
+                throw new Error(errorMsg);
+            }
+        }
+    }
+    /**
+     * 🎯 REGISTRAR AÇÃO EXECUTADA DURANTE STATEMENT (DENTRO DO CT)
+     * @param type Tipo da ação (API, SSH, DB, UI, MOBILE, OTHER)
+     * @param description Descrição da ação executada
+     * @param success Se a ação foi bem-sucedida
+     * @param duration Duração em milissegundos
+     * @param details Detalhes específicos da ação (método, url, statusCode, command, query, selector, etc.)
+     */
+    static recordAction(type, description, success = true, duration, details) {
+        const testName = StatementTracker.getCurrentTestName();
+        const testData = StatementTracker.executions.get(testName);
+        if (!testData)
+            return;
+        const currentCT = testData.cts.find((c) => c.status === 'running');
+        if (!currentCT)
+            return;
+        // 🎯 CORRIGIDO: Pegar o statement mais recente em execução (último iniciado)
+        // Isso resolve o problema de múltiplos statements simultâneos
+        const activeStatement = currentCT.statements
+            .filter((s) => s.status === 'running')
+            .sort((a, b) => b.startTime - a.startTime)[0]; // Mais recente primeiro
+        const action = {
+            type,
+            description,
+            timestamp: new Date().toISOString(),
+            duration,
+            success,
+            details,
+        };
+        // Registrar no Statement ativo (prioridade)
+        if (activeStatement) {
+            if (!activeStatement.executedActions)
+                activeStatement.executedActions = [];
+            activeStatement.executedActions.push(action);
+        }
+        else {
+            // Fallback: Registrar no CT se não houver Statement ativo
+            if (!currentCT.executedActions)
+                currentCT.executedActions = [];
+            currentCT.executedActions.push(action);
+        }
+    }
+    /**
+     * 📊 OBTER DADOS FORMATADOS PARA INTEGRAÇÃO COM RELATÓRIOS HTML
+     */
+    static getReportData() {
+        const reportData = {
+            cts: [],
+            totalCTs: 0,
+            passedCTs: 0,
+            failedCTs: 0,
+            totalDuration: 0,
+        };
+        for (const testData of StatementTracker.executions.values()) {
+            for (let i = 0; i < testData.cts.length; i++) {
+                const ct = testData.cts[i];
+                const ctNumber = i + 1;
+                reportData.cts.push({
+                    ctId: `${testData.testName}_CT${ctNumber.toString().padStart(3, '0')}`,
+                    ctName: ct.name,
+                    ctOrder: ctNumber,
+                    className: ct.name.split('.')[0] || 'Unknown',
+                    methodName: ct.name.split('.')[1] || 'unknown',
+                    testName: testData.testName,
+                    parentTest: testData.testName,
+                    status: ct.status,
+                    duration: ct.duration || 0,
+                    timestamp: new Date(ct.startTime).toISOString(),
+                    error: ct.error,
+                    success: ct.status === 'passed',
+                    executedActions: ct.executedActions || [],
+                    statusIcon: ct.status === 'passed'
+                        ? '✅'
+                        : ct.status === 'failed'
+                            ? '❌'
+                            : '⏳',
+                });
+            }
+            reportData.totalCTs += testData.totalCTs;
+            reportData.passedCTs += testData.passedCTs;
+            reportData.failedCTs += testData.failedCTs;
+            reportData.totalDuration += testData.totalDuration;
+        }
+        return reportData.cts;
+    }
+    /**
+     * 📊 OBTER RELATÓRIO COMPLETO
+     */
+    static getFullReport() {
+        return Array.from(StatementTracker.executions.values());
+    }
+    /**
+     * 🔢 OBTER TOTAL DE CTs
+     */
+    static getTotalCTs() {
+        let total = 0;
+        const executionsSize = StatementTracker.executions.size;
+        Logger.info(`🔍 [StatementTracker] getTotalCTs() - Executions map size: ${executionsSize}`);
+        // 🔍 DEBUGGING ULTRA-DETALHADO
+        Logger.info(`🔍 [ULTRA-DEBUG] Global instance check: ${globalThis.__SIMPLE_STATEMENT_TRACKER__ === StatementTracker}`);
+        Logger.info(`🔍 [ULTRA-DEBUG] Executions Map keys: ${Array.from(StatementTracker.executions.keys())}`);
+        for (const [testName, testData] of StatementTracker.executions.entries()) {
+            Logger.info(`🔍 [ULTRA-DEBUG] Test "${testName}":`);
+            Logger.info(`🔍 [ULTRA-DEBUG]   - totalCTs property: ${testData.totalCTs}`);
+            Logger.info(`🔍 [ULTRA-DEBUG]   - cts.length: ${testData.cts.length}`);
+            Logger.info(`🔍 [ULTRA-DEBUG]   - CTs: ${testData.cts.map((ct) => `${ct.name}(${ct.status})`).join(', ')}`);
+            total += testData.totalCTs;
+        }
+        Logger.info(`🔍 [StatementTracker] Total calculado: ${total}`);
+        return total;
+    }
+    /**
+     * 📈 OBTER ESTATÍSTICAS
+     */
+    static getStats() {
+        let totalCTs = 0;
+        let passedCTs = 0;
+        let failedCTs = 0;
+        let totalDuration = 0;
+        for (const testData of StatementTracker.executions.values()) {
+            StatementTracker.recomputeTestStats(testData);
+            totalCTs += testData.totalCTs;
+            passedCTs += testData.passedCTs;
+            failedCTs += testData.failedCTs;
+            totalDuration += testData.totalDuration;
+        }
+        return { totalCTs, passedCTs, failedCTs, totalDuration };
+    }
+    /**
+     * 🔍 DETECTAR NOME DO TESTE AUTOMATICAMENTE - VERSÃO ROBUSTA COM MÚLTIPLOS FALLBACKS
+     * CORRIGIDO: Pega o CN (test.describe) com compatibilidade total para projetos consumidores
+     * ✅ ACEITA qualquer nome no test.describe, com ou sem prefixo "CN"
+     * ES MODULES PURO + COMPATIBILIDADE UNIVERSAL
+     */
+    static getCurrentTestName() {
+        // 🆕 PRIORIDADE MÁXIMA: testName definido globalmente (usado em recursão de finalizarCT)
+        const globalTestName = globalThis
+            .__SIMPLE_STATEMENT_CURRENT_TEST_NAME__;
+        if (globalTestName && globalTestName !== 'Unknown Test') {
+            return globalTestName;
+        }
+        try {
+            // 1️⃣ MÉTODO PREFERIDO: TestContext (método mais confiável)
+            const TestContext = globalThis.__TEST_CONTEXT__;
+            if (TestContext) {
+                const testInfo = TestContext?.getSafeTestInfo?.();
+                if (testInfo) {
+                    // ✅ CRÍTICO: titlePath[0] = FILENAME, titlePath[1] = CN (test.describe), titlePath[2] = CT (test())
+                    // Exemplos:
+                    // titlePath = ["CN0001_Orquestrador.spec.ts", "CN001_Orquestrador FTTH", "CT001_Token"] → "CN001_Orquestrador FTTH"
+                    // titlePath = ["SSH.spec.ts", "Teste SSH via Gateway - SMP", "CT01 - Consumo de Voz"] → "Teste SSH via Gateway - SMP"
+                    if (testInfo.titlePath && testInfo.titlePath.length > 1) {
+                        const cnName = testInfo.titlePath[1];
+                        return cnName;
+                    }
+                    // Fallback para title se titlePath não existir
+                    if (testInfo.title) {
+                        return testInfo.title;
+                    }
+                }
+            }
+        }
+        catch (error) {
+            Logger.warning(`⚠️ [getCurrentTestName] Erro no TestContext: ${error}`);
+            // Ignorar erro e tentar próximo método
+        }
+        try {
+            // 2️⃣ MÉTODO DIRETO: Playwright test.info() (para projetos consumidores)
+            if (typeof globalThis !== 'undefined' && globalThis.test) {
+                const testInfo = globalThis.test.info?.();
+                if (testInfo) {
+                    // ✅ CRÍTICO: titlePath[0] = FILENAME, titlePath[1] = CN (test.describe)
+                    if (testInfo.titlePath && testInfo.titlePath.length > 1) {
+                        const cnName = testInfo.titlePath[1];
+                        return cnName;
+                    }
+                    // Fallback para title
+                    if (testInfo.title) {
+                        return testInfo.title;
+                    }
+                }
+            }
+        }
+        catch (error) {
+            Logger.warning(`⚠️ [getCurrentTestName] Erro no Playwright direto: ${error}`);
+            // Ignorar erro
+        }
+        // 3️⃣ MÉTODO MANUAL: Nome setado via setTestName()
+        const currentTestName = StatementTracker.currentTest;
+        if (currentTestName && currentTestName !== 'Unknown Test') {
+            return currentTestName;
+        }
+        // 4️⃣ MÉTODO STACK TRACE: Analisar call stack para detectar teste
+        try {
+            const stackTrace = new Error().stack;
+            if (stackTrace) {
+                // Procurar por padrões de nome de teste em arquivos .spec.ts
+                const testFilePattern = /([^/\\]+)\.spec\.ts/i;
+                const testFileMatch = stackTrace.match(testFilePattern);
+                if (testFileMatch) {
+                    const testFileName = testFileMatch[1];
+                    return testFileName;
+                }
+            }
+        }
+        catch (error) {
+            Logger.warning(`⚠️ [getCurrentTestName] Erro na análise de stack: ${error}`);
+        }
+        // 5️⃣ ÚLTIMO RECURSO: Unknown Test
+        Logger.warning(`⚠️ [getCurrentTestName] TODOS OS MÉTODOS FALHARAM - usando "Unknown Test"`);
+        return 'Unknown Test';
+    }
+    /**
+     * 🏷️ DEFINIR NOME DO TESTE MANUALMENTE
+     * Use este método para garantir que o nome correto do teste seja usado
+     */
+    static setTestName(testName) {
+        if (testName && testName !== 'Unknown Test') {
+            StatementTracker.currentTest = testName;
+            // 💾 Criar entrada para o teste se não existir
+            if (!StatementTracker.executions.has(testName)) {
+                StatementTracker.executions.set(testName, {
+                    testName,
+                    cts: [],
+                    totalDuration: 0,
+                    totalCTs: 0,
+                    passedCTs: 0,
+                    failedCTs: 0,
+                });
+                StatementTracker.saveDataToFile();
+            }
+        }
+        else {
+            Logger.warning(`⚠️ [StatementTracker] Tentativa de definir nome de teste inválido: "${testName}"`);
+        }
+    }
+    /**
+     * 🔍 OBTER NOME DO TESTE ATUAL (PÚBLICO)
+     * Retorna o nome do teste atual sendo executado
+     */
+    static getCurrentTest() {
+        return StatementTracker.getCurrentTestName();
+    }
+    /**
+     * ❌ FINALIZAR APENAS CTs "RUNNING" COMO "FAILED"
+     * ✅ PRESERVA CTs que já passaram (status='passed')
+     * ❌ Marca apenas CTs em execução (status='running') como failed
+     * 📊 Preserva duração, logs e ações de todos os CTs
+     */
+    /**
+     * ✅ NOVO: Finaliza CTs "running" como PASSED quando teste PASSOU
+     */
+    static finalizeRunningCTsAsPassed(testName, ctName) {
+        const targetTestName = testName || StatementTracker.getCurrentTestName();
+        const testData = StatementTracker.executions.get(targetTestName);
+        if (!testData) {
+            Logger.warning(`⚠️ [StatementTracker] Nenhum dado encontrado para teste: ${targetTestName}`);
+            return;
+        }
+        let finalizados = 0;
+        let preservados = 0;
+        for (let i = 0; i < testData.cts.length; i++) {
+            const ct = testData.cts[i];
+            if (ctName && ct.name !== ctName) {
+                continue;
+            }
+            if (ct.status === 'running') {
+                // ✅ CORREÇÃO: Analisar statements para determinar status do CT
+                ct.endTime = Date.now();
+                ct.duration = ct.endTime - ct.startTime;
+                // ✅ PROTEÇÃO: Verificar se statements existe e é array
+                const statements = Array.isArray(ct.statements) ? ct.statements : [];
+                // Verificar se alguma statement falhou
+                const hasFailedStatement = statements.some((stmt) => stmt.status === 'failed');
+                if (hasFailedStatement) {
+                    // Se alguma statement falhou, CT falhou (mesmo que teste tenha passado)
+                    ct.status = 'failed';
+                    ct.error =
+                        ct.statements.find((stmt) => stmt.error)?.error ||
+                            'Statement falhou';
+                    testData.failedCTs++;
+                    Logger.info(`   ❌ CT${i + 1} "${ct.name}": RUNNING → FAILED (${ct.duration}ms) - Statement falhou`);
+                }
+                else {
+                    // ✅ Teste passou, CT passou (assume sucesso se não falhou explicitamente)
+                    ct.status = 'passed';
+                    testData.passedCTs++;
+                    Logger.info(`   ✅ CT${i + 1} "${ct.name}": RUNNING → PASSED (${ct.duration}ms) - Teste OK`);
+                }
+                testData.totalDuration += ct.duration;
+                finalizados++;
+            }
+            else if (ct.status === 'passed') {
+                // ✅ Preservar CT que já passou
+                preservados++;
+                Logger.info(`   ✅ CT${i + 1} "${ct.name}": PASSED → PRESERVADO (${ct.duration || 0}ms)`);
+            }
+            else if (ct.status === 'failed') {
+                // ❌ CT que já tinha falhado antes
+                preservados++;
+                Logger.info(`   ❌ CT${i + 1} "${ct.name}": FAILED → PRESERVADO (${ct.duration || 0}ms)`);
+            }
+            else if (ct.status === 'skipped') {
+                preservados++;
+                Logger.info(`   ⏭️ CT${i + 1} "${ct.name}": SKIPPED → PRESERVADO (${ct.duration || 0}ms)`);
+            }
+        }
+        if (finalizados > 0) {
+            StatementTracker.saveDataToFile();
+        }
+    }
+    /**
+     * ❌ Finaliza CTs "running" como FAILED quando teste FALHOU
+     */
+    static finalizeRunningCTsAsFailed(testName, reason, ctName) {
+        const targetTestName = testName || StatementTracker.getCurrentTestName();
+        const testData = StatementTracker.executions.get(targetTestName);
+        if (!testData) {
+            Logger.warning(`⚠️ [StatementTracker] Nenhum dado encontrado para teste: ${targetTestName}`);
+            return;
+        }
+        let finalizados = 0;
+        let preservados = 0;
+        for (let i = 0; i < testData.cts.length; i++) {
+            const ct = testData.cts[i];
+            if (ctName && ct.name !== ctName) {
+                continue;
+            }
+            if (ct.status === 'running') {
+                // ✅ CORREÇÃO: Analisar statements para determinar status do CT
+                ct.endTime = Date.now();
+                ct.duration = ct.endTime - ct.startTime;
+                // ✅ PROTEÇÃO: Verificar se statements existe e é array
+                const statements = Array.isArray(ct.statements) ? ct.statements : [];
+                // Verificar se alguma statement falhou
+                const hasFailedStatement = statements.some((stmt) => stmt.status === 'failed');
+                const hasRunningStatement = statements.some((stmt) => stmt.status === 'running');
+                if (hasFailedStatement) {
+                    // Se alguma statement falhou, CT falhou
+                    ct.status = 'failed';
+                    ct.error =
+                        ct.statements.find((stmt) => stmt.error)?.error ||
+                            reason ||
+                            'Statement falhou';
+                    testData.failedCTs++;
+                    Logger.info(`   ❌ CT${i + 1} "${ct.name}": RUNNING → FAILED (${ct.duration}ms) - Statement falhou`);
+                }
+                else if (hasRunningStatement) {
+                    // Se tem statement ainda rodando, marcar como failed (não finalizou corretamente)
+                    ct.status = 'failed';
+                    ct.error = 'Teste interrompido - statements não finalizadas';
+                    testData.failedCTs++;
+                    Logger.info(`   ❌ CT${i + 1} "${ct.name}": RUNNING → FAILED (${ct.duration}ms) - Interrompido`);
+                }
+                else if (statements.length > 0 &&
+                    statements.every((stmt) => stmt.status === 'passed')) {
+                    // Se todas as statements passaram, CT passou!
+                    ct.status = 'passed';
+                    testData.passedCTs++;
+                    Logger.info(`   ✅ CT${i + 1} "${ct.name}": RUNNING → PASSED (${ct.duration}ms) - Todas statements OK`);
+                }
+                else {
+                    // Sem statements ou status desconhecido, marcar como failed
+                    ct.status = 'failed';
+                    ct.error = reason || 'CT sem statements executadas';
+                    testData.failedCTs++;
+                    Logger.info(`   ❌ CT${i + 1} "${ct.name}": RUNNING → FAILED (${ct.duration}ms) - Sem statements`);
+                }
+                testData.totalDuration += ct.duration;
+                finalizados++;
+            }
+            else if (ct.status === 'passed') {
+                // ✅ Preservar CT que já passou
+                preservados++;
+                Logger.info(`   ✅ CT${i + 1} "${ct.name}": PASSED → PRESERVADO (${ct.duration || 0}ms)`);
+            }
+            else if (ct.status === 'failed') {
+                // ❌ CT que já tinha falhado antes
+                preservados++;
+                Logger.info(`   ❌ CT${i + 1} "${ct.name}": FAILED → PRESERVADO (${ct.duration || 0}ms)`);
+            }
+            else if (ct.status === 'skipped') {
+                preservados++;
+                Logger.info(`   ⏭️ CT${i + 1} "${ct.name}": SKIPPED → PRESERVADO (${ct.duration || 0}ms)`);
+            }
+        }
+        if (finalizados > 0) {
+            StatementTracker.saveDataToFile();
+        }
+    }
+    /**
+     * 🧹 LIMPAR DADOS
+     */
+    static clear() {
+        const totalBefore = StatementTracker.getTotalCTs();
+        Logger.info('Stack trace do clear():');
+        StatementTracker.executions.clear();
+        StatementTracker.currentTest = 'Unknown Test';
+        StatementTracker.ctCounter = 0;
+        StatementTracker.currentCTName = null;
+        StatementTracker.lastLoggedCT = null;
+        StatementTracker.lastLoggedRequest = null;
+        StatementTracker.lastRequestTimestamp = 0;
+    }
+    /**
+     * 📡 LOG DE REQUEST COM PROTEÇÃO ANTI-DUPLICAÇÃO
+     * Evita logs duplicados de requisições consecutivas idênticas
+     * @param method Método HTTP (POST, GET, PUT, DELETE)
+     * @param descricao Descrição da requisição
+     */
+    static logRequest(method, descricao) {
+        const now = Date.now();
+        const requestKey = `${method.toUpperCase()}_${descricao}`;
+        // 🔒 PROTEÇÃO: Ignora se é a mesma request nos últimos 500ms
+        if (StatementTracker.lastLoggedRequest === requestKey &&
+            (now - StatementTracker.lastRequestTimestamp) < 500) {
+            return; // Duplicata, ignorar
+        }
+        // Atualizar controle
+        StatementTracker.lastLoggedRequest = requestKey;
+        StatementTracker.lastRequestTimestamp = now;
+        // Formatar horário
+        const time = new Date().toLocaleTimeString('pt-BR', {
+            hour: '2-digit',
+            minute: '2-digit',
+            second: '2-digit'
+        });
+        // Log formatado
+        Logger.info('\n📡 NOVA REQUEST INICIADA');
+        Logger.info(`   🌐 Método: ${method.toUpperCase()}`);
+        Logger.info(`   📋 Descrição: ${descricao}`);
+        Logger.info(`   🕐 Horário: ${time}\n`);
+    }
+    /**
+     * 📋 IMPRIMIR RELATÓRIO
+     */
+    static printReport() {
+        Logger.info('\n📊 === RELATÓRIO AUTOMÁTICO DE CTs ===');
+        const stats = StatementTracker.getStats();
+        Logger.info(`📈 Total: ${stats.totalCTs} CTs`);
+        Logger.info(`✅ Passou: ${stats.passedCTs} CTs`);
+        Logger.info(`❌ Falhou: ${stats.failedCTs} CTs`);
+        Logger.info(`⏱️ Tempo Total: ${stats.totalDuration}ms`);
+        Logger.info('\n📋 Detalhes por teste:');
+        for (const testData of StatementTracker.executions.values()) {
+            Logger.info(`\n🧪 ${testData.testName}`);
+            Logger.info(`   📊 ${testData.totalCTs} CTs - ✅${testData.passedCTs} ❌${testData.failedCTs} - ${testData.totalDuration}ms`);
+            for (let i = 0; i < testData.cts.length; i++) {
+                const ct = testData.cts[i];
+                const statusIcon = ct.status === 'passed' ? '✅' : ct.status === 'failed' ? '❌' : '⏳';
+                Logger.info(`      CT${i + 1}: ${statusIcon} ${ct.name} - ${ct.duration || 0}ms`);
+                if (ct.executedActions && ct.executedActions.length > 0) {
+                    Logger.info('         🔍 Ações executadas:');
+                    for (const action of ct.executedActions) {
+                        const actionStatus = action.success ? '✅' : '❌';
+                        Logger.info(`           ${actionStatus} ${action.type}: ${action.description}`);
+                    }
+                }
+                if (ct.error) {
+                    Logger.info(`         ❌ ${ct.error}`);
+                }
+            }
+        }
+    }
+    /**
+     * 🚨 MÉTODO DE EMERGÊNCIA: Força criação de CT quando detecção falha
+     * Para projetos consumidores onde a detecção automática não funciona
+     */
+    static forceCreateCT(ctName) {
+        const testName = StatementTracker.getCurrentTestName();
+        // Se não forneceu nome, criar um
+        if (!ctName) {
+            ctName = `CT_${testName}_${Date.now()}`;
+        }
+        Logger.info(`🚨 [forceCreateCT] FORÇANDO criação do CT: "${ctName}"`);
+        Logger.info(`   📋 Para teste: "${testName}"`);
+        const testData = StatementTracker.executions.get(testName);
+        // Verificar se já existe
+        if (testData && testData.cts.length > 0) {
+            const existingCT = testData.cts.find((ct) => ct.name === ctName);
+            if (existingCT) {
+                Logger.warning(`⚠️ [forceCreateCT] CT "${ctName}" já existe - não forçando criação`);
+                return;
+            }
+        }
+        // Força criação
+        StatementTracker.startCT(ctName);
+        StatementTracker.ctAutoCreated = true;
+        Logger.success(`✅ [forceCreateCT] CT forçado criado com sucesso: "${ctName}"`);
+    }
+    /**
+     * ✅ NOVO: Finaliza CT individual com status específico
+     * Chamado pelo CustomReporter quando cada test() termina
+     */
+    static finalizarCT(ctName, status, options) {
+        const targetTestName = options?.testName || StatementTracker.getCurrentTestName();
+        const testData = StatementTracker.executions.get(targetTestName);
+        if (!testData) {
+            // 🔧 Tentar encontrar o CT em qualquer teste existente
+            for (const [name, data] of StatementTracker.executions.entries()) {
+                const ct = data.cts.find((c) => c.name === ctName);
+                if (ct) {
+                    // Recursivamente chamar com testName correto
+                    StatementTracker.finalizarCT(ctName, status, {
+                        testName: name,
+                        errorMessage: options?.errorMessage,
+                    });
+                    return;
+                }
+            }
+            return;
+        }
+        // Encontrar o CT
+        const ct = testData.cts.find((c) => c.name === ctName);
+        if (!ct) {
+            return;
+        }
+        if (!ct.logs || ct.logs.length === 0) {
+            // ✅ CORREÇÃO: Usar hydrateCTLogs que possui a estratégia híbrida robusta
+            StatementTracker.hydrateCTLogs(ct, targetTestName);
+        }
+        // Se já foi finalizado, não sobrescrever
+        if (ct.status === 'passed' || ct.status === 'failed' || ct.status === 'skipped') {
+            return;
+        }
+        // Finalizar o CT
+        ct.endTime = Date.now();
+        ct.duration = ct.endTime - ct.startTime;
+        // ✅ CORREÇÃO CRÍTICA: Respeitar status do Playwright, verificar statements só se status='passed'
+        // Isso garante que CT001 PASSED não seja marcado como FAILED por causa de CT002
+        const statements = Array.isArray(ct.statements) ? ct.statements : [];
+        const hasFailedStatement = statements.some((stmt) => stmt.status === 'failed');
+        // 🎯 LÓGICA CORRIGIDA:
+        // 1. Se Playwright diz PASSED e não há statement failed → PASSED
+        // 2. Se Playwright diz FAILED → FAILED (mesmo que statements passaram)
+        // 3. Se Playwright diz PASSED mas há statement failed → FAILED
+        const resolvedErrorMessage = options?.errorMessage || ct.error ||
+            (status === 'failed'
+                ? 'Teste falhou'
+                : hasFailedStatement
+                    ? statements.find((stmt) => stmt.error)?.error || 'Statement falhou'
+                    : undefined);
+        if (status === 'passed' && !hasFailedStatement) {
+            // ✅ Teste passou e nenhuma statement falhou
+            ct.status = 'passed';
+            ct.error = undefined;
+            testData.passedCTs++;
+        }
+        else if (status === 'failed') {
+            // ❌ Playwright reportou falha
+            ct.status = 'failed';
+            ct.error = resolvedErrorMessage;
+            testData.failedCTs++;
+            Logger.info(`❌ [finalizarCT] CT "${ctName}": RUNNING → FAILED (${ct.duration}ms) - Playwright reportou erro`);
+            // 🛑 STOP ON FAILURE: Marcar flag se stopOnFailure está ativo
+            if (StatementTracker.isStopOnFailureEnabled()) {
+                StatementTracker.markFailedWithStopOnFailure();
+            }
+        }
+        else if (status === 'passed' && hasFailedStatement) {
+            // ⚠️ Playwright diz passed mas statement falhou
+            ct.status = 'failed';
+            ct.error = resolvedErrorMessage;
+            testData.failedCTs++;
+            Logger.info(`❌ [finalizarCT] CT "${ctName}": RUNNING → FAILED (${ct.duration}ms) - Statement falhou`);
+            // 🛑 STOP ON FAILURE: Marcar flag se stopOnFailure está ativo
+            if (StatementTracker.isStopOnFailureEnabled()) {
+                StatementTracker.markFailedWithStopOnFailure();
+            }
+        }
+        else {
+            // skipped
+            ct.status = 'skipped';
+            ct.error = resolvedErrorMessage;
+            // Não incrementar failed para skipped
+        }
+        testData.totalDuration += ct.duration;
+        StatementTracker.saveDataToFile();
+    }
+    /**
+     * 🎯 OBTER CT ATUAL
+     */
+    static getCurrentCT() {
+        return StatementTracker.currentCTName;
+    }
+    /**
+     * 🛑 Marca que um CT falhou com stopOnFailure ativo
+     */
+    static markFailedWithStopOnFailure() {
+        StatementTracker.hasFailedWithStopOnFailure = true;
+        Logger.info('🛑 [STOP-ON-FAILURE] Flag global ativada - próximos CTs serão pulados');
+    }
+    /**
+     * 🛑 Verifica se algum CT já falhou com stopOnFailure ativo
+     */
+    static hasAnyTestFailedWithStopOnFailure() {
+        return StatementTracker.hasFailedWithStopOnFailure;
+    }
+    /**
+     * 🛑 Reseta a flag de falha (útil para novos describes)
+     */
+    static resetStopOnFailureFlag() {
+        StatementTracker.hasFailedWithStopOnFailure = false;
+    }
+    /**
+     * 🛑 Carrega a flag de stopOnFailure do arquivo JSON (para comunicação entre processos)
+     * Retorna true se a flag foi encontrada e está ativa
+     */
+    static loadStopOnFailureFlagFromFile() {
+        try {
+            const filePath = StatementTracker.getDataFilePath();
+            const fs = require('fs');
+            if (!fs.existsSync(filePath)) {
+                return false;
+            }
+            const content = fs.readFileSync(filePath, 'utf8');
+            const data = JSON.parse(content);
+            if (data.stopOnFailureTriggered === true) {
+                StatementTracker.hasFailedWithStopOnFailure = true;
+                Logger.info('🛑 [STOP-ON-FAILURE] Flag carregada do arquivo - testes subsequentes serão bloqueados');
+                return true;
+            }
+            return false;
+        }
+        catch (error) {
+            // Silenciosamente retorna false se não conseguir ler
+            return false;
+        }
+    }
+    /**
+     * 🛑 Verificar se stopOnFailure está ativo
+     * Esta função permite ao StatementTracker acessar a configuração do TestAnnotations
+     */
+    static isStopOnFailureEnabled() {
+        try {
+            // Importação dinâmica para evitar dependência circular
+            const { TestAnnotations } = require('./TestAnnotations.js');
+            return TestAnnotations?.isStopOnFailureEnabled?.() ?? false;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * 💾 SALVAR DADOS DOS CTS EM ARQUIVO
+     */
+    static async saveExecutionData(outputPath) {
+        try {
+            Logger.info('💾 [SAVE-EXECUTION] Delegando para sistema de persistência unificado...');
+            // Usar o sistema de persistência unificado
+            StatementTracker.saveDataToFile();
+            // Se outputPath específico foi fornecido, copiar também para lá
+            if (outputPath) {
+                const sourceFilePath = StatementTracker.getDataFilePath();
+                if (fs.existsSync(sourceFilePath)) {
+                    const dir = path.dirname(outputPath);
+                    if (!fs.existsSync(dir)) {
+                        fs.mkdirSync(dir, { recursive: true });
+                    }
+                    fs.copyFileSync(sourceFilePath, outputPath);
+                    Logger.info(`💾 [SAVE-EXECUTION] Dados copiados para: ${outputPath}`);
+                }
+            }
+            Logger.success('💾 [SAVE-EXECUTION] Execução salva com sucesso!');
+        }
+        catch (error) {
+            Logger.error('❌ [SAVE-EXECUTION] Erro ao salvar:', error);
+        }
+    }
+    /**
+     * � OBTER EXECUÇÕES (GETTER PÚBLICO)
+     */
+    static getExecutions() {
+        // Auto-carregar dados se não há execuções carregadas
+        if (StatementTracker.executions.size === 0) {
+            StatementTracker.loadDataFromFile();
+        }
+        return StatementTracker.executions;
+    }
+    /**
+     * �🔗 INTEGRAR COM EXECUTION TRACKER
+     */
+    static integrateWithExecutionTracker() {
+        ;
+        globalThis.__SIMPLE_STATEMENT_TRACKER__ = StatementTracker;
+        globalThis.statementTracker = StatementTracker;
+        globalThis.StatementTracker = StatementTracker;
+    }
+}
+// 🔗 AUTO-INTEGRAÇÃO
+try {
+    StatementTracker.integrateWithExecutionTracker();
+}
+catch (error) {
+    Logger.error('❌ Erro na auto-integração:', error);
+}
+/**
+ * 🌐 FUNÇÃO AUTOMÁTICA PARA FÁCIL USO
+ */
+export const interceptStatement = StatementTracker.interceptStatement.bind(StatementTracker);