@orkastery/cli 0.6.1 → 0.6.3

package/dist/verify.js

@@ -78,6 +78,7 @@ const thread_1 = require("./thread");
 const estado_thread_1 = require("./estado-thread");
 const dependencias_da_worktree_1 = require("./dependencias-da-worktree");
 const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
 const node_fs_1 = require("node:fs");
 const path = __importStar(require("node:path"));
 const node_path_1 = require("node:path");
@@ -98,6 +99,7 @@ const check_modo_1 = require("./check-modo");
 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");
 /** 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. */
@@ -302,6 +304,7 @@ function comandoNoLedger(c) {
     // RM-072 (D2): a duracao vai tambem no comando que passa, para a meta do CHECK ser medida pelo ledger. RM-072 (D4, D5):
     // 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) } : {}) };
     if (c.ok)
@@ -327,6 +330,19 @@ function comandosDoManifesto(manifesto) {
     }
     return lista;
 }
+/** 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))
+        return null;
+    const inicio = Date.now();
+    const comando = `node core/scripts/checar-changelog.cjs --base "${base}"`;
+    const r = (0, changelog_check_1.checarChangelog)(cwd, { base, head: 'HEAD', baseCarimbada });
+    return {
+        nome: 'changelog', comando, ok: r.ok, code: r.ok ? 0 : r.motivo === 'changelog.base-indisponivel' ? 2 : 1,
+        resumo: r.ok ? r.detalhe : `${r.motivo}: ${r.detalhe}\ncorrecao: ${r.correcao ?? 'corrija o CHANGELOG'}`,
+        causa: 'exit', prazoMs: 0, duracaoMs: Date.now() - inicio, executado: true,
+    };
+}
 /**
  * Diretorio onde a verificacao roda: a worktree da thread, ou a raiz do projeto. RM-047 (P2): a worktree
  * do `thread.json` so vale registrada no `git worktree list` e com o estado local (`estado.rastreado`,
@@ -464,12 +480,15 @@ function agileNoLedger(raiz, threadId, commit, pecasDoVerify, doAgile, guarda, r
     relatorio.fechar();
     const doRelatorio = (0, check_agil_1.pecasDoRelatorio)(linhas);
     const listas = (0, check_agil_1.listasDasLanes)(linhas);
+    const resultados = (0, check_agil_1.resultadosDasLanes)(linhas);
     const usos = claims.flatMap((c) => c.execucoes.map((e) => e.preparo).filter((u) => !!u));
+    const usosDasLanes = claims.flatMap((c) => c.execucoes.filter((e) => e.lane));
     const resumo = {
         pecas: [...pecasDoVerify, ...doRelatorio],
         grupo: { paralelo: doAgile?.paralelo ?? false, lanes: doAgile?.lanes ?? [] },
         produto: guarda.hashCurto(),
-        claims: { reaproveitadas: usos.filter((u) => u.reaproveitado).length, inteiras: usos.filter((u) => !u.reaproveitado).length },
+        claims: { reaproveitadas: usos.filter((u) => u.reaproveitado).length, inteiras: usos.filter((u) => !u.reaproveitado).length,
+            lanes: usosDasLanes.length },
         lanes: listas.map((l) => ({ lane: l.lane, arquivos: l.arquivos.length, sha256: l.sha256 })),
         orcamento: linhas.filter((l) => l.tipo === 'duracoes').map(({ tipo: _tipo, ...resto }) => resto),
     };
@@ -478,7 +497,7 @@ function agileNoLedger(raiz, threadId, commit, pecasDoVerify, doAgile, guarda, r
         const arquivo = path.join((0, thread_1.dirThread)(raiz, threadId), 'check', `${commit.slice(0, 12)}-lanes.json`);
         try {
             fs.mkdirSync(path.dirname(arquivo), { recursive: true, mode: 0o700 });
-            fs.writeFileSync(arquivo, JSON.stringify({ commit, lanes: listas.map((l) => ({ lane: l.lane, arquivos: l.arquivos })) }, null, 1) + '\n', { mode: 0o600 });
+            fs.writeFileSync(arquivo, JSON.stringify({ commit, lanes: listas.map((l) => ({ lane: l.lane, arquivos: l.arquivos })), resultados }, null, 1) + '\n', { mode: 0o600 });
             resumo.evidencia = path.relative((0, estado_thread_1.raizDoEstado)(raiz), arquivo);
         }
         catch { /* sem o arquivo, o ledger ainda guarda a contagem e o sha256 de cada lane */ }
