@orkastery/cli 0.6.4 → 0.6.5

package/dist/junit.js

@@ -0,0 +1,546 @@
+"use strict";
+/**
+ * RM-081 F1: o subconjunto de JUnit XML que o verify usa como evidencia nominal.
+ *
+ * O parser e deliberadamente pequeno: valida o balanceamento do XML, nao aceita DTD e so
+ * interpreta suites, casos e os tres marcadores de resultado. Saida, propriedades e mensagens
+ * continuam opacas. O codigo de saida do comando permanece a autoridade do veredito.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LIMITE_JUNIT_BYTES = void 0;
+exports.lerJUnitXml = lerJUnitXml;
+exports.caminhoJUnitDoComando = caminhoJUnitDoComando;
+exports.marcacaoDeRelogioDoComando = marcacaoDeRelogioDoComando;
+exports.prepararRelatorioJUnit = prepararRelatorioJUnit;
+exports.lerRelatorioJUnit = lerRelatorioJUnit;
+exports.anexarRelatorioJUnit = anexarRelatorioJUnit;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_util_1 = require("node:util");
+const policies_1 = require("./policies");
+const redacao_url_1 = require("./redacao-url");
+/** Relatorio acima deste teto e evidencia invalida, sem tentar alocar o XML inteiro. */
+exports.LIMITE_JUNIT_BYTES = 16 * 1024 * 1024;
+/** Sistemas de arquivos podem arredondar mtime; a remocao previa continua sendo a barreira principal. */
+const TOLERANCIA_MTIME_MS = 2_000;
+const NOME_XML = /^[A-Za-z_][A-Za-z0-9_.:-]*/;
+const ENTIDADES = {
+    amp: '&', lt: '<', gt: '>', quot: '"', apos: "'",
+};
+function erro(detalhe) {
+    throw new Error(`junit.xml.invalido: ${detalhe}`);
+}
+function decodificar(texto) {
+    for (let i = texto.indexOf('&'); i >= 0; i = texto.indexOf('&', i)) {
+        const entidade = /^&([A-Za-z][A-Za-z0-9]*);/.exec(texto.slice(i));
+        if (!entidade || !Object.hasOwn(ENTIDADES, entidade[1])) {
+            return erro('entidade XML nao aceita');
+        }
+        i += entidade[0].length;
+    }
+    return texto.replace(/&([^;]+);/g, (_tudo, nome) => ENTIDADES[nome] ?? erro(`entidade &${nome}; nao aceita`));
+}
+function codigoDoErro(e) {
+    const codigo = e?.code;
+    return typeof codigo === 'string' && /^[A-Z0-9_]+$/.test(codigo) ? codigo : 'DESCONHECIDO';
+}
+function nomeLocal(nome) {
+    return nome.slice(nome.lastIndexOf(':') + 1);
+}
+function fimDaTag(xml, inicio) {
+    let aspas = null;
+    for (let i = inicio; i < xml.length; i++) {
+        const c = xml[i];
+        if (aspas) {
+            if (c === aspas)
+                aspas = null;
+            continue;
+        }
+        if (c === '"' || c === "'") {
+            aspas = c;
+            continue;
+        }
+        if (c === '>')
+            return i;
+    }
+    return erro('tag sem fechamento');
+}
+function lerInicio(bruto) {
+    let texto = bruto.trim();
+    const autocontido = texto.endsWith('/');
+    if (autocontido)
+        texto = texto.slice(0, -1).trimEnd();
+    const achado = NOME_XML.exec(texto);
+    if (!achado)
+        return erro('nome de elemento ausente');
+    const nome = achado[0];
+    const atributos = {};
+    let i = nome.length;
+    while (i < texto.length) {
+        while (/\s/.test(texto[i] ?? ''))
+            i++;
+        if (i >= texto.length)
+            break;
+        const atributo = NOME_XML.exec(texto.slice(i));
+        if (!atributo)
+            return erro(`atributo invalido em <${nome}>`);
+        const chave = atributo[0];
+        i += chave.length;
+        while (/\s/.test(texto[i] ?? ''))
+            i++;
+        if (texto[i++] !== '=')
+            return erro(`atributo ${chave} sem =`);
+        while (/\s/.test(texto[i] ?? ''))
+            i++;
+        const aspas = texto[i++];
+        if (aspas !== '"' && aspas !== "'")
+            return erro(`atributo ${chave} sem aspas`);
+        const fim = texto.indexOf(aspas, i);
+        if (fim < 0)
+            return erro(`atributo ${chave} sem fechamento`);
+        if (Object.hasOwn(atributos, chave))
+            return erro(`atributo ${chave} repetido`);
+        atributos[chave] = decodificar(texto.slice(i, fim)).replace(/[\t\n]/g, ' ');
+        i = fim + 1;
+    }
+    return { nome, atributos, autocontido };
+}
+function duracao(atributos) {
+    if (atributos.time === undefined || atributos.time === '')
+        return 0;
+    const segundos = Number(atributos.time);
+    if (!Number.isFinite(segundos) || segundos < 0)
+        return erro(`duracao invalida: ${atributos.time}`);
+    const milissegundos = segundos * 1000;
+    if (!Number.isFinite(milissegundos) || milissegundos > Number.MAX_SAFE_INTEGER) {
+        return erro('duracao fora do intervalo aceito');
+    }
+    return Math.round(milissegundos * 1000) / 1000;
+}
+function identidade(atributos) {
+    const nome = atributos.name?.trim();
+    if (!nome)
+        return erro('testcase sem name');
+    const prefixo = (atributos.classname || atributos.file || '').trim();
+    return prefixo ? `${prefixo} :: ${nome}` : nome;
+}
+function conferirIdentidadePersistivel(caso) {
+    if (caso.estado !== 'falhou' && caso.estado !== 'erro')
+        return;
+    if (caso.nome.length > 200 || (0, redacao_url_1.redigirCredenciaisUrl)(caso.nome) !== caso.nome || (0, policies_1.procurarSegredos)(caso.nome).length > 0) {
+        return erro('identidade de testcase nao pode ser persistida com seguranca');
+    }
+}
+/** Le pytest, Vitest, Jest, Playwright e gotestsum pelo contrato JUnit comum. */
+function lerJUnitXml(xml) {
+    if (/[\u0000-\u0008\u000b\u000c\u000e-\u001f]/.test(xml))
+        return erro('caractere de controle nao aceito');
+    xml = xml.replace(/\r\n?/g, '\n');
+    const pilha = [];
+    const casos = [];
+    let atual = null;
+    let raiz = null;
+    let viuSuite = false;
+    let suitesAbertas = 0;
+    let pos = xml.charCodeAt(0) === 0xfeff ? 1 : 0;
+    const marcar = (estado) => {
+        if (!atual)
+            return;
+        const peso = { passou: 0, pulado: 1, falhou: 2, erro: 3 };
+        if (peso[estado] > peso[atual.estado])
+            atual.estado = estado;
+    };
+    while (pos < xml.length) {
+        const abre = xml.indexOf('<', pos);
+        const texto = abre < 0 ? xml.slice(pos) : xml.slice(pos, abre);
+        if (pilha.length === 0 && texto.trim())
+            return erro('texto fora da raiz');
+        if (pilha.length > 0 && texto)
+            decodificar(texto);
+        if (abre < 0) {
+            pos = xml.length;
+            break;
+        }
+        if (xml.startsWith('<!--', abre)) {
+            const fim = xml.indexOf('-->', abre + 4);
+            if (fim < 0)
+                return erro('comentario sem fechamento');
+            pos = fim + 3;
+            continue;
+        }
+        if (xml.startsWith('<![CDATA[', abre)) {
+            const fim = xml.indexOf(']]>', abre + 9);
+            if (fim < 0)
+                return erro('CDATA sem fechamento');
+            pos = fim + 3;
+            continue;
+        }
+        if (xml.startsWith('<?', abre)) {
+            const fim = xml.indexOf('?>', abre + 2);
+            if (fim < 0)
+                return erro('instrucao sem fechamento');
+            pos = fim + 2;
+            continue;
+        }
+        if (xml.startsWith('<!', abre))
+            return erro('declaracao ou DTD nao aceita');
+        const fim = fimDaTag(xml, abre + 1);
+        const conteudo = xml.slice(abre + 1, fim);
+        if (conteudo.startsWith('/')) {
+            const nome = conteudo.slice(1).trim();
+            if (!NOME_XML.test(nome) || NOME_XML.exec(nome)?.[0] !== nome)
+                return erro('fechamento invalido');
+            const esperado = pilha.pop();
+            if (esperado !== nome)
+                return erro(`fechamento </${nome}> nao corresponde a <${esperado ?? 'ausente'}>`);
+            if (nomeLocal(nome) === 'testcase') {
+                if (!atual)
+                    return erro('testcase fechado sem abertura');
+                casos.push(atual);
+                atual = null;
+            }
+            if (nomeLocal(nome) === 'testsuite')
+                suitesAbertas--;
+            pos = fim + 1;
+            continue;
+        }
+        const inicio = lerInicio(conteudo);
+        const local = nomeLocal(inicio.nome);
+        if (!raiz) {
+            if (local !== 'testsuite' && local !== 'testsuites')
+                return erro(`raiz <${inicio.nome}> nao e JUnit`);
+            raiz = inicio.nome;
+        }
+        else if (pilha.length === 0)
+            return erro('mais de uma raiz');
+        if (local === 'testsuite')
+            viuSuite = true;
+        if (local === 'testcase') {
+            if (atual)
+                return erro('testcase aninhado');
+            if (suitesAbertas === 0)
+                return erro('testcase fora de testsuite');
+            atual = { nome: identidade(inicio.atributos), estado: 'passou', duracaoMs: duracao(inicio.atributos) };
+        }
+        else if (local === 'failure')
+            marcar('falhou');
+        else if (local === 'error')
+            marcar('erro');
+        else if (local === 'skipped')
+            marcar('pulado');
+        if (inicio.autocontido) {
+            if (local === 'testcase') {
+                casos.push(atual);
+                atual = null;
+            }
+        }
+        else {
+            pilha.push(inicio.nome);
+            if (local === 'testsuite')
+                suitesAbertas++;
+        }
+        pos = fim + 1;
+    }
+    if (pilha.length > 0)
+        return erro(`elemento <${pilha.at(-1)}> sem fechamento`);
+    if (!raiz || !viuSuite)
+        return erro('nenhuma testsuite');
+    casos.forEach(conferirIdentidadePersistivel);
+    const contar = (estado) => casos.filter((c) => c.estado === estado).length;
+    const duracaoMs = casos.reduce((soma, caso) => soma + caso.duracaoMs, 0);
+    if (!Number.isSafeInteger(Math.round(duracaoMs)))
+        return erro('duracao somada fora do intervalo aceito');
+    return {
+        casos,
+        testes: casos.length,
+        falhas: contar('falhou'),
+        erros: contar('erro'),
+        pulados: contar('pulado'),
+        duracaoMs: Math.round(duracaoMs * 1000) / 1000,
+    };
+}
+function dentro(raiz, alvo) {
+    const relativo = path.relative(raiz, alvo);
+    return relativo !== '..' && !relativo.startsWith(`..${path.sep}`) && !path.isAbsolute(relativo);
+}
+function evidencia(caminho, estado, motivo) {
+    return { caminho, estado, motivo: motivo.slice(0, 300) };
+}
+/** O caminho declarado para o nome interno do comando (`test:<lane>` no Agile). */
+function caminhoJUnitDoComando(manifesto, nome) {
+    if (nome.startsWith('test:'))
+        return manifesto.check?.agile?.junit?.[nome.slice('test:'.length)];
+    return manifesto.verify.junit?.[nome];
+}
+/** A marcacao fechada que acompanha o relatorio do mesmo comando ou lane. */
+function marcacaoDeRelogioDoComando(manifesto, nome) {
+    if (nome.startsWith('test:'))
+        return manifesto.check?.agile?.relogio?.[nome.slice('test:'.length)];
+    return manifesto.verify.relogio?.[nome];
+}
+/** Nome e granular; marcador e tag declaram que o proprio comando ja selecionou aquela categoria. */
+function casoMedeRelogio(nome, marcacao) {
+    if (!marcacao)
+        return false;
+    if ('marcador' in marcacao || 'tag' in marcacao)
+        return true;
+    return marcacao.nome.some((padrao) => {
+        try {
+            return new RegExp(padrao).test(nome);
+        }
+        catch {
+            return false;
+        }
+    });
+}
+function acessoAoDescritor(descritor) {
+    for (const base of ['/proc/self/fd', '/dev/fd']) {
+        const atalho = path.join(base, String(descritor));
+        try {
+            return { atalho, real: fs.realpathSync(atalho) };
+        }
+        catch { /* tenta o acesso por descritor que a plataforma oferece */ }
+    }
+    return null;
+}
+/**
+ * Abre o diretorio pai sem seguir o ultimo link e ancora as operacoes no descritor. O realpath do
+ * descritor detecta troca em qualquer ancestral; dali em diante, rename de caminho nao muda o pai.
+ */
+function abrirDiretorioAncorado(absoluto, raizReal) {
+    const pai = path.dirname(absoluto);
+    let descritor;
+    try {
+        descritor = fs.openSync(pai, fs.constants.O_RDONLY | fs.constants.O_DIRECTORY | fs.constants.O_NOFOLLOW);
+    }
+    catch (e) {
+        const codigo = codigoDoErro(e);
+        return { ok: false, estado: codigo === 'ENOENT' ? 'ausente' : codigo === 'ELOOP' || codigo === 'ENOTDIR' ? 'inseguro' : 'erro',
+            motivo: `nao foi possivel ancorar o diretorio do relatorio (${codigo})` };
+    }
+    try {
+        const acesso = acessoAoDescritor(descritor);
+        if (!acesso) {
+            fs.closeSync(descritor);
+            return { ok: false, estado: 'erro', motivo: 'a plataforma nao oferece acesso ancorado ao relatorio' };
+        }
+        const info = fs.fstatSync(descritor);
+        const atual = fs.statSync(pai);
+        if (!info.isDirectory() || !dentro(raizReal, acesso.real) || atual.dev !== info.dev || atual.ino !== info.ino) {
+            fs.closeSync(descritor);
+            return { ok: false, estado: 'inseguro', motivo: 'o diretorio do relatorio mudou ou sai da worktree' };
+        }
+        return { ok: true, descritor, alvo: path.join(acesso.atalho, path.basename(absoluto)) };
+    }
+    catch (e) {
+        fs.closeSync(descritor);
+        return { ok: false, estado: 'erro', motivo: `nao foi possivel validar o diretorio do relatorio (${codigoDoErro(e)})` };
+    }
+}
+/** Le no maximo o teto mais um byte, suficiente para detectar crescimento sem alocacao aberta. */
+function lerComLimite(descritor) {
+    const partes = [];
+    let total = 0;
+    while (total <= exports.LIMITE_JUNIT_BYTES) {
+        const tamanho = Math.min(64 * 1024, exports.LIMITE_JUNIT_BYTES + 1 - total);
+        if (tamanho === 0)
+            break;
+        const parte = Buffer.allocUnsafe(tamanho);
+        const lidos = fs.readSync(descritor, parte, 0, tamanho, null);
+        if (lidos === 0)
+            break;
+        partes.push(parte.subarray(0, lidos));
+        total += lidos;
+    }
+    return total > exports.LIMITE_JUNIT_BYTES ? { excedeu: true } : { bytes: Buffer.concat(partes, total), excedeu: false };
+}
+/** Remove a evidencia anterior antes do comando. Falha fechada: o comando ainda roda, mas o XML nao sera usado. */
+function prepararRelatorioJUnit(cwd, caminho) {
+    const absoluto = path.resolve(cwd, caminho);
+    let raizReal = cwd;
+    try {
+        raizReal = fs.realpathSync(cwd);
+    }
+    catch {
+        return { cwd, caminho, absoluto, raizReal, iniciadoEmMs: Date.now(),
+            descarte: evidencia(caminho, 'inseguro', 'worktree sem realpath') };
+    }
+    const pai = abrirDiretorioAncorado(absoluto, raizReal);
+    if (!pai.ok) {
+        if (pai.estado === 'ausente')
+            return { cwd, caminho, absoluto, raizReal, iniciadoEmMs: Date.now() };
+        return { cwd, caminho, absoluto, raizReal, iniciadoEmMs: Date.now(),
+            descarte: evidencia(caminho, pai.estado, pai.motivo) };
+    }
+    try {
+        const anterior = fs.lstatSync(pai.alvo, { throwIfNoEntry: false });
+        if (!anterior)
+            return { cwd, caminho, absoluto, raizReal, iniciadoEmMs: Date.now() };
+        if (anterior.isDirectory()) {
+            return { cwd, caminho, absoluto, raizReal, iniciadoEmMs: Date.now(),
+                descarte: evidencia(caminho, 'inseguro', 'relatorio anterior nao e arquivo removivel') };
+        }
+        fs.unlinkSync(pai.alvo);
+        if (fs.lstatSync(pai.alvo, { throwIfNoEntry: false })) {
+            return { cwd, caminho, absoluto, raizReal, iniciadoEmMs: Date.now(),
+                descarte: evidencia(caminho, 'erro', 'relatorio anterior permaneceu depois da remocao') };
+        }
+        return { cwd, caminho, absoluto, raizReal, iniciadoEmMs: Date.now() };
+    }
+    catch (e) {
+        return { cwd, caminho, absoluto, raizReal, iniciadoEmMs: Date.now(),
+            descarte: evidencia(caminho, 'erro', `nao foi possivel remover o relatorio anterior (${codigoDoErro(e)})`) };
+    }
+    finally {
+        fs.closeSync(pai.descritor);
+    }
+}
+/** Le somente o arquivo novo e regular da rodada; qualquer duvida vira motivo de descarte. */
+function lerRelatorioJUnit(preparado) {
+    if (preparado.descarte)
+        return { evidencia: preparado.descarte };
+    const { caminho, absoluto, raizReal } = preparado;
+    try {
+        const pai = abrirDiretorioAncorado(absoluto, raizReal);
+        if (!pai.ok) {
+            const estado = pai.estado === 'ausente' ? 'ausente' : pai.estado;
+            const motivo = pai.estado === 'ausente' ? 'o comando nao escreveu o relatorio' : pai.motivo;
+            return { evidencia: evidencia(caminho, estado, motivo) };
+        }
+        let bytes;
+        let descarteAposFechar;
+        let identidadeLida;
+        try {
+            const inicial = fs.lstatSync(pai.alvo, { throwIfNoEntry: false });
+            if (!inicial)
+                descarteAposFechar = evidencia(caminho, 'ausente', 'o comando nao escreveu o relatorio');
+            else if (!inicial.isFile() || inicial.isSymbolicLink()) {
+                descarteAposFechar = evidencia(caminho, 'inseguro', 'o relatorio nao e arquivo regular');
+            }
+            else {
+                let descritor;
+                try {
+                    descritor = fs.openSync(pai.alvo, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW | fs.constants.O_NONBLOCK);
+                    const info = fs.fstatSync(descritor);
+                    const acesso = acessoAoDescritor(descritor);
+                    const atual = fs.statSync(pai.alvo);
+                    if (!acesso || !info.isFile() || !dentro(raizReal, acesso.real) ||
+                        atual.dev !== info.dev || atual.ino !== info.ino) {
+                        descarteAposFechar = evidencia(caminho, 'inseguro', 'o relatorio mudou durante a validacao de confinamento');
+                    }
+                    else {
+                        identidadeLida = { dev: info.dev, ino: info.ino };
+                        if (info.mtimeMs + TOLERANCIA_MTIME_MS < preparado.iniciadoEmMs) {
+                            descarteAposFechar = evidencia(caminho, 'outra-rodada', 'o relatorio e anterior ao inicio do comando');
+                        }
+                        else if (info.size > exports.LIMITE_JUNIT_BYTES) {
+                            descarteAposFechar = evidencia(caminho, 'invalido', `o relatorio excede ${exports.LIMITE_JUNIT_BYTES} bytes`);
+                        }
+                        else {
+                            const lido = lerComLimite(descritor);
+                            if (lido.excedeu)
+                                descarteAposFechar = evidencia(caminho, 'invalido', `o relatorio excede ${exports.LIMITE_JUNIT_BYTES} bytes`);
+                            else
+                                bytes = lido.bytes;
+                            const final = fs.fstatSync(descritor);
+                            if (final.size !== info.size || final.mtimeMs !== info.mtimeMs || final.ctimeMs !== info.ctimeMs) {
+                                descarteAposFechar = evidencia(caminho, 'inseguro', 'o relatorio mudou durante a leitura');
+                                bytes = undefined;
+                            }
+                        }
+                    }
+                }
+                catch (e) {
+                    const estado = codigoDoErro(e) === 'ELOOP' ? 'inseguro' : 'erro';
+                    descarteAposFechar = evidencia(caminho, estado, `nao foi possivel abrir o relatorio (${codigoDoErro(e)})`);
+                }
+                finally {
+                    if (descritor !== undefined)
+                        fs.closeSync(descritor);
+                }
+            }
+            const atual = fs.lstatSync(pai.alvo, { throwIfNoEntry: false });
+            if (identidadeLida && (!atual || !atual.isFile() || atual.isSymbolicLink() ||
+                atual.dev !== identidadeLida.dev || atual.ino !== identidadeLida.ino)) {
+                descarteAposFechar = evidencia(caminho, 'inseguro', 'o relatorio mudou antes da limpeza');
+                bytes = undefined;
+            }
+            if (atual && !atual.isDirectory())
+                fs.unlinkSync(pai.alvo);
+        }
+        finally {
+            fs.closeSync(pai.descritor);
+        }
+        if (descarteAposFechar)
+            return { evidencia: descarteAposFechar };
+        if (!bytes)
+            return { evidencia: evidencia(caminho, 'erro', 'o relatorio nao pode ser lido') };
+        let xml;
+        try {
+            xml = new node_util_1.TextDecoder('utf-8', { fatal: true }).decode(bytes);
+        }
+        catch {
+            return { evidencia: evidencia(caminho, 'invalido', 'o relatorio nao e UTF-8 valido') };
+        }
+        let relatorio;
+        try {
+            relatorio = lerJUnitXml(xml);
+        }
+        catch {
+            return { evidencia: evidencia(caminho, 'invalido', 'o relatorio nao contem XML JUnit valido') };
+        }
+        return { evidencia: { caminho, estado: 'lido', testes: relatorio.testes, falhas: relatorio.falhas,
+                erros: relatorio.erros, pulados: relatorio.pulados, duracaoMs: relatorio.duracaoMs }, relatorio };
+    }
+    catch (e) {
+        return { evidencia: evidencia(caminho, 'erro', `nao foi possivel ler o relatorio (${codigoDoErro(e)})`) };
+    }
+}
+/** Anexa estatisticas e, em comando vermelho, substitui o extrator de stdout pelos nomes completos do XML. */
+function anexarRelatorioJUnit(resultado, preparado, marcacao) {
+    const lido = lerRelatorioJUnit(preparado);
+    if (!lido.relatorio)
+        return { ...resultado, junit: lido.evidencia };
+    if (resultado.ok)
+        return { ...resultado, junit: lido.evidencia };
+    const caidos = lido.relatorio.casos.filter((c) => c.estado === 'falhou' || c.estado === 'erro').map((c) => c.nome);
+    const base = { ...resultado, junit: lido.evidencia, testeQueCaiu: caidos,
+        falhasDeTeste: caidos.map((nome) => ({ nome, relogio: casoMedeRelogio(nome, marcacao) })) };
+    if (caidos.length > 0)
+        return base;
+    const { testeQueCaiu: _testes, falhasDeTeste: _falhas, ...semNomes } = base;
+    return semNomes;
+}

