@orkastery/cli 0.6.0 → 0.6.2

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");
@@ -97,6 +98,8 @@ const policies_1 = require("./policies");
 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. */
@@ -121,7 +124,9 @@ exports.PREFIXO_BLOQUEADO_NO_VERIFY = 'ORK_HITL_';
  * RM-072 (S-b do CHECK 2): as variaveis de uma rodada do Agile. Cada rodada poe as suas onde precisa; herdadas de outra
  * 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]);
+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,
+]);
 function ambienteDoVerify(base = process.env) {
     return Object.fromEntries(Object.entries(base).filter(([chave]) => !chave.startsWith(exports.PREFIXO_BLOQUEADO_NO_VERIFY)
         && !VARIAVEIS_DA_RODADA.has(chave)));
@@ -206,7 +211,9 @@ function resultadoDoProcesso(nome, comando, r, comGrupo, duracaoMs, tetoMs) {
         prazoMs: tetoMs,
         duracaoMs,
         // I-54 (D11): so nao rodou o que o sistema recusou lancar; estouro e sinal rodaram e acabaram.
-        executado: !(r.error && NAO_LANCADO.has(r.error)),
+        // `spawnSync` pode devolver um erro tardio do sandbox junto de um status real (por exemplo EPERM com status 0):
+        // nesse caso o processo existiu e o codigo observado e o veredito. So status ausente (`code: -1`) prova que nao lancou.
+        executado: !(r.code === -1 && r.error && NAO_LANCADO.has(r.error)),
     };
     if (!r.ok) {
         const saida = r.stdout + (r.stderr ? '\n' + r.stderr : '');
@@ -297,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)
@@ -322,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`,
@@ -407,16 +428,16 @@ 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.
  */
-function executorDoGrupo(manifesto, ambienteDaRodada, instabilidade, leitor, conducao, injetado) {
+function executorDoGrupo(manifesto, ambienteDaRodada, instabilidade, leitor, conducao, injetado, medicaoCpu) {
     if (injetado)
         return (itens, cwd) => itens.map((i) => injetado(i.nome, i.comando, cwd));
     const relogio = (0, instabilidade_1.testesDeRelogioVigentes)(instabilidade);
     // 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;
-    return (itens, cwd) => {
+    const executar = ((itens, cwd) => {
         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.nice ? { nice: i.nice } : {}), ...(i.apos?.length ? { apos: i.apos } : {}), ...(i.papelCpu ? { papelCpu: i.papelCpu } : {}),
             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])),
@@ -424,7 +445,15 @@ function executorDoGrupo(manifesto, ambienteDaRodada, instabilidade, leitor, con
         // A conducao cobre o grupo inteiro: com a lane encadeada, a varredura e a lane somam.
         conducao.renovar((0, check_paralelo_1.esperaDoGrupo)(paraOAuxiliar));
         const janela = (0, steal_1.abrirJanela)(leitor);
-        const processos = (0, check_paralelo_1.rodarEmParalelo)(paraOAuxiliar, ambienteDoVerify());
+        const processos = (0, check_paralelo_1.rodarEmParalelo)(paraOAuxiliar, ambienteDoVerify(), medicaoCpu ? { medicaoCpu } : {});
+        if (processos.agendamentoCpu) {
+            const p = processos.agendamentoCpu;
+            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 e ${p.cpusDaFatia} reservadas; conteineres com ${p.cpusPorContainer} CPU`,
+                    ...(p.saturado ? { fallback: 'ordem do Classic para hermetica, varredura e integracao' } : {}) }];
+        }
         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 };
@@ -438,7 +467,9 @@ function executorDoGrupo(manifesto, ambienteDaRodada, instabilidade, leitor, con
             }
             return r;
         });
-    };
+    });
+    executar.pecas = [];
+    return executar;
 }
 /**
  * RM-072 (D8): le o relatorio das pecas da rodada, grava a lista inteira de cada lane em
@@ -449,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),
     };
@@ -463,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 */ }
@@ -514,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) {
@@ -536,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);
@@ -545,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);
@@ -567,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.
@@ -577,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.
  *
@@ -641,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);
@@ -658,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;
@@ -698,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));
@@ -722,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), 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 ?? []);
@@ -743,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;
@@ -808,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) } : {}),
             };
         }),
@@ -816,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,
@@ -856,15 +991,18 @@ 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) => r.nome),
+                            ...estouros.map((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'
                             ? [produtoAlterado ? 'o produto mudou entre o preparo e o fim da rodada' : '',
-                                ...naoExecutados.map((c) => `${c.nome} nao foi executado`),
+                                // RM-074 (F4): no Agile, o `test` diz qual lane ficou sem veredito e por que.
+                                ...naoExecutados.map((c) => (0, check_agil_1.porQueDasLanes)(c) ? `${c.nome} sem veredito (${(0, check_agil_1.porQueDasLanes)(c)})` : `${c.nome} nao foi executado`),
                                 ...claims.filter((c) => c.motivo === 'verify.sem-veredito').map((c) => `${c.claim.id}: ${c.detalhe}`)]
                                 .filter(Boolean).join('; ')
                             : motivo === 'policy.violation'
@@ -898,6 +1036,7 @@ function verificarSobConducao(carregado, threadId, opcoes, conducao, canal, fila
         regressoes,
         preExistentes,
         falhasSemBaseline,
+        comparacoes,
         estouros,
         preparo: preparo ? { ...preparo, identidadeFinal: identidadeFinal, produtoAlterado } : null,
         steal,
@@ -1001,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orkastery/cli",
-  "version": "0.6.0",
+  "version": "0.6.2",
   "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",
@@ -73,7 +73,7 @@
     "markdownlint-cli2": "^0.22.1"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "1.29.0",
+    "@modelcontextprotocol/sdk": "1.32.2",
     "decode-named-character-reference": "1.3.0",
     "micromark": "4.0.2",
     "micromark-extension-gfm-table": "2.1.1",

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