@@ -529,7 +548,7 @@ function exigirDependenciasDaWorktree(carregado, threadId, cwd, operacao, conduc
 }
 /** `ork verify --baseline`: grava o estado do mundo ANTES do GO. Sem `executor`, o da rodada (`executorDaRodada`). */
 function gravarBaseline(carregado, threadId, executor, conducao = {}, origem = 'cli', leitor = steal_1.lerProcStat, modo) {
-    const pedido = pedidoDoVerify(carregado, threadId, 'baseline', comandosDoManifesto(carregado.manifesto).length, conducao);
+    const pedido = pedidoDoVerify(carregado, threadId, 'baseline', comandosDoManifesto(carregado.manifesto).length + 1, conducao);
     return (0, conducao_1.comConducao)(carregado.raiz, threadId, pedido, (tomada) => naFilaPesada(carregado, threadId, 'baseline', conducao, () => gravarBaselineSobConducao(carregado, threadId, executor, tomada, origem, leitor, modo)));
 }
 function gravarBaselineSobConducao(carregado, threadId, base, tomada, origem, leitor, modo) {
@@ -551,7 +570,7 @@ function gravarBaselineSobConducao(carregado, threadId, base, tomada, origem, le
     // seria reaproveitado e os comandos rodam como no Classic.
     // RM-072 (A6 do CHECK): as pecas do preparo, do grupo e do relatorio vao ao `baseline_recorded`, como no `verify_run`.
     const pecasDaBaseline = [];
-    const comandos = relatorio && manifesto.check?.agile?.produto?.length
+    const comandosDoManifestoExecutados = relatorio && manifesto.check?.agile?.produto?.length
         ? (() => {
             const p = (0, check_agil_1.prepararNoAgile)(manifesto, cwd, executor);
             pecasDaBaseline.push(...p.pecas);
@@ -560,6 +579,8 @@ function gravarBaselineSobConducao(carregado, threadId, base, tomada, origem, le
             return r.comandos;
         })()
         : comandosDoManifesto(manifesto).map((c) => executorDosComandos(c.nome, c.comando, cwd));
+    const changelog = verificarChangelog(cwd, manifesto.worktree.base_branch, thread.base?.commit);
+    const comandos = changelog ? [...comandosDoManifestoExecutados, changelog] : comandosDoManifestoExecutados;
     if (relatorio) {
         if (base)
             pecasDaBaseline.push(check_agil_1.PECA_SEM_RELATORIO);
@@ -582,7 +603,9 @@ function gravarBaselineSobConducao(carregado, threadId, base, tomada, origem, le
         commit: baseline.commit,
         cwd,
         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.duracaoMs !== undefined ? { duracaoMs: c.duracaoMs } : {}), ...(c.ok ? {} : { causa: c.causa ?? null }),
+            ...(c.testeQueCaiu?.length ? { testeQueCaiu: c.testeQueCaiu } : {}),
+            ...(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 } } : {}),
         // RM-037 (defeito 1 de 19 e 20/10/2026): o que a baseline nao provou fica dito no proprio evento.
@@ -592,6 +615,38 @@ function gravarBaselineSobConducao(carregado, threadId, base, tomada, origem, le
     });
     return baseline;
 }