package/dist/locale-verify.js

@@ -54,6 +54,9 @@ exports.VERIFY_PT_BR = {
     agile: (reaproveitadas, inteiras, paralelo, lanes) => `  agile       ${reaproveitadas} comando(s) de claim contra o produto do preparo, ${inteiras} inteiro(s); ` +
         `${paralelo ? `grupo em paralelo${lanes.length ? ` com as lanes ${lanes.join(', ')}` : ''}` : 'comandos do manifesto em serie'}`,
     agileFallback: (peca, motivo, fallback) => `  fallback    ${peca}: ${motivo || 'sem motivo dito'}; rodou ${fallback || 'o equivalente do Classic'}`,
+    agileDegradado: (peca, motivo) => `  degradado   ${peca}: ${motivo || 'sem motivo dito'}; preservou o plano paralelo`,
+    agilePeca: (peca, motivo) => `  agile       ${peca}: ${motivo || 'sem motivo dito'}`,
+    reservaIntegracao: (cpus, fonte) => `reserva da integracao ${cpus} CPU(s), origem ${{ medida: 'medida', conservadora: 'conservadora', classic: 'Classic' }[fonte]}`,
     preparo: (situacao, segundos, alterado) => `  preparo     ${situacao} em ` +
         `${segundos} s, uma vez para a rodada; produto ` +
         `${alterado ? 'MUDOU no meio da rodada: nenhum veredito vale' : 'conferido do preparo ao fim'}`,
@@ -73,6 +76,21 @@ exports.VERIFY_PT_BR = {
     comandosDoManifesto: 'Comandos de verify do manifesto:',
     comandoOk: 'ok',
     comando: (nome, situacao, comando) => `  ${nome.padEnd(10)} ${situacao}  ${comando}`,
+    rodadaParcial: (testes) => `             rodada PARCIAL; teste(s) filtrado(s): ${testes}`,
+    selecaoDaLane: (lane, modo, motivo, arquivos) => {
+        const razoes = {
+            'rodada-fria': 'rodada fria', 'cache-ausente': 'cache anterior ausente', 'cache-invalido': 'cache anterior invalido',
+            'base-mudou': 'base mudou', 'manifesto-mudou': 'manifesto mudou', 'lockfile-mudou': 'lockfile mudou',
+            'configuracao-mudou': 'configuracao do runner mudou', 'fora-do-mapeamento': 'mudanca fora do mapeamento do runner',
+            'runner-sem-garantia': 'runner sem garantia declarada', 'sem-mudancas': 'nenhuma mudanca verificavel',
+            selecionada: 'cache valido e mudancas mapeadas',
+        };
+        return `             lane ${lane} ${modo === 'selecionada' ? 'SELECIONADA' : 'INTEIRA'}: ` +
+            `${razoes[motivo] ?? motivo}${arquivos ? ` (${arquivos})` : ''}`;
+    },
+    retesteDeRelogio: (testes, steal, estado, code) => `             relogio protegido: ${testes}; steal ${steal}%; segunda rodada ${estado === 'sem-filtro'
+        ? 'nao executada (filtro ausente)' : estado === 'sem-veredito' ? `sem veredito (codigo ${code ?? 'ausente'})`
+        : `${estado} (codigo ${code ?? 'ausente'})`}`,
     testesQueCairam: (testes) => `             teste(s) que caiu(ram): ${testes}`,
     estourou: (prazo, rodou) => `ESTOUROU O PRAZO (${prazo}, rodou ${rodou})`,
     relogioSobSteal: (pct, limiar) => `RELOGIO SOB STEAL (${pct}% de steal, acima de ${limiar}%)`,
@@ -155,6 +173,10 @@ exports.VERIFY_EN = {
     agile: (reaproveitadas, inteiras, paralelo, lanes) => `  agile       ${reaproveitadas} claim command(s) against the prepared product, ${inteiras} in full; ` +
         `${paralelo ? `parallel group${lanes.length ? ` with lanes ${lanes.join(', ')}` : ''}` : 'manifest commands in series'}`,
     agileFallback: (peca, motivo, fallback) => `  fallback    ${peca}: ${motivo || 'no reason given'}; ran ${fallback || 'the Classic equivalent'}`,
+    agileDegradado: (peca, motivo) => `  degraded    ${peca}: ${motivo || 'no reason given'}; kept the parallel plan`,
+    agilePeca: (peca, motivo) => `  agile       ${peca}: ${motivo || 'no reason given'}`,
+    reservaIntegracao: (cpus, fonte) => `integration reservation ${cpus} CPU(s), ` +
+        `source ${{ medida: 'measured', conservadora: 'conservative', classic: 'Classic' }[fonte]}`,
     preparo: (situacao, segundos, alterado) => `  prepare     ${situacao} in ${segundos} s, once for the run; product ` +
         `${alterado ? 'CHANGED during the run: no verdict counts' : 'checked from prepare to end'}`,
     stealMedido: (pct, fonte, limiar) => `  steal       ${pct}% in the run (${fonte}; above ${limiar}%, a failing clock-bound test gets no verdict)`,
@@ -171,6 +193,21 @@ exports.VERIFY_EN = {
     comandosDoManifesto: 'Manifest verify commands:',
     comandoOk: 'ok',
     comando: (nome, situacao, comando) => `  ${nome.padEnd(10)} ${situacao}  ${comando}`,
+    rodadaParcial: (testes) => `             PARTIAL run; filtered test(s): ${testes}`,
+    selecaoDaLane: (lane, modo, motivo, arquivos) => {
+        const razoes = {
+            'rodada-fria': 'cold run', 'cache-ausente': 'previous cache missing', 'cache-invalido': 'previous cache invalid',
+            'base-mudou': 'base changed', 'manifesto-mudou': 'manifest changed', 'lockfile-mudou': 'lockfile changed',
+            'configuracao-mudou': 'runner configuration changed', 'fora-do-mapeamento': 'change outside runner mapping',
+            'runner-sem-garantia': 'runner has no declared guarantee', 'sem-mudancas': 'no verifiable changes',
+            selecionada: 'valid cache and mapped changes',
+        };
+        return `             lane ${lane} ${modo === 'selecionada' ? 'SELECTED' : 'FULL'}: ` +
+            `${razoes[motivo] ?? motivo}${arquivos ? ` (${arquivos})` : ''}`;
+    },
+    retesteDeRelogio: (testes, steal, estado, code) => `             protected clock test(s): ${testes}; ${steal}% steal; second run ${estado === 'sem-filtro'
+        ? 'not run (no filter)' : estado === 'sem-veredito' ? `had no verdict (exit ${code ?? 'missing'})`
+        : `${estado === 'passou' ? 'passed' : 'failed'} (exit ${code ?? 'missing'})`}`,
     testesQueCairam: (testes) => `             failing test(s): ${testes}`,
     estourou: (prazo, rodou) => `TIMED OUT (${prazo}, ran ${rodou})`,
     relogioSobSteal: (pct, limiar) => `CLOCK UNDER STEAL (${pct}% steal, above ${limiar}%)`,