@orkastery/cli 0.6.4 → 0.6.6

package/dist/verify.js

@@ -56,15 +56,23 @@ exports.executorDoManifesto = executorDoManifesto;
 exports.executar = executar;
 exports.resultadoDoProcesso = resultadoDoProcesso;
 exports.semVereditoPorTempo = semVereditoPorTempo;
+exports.resultadoComSteal = resultadoComSteal;
 exports.executorComSteal = executorComSteal;
+exports.executorComJUnit = executorComJUnit;
 exports.identidadeDoProduto = identidadeDoProduto;
 exports.causaDoEncerramento = causaDoEncerramento;
 exports.comandoNoLedger = comandoNoLedger;
+exports.filtroDoComandoNoManifesto = filtroDoComandoNoManifesto;
 exports.comandosDoManifesto = comandosDoManifesto;
+exports.comandoComTestesFiltrados = comandoComTestesFiltrados;
+exports.executarComFiltro = executarComFiltro;
+exports.executarPassagemParcial = executarPassagemParcial;
+exports.selecaoDaRodadaAnterior = selecaoDaRodadaAnterior;
 exports.cwdDaThread = cwdDaThread;
 exports.commitReal = commitReal;
 exports.executorDaRodada = executorDaRodada;
 exports.ambienteDoModo = ambienteDoModo;
+exports.pecaDoAgendadorCpu = pecaDoAgendadorCpu;
 exports.vereditoDaBaseline = vereditoDaBaseline;
 exports.gravarBaseline = gravarBaseline;
 exports.verificarClaim = verificarClaim;
@@ -100,6 +108,8 @@ const check_agil_1 = require("./check-agil");
 const check_paralelo_1 = require("./check-paralelo");
 const agendador_cpu_1 = require("./agendador-cpu");
 const changelog_check_1 = require("./changelog-check");
+const junit_1 = require("./junit");
+const check_selecao_1 = require("./check-selecao");
 /** Teto de tempo de um comando de verificacao (build e suite completa cabem). */
 exports.TIMEOUT_VERIFY_MS = 10 * 60 * 1000;
 /** Ultimas linhas da saida real, o suficiente para servir de evidencia no ledger. */