+function nomesUnicos(nomes) {
+    return [...new Set(nomes ?? [])];
+}
+/** Compara os conjuntos que o runner realmente nomeou; sucesso prova que o conjunto atual e vazio. */
+function compararComBaseline(atual, antes) {
+    if (atual.ok && antes.ok)
+        return null;
+    const nomesAntes = nomesUnicos(antes.testeQueCaiu);
+    const nomesAtuais = nomesUnicos(atual.testeQueCaiu);
+    const baselineNominal = antes.ok || nomesAntes.length > 0;
+    const rodadaNominal = atual.ok || nomesAtuais.length > 0;
+    if (baselineNominal && rodadaNominal) {
+        const antesSet = new Set(nomesAntes);
+        const atualSet = new Set(nomesAtuais);
+        return {
+            comando: atual.nome,
+            granularidade: 'teste',
+            regressoes: nomesAtuais.filter((nome) => !antesSet.has(nome)),
+            preExistentes: nomesAtuais.filter((nome) => antesSet.has(nome)),
+            corrigidos: nomesAntes.filter((nome) => !atualSet.has(nome)),
+        };
+    }
+    return {
+        comando: atual.nome,
+        granularidade: 'comando',
+        regressoes: [],
+        preExistentes: [],
+        corrigidos: [],
+        classificacaoDoComando: atual.ok ? 'corrigido' : antes.ok ? 'regressao' : 'pre-existente',
+        motivoDoFallback: baselineNominal ? 'rodada-sem-nomes' : 'baseline-sem-nomes',
+    };
+}
 /**
  * Reexecuta a claim no HEAD real e devolve o veredito com o motivo tipado.
  *
@@ -656,6 +711,7 @@ function verificarSobConducao(carregado, threadId, opcoes, conducao, canal, fila
     const inicioDaRodada = Date.now();
     const thread = (0, thread_1.lerThread)(raiz, threadId);
     const cwd = cwdDaThread(raiz, thread);
+    opcoes.progresso?.('preflight');
     exigirDependenciasDaWorktree(carregado, threadId, cwd, 'verify', conducao, opcoes.executor);
     const commit = commitReal(cwd);
     const dir = (0, thread_1.dirThread)(raiz, threadId);
@@ -673,14 +729,26 @@ function verificarSobConducao(carregado, threadId, opcoes, conducao, canal, fila
     // RM-072 (D8): no Agile, as pecas contam o que rodaram num relatorio da rodada, lido no fim.
     const agil = check.modo === 'agile';
     const relatorio = agil ? new check_agil_1.RelatorioDoCheck() : null;
-    const ambienteDaRodada = { ...ambienteDoModo(check), ...relatorio?.ambiente() };
+    const casaDaRodada = agil && !(process.env.ORKASTERY_HOME || '').trim()
+        ? fs.mkdtempSync(path.join(os.tmpdir(), 'ork-verify-casa-')) : null;
+    const ambienteFuncional = { ...ambienteDoModo(check), ...(casaDaRodada ? { ORKASTERY_HOME: casaDaRodada } : {}) };
+    const ambienteDaRodada = { ...ambienteFuncional, ...relatorio?.ambiente() };
     // I-37 (D2, D3): o prazo de cada comando sai do manifesto carregado no inicio da rodada;
     // editar o manifesto no meio dela nao muda o teto de quem ainda vai rodar.
-    const executor = executorSobConducao(executorDaRodada(manifesto, instabilidade, opcoes.executor, leitor, ambienteDaRodada), manifesto, conducao);
+    const observar = (base) => opcoes.progresso
+        ? (nome, comando, dir) => { opcoes.progresso(nome); return base(nome, comando, dir); }
+        : base;
+    const executor = executorSobConducao(observar(executorDaRodada(manifesto, instabilidade, opcoes.executor, leitor, ambienteDaRodada)), manifesto, conducao);
     // RM-072 (A3 do CHECK): as claims recebem o modo, nunca o relatorio da rodada; o teste que roda a varredura dentro de uma
     // claim gravaria pecas de fixture no relatorio do verify. O relatorio fica com o preparo e o grupo.
     const executorDasClaims = relatorio
-        ? executorSobConducao(executorDaRodada(manifesto, instabilidade, opcoes.executor, leitor, ambienteDoModo(check)), manifesto, conducao)
+        ? executorSobConducao(observar(executorDaRodada(manifesto, instabilidade, opcoes.executor, leitor, ambienteFuncional)), manifesto, conducao)
+        : executor;
+    // Uma claim `node --test` elegivel usa o mesmo ambiente funcional das lanes: casa compartilhada, sem o modo da
+    // orquestracao. Assim o fallback da claim e a prova reaproveitada observam exatamente a mesma bateria.
+    const ambienteFuncionalDasLanes = { ...(casaDaRodada ? { ORKASTERY_HOME: casaDaRodada } : {}) };
+    const executorDasClaimsComoLane = relatorio
+        ? executorSobConducao(observar(executorDaRodada(manifesto, instabilidade, opcoes.executor, leitor, ambienteFuncionalDasLanes)), manifesto, conducao)
         : executor;
     // RM-072 (S-b do CHECK 2): fora do preparo, so a varredura e as lanes recebem o relatorio.
     const executorDosComandos = relatorio ? soAVarreduraEAsLanesComRelatorio(executor, executorDasClaims) : executor;
@@ -713,15 +781,34 @@ function verificarSobConducao(carregado, threadId, opcoes, conducao, canal, fila
         pecas.push(...(0, check_agil_1.refazerPreparo)(manifesto, cwd, executor, vigente, (p) => guardaDoPreparo(manifesto, cwd, p), quando));
     };
     let preparosRefeitos = 0;
+    let lanesVigentes = true;
     const refazerAntesDaClaim = (nome) => {
         if (!vigente || preparosRefeitos >= check_agil_1.MAXIMO_DE_PREPAROS_REFEITOS)
             return false;
         preparosRefeitos++;
+        lanesVigentes = false;
         refazer(`antes da claim ${nome}`);
         return true;
     };
+    // RM-074 M1: no Agile, as lanes rodam antes das claims para seus resultados nominais poderem provar `node --test`.
+    // Classic conserva a ordem anterior. O build continua vindo do preparo desta mesma rodada.
+    let doAgile = null;
+    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
+        : [];
+    if (doAgile)
+        pecas.push(...doAgile.pecas);
+    const evidenciasDasLanes = relatorio && doAgile ? (0, check_agil_1.resultadosDasLanes)(relatorio.ler()) : [];
+    const ambienteEfetivoDasClaims = { ...ambienteDoVerify(), ...ambienteFuncionalDasLanes };
+    const executorComLanes = evidenciasDasLanes.length > 0
+        ? (0, check_agil_1.executorDaClaimPelasLanes)(executorDasClaims, evidenciasDasLanes, { head: commit, ambiente: ambienteEfetivoDasClaims,
+            podeReaproveitar: () => lanesVigentes && vigente?.guarda.conferir() === null,
+            executorEquivalente: executorDasClaimsComoLane })
+        : executorDasClaims;
     // Claim retirada sai do gate: o historico guarda a alegacao e o motivo da retirada.
-    const executorDaClaim = vigente ? (0, check_agil_1.executorDaClaimNoAgile)(manifesto, executorDasClaims, vigente, refazerAntesDaClaim) : executorDasClaims;
+    const executorDaClaim = vigente ? (0, check_agil_1.executorDaClaimNoAgile)(manifesto, executorComLanes, vigente, refazerAntesDaClaim) : executorComLanes;
     const claims = (0, claims_1.lerClaims)(raiz, threadId)
         .filter((c) => c.estado !== 'retirada')
         .map((c) => verificarClaim(c, cwd, executorDaClaim));
@@ -737,20 +824,33 @@ function verificarSobConducao(carregado, threadId, opcoes, conducao, canal, fila
         if (r.claim.estado !== estado)
             (0, claims_1.carimbarEstado)(raiz, r.claim, estado);
     }
-    // RM-072 (A1 do CHECK): o produto que mudou durante as claims tem o preparo refeito antes do grupo, que segue em paralelo.
-    // S-h do CHECK 3: o grupo tem a vaga dele, fora do teto das claims.
-    if (vigente && !opcoes.soClaims && vigente.guarda.conferir() === 'produto-mudou')
-        refazer('antes do grupo');
-    // RM-072 (D4, D6): no Agile, build do preparo e o resto no grupo paralelo, com a guarda valendo.
-    let doAgile = null;
-    const comandos = opcoes.soClaims
-        ? []
-        : vigente
-            ? (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) => executor(c.nome, c.comando, cwd));
-    if (doAgile)
+    // Claim nao reaproveitada pode recompilar e mudar o produto depois das lanes. Nesse caso o preparo e o grupo rodam
+    // novamente sobre o produto final; na rodada comum, as claims de teste vieram das lanes e este caminho nao custa nada.
+    const guardaDepoisDasClaims = grupoAntesDasClaims ? vigente?.guarda.conferir() : null;
+    if (grupoAntesDasClaims && guardaDepoisDasClaims) {
+        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);
+        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));
+        if (doAgile)
+            pecas.push(...doAgile.pecas);
+    }
+    const changelog = opcoes.soClaims ? null
+        : verificarChangelog(cwd, manifesto.worktree.base_branch, thread.base?.commit);
+    const comandos = opcoes.soClaims ? []
+        : changelog ? [...comandosDoManifestoExecutados, changelog] : comandosDoManifestoExecutados;
     const resumoDoAgile = vigente ? agileNoLedger(raiz, threadId, commit, pecas, doAgile, vigente.guarda, relatorio, claims) : null;
+    if (relatorio && !vigente)
+        relatorio.fechar();
+    if (casaDaRodada)
+        fs.rmSync(casaDaRodada, { recursive: true, force: true });
     // RM-062 (F2): a barreira de dado privado no diff da thread, so com a policy `dado_privado` no manifesto.
     const dadoPrivado = (0, dado_privado_1.barreiraDaThread)(carregado, thread, cwd, 'verify');
     const dadoPrivadoBloqueia = (0, policies_1.bloqueantes)(dadoPrivado?.violacoes ?? []);
@@ -758,23 +858,41 @@ function verificarSobConducao(carregado, threadId, opcoes, conducao, canal, fila
     const regressoes = [];
     const preExistentes = [];
     const falhasSemBaseline = [];
+    const comparacoes = [];
     const estouros = [];
     // RM-037 (defeito 1 de 19 e 20/10/2026): o comando sem veredito na baseline nao separa regressao de divida.
     const baselineSemVeredito = (baseline?.comandos ?? []).filter((c) => vereditoDaBaseline(c) === 'sem-veredito').map((c) => c.nome);
     for (const atual of comandos) {
-        if (atual.ok)
+        // I-54 (D11): comando que nao rodou nao tem resultado para comparar. O motivo tipado entra abaixo como
+        // `verify.sem-veredito`, sem tambem inventar regressao ou divida a partir da ausencia de nomes.
+        if (atual.executado === false)
             continue;
-        if (semVereditoPorTempo(atual)) {
+        if (!atual.ok && semVereditoPorTempo(atual)) {
             estouros.push(atual);
             continue;
         }
         const antes = baseline?.comandos.find((c) => c.nome === atual.nome);
-        if (!antes || vereditoDaBaseline(antes) === 'sem-veredito')
-            falhasSemBaseline.push(atual);
-        else if (antes.ok)
+        if (!antes || vereditoDaBaseline(antes) === 'sem-veredito') {
+            if (!atual.ok)
+                falhasSemBaseline.push(atual);
+            continue;
+        }
+        const comparacao = compararComBaseline(atual, antes);
+        if (!comparacao)
+            continue;
+        comparacoes.push(comparacao);
+        if (comparacao.granularidade === 'teste') {
+            if (comparacao.regressoes.length > 0)
+                regressoes.push(atual);
+            if (comparacao.preExistentes.length > 0)
+                preExistentes.push(atual);
+        }
+        else if (comparacao.classificacaoDoComando === 'regressao') {
             regressoes.push(atual);
-        else
+        }
+        else if (comparacao.classificacaoDoComando === 'pre-existente') {
             preExistentes.push(atual);
+        }
     }
     // I-54 (D11): o produto mudou entre o preparo e o fim da rodada? Entao nenhum veredito vale.
     const identidadeFinal = preparo ? identidadeDoProduto(cwd) : null;
@@ -823,6 +941,7 @@ function verificarSobConducao(carregado, threadId, opcoes, conducao, canal, fila
                 duracaoMs: c.execucoes.reduce((t, e) => t + (e.duracaoMs ?? 0), 0),
                 // RM-072 (D5): no Agile, o que a guarda fez com cada comando da claim.
                 ...(c.execucoes.some((e) => e.preparo) ? { preparo: c.execucoes.map((e) => e.preparo ?? null) } : {}),
+                ...(c.execucoes.some((e) => e.lane) ? { lane: c.execucoes.map((e) => e.lane ?? null) } : {}),
                 ...(falhou ? { execucao: comandoNoLedger(falhou) } : {}),
             };
         }),
@@ -831,6 +950,7 @@ function verificarSobConducao(carregado, threadId, opcoes, conducao, canal, fila
         regressoes: regressoes.map((r) => r.nome),
         preExistentes: preExistentes.map((r) => r.nome),
         falhasSemBaseline: falhasSemBaseline.map((r) => r.nome),
+        comparacoes,
         ...(baselineSemVeredito.length > 0 ? { baselineSemVeredito } : {}),
         estouros: estouros.map((r) => r.nome),
         prazoMs: manifesto.verify.timeout_ms ?? exports.TIMEOUT_VERIFY_MS,
@@ -871,7 +991,9 @@ function verificarSobConducao(carregado, threadId, opcoes, conducao, canal, fila
                     .map((c) => `${c.claim.id}: ${c.detalhe}`)
                     .join('; ')
                 : motivo === 'verify.regression'
-                    ? `regressao em: ${regressoes.map((r) => r.nome).join(', ')}`
+                    ? `regressao em: ${comparacoes.flatMap((c) => c.granularidade === 'teste'
+                        ? c.regressoes.map((teste) => `${c.comando}: ${teste}`)
+                        : 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),
@@ -914,6 +1036,7 @@ function verificarSobConducao(carregado, threadId, opcoes, conducao, canal, fila
         regressoes,
         preExistentes,
         falhasSemBaseline,
+        comparacoes,
         estouros,
         preparo: preparo ? { ...preparo, identidadeFinal: identidadeFinal, produtoAlterado } : null,
         steal,
@@ -1017,13 +1140,22 @@ function textoDoVerify(r) {
         linhas.push('');
         linhas.push(m.semVeredito(r.estouros.map((c) => c.nome).join(', ')));
     }
-    if (r.regressoes.length > 0 || r.preExistentes.length > 0 || r.falhasSemBaseline.length > 0) {
+    if (r.comparacoes.length > 0 || r.falhasSemBaseline.length > 0) {
         linhas.push('');
-        linhas.push(m.classificacao(r.regressoes.length, r.preExistentes.length, r.falhasSemBaseline.length));
-        for (const c of r.regressoes)
-            linhas.push(m.regressao(c.nome, c.comando));
-        for (const c of r.preExistentes)
-            linhas.push(m.preExistente(c.nome, c.comando));
+        for (const c of r.comparacoes) {
+            if (c.granularidade === 'teste') {
+                linhas.push(m.comparacaoPorTeste(c.comando, c.regressoes.length, c.preExistentes.length, c.corrigidos.length));
+                for (const teste of c.regressoes)
+                    linhas.push(m.testeRegressao(teste));
+                for (const teste of c.preExistentes)
+                    linhas.push(m.testePreExistente(teste));
+                for (const teste of c.corrigidos)
+                    linhas.push(m.testeCorrigido(teste));
+            }
+            else {
+                linhas.push(m.comparacaoPorComando(c.comando, c.classificacaoDoComando, c.motivoDoFallback));
+            }
+        }
         // RM-037 (defeito 1 de 19 e 20/10/2026): a baseline existe, mas nao teve veredito deste comando.
         const semVeredito = new Set((r.baseline?.comandos ?? []).filter((c) => vereditoDaBaseline(c) === 'sem-veredito').map((c) => c.nome));
         for (const c of r.falhasSemBaseline) {

package/eval/README.md

@@ -1,13 +1,13 @@
 # eval/
 
 Avaliacao deterministica do Orkastery, rodada por `ork eval`. Regra do catalogo original,
-mantida e agora executavel: **skill sem eval nao entra**, e comportamento sem canario tambem nao.
+mantida e agora executavel: **skill sem eval nao entra**, e comportamento sem cenario tambem nao.
 
 ```bash
-ork eval                                  # canarios + corpus das skills
-ork eval --so-canarios                    # so o comportamento do nucleo
+ork eval                                  # cenarios + corpus das skills
+ork eval --so-cenarios                    # so o comportamento do nucleo
 ork eval --skill code-reviewer            # so uma skill
-ork eval --canario fx-stale-base          # so um canario
+ork eval --cenario fx-stale-base          # so um cenario
 ork eval --json                           # para o CI
 ```
 
@@ -35,14 +35,14 @@ monta uma copia do catalogo, apaga uma regra, planta uma skill sem eval e ancora
 dentro da tabela de desculpas, e confere que os tres ficam vermelhos. Corpus que fica verde
 depois de a regra sumir nao protege nada.
 
-## `fixtures/`, os canarios
+## `fixtures/`, os cenarios
 
 Seis comportamentos do nucleo, exercitados ponta a ponta contra git de verdade, em repositorio
 temporario, sem rede e sem credencial. A expectativa de cada um e **dado versionado**
-(`caso.json`), e o executor e codigo tipado (`core/src/canarios.ts`): assim, mudar o que se
+(`caso.json`), e o executor e codigo tipado (`core/src/cenarios.ts`): assim, mudar o que se
 espera do produto e um diff que aparece na revisao, revisavel por quem nao le TypeScript.
 
-| Canario | O que ele impede de voltar |
+| Cenario | O que ele impede de voltar |
 |---|---|
 | `fx-happy` | O caminho feliz parar de funcionar sem ninguem notar |
 | `fx-hallucination` | Citacao de arquivo e de teste que nao existem passar no gate |
@@ -54,7 +54,7 @@ espera do produto e um diff que aparece na revisao, revisavel por quem nao le Ty
 Ha ainda duas fixtures de contrato, mais antigas, rodadas pela suite (`npm test`) em
 `core/test/eval.test.ts`: `b0-slug-e-modos` (a #TAG do pedido vira slug, blocos e pausas) e
 `b2-master-log` (o contrato congelado do MASTER log, com as mutacoes que precisam reprovar).
-A segunda tem dois consumidores de proposito: a suite e o canario `fx-schema-drift`.
+A segunda tem dois consumidores de proposito: a suite e o cenario `fx-schema-drift`.
 
 ## `casos/`, o corpus das skills
 

package/eval/fixtures/fx-codex-dry/caso.json

@@ -1,7 +1,7 @@
 {
   "id": "fx-codex-dry",
   "sobre": "O setup do bloco leva o despacho governado ao controller Codex app-server via stdio em dry-run; o default continua claude-bg.",
-  "porque": "Novos despachos governados precisam de entrada bidirecional e controller próprio. O canário exige o comando app-server via stdio, preserva runtime/modelo/esforço e garante que dry-run não despacha. Provas de recepção nativa são separadas.",
+  "porque": "Novos despachos governados precisam de entrada bidirecional e controller próprio. O cenário exige o comando app-server via stdio, preserva runtime/modelo/esforço e garante que dry-run não despacha. Provas de recepção nativa são separadas.",
   "precisa": [
     "git"
   ],

package/eval/fixtures/fx-happy/caso.json

@@ -1,7 +1,7 @@
 {
   "id": "fx-happy",
   "sobre": "O ciclo que funciona: thread aberta no modo do pedido, fase montada com prompt gravado e hash, e claim que passa na reexecucao no HEAD real.",
-  "porque": "Um corpus que so tem canario de falha nao percebe quando o caminho feliz para de funcionar. Este e o unico que reprova se o produto deixar de fazer o basico.",
+  "porque": "Um corpus que so tem cenario de falha nao percebe quando o caminho feliz para de funcionar. Este e o unico que reprova se o produto deixar de fazer o basico.",
   "precisa": [
     "git"
   ],

package/eval/fixtures/fx-indice-reversao/caso.json

@@ -1,7 +1,7 @@
 {
   "id": "fx-indice-reversao",
   "sobre": "Uma entrega revertida depois do ship se rebaixa SOZINHA no caminho que o produto percorre de verdade: `ork master` mostra a reversão em vez de \"sem tropeço\", e a aceitação por omissão grava score 2, não 5, sem ninguém pontuar nada.",
-  "porque": "É o canário que libera a saída da fila de ratificação de score, e prova a propriedade exata que a fila não entregava: ela tinha 13 entradas esperando nota humana justamente porque lembrete não converte em nota, e nenhuma delas dizia se a entrega havia sido desfeita depois. Na primeira versão ele chamava `registrarReversaoDaEntrega` À MÃO, e o CHECK de 20/09/2026 provou com `git revert` real que isso não provava nada: no produto o único chamador era o começo de um `ork ship` SEGUINTE da mesma thread, que depois do MASTER não acontece, e `ork master --aceitar-omissao` gravava score 5 com a justificativa \"sem reversão\" sobre uma entrega desfeita. Agora o canário roda o que o dono roda: `tabelaDeEntregas` e `aceitarPorOmissao`. A detecção ancora no marcador que o próprio git escreve (\"This reverts commit <sha>\") e não em diff de árvore, porque um arquivo que voltou ao estado anterior pode ser trabalho de outra thread, e chamar isso de reversão rebaixaria entrega alheia por coincidência. A idempotência é condição dura agora que a detecção roda em toda consulta: sem ela, abrir a tabela afundaria a nota da thread a cada vez.",
+  "porque": "É o cenário que libera a saída da fila de ratificação de score, e prova a propriedade exata que a fila não entregava: ela tinha 13 entradas esperando nota humana justamente porque lembrete não converte em nota, e nenhuma delas dizia se a entrega havia sido desfeita depois. Na primeira versão ele chamava `registrarReversaoDaEntrega` À MÃO, e o CHECK de 20/09/2026 provou com `git revert` real que isso não provava nada: no produto o único chamador era o começo de um `ork ship` SEGUINTE da mesma thread, que depois do MASTER não acontece, e `ork master --aceitar-omissao` gravava score 5 com a justificativa \"sem reversão\" sobre uma entrega desfeita. Agora o cenário roda o que o dono roda: `tabelaDeEntregas` e `aceitarPorOmissao`. A detecção ancora no marcador que o próprio git escreve (\"This reverts commit <sha>\") e não em diff de árvore, porque um arquivo que voltou ao estado anterior pode ser trabalho de outra thread, e chamar isso de reversão rebaixaria entrega alheia por coincidência. A idempotência é condição dura agora que a detecção roda em toda consulta: sem ela, abrir a tabela afundaria a nota da thread a cada vez.",
   "precisa": [
     "git"
   ],

package/eval/fixtures/fx-listagem-abertas/caso.json

@@ -1,7 +1,7 @@
 {
   "id": "fx-listagem-abertas",
   "sobre": "O default de `ork thread list` mostra o que ainda pede atenção (aberta e pausada) e omite a fechada, avisando que omitiu; `--todas` abre o resto.",
-  "porque": "O custo medido era o DEFAULT e não a falta de flag: em 20/09/2026 o comando imprimia 137 linhas para as 31 que interessavam, e 71 delas (52 por cento) eram threads `Sessão adotada claude-bg <uuid>`, lixo do mecanismo de adoção de 07 a 14/09. Quem pagava era quem não sabia que existia flag, porque flag nenhuma existia. A thread PAUSADA é a razão de o default ser \"não fechadas\" e não \"só abertas\", que era o texto do GOAL: esconder a pausada seria esconder justamente a que mais pede atenção. O canário roda em sandbox porque `ork thread list` dentro de uma worktree lê o estado da árvore principal (M8): conferir \"no projeto\" seria afirmar contagem de artefato vivo, que reprova sozinha quando a branch cresce.",
+  "porque": "O custo medido era o DEFAULT e não a falta de flag: em 20/09/2026 o comando imprimia 137 linhas para as 31 que interessavam, e 71 delas (52 por cento) eram threads `Sessão adotada claude-bg <uuid>`, lixo do mecanismo de adoção de 07 a 14/09. Quem pagava era quem não sabia que existia flag, porque flag nenhuma existia. A thread PAUSADA é a razão de o default ser \"não fechadas\" e não \"só abertas\", que era o texto do GOAL: esconder a pausada seria esconder justamente a que mais pede atenção. O cenário roda em sandbox porque `ork thread list` dentro de uma worktree lê o estado da árvore principal (M8): conferir \"no projeto\" seria afirmar contagem de artefato vivo, que reprova sozinha quando a branch cresce.",
   "precisa": ["git"],
   "esperado": {
     "noDefault": ["aberta", "pausada"],

package/eval/fixtures/fx-omnicanal/caso.json

@@ -13,5 +13,5 @@
     "humanosSemIngresso": 0,
     "ofertaDisponivel": 4
   },
-  "porque": "D12 exige HITL omnicanal nos quatro hosts homologados com identidade, correlacao e recibo equivalentes, e FX1 exige que a chave de ingresso seja de cada canal. O canario impede quatro regressoes: reduzir a lista de canais, voltar a gravar recibo que nao distingue Hermes de OpenClaw, aceitar resposta sem ingresso homologado (aprovacao cega, transcrito de tool ou canal de outro transporte), e voltar a compartilhar uma chave entre os dois canais de telegram."
+  "porque": "D12 exige HITL omnicanal nos quatro hosts homologados com identidade, correlacao e recibo equivalentes, e FX1 exige que a chave de ingresso seja de cada canal. O cenario impede quatro regressoes: reduzir a lista de canais, voltar a gravar recibo que nao distingue Hermes de OpenClaw, aceitar resposta sem ingresso homologado (aprovacao cega, transcrito de tool ou canal de outro transporte), e voltar a compartilhar uma chave entre os dois canais de telegram."
 }

package/eval/fixtures/fx-pedido-colado/caso.json

@@ -16,5 +16,5 @@
     "tempoParadoMs": 0,
     "adaptadoresComARegra": 4
   },
-  "porque": "Na noite de 01 para 02/10 o condutor parou mais de 10 h pedindo um confirmo em texto livre a um pedido colado que já trazia a autorização. O canário prova, contra o código real, que o #Auto não pausa, a dúvida vira decisão informada, o confirmo em texto é recusado sem gravar nada, ninguém aparece esperando no pulse, o tempo parado é zero e os quatro adaptadores dizem a regra."
+  "porque": "Na noite de 01 para 02/10 o condutor parou mais de 10 h pedindo um confirmo em texto livre a um pedido colado que já trazia a autorização. O cenário prova, contra o código real, que o #Auto não pausa, a dúvida vira decisão informada, o confirmo em texto é recusado sem gravar nada, ninguém aparece esperando no pulse, o tempo parado é zero e os quatro adaptadores dizem a regra."
 }

package/eval/fixtures/fx-schema-drift/caso.json

@@ -1,7 +1,7 @@
 {
   "id": "fx-schema-drift",
   "sobre": "Seis mutacoes do MASTER log valido: contrato trocado sem trocar a versao, score fora da escala, classe de falha inventada, fase fora do ciclo canonico, justificativa vazia e evidencia ausente.",
-  "porque": "O MASTER log e contrato publico congelado (ork.master-log/v1). Se ele aceitar mutacao em silencio, a telemetria de conducao deixa de ser comparavel entre threads e o score vira opiniao com formato de dado. O canario le a mesma fixture b2-master-log que a suite ja usa: uma fonte, dois consumidores.",
+  "porque": "O MASTER log e contrato publico congelado (ork.master-log/v1). Se ele aceitar mutacao em silencio, a telemetria de conducao deixa de ser comparavel entre threads e o score vira opiniao com formato de dado. O cenario le a mesma fixture b2-master-log que a suite ja usa: uma fonte, dois consumidores.",
   "precisa": [],
   "esperado": {
     "validoPassa": true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orkastery/cli",
-  "version": "0.6.1",
+  "version": "0.6.3",
   "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",

package/references/testing-patterns.md

@@ -33,7 +33,7 @@ flowchart LR
 | 6 | A suite roda no HEAD real, no diretorio de trabalho da thread. Passagem relatada por agente nao e passagem. | `ork verify <thread>` reexecuta os comandos do manifesto e as claims, e carimba o commit real. |
 | 7 | Nenhum teste foi desligado, marcado para pular ou afrouxado para fechar a entrega. Pular teste e mudanca de escopo com registro, nunca ajuste de rota silencioso. | Diff sobre os arquivos de teste, procurando teste removido, `skip` e assercao relaxada. |
 | 8 | Nenhuma assercao foi trocada pelo valor que o codigo produz hoje sem que alguem tenha dito por que o valor certo mudou. Ajustar o esperado ao observado e a forma mais comum de transformar defeito em contrato. | Diff das assercoes contra a intencao declarada no PLAN. |
-| 9 | Teste nao depende de rede, de credencial paga nem de relogio de parede. Fixture deterministica e o padrao; o que precisa de mundo externo fica fora do gate e e declarado. | Rodar a suite offline. No `ork`, os canarios de `ork eval` montam repositorio git temporario e nao tocam a rede. |
+| 9 | Teste nao depende de rede, de credencial paga nem de relogio de parede. Fixture deterministica e o padrao; o que precisa de mundo externo fica fora do gate e e declarado. | Rodar a suite offline. No `ork`, os cenarios de `ork eval` montam repositorio git temporario e nao tocam a rede. |
 | 10 | Teste nao depende de outro teste nem da ordem de execucao. Estado compartilhado entre casos e defeito, mesmo quando a suite esta verde hoje. | Rodar em ordem embaralhada ou isoladamente o caso suspeito. |
 
 ## Contagem e cobertura

package/skills/core/orkastery-bootstrap/SKILL.md

@@ -21,7 +21,7 @@ Distinga o contexto antes de agir:
 - **Sessao condutora:** recebe o pedido do dono, identifica ou abre a thread, despacha pelo `ork` e acompanha o resultado; nunca escreve codigo de produto no lugar da sessao despachada.
 - **Sessao de fase ja despachada:** recebeu thread, fase, prompt e worktree do `ork`.
   Trabalhe nesse escopo pela skill da fase. Nao abra outra thread nem redespache a propria fase para fazer o trabalho que ja lhe foi atribuido.
-  - Esperas: nunca dispare verify, build ou suite com `&` dentro do comando, porque o processo se perde e a sessao espera um aviso que nunca vem; rode o `ork verify` em primeiro plano, com `timeout` (ele espera a vez na fila de recursos pesados), ou use a execucao em segundo plano do host, que avisa quando termina; nunca espere com `pgrep -f` cujo padrao aparece no proprio comando, porque o laco acha a si mesmo e nao termina: espere pelo arquivo de saida com prazo, ou pelo PID guardado.
+  - Esperas: nunca dispare verify, build ou suite com `&` dentro do comando, porque o processo se perde e a sessao espera um aviso que nunca vem; prefira `ork_verify` assíncrono e consulte `ork_verify_status` a cada 30–60 s; sem essa ferramenta, rode o `ork verify` em primeiro plano, com `timeout` (ele espera a vez na fila de recursos pesados), ou use a execucao em segundo plano do host, que avisa quando termina; nunca espere com `pgrep -f` cujo padrao aparece no proprio comando, porque o laco acha a si mesmo e nao termina: espere pelo arquivo de saida com prazo, ou pelo PID guardado.
 
 ## Comecar ou retomar
 

package/skills/phases/check-quality/SKILL.md

@@ -23,7 +23,7 @@ ork worktree audit <thread>          # a worktree confere no proprio git
 ork gate request <thread>            # o pedido da pausa; o humano responde pelo canal autenticado
 ```
 
-- Esperas: nunca dispare verify, build ou suite com `&` dentro do comando, porque o processo se perde e a sessao espera um aviso que nunca vem; rode o `ork verify` em primeiro plano, com `timeout` (ele espera a vez na fila de recursos pesados), ou use a execucao em segundo plano do host, que avisa quando termina; nunca espere com `pgrep -f` cujo padrao aparece no proprio comando, porque o laco acha a si mesmo e nao termina: espere pelo arquivo de saida com prazo, ou pelo PID guardado.
+- Esperas: nunca dispare verify, build ou suite com `&` dentro do comando, porque o processo se perde e a sessao espera um aviso que nunca vem; prefira `ork_verify` assíncrono e consulte `ork_verify_status` a cada 30–60 s; sem essa ferramenta, rode o `ork verify` em primeiro plano, com `timeout` (ele espera a vez na fila de recursos pesados), ou use a execucao em segundo plano do host, que avisa quando termina; nunca espere com `pgrep -f` cujo padrao aparece no proprio comando, porque o laco acha a si mesmo e nao termina: espere pelo arquivo de saida com prazo, ou pelo PID guardado.
 
 Quando o veredito e PRECISA DE MUDANCA, o sub-loop GO-FIX / CHECK-REVERIFY do bloco B3 e
 quem conduz a volta, e ele nao depende de humano ate o veredito final:

package/skills/phases/go-implementation/SKILL.md

@@ -24,7 +24,7 @@ ork claims add <thread> <arquivo> --claim "<...>" --verificar "<comando>" --fase
 ork verify <thread>                           # reexecuta no HEAD real
 ```
 
-- Esperas: nunca dispare verify, build ou suite com `&` dentro do comando, porque o processo se perde e a sessao espera um aviso que nunca vem; rode o `ork verify` em primeiro plano, com `timeout` (ele espera a vez na fila de recursos pesados), ou use a execucao em segundo plano do host, que avisa quando termina; nunca espere com `pgrep -f` cujo padrao aparece no proprio comando, porque o laco acha a si mesmo e nao termina: espere pelo arquivo de saida com prazo, ou pelo PID guardado.
+- Esperas: nunca dispare verify, build ou suite com `&` dentro do comando, porque o processo se perde e a sessao espera um aviso que nunca vem; prefira `ork_verify` assíncrono e consulte `ork_verify_status` a cada 30–60 s; sem essa ferramenta, rode o `ork verify` em primeiro plano, com `timeout` (ele espera a vez na fila de recursos pesados), ou use a execucao em segundo plano do host, que avisa quando termina; nunca espere com `pgrep -f` cujo padrao aparece no proprio comando, porque o laco acha a si mesmo e nao termina: espere pelo arquivo de saida com prazo, ou pelo PID guardado.
 
 ## O que o GO entrega