@@ -125,7 +135,7 @@ exports.PREFIXO_BLOQUEADO_NO_VERIFY = 'ORK_HITL_';
  * rodada (o verify que roda dentro de um comando de outro verify), elas levariam pecas ao relatorio errado.
  */
 const VARIAVEIS_DA_RODADA = new Set([
-    check_modo_1.ENV_RELATORIO_DO_CHECK, check_modo_1.ENV_VARREDURA_PARALELA_DO_CHECK, agendador_cpu_1.ENV_CPUS_DA_LANE, agendador_cpu_1.ENV_CPUS_DOCKER,
+    check_modo_1.ENV_RELATORIO_DO_CHECK, check_modo_1.ENV_VARREDURA_PARALELA_DO_CHECK, agendador_cpu_1.ENV_CPUS_DA_LANE, agendador_cpu_1.ENV_CPUS_DOCKER, agendador_cpu_1.ENV_WORKERS,
 ]);
 function ambienteDoVerify(base = process.env) {
     return Object.fromEntries(Object.entries(base).filter(([chave]) => !chave.startsWith(exports.PREFIXO_BLOQUEADO_NO_VERIFY)
@@ -234,23 +244,43 @@ function resultadoDoProcesso(nome, comando, r, comGrupo, duracaoMs, tetoMs) {
 function semVereditoPorTempo(c) {
     return c.causa === 'timeout' || (c.relogioSobSteal?.length ?? 0) > 0;
 }
-/**
- * RM-037 (fatia 6): mede o steal na janela de cada comando e marca a reprovacao que foi so de teste com
- * relogio sob steal alto. Os testes de relogio sao os da assinatura de prazo do runner e os do registro
- * de instabilidade vigente. Comando que passou, estourou ou nem rodou so ganha a medida.
- */
-function executorComSteal(base, leitor = steal_1.lerProcStat, registro = new Set()) {
+function reciboDoReteste(testes, resultado) {
+    if (!resultado)
+        return { testes: [...testes], estado: 'sem-filtro' };
+    if (resultado.executado === false || resultado.causa === 'timeout') {
+        return { testes: [...testes], estado: 'sem-veredito', code: resultado.code };
+    }
+    return { testes: [...testes], estado: resultado.ok ? 'passou' : 'reprovou', code: resultado.code };
+}
+/** Aplica a medida a um resultado ja enriquecido pelo JUnit e, quando cabivel, registra o reteste isolado. */
+function resultadoComSteal(r, stealPct, registro, retestar) {
+    const resultado = { ...r, stealPct };
+    if (!r.ok && r.causa !== 'timeout' && r.executado !== false && (0, steal_1.stealAlto)(stealPct)) {
+        const testes = (0, steal_1.reprovacaoSoDeRelogio)(r.falhasDeTeste, registro);
+        if (testes) {
+            resultado.relogioSobSteal = testes;
+            if (retestar)
+                resultado.retesteDeRelogio = reciboDoReteste(testes, retestar(testes));
+        }
+    }
+    return resultado;
+}
+function executorComSteal(base, leitor = steal_1.lerProcStat, registro = new Set(), retestar) {
     return (nome, comando, cwd) => {
         const janela = (0, steal_1.abrirJanela)(leitor);
         const r = base(nome, comando, cwd);
         const stealPct = janela.fechar();
-        const resultado = { ...r, stealPct };
-        if (!r.ok && r.causa !== 'timeout' && r.executado !== false && (0, steal_1.stealAlto)(stealPct)) {
-            const testes = (0, steal_1.reprovacaoSoDeRelogio)(r.falhasDeTeste, registro);
-            if (testes)
-                resultado.relogioSobSteal = testes;
-        }
-        return resultado;
+        return resultadoComSteal(r, stealPct, registro, retestar ? (testes) => retestar(nome, comando, cwd, testes) : undefined);
+    };
+}
+/** RM-081 F1: o relatorio e preparado antes e anexado depois, sem alterar o codigo de saida observado. */
+function executorComJUnit(base, manifesto) {
+    return (nome, comando, cwd) => {
+        const caminho = (0, junit_1.caminhoJUnitDoComando)(manifesto, nome);
+        if (!caminho)
+            return base(nome, comando, cwd);
+        const preparado = (0, junit_1.prepararRelatorioJUnit)(cwd, caminho);
+        return (0, junit_1.anexarRelatorioJUnit)(base(nome, comando, cwd), preparado, (0, junit_1.marcacaoDeRelogioDoComando)(manifesto, nome));
     };
 }
 /** I-54 (D11): erros de spawn em que o processo nem chegou a existir. */
@@ -305,8 +335,12 @@ function comandoNoLedger(c) {
     // no Agile, o uso do preparo e as lanes; o Classic nao tem esses campos.
     const doAgile = { ...(c.preparo ? { preparo: c.preparo } : {}),
         ...(c.lane ? { lane: c.lane } : {}),
-        ...(c.lanes ? { lanes: c.lanes.map((l) => ({ ...l, comando: (0, redacao_url_1.redigirCredenciaisUrl)(l.comando) })) } : {}),
-        ...(c.comandoExecutado ? { comandoExecutado: (0, redacao_url_1.redigirCredenciaisUrl)(c.comandoExecutado) } : {}) };
+        ...(c.lanes ? { lanes: c.lanes.map((l) => ({ ...l, comando: (0, redacao_url_1.redigirCredenciaisUrl)(l.comando),
+                ...(l.comandoExecutado ? { comandoExecutado: (0, redacao_url_1.redigirCredenciaisUrl)(l.comandoExecutado) } : {}) })) } : {}),
+        ...(c.comandoExecutado ? { comandoExecutado: (0, redacao_url_1.redigirCredenciaisUrl)(c.comandoExecutado) } : {}),
+        ...(c.parcial ? { parcial: c.parcial } : {}),
+        ...(c.junit ? { junit: c.junit } : {}),
+        ...(c.retesteDeRelogio ? { retesteDeRelogio: c.retesteDeRelogio } : {}) };
     if (c.ok)
         return { nome: c.nome, ok: true, code: c.code, ...(c.duracaoMs !== undefined ? { duracaoMs: c.duracaoMs } : {}), ...doAgile };
     return {
@@ -320,16 +354,89 @@ function comandoNoLedger(c) {
         ...(c.relogioSobSteal?.length ? { relogioSobSteal: c.relogioSobSteal } : {}),
     };
 }
-/** Comandos declarados em `verify:` no manifesto, na ordem canonica. */
+/** O filtro nominal da F3 para o mesmo comando/lane; F2 nao cria uma segunda selecao. */
+function filtroDoComandoNoManifesto(manifesto, nome) {
+    if (nome.startsWith('test:'))
+        return manifesto.check?.agile?.filtro?.[nome.slice('test:'.length)];
+    return manifesto.verify.filtro?.[nome];
+}
 function comandosDoManifesto(manifesto) {
     const lista = [];
     for (const nome of ['typecheck', 'build', 'test', 'security_scan']) {
         const comando = manifesto.verify[nome];
         if (comando && comando.trim() !== '')
-            lista.push({ nome, comando });
+            lista.push({ nome, comando,
+                ...(manifesto.verify.junit?.[nome] ? { junit: manifesto.verify.junit[nome] } : {}),
+                ...(manifesto.verify.filtro?.[nome] ? { filtro: manifesto.verify.filtro[nome] } : {}) });
     }
     return lista;
 }
+/** Um argumento por nome, sem deixar metacaractere do JUnit virar sintaxe do shell. */
+function argumentoDoFiltro(nome) {
+    return `'${nome.replace(/'/g, `'"'"'`)}'`;
+}
+/** RM-081 F3: expande o unico marcador validado pelo manifesto. */
+function comandoComTestesFiltrados(filtro, testes) {
+    return filtro.replace('{testes}', testes.map(argumentoDoFiltro).join(' '));
+}
+/**
+ * Roda a passagem parcial e so segue para o comando integral quando ela fica verde. O resultado
+ * parcial conserva `comando` como o contrato integral e guarda em `comandoExecutado` o que rodou.
+ */
+function executarComFiltro(nome, comando, cwd, executor, filtro, testes) {
+    const parcial = executarPassagemParcial(nome, comando, cwd, executor, filtro, testes);
+    if (!parcial)
+        return executor(nome, comando, cwd);
+    if (parcial.ok)
+        return executor(nome, comando, cwd);
+    return parcial;
+}
+/** Uma passagem parcial isolada; o Agile decide depois se inclui a suite completa no grupo. */
+function executarPassagemParcial(nome, comando, cwd, executor, filtro, testes) {
+    if (!filtro || !testes?.length)
+        return null;
+    const filtrado = comandoComTestesFiltrados(filtro, testes);
+    return { ...executor(nome, filtrado, cwd), comando, comandoExecutado: filtrado, parcial: { testes: [...testes] } };
+}
+function objeto(v) {
+    return v && typeof v === 'object' && !Array.isArray(v) ? v : null;
+}
+function nomesPersistidos(v) {
+    return Array.isArray(v) ? [...new Set(v.filter((x) => typeof x === 'string' && !!x))] : [];
+}
+/**
+ * So o ultimo verify_run da thread vale. Comando, JUnit lido e nomes precisam conferir; uma
+ * baseline, um stdout heuristico ou um comando antigo nunca autorizam reduzir a cobertura.
+ */
+function selecaoDaRodadaAnterior(eventos, manifesto) {
+    const rodada = [...eventos].reverse().find((e) => e.tipo === ledger_1.TIPOS_DE_EVENTO.verificacao);
+    const comandos = {}, lanes = {};
+    if (!rodada || !Array.isArray(rodada.comandos))
+        return { comandos, lanes };
+    for (const atual of comandosDoManifesto(manifesto)) {
+        if (!atual.filtro || !atual.junit)
+            continue;
+        const anterior = rodada.comandos.map(objeto).find((c) => c?.nome === atual.nome);
+        const junit = objeto(anterior?.junit);
+        const nomes = nomesPersistidos(anterior?.testeQueCaiu);
+        if (anterior?.ok === false && anterior.comando === (0, redacao_url_1.redigirCredenciaisUrl)(atual.comando)
+            && junit?.estado === 'lido' && nomes.length > 0)
+            comandos[atual.nome] = nomes;
+    }
+    const anteriorTest = rodada.comandos.map(objeto).find((c) => c?.nome === 'test');
+    const lanesAnteriores = Array.isArray(anteriorTest?.lanes) ? anteriorTest.lanes.map(objeto) : [];
+    for (const [lane, comando] of Object.entries(manifesto.check?.agile?.test ?? {})) {
+        if (!manifesto.check?.agile?.filtro?.[lane] || !manifesto.check.agile.junit?.[lane])
+            continue;
+        const anterior = lanesAnteriores.find((l) => l?.lane === lane);
+        const junit = objeto(anterior?.junit);
+        const nomes = nomesPersistidos(anterior?.testeQueCaiu);
+        if (anterior?.ok === false && anterior.comando === (0, redacao_url_1.redigirCredenciaisUrl)(comando)
+            && junit?.estado === 'lido' && nomes.length > 0)
+            lanes[lane] = nomes;
+    }
+    return { comandos, lanes };
+}
 /** A regra estrutural do CHANGELOG entra no mesmo veredito e na mesma baseline dos comandos do manifesto. */
 function verificarChangelog(cwd, base, baseCarimbada) {
     if (!(0, changelog_check_1.changelogAplicavel)(cwd))
@@ -398,11 +505,15 @@ function executorSobConducao(base, manifesto, conducao) {
  * falhava" com o manifesto dando 2400 s.
  */
 function executorDaRodada(manifesto, instabilidade, base, leitor = steal_1.lerProcStat, ambienteDaRodada) {
-    return executorComSteal(base ?? executorDoManifesto(manifesto, ambienteDaRodada), leitor, (0, instabilidade_1.testesDeRelogioVigentes)(instabilidade));
+    const comJUnit = executorComJUnit(base ?? executorDoManifesto(manifesto, ambienteDaRodada), manifesto);
+    return executorComSteal(comJUnit, leitor, (0, instabilidade_1.testesDeRelogioVigentes)(instabilidade), (nome, _comando, cwd, testes) => {
+        const filtro = filtroDoComandoNoManifesto(manifesto, nome);
+        return filtro ? comJUnit(nome, comandoComTestesFiltrados(filtro, testes), cwd) : null;
+    });
 }
 /** RM-072 (D2): o que a rodada passa a todo comando dela, nos dois modos: o modo do CHECK. */
 function ambienteDoModo(check) {
-    return { [check_modo_1.ENV_MODO_DO_CHECK]: check.modo };
+    return { [check_modo_1.ENV_MODO_DO_CHECK]: check.modo, [agendador_cpu_1.ENV_WORKERS]: String((0, agendador_cpu_1.workersDaReserva)(os.availableParallelism())) };
 }
 /** RM-072 (D1, D2): o modo da rodada, como vai ao ledger. */
 function checkNoLedger(check) {
@@ -428,6 +539,28 @@ function soAVarreduraEAsLanesComRelatorio(comRelatorio, semRelatorio) {
  * cada um com o prazo e o ambiente que o `executorDoManifesto` daria a ele (o do scan com o prazo interno), o steal medido
  * na janela do grupo e a conducao renovada com o maior prazo. Com executor injetado (MCP, testes), um por vez, por ele.
  */
+/** A evidencia publica do plano: estado, capacidade usada, amostras e, no fallback, o equivalente do Classic. */
+function pecaDoAgendadorCpu(p) {
+    const medida = p.medicaoCpuIntegracao;
+    const evidencia = medida
+        ? `; CPU da integracao: arvore ${Math.round(medida.arvoreMs)} ms + conteineres ${Math.round(medida.containersMs)} ms` +
+            ` = ${Math.round(medida.totalMs)} ms, pico da arvore ${medida.picoCpusDaArvore ?? 'indisponivel'} CPU ` +
+            `(${medida.arvoreCompleta ? 'arvore completa' : medida.anomaliaDaArvore
+                ? `arvore anomala: ${medida.anomaliaDaArvore}` : 'arvore incompleta'}), pico total ${medida.picoCpus ?? 'indisponivel'} CPU, ` +
+            (medida.completa ? 'medida completa' : medida.anomalia
+                ? `medida anomala (${medida.anomalia})`
+                : `medida incompleta (${medida.motivosDosAusentes.map((x) => `${x.container}: ${x.motivo}`).join('; ')})`)
+        : '';
+    return { peca: 'agendador-cpu', estado: p.estado,
+        motivo: p.saturado
+            ? `${p.motivo}; hermetica com ${p.cpusHermetica}/${p.capacidadeEfetiva} CPUs, varredura e integracao depois dela`
+            : `${p.motivo}; ${p.cpusHermetica}/${p.capacidadeEfetiva} CPUs na hermetica; depois da varredura ` +
+                `${p.cpusHermeticaAposVarredura} e depois da integracao ${p.cpusHermeticaAposReserva}; integracao ` +
+                `${p.integracaoEmParalelo ? 'em paralelo com a varredura' : 'encadeada depois da varredura'}; ` +
+                `conteineres com ${p.cpusPorContainer} CPU${evidencia}`,
+        reservaIntegracao: { cpus: p.cpusIntegracao, fonte: p.fonteCpusIntegracao },
+        ...(p.saturado ? { fallback: 'ordem do Classic para hermetica, varredura e integracao' } : {}) };
+}
 function executorDoGrupo(manifesto, ambienteDaRodada, instabilidade, leitor, conducao, injetado, medicaoCpu) {
     if (injetado)
         return (itens, cwd) => itens.map((i) => injetado(i.nome, i.comando, cwd));
@@ -435,9 +568,11 @@ function executorDoGrupo(manifesto, ambienteDaRodada, instabilidade, leitor, con
     // N5 do CHECK 3: no grupo, como em serie, so a varredura e as lanes recebem o relatorio da rodada.
     const { [check_modo_1.ENV_RELATORIO_DO_CHECK]: _relatorio, ...semRelatorio } = ambienteDaRodada;
     const executar = ((itens, cwd) => {
+        const relatorios = itens.map((i) => i.junit ? (0, junit_1.prepararRelatorioJUnit)(cwd, i.junit) : null);
         const prazos = itens.map((i) => prazoDaExecucao(manifesto, i.nome, i.comando));
         const paraOAuxiliar = itens.map((i, k) => ({ nome: i.nome, comando: i.comando, cwd, prazoMs: prazos[k],
             ...(i.nice ? { nice: i.nice } : {}), ...(i.apos?.length ? { apos: i.apos } : {}), ...(i.papelCpu ? { papelCpu: i.papelCpu } : {}),
+            ...(i.recursos?.length ? { recursos: i.recursos } : {}),
             ambiente: { ...(recebeORelatorio(i.nome) ? ambienteDaRodada : semRelatorio), ...(ehComandoDoScan(manifesto, i.nome, i.comando)
                     // RM-072: ao lado das lanes, a varredura roda poucas ferramentas por vez, para o grupo nao passar da CPU.
                     ? { ORK_SECURITY_SCAN_DEADLINE_MS: String(prazoInternoDoScan(prazos[k])),
@@ -447,36 +582,23 @@ function executorDoGrupo(manifesto, ambienteDaRodada, instabilidade, leitor, con
         const janela = (0, steal_1.abrirJanela)(leitor);
         const processos = (0, check_paralelo_1.rodarEmParalelo)(paraOAuxiliar, ambienteDoVerify(), medicaoCpu ? { medicaoCpu } : {});
         if (processos.agendamentoCpu) {
-            const p = processos.agendamentoCpu;
-            const medida = p.medicaoCpuIntegracao;
-            const evidencia = medida
-                ? `; CPU da integracao: arvore ${Math.round(medida.arvoreMs)} ms + conteineres ${Math.round(medida.containersMs)} ms` +
-                    ` = ${Math.round(medida.totalMs)} ms, pico ${medida.picoCpus ?? 'indisponivel'} CPU, ` +
-                    (medida.completa ? 'medida completa' : medida.anomalia
-                        ? `medida anomala (${medida.anomalia})`
-                        : `medida incompleta (${medida.motivosDosAusentes.map((x) => `${x.container}: ${x.motivo}`).join('; ')})`)
-                : '';
-            executar.pecas = [{ peca: 'agendador-cpu', estado: p.saturado ? 'fallback' : 'agile',
-                    motivo: p.saturado
-                        ? `${p.motivo}; hermetica com ${p.cpusHermetica}/${p.cpus} CPUs, varredura e integracao depois dela`
-                        : `${p.cpusHermetica}/${p.cpus} CPUs na hermetica; depois da varredura ${p.cpusHermeticaAposVarredura}` +
-                            ` e depois da integracao ${p.cpusHermeticaAposReserva}; reserva da integracao ${p.fonteCpusIntegracao}` +
-                            ` (${p.cpusIntegracao} CPU), ${p.integracaoEmParalelo ? 'em paralelo com a varredura' : 'encadeada depois da varredura'}` +
-                            `; conteineres com ${p.cpusPorContainer} CPU${evidencia}`,
-                    ...(p.saturado ? { fallback: 'ordem do Classic para hermetica, varredura e integracao' } : {}) }];
+            executar.pecas = [pecaDoAgendadorCpu(processos.agendamentoCpu)];
         }
         const stealPct = janela.fechar();
         return processos.map((p, k) => {
-            const r = { ...resultadoDoProcesso(itens[k].nome, itens[k].comando, p, p.comGrupo, p.duracaoMs, prazos[k]), stealPct };
+            let r = { ...resultadoDoProcesso(itens[k].nome, itens[k].comando, p, p.comGrupo, p.duracaoMs, prazos[k]), stealPct };
+            if (relatorios[k])
+                r = (0, junit_1.anexarRelatorioJUnit)(r, relatorios[k], (0, junit_1.marcacaoDeRelogioDoComando)(manifesto, itens[k].nome));
             // S1 do CHECK: o auxiliar que morreu sem gravar o resultado deixa o comando sem veredito, nunca uma regressao.
             if (p.semResultado)
                 r.executado = false;
-            if (!r.ok && r.causa !== 'timeout' && r.executado !== false && (0, steal_1.stealAlto)(stealPct)) {
-                const testes = (0, steal_1.reprovacaoSoDeRelogio)(r.falhasDeTeste, relogio);
-                if (testes)
-                    r.relogioSobSteal = testes;
-            }
-            return r;
+            return resultadoComSteal(r, stealPct, relogio, (testes) => {
+                if (!itens[k].filtro)
+                    return null;
+                const filtrado = comandoComTestesFiltrados(itens[k].filtro, testes);
+                const executarReteste = executorSobConducao(executorComJUnit(executorDoManifesto(manifesto, paraOAuxiliar[k].ambiente), manifesto), manifesto, conducao);
+                return executarReteste(itens[k].nome, filtrado, cwd);
+            });
         });
     });
     executar.pecas = [];
@@ -616,6 +738,7 @@ function gravarBaselineSobConducao(carregado, threadId, base, tomada, origem, le
         comandos: comandos.map((c) => ({ nome: c.nome, comando: c.comando, ok: c.ok, code: c.code, prazoMs: c.prazoMs ?? null,
             ...(c.duracaoMs !== undefined ? { duracaoMs: c.duracaoMs } : {}), ...(c.ok ? {} : { causa: c.causa ?? null }),
             ...(c.testeQueCaiu?.length ? { testeQueCaiu: c.testeQueCaiu } : {}),
+            ...(c.junit ? { junit: c.junit } : {}),
             ...(c.lanes?.length ? { lanes: c.lanes.map((l) => ({ ...l, comando: (0, redacao_url_1.redigirCredenciaisUrl)(l.comando) })) } : {}) })),
         check: checkNoLedger(check),
         ...(pecasDaBaseline.length ? { agile: { pecas: pecasDaBaseline } } : {}),
@@ -726,8 +849,11 @@ function verificarSobConducao(carregado, threadId, opcoes, conducao, canal, fila
     exigirDependenciasDaWorktree(carregado, threadId, cwd, 'verify', conducao, opcoes.executor);
     const commit = commitReal(cwd);
     const dir = (0, thread_1.dirThread)(raiz, threadId);
+    const eventos = (0, ledger_1.lerLedger)(dir);
+    const selecaoAnterior = selecaoDaRodadaAnterior(eventos, manifesto);
     // RM-072 (D1): o modo da rodada; a opcao vence o manifesto, que vence o padrao.
     const check = (0, check_modo_1.resolverModo)(manifesto.check?.mode, opcoes.check);
+    const selecaoPorMudanca = (0, check_selecao_1.planejarSelecaoNativa)(cwd, manifesto, eventos, commit, check.modo);
     // I-43 (D4, viga b): os criterios de pronto da thread viram claims do nucleo ANTES
     // da reexecucao, para entrarem no MESMO veredito das demais alegacoes. Idempotente:
     // `ork verify` roda em toda fase, e uma claim por criterio por rodada viraria
@@ -807,7 +933,7 @@ function verificarSobConducao(carregado, threadId, opcoes, conducao, canal, fila
     const grupoAntesDasClaims = !opcoes.soClaims && !!vigente && vigente.guarda.conferir() === null
         && Object.keys(manifesto.check?.agile?.test ?? {}).length > 0;
     let comandosDoManifestoExecutados = grupoAntesDasClaims
-        ? (opcoes.progresso?.('grupo-agile'), doAgile = (0, check_agil_1.comandosNoAgile)(manifesto, cwd, comandosDoManifesto(manifesto), executorDosComandos, executorDoGrupo(manifesto, ambienteDaRodada, instabilidade, leitor, conducao, opcoes.executor ? executor : undefined, opcoes.medicaoCpuAgendador), vigente.guarda, vigente.preparo)).comandos
+        ? (opcoes.progresso?.('grupo-agile'), doAgile = (0, check_agil_1.comandosNoAgile)(manifesto, cwd, comandosDoManifesto(manifesto), executorDosComandos, executorDoGrupo(manifesto, ambienteDaRodada, instabilidade, leitor, conducao, opcoes.executor ? executor : undefined, opcoes.medicaoCpuAgendador), vigente.guarda, vigente.preparo, selecaoAnterior, (nome, comando, dir, filtro, testes) => executarPassagemParcial(nome, comando, dir, executorDosComandos, filtro, testes), selecaoPorMudanca.lanes)).comandos
         : [];
     if (doAgile)
         pecas.push(...doAgile.pecas);
@@ -842,14 +968,14 @@ function verificarSobConducao(carregado, threadId, opcoes, conducao, canal, fila
         if (guardaDepoisDasClaims === 'produto-mudou')
             refazer('depois das claims');
         opcoes.progresso?.('grupo-agile');
-        doAgile = (0, check_agil_1.comandosNoAgile)(manifesto, cwd, comandosDoManifesto(manifesto), executorDosComandos, executorDoGrupo(manifesto, ambienteDaRodada, instabilidade, leitor, conducao, opcoes.executor ? executor : undefined, opcoes.medicaoCpuAgendador), vigente.guarda, vigente.preparo);
+        doAgile = (0, check_agil_1.comandosNoAgile)(manifesto, cwd, comandosDoManifesto(manifesto), executorDosComandos, executorDoGrupo(manifesto, ambienteDaRodada, instabilidade, leitor, conducao, opcoes.executor ? executor : undefined, opcoes.medicaoCpuAgendador), vigente.guarda, vigente.preparo, selecaoAnterior, (nome, comando, dir, filtro, testes) => executarPassagemParcial(nome, comando, dir, executorDosComandos, filtro, testes), selecaoPorMudanca.lanes);
         comandosDoManifestoExecutados = doAgile.comandos;
         pecas.push(...doAgile.pecas);
     }
     if (!opcoes.soClaims && !grupoAntesDasClaims) {
         comandosDoManifestoExecutados = vigente
-            ? (opcoes.progresso?.('grupo-agile'), doAgile = (0, check_agil_1.comandosNoAgile)(manifesto, cwd, comandosDoManifesto(manifesto), executorDosComandos, executorDoGrupo(manifesto, ambienteDaRodada, instabilidade, leitor, conducao, opcoes.executor ? executor : undefined, opcoes.medicaoCpuAgendador), vigente.guarda, vigente.preparo)).comandos
-            : comandosDoManifesto(manifesto).map((c) => executorDosComandos(c.nome, c.comando, cwd));
+            ? (opcoes.progresso?.('grupo-agile'), doAgile = (0, check_agil_1.comandosNoAgile)(manifesto, cwd, comandosDoManifesto(manifesto), executorDosComandos, executorDoGrupo(manifesto, ambienteDaRodada, instabilidade, leitor, conducao, opcoes.executor ? executor : undefined, opcoes.medicaoCpuAgendador), vigente.guarda, vigente.preparo, selecaoAnterior, (nome, comando, dir, filtro, testes) => executarPassagemParcial(nome, comando, dir, executorDosComandos, filtro, testes), selecaoPorMudanca.lanes)).comandos
+            : comandosDoManifesto(manifesto).map((c) => executarComFiltro(c.nome, c.comando, cwd, executorDosComandos, c.filtro, selecaoAnterior.comandos[c.nome]));
         if (doAgile)
             pecas.push(...doAgile.pecas);
     }
@@ -857,6 +983,7 @@ function verificarSobConducao(carregado, threadId, opcoes, conducao, canal, fila
         : verificarChangelog(cwd, manifesto.worktree.base_branch, thread.base?.commit);
     const comandos = opcoes.soClaims ? []
         : changelog ? [...comandosDoManifestoExecutados, changelog] : comandosDoManifestoExecutados;
+    const parcial = comandos.some((c) => !!c.parcial || c.lanes?.some((l) => !!l.parcial));
     const resumoDoAgile = vigente ? agileNoLedger(raiz, threadId, commit, pecas, doAgile, vigente.guarda, relatorio, claims) : null;
     if (relatorio && !vigente)
         relatorio.fechar();
@@ -957,6 +1084,8 @@ function verificarSobConducao(carregado, threadId, opcoes, conducao, canal, fila
             };
         }),
         comandos: comandos.map(comandoNoLedger),
+        parcial,
+        ...(selecaoPorMudanca.cache ? { selecao: selecaoPorMudanca.cache } : {}),
         baseline: baseline ? { commit: baseline.commit, gravadaEm: baseline.gravadaEm } : null,
         regressoes: regressoes.map((r) => r.nome),
         preExistentes: preExistentes.map((r) => r.nome),
@@ -1007,7 +1136,8 @@ function verificarSobConducao(carregado, threadId, opcoes, conducao, canal, fila
                         : c.classificacaoDoComando === 'regressao' ? [c.comando] : []).join(', ')}`
                     : motivo === 'verify.timeout'
                         ? `sem veredito por tempo (prazo estourado, ou teste com relogio sob steal acima de ${steal_1.LIMIAR_STEAL_PCT}%): ${[
-                            ...estouros.map((r) => (0, check_agil_1.porQueDasLanes)(r) ? `${r.nome} (${(0, check_agil_1.porQueDasLanes)(r)})` : r.nome),
+                            ...estouros.map((r) => r.relogioSobSteal?.length ? motivoDoRelogioSobSteal(r)
+                                : (0, check_agil_1.porQueDasLanes)(r) ? `${r.nome} (${(0, check_agil_1.porQueDasLanes)(r)})` : r.nome),
                             ...claims.filter((c) => c.motivo === 'verify.timeout').map((c) => c.claim.id)
                         ].join(', ')}`
                         : motivo === 'verify.sem-veredito'
@@ -1059,6 +1189,7 @@ function verificarSobConducao(carregado, threadId, opcoes, conducao, canal, fila
         agile: resumoDoAgile,
         motivos,
         ok,
+        parcial,
     };
 }
 /**
@@ -1084,6 +1215,20 @@ function situacaoDoComando(c) {
         return m.mortoPorSinal(c.code);
     return m.falhou(c.code);
 }
+function resultadoDoReteste(c) {
+    const reteste = c.retesteDeRelogio;
+    if (!reteste)
+        return 'segunda rodada sem recibo';
+    if (reteste.estado === 'sem-filtro')
+        return 'segunda rodada nao executada: filtro ausente';
+    if (reteste.estado === 'sem-veredito')
+        return `segunda rodada sem veredito (codigo ${reteste.code ?? 'ausente'})`;
+    return `segunda rodada ${reteste.estado} (codigo ${reteste.code ?? 'ausente'})`;
+}
+function motivoDoRelogioSobSteal(c) {
+    return `${c.nome}: testes ${c.relogioSobSteal?.join(', ') ?? 'nao informados'}; steal ${c.stealPct ?? 'nao medido'}%; ` +
+        resultadoDoReteste(c);
+}
 /**
  * RM-037 (defeito 1 de 19 e 20/10/2026): as linhas de cada comando de `ork verify --baseline`, com o veredito dele, e a
  * linha que diz o que a baseline nao provou e como regravar.
@@ -1112,8 +1257,15 @@ function textoDoVerify(r) {
     if (a && (a.claims.reaproveitadas + a.claims.inteiras > 0 || a.grupo.paralelo)) {
         linhas.push(m.agile(a.claims.reaproveitadas, a.claims.inteiras, a.grupo.paralelo, a.grupo.lanes));
     }
+    const motivoDaPeca = (p) => [p.motivo,
+        p.reservaIntegracao ? m.reservaIntegracao(p.reservaIntegracao.cpus, p.reservaIntegracao.fonte) : null]
+        .filter((x) => !!x).join('; ');
     for (const p of a?.pecas.filter((x) => x.estado === 'fallback') ?? [])
-        linhas.push(m.agileFallback(p.peca, p.motivo ?? '', p.fallback ?? ''));
+        linhas.push(m.agileFallback(p.peca, motivoDaPeca(p), p.fallback ?? ''));
+    for (const p of a?.pecas.filter((x) => x.estado === 'degradado') ?? [])
+        linhas.push(m.agileDegradado(p.peca, motivoDaPeca(p)));
+    for (const p of a?.pecas.filter((x) => x.estado === 'agile' && x.reservaIntegracao) ?? [])
+        linhas.push(m.agilePeca(p.peca, motivoDaPeca(p)));
     linhas.push(r.baseline ? m.baseline((0, util_1.shaCurto)(r.baseline.commit), (0, horario_1.formatarDataHoraRotulada)(r.baseline.gravadaEm)) : m.semBaseline);
     if (r.preparo) {
         const p = r.preparo;
@@ -1143,8 +1295,19 @@ function textoDoVerify(r) {
         linhas.push(m.comandosDoManifesto);
         for (const c of r.comandos) {
             linhas.push(m.comando(c.nome, c.ok ? m.comandoOk : situacaoDoComando(c), c.comando));
-            if (!c.ok && c.testeQueCaiu?.length)
-                linhas.push(m.testesQueCairam(c.testeQueCaiu.join('; ')));
+            for (const lane of c.lanes ?? [])
+                if (lane.selecao) {
+                    linhas.push(m.selecaoDaLane(lane.lane, lane.selecao.modo, lane.selecao.motivo, lane.selecao.arquivos?.join('; ') ?? ''));
+                }
+            if (c.parcial?.testes.length)
+                linhas.push(m.rodadaParcial(c.parcial.testes.join('; ')));
+            if (c.retesteDeRelogio)
+                linhas.push(m.retesteDeRelogio(c.retesteDeRelogio.testes.join('; '), c.stealPct, c.retesteDeRelogio.estado, c.retesteDeRelogio.code));
+            if (!c.ok && c.testeQueCaiu?.length) {
+                const visiveis = c.junit?.estado === 'lido' ? c.testeQueCaiu.slice(0, 10) : c.testeQueCaiu;
+                const restante = c.testeQueCaiu.length - visiveis.length;
+                linhas.push(m.testesQueCairam(visiveis.join('; ') + (restante > 0 ? `; +${restante} no ledger` : '')));
+            }
         }
     }
     if (r.estouros.length > 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orkastery/cli",
-  "version": "0.6.4",
+  "version": "0.6.6",
   "description": "A software factory of AI agents that proves its work: parallel threads, verified results, and short decisions only when they matter.",
   "license": "MIT",
   "homepage": "https://github.com/orkastery/orkastery#readme",