@orkastery/cli 0.6.6 → 0.6.7

package/dist/verify.js

@@ -47,6 +47,10 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ESPERA_PADRAO_DA_FILA_PESADA_MS = exports.ESPERA_DA_FILA_PESADA_MS = exports.MARGEM_MAX_DO_SCAN_MS = exports.PREFIXO_BLOQUEADO_NO_VERIFY = exports.TIMEOUT_VERIFY_MS = void 0;
+exports.impressaoDosComandos = impressaoDosComandos;
+exports.impressaoDoComando = impressaoDoComando;
+exports.resultadoDeComandoRedigido = resultadoDeComandoRedigido;
+exports.resultadoVerifyRedigido = resultadoVerifyRedigido;
 exports.ambienteDoVerify = ambienteDoVerify;
 exports.prazoDoComando = prazoDoComando;
 exports.prazoInternoDoScan = prazoInternoDoScan;
@@ -76,6 +80,7 @@ exports.pecaDoAgendadorCpu = pecaDoAgendadorCpu;
 exports.vereditoDaBaseline = vereditoDaBaseline;
 exports.gravarBaseline = gravarBaseline;
 exports.verificarClaim = verificarClaim;
+exports.verificarClaimsAgendadas = verificarClaimsAgendadas;
 exports.verificar = verificar;
 exports.linhasDaBaseline = linhasDaBaseline;
 exports.textoDoVerify = textoDoVerify;
@@ -99,6 +104,7 @@ const steal_1 = require("./steal");
 const instabilidade_1 = require("./instabilidade");
 const fila_pesada_1 = require("./fila-pesada");
 const redacao_url_1 = require("./redacao-url");
+const hitl_1 = require("./hitl");
 const conducao_1 = require("./conducao");
 const procedencia_1 = require("./procedencia");
 const dado_privado_1 = require("./dado-privado");
@@ -110,8 +116,72 @@ 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");
+const recibo_prova_1 = require("./recibo-prova");
+const temporario_das_lanes_1 = require("./temporario-das-lanes");
+const ambiente_funcional_1 = require("./ambiente-funcional");
 /** Teto de tempo de um comando de verificacao (build e suite completa cabem). */
 exports.TIMEOUT_VERIFY_MS = 10 * 60 * 1000;
+/**
+ * RM-079 GO-FIX 2: identidade estável da lista `verificar` sem persistir o texto.
+ * A ordem faz parte da prova; o prefixo permite trocar a forma canônica sem
+ * confundir recibos produzidos por versões diferentes.
+ */
+function impressaoDosComandos(verificar) {
+    return (0, node_crypto_1.createHash)('sha256')
+        .update('ork.verify-command-list/v1\0')
+        .update(JSON.stringify(verificar))
+        .digest('hex');
+}
+/** RM-079 GO-FIX 4: identidade do comando executável, separada da sua projeção pública. */
+function impressaoDoComando(comando) {
+    return (0, node_crypto_1.createHash)('sha256')
+        .update('ork.verify-command/v1\0')
+        .update(comando)
+        .digest('hex');
+}
+/** RM-079 GO-FIX 3: texto de comando cru fica no domínio de execução; cópias de saída usam o redator geral. */
+function redigirTextoDoComando(comando) {
+    return (0, hitl_1.redigirSegredos)(comando);
+}
+/** Cópia segura para recibo, ledger, SHIP e saída serializada; nunca muta o resultado executável. */
+function resultadoDeComandoRedigido(c) {
+    return {
+        ...c,
+        comando: redigirTextoDoComando(c.comando),
+        resumo: (0, hitl_1.redigirSegredos)(c.resumo),
+        ...(c.trecho !== undefined ? { trecho: (0, hitl_1.redigirSegredos)(c.trecho) } : {}),
+        ...(c.comandoExecutado ? { comandoExecutado: redigirTextoDoComando(c.comandoExecutado) } : {}),
+        ...(c.preparo ? { preparo: { ...c.preparo,
+                ...(c.preparo.passos ? { passos: c.preparo.passos.map(redigirTextoDoComando) } : {}),
+                ...(c.preparo.motivo ? { motivo: (0, hitl_1.redigirSegredos)(c.preparo.motivo) } : {}) } } : {}),
+        ...(c.lanes ? { lanes: c.lanes.map((lane) => ({
+                ...lane,
+                comando: redigirTextoDoComando(lane.comando),
+                ...(lane.comandoExecutado ? { comandoExecutado: redigirTextoDoComando(lane.comandoExecutado) } : {}),
+            })) } : {}),
+    };
+}
+/** Projeção do verify para fronteiras públicas; a decisão continua usando o `ResultadoVerify` original. */
+function resultadoVerifyRedigido(r) {
+    const comandos = (lista) => (lista ?? []).map(resultadoDeComandoRedigido);
+    const claims = r.claims ?? [];
+    return {
+        ...r,
+        claims: claims.map((c) => ({
+            ...c,
+            claim: { ...c.claim, verificar: c.claim.verificar.map(redigirTextoDoComando) },
+            detalhe: (0, hitl_1.redigirSegredos)(c.detalhe),
+            execucoes: comandos(c.execucoes),
+        })),
+        comandos: comandos(r.comandos),
+        baseline: r.baseline ? { ...r.baseline, comandos: comandos(r.baseline.comandos) } : null,
+        regressoes: comandos(r.regressoes),
+        preExistentes: comandos(r.preExistentes),
+        falhasSemBaseline: comandos(r.falhasSemBaseline),
+        estouros: comandos(r.estouros),
+        preparo: r.preparo ? { ...r.preparo, resultado: resultadoDeComandoRedigido(r.preparo.resultado) } : null,
+    };
+}
 /** Ultimas linhas da saida real, o suficiente para servir de evidencia no ledger. */
 function resumirSaida(stdout, stderr) {
     const bruto = (stdout + (stderr ? '\n' + stderr : '')).trim();
@@ -136,6 +206,7 @@ exports.PREFIXO_BLOQUEADO_NO_VERIFY = 'ORK_HITL_';
  */
 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, agendador_cpu_1.ENV_WORKERS,
+    ambiente_funcional_1.ENV_PATH_FUNCIONAL_DA_RODADA,
 ]);
 function ambienteDoVerify(base = process.env) {
     return Object.fromEntries(Object.entries(base).filter(([chave]) => !chave.startsWith(exports.PREFIXO_BLOQUEADO_NO_VERIFY)
@@ -177,13 +248,13 @@ function prazoDaExecucao(manifesto, nome, comando) {
  * O executor resolvido pelo manifesto: prazo de cada comando e, no scan, o prazo interno no ambiente. RM-072 (D2):
  * `ambienteDaRodada` e o que a rodada passa a todo comando dela (o modo do CHECK); o CI hospedado nao passa nada.
  */
-function executorDoManifesto(manifesto, ambienteDaRodada) {
+function executorDoManifesto(manifesto, ambienteDaRodada, ambienteBase) {
     return (nome, comando, cwd) => {
         const prazo = prazoDaExecucao(manifesto, nome, comando);
         const extra = ehComandoDoScan(manifesto, nome, comando)
             ? { ORK_SECURITY_SCAN_DEADLINE_MS: String(prazoInternoDoScan(prazo)) }
             : undefined;
-        return executar(nome, comando, cwd, prazo, ambienteDaRodada || extra ? { ...ambienteDaRodada, ...extra } : undefined);
+        return executar(nome, comando, cwd, prazo, ambienteDaRodada || extra ? { ...ambienteDaRodada, ...extra } : undefined, ambienteBase);
     };
 }
 /**
@@ -195,13 +266,13 @@ function executorDoManifesto(manifesto, ambienteDaRodada) {
  * o proprio `ork` morrer no meio, o `timeout` segue de pe e encerra o grupo no prazo.
  * O estouro continua saindo como `code: -1`, o contrato de antes.
  */
-function executar(nome, comando, cwd, tetoMs = exports.TIMEOUT_VERIFY_MS, ambienteExtra) {
+function executar(nome, comando, cwd, tetoMs = exports.TIMEOUT_VERIFY_MS, ambienteExtra, ambienteBase) {
     const comGrupo = (0, node_fs_1.existsSync)(TIMEOUT_BIN);
     const inicio = Date.now();
-    const ambiente = { ...ambienteDoVerify(), ...ambienteExtra };
+    const ambiente = { ...(ambienteBase ?? ambienteDoVerify()), ...ambienteExtra };
     const r = comGrupo
-        ? (0, util_1.exec)(TIMEOUT_BIN, ['--kill-after=15', `${Math.ceil(tetoMs / 1000)}`, 'bash', '-c', comando], cwd, tetoMs + 30_000, ambiente)
-        : (0, util_1.exec)('bash', ['-c', comando], cwd, tetoMs, ambiente);
+        ? (0, util_1.exec)(TIMEOUT_BIN, ['--kill-after=15', `${Math.ceil(tetoMs / 1000)}`, '/usr/bin/bash', '--noprofile', '--norc', '-c', comando], cwd, tetoMs + 30_000, ambiente)
+        : (0, util_1.exec)('/usr/bin/bash', ['--noprofile', '--norc', '-c', comando], cwd, tetoMs, ambiente);
     return resultadoDoProcesso(nome, comando, r, comGrupo, Date.now() - inicio, tetoMs);
 }
 /**
@@ -331,27 +402,34 @@ function causaDoEncerramento(r) {
 }
 /** I-37 (D8): o que o ledger grava de um comando. Sucesso e o codigo 0; falha leva a evidencia. */
 function comandoNoLedger(c) {
+    const seguro = resultadoDeComandoRedigido(c);
+    const lanes = seguro.lanes?.map((lane, indice) => {
+        const original = c.lanes[indice];
+        return { ...lane, comandoSha256: impressaoDoComando(original.comando) };
+    });
     // 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),
-                ...(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 };
+    const doAgile = { ...(seguro.preparo ? { preparo: seguro.preparo } : {}),
+        ...(seguro.agendamento ? { agendamento: seguro.agendamento } : {}),
+        ...(seguro.lane ? { lane: seguro.lane } : {}),
+        ...(lanes ? { lanes } : {}),
+        ...(seguro.comandoExecutado ? { comandoExecutado: seguro.comandoExecutado } : {}),
+        ...(seguro.parcial ? { parcial: seguro.parcial } : {}),
+        ...(seguro.junit ? { junit: seguro.junit } : {}),
+        ...(seguro.retesteDeRelogio ? { retesteDeRelogio: seguro.retesteDeRelogio } : {}) };
+    if (seguro.ok)
+        return { nome: seguro.nome, ok: true, code: seguro.code,
+            ...(seguro.duracaoMs !== undefined ? { duracaoMs: seguro.duracaoMs } : {}), ...doAgile };
     return {
-        nome: c.nome, comando: (0, redacao_url_1.redigirCredenciaisUrl)(c.comando), ok: false, code: c.code, ...doAgile,
-        ...(c.causa ? { causa: c.causa } : {}),
-        ...(c.prazoMs !== undefined ? { prazoMs: c.prazoMs } : {}),
-        ...(c.duracaoMs !== undefined ? { duracaoMs: c.duracaoMs } : {}),
-        ...(c.testeQueCaiu?.length ? { testeQueCaiu: c.testeQueCaiu } : {}),
-        ...(c.trecho !== undefined ? { trecho: c.trecho } : {}),
-        ...(c.stealPct !== undefined ? { stealPct: c.stealPct } : {}),
-        ...(c.relogioSobSteal?.length ? { relogioSobSteal: c.relogioSobSteal } : {}),
+        nome: seguro.nome, comando: seguro.comando, comandoSha256: impressaoDoComando(c.comando),
+        ok: false, code: seguro.code, ...doAgile,
+        ...(seguro.causa ? { causa: seguro.causa } : {}),
+        ...(seguro.prazoMs !== undefined ? { prazoMs: seguro.prazoMs } : {}),
+        ...(seguro.duracaoMs !== undefined ? { duracaoMs: seguro.duracaoMs } : {}),
+        ...(seguro.testeQueCaiu?.length ? { testeQueCaiu: seguro.testeQueCaiu } : {}),
+        ...(seguro.trecho !== undefined ? { trecho: seguro.trecho } : {}),
+        ...(seguro.stealPct !== undefined ? { stealPct: seguro.stealPct } : {}),
+        ...(seguro.relogioSobSteal?.length ? { relogioSobSteal: seguro.relogioSobSteal } : {}),
     };
 }
 /** O filtro nominal da F3 para o mesmo comando/lane; F2 nao cria uma segunda selecao. */
@@ -404,6 +482,14 @@ function objeto(v) {
 function nomesPersistidos(v) {
     return Array.isArray(v) ? [...new Set(v.filter((x) => typeof x === 'string' && !!x))] : [];
 }
+/** Evento novo usa a identidade original; só evento legado sem impressão compara a projeção histórica. */
+function mesmoComandoDaRodadaAnterior(anterior, atual) {
+    if (!anterior)
+        return false;
+    if (typeof anterior.comandoSha256 === 'string')
+        return anterior.comandoSha256 === impressaoDoComando(atual);
+    return anterior.comando === (0, redacao_url_1.redigirCredenciaisUrl)(atual);
+}
 /**
  * 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.
@@ -419,7 +505,7 @@ function selecaoDaRodadaAnterior(eventos, manifesto) {
         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)
+        if (anterior?.ok === false && mesmoComandoDaRodadaAnterior(anterior, atual.comando)
             && junit?.estado === 'lido' && nomes.length > 0)
             comandos[atual.nome] = nomes;
     }
@@ -431,7 +517,7 @@ function selecaoDaRodadaAnterior(eventos, manifesto) {
         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)
+        if (anterior?.ok === false && mesmoComandoDaRodadaAnterior(anterior, comando)
             && junit?.estado === 'lido' && nomes.length > 0)
             lanes[lane] = nomes;
     }
@@ -531,8 +617,9 @@ function guardaDoPreparo(manifesto, cwd, preparo) {
 function recebeORelatorio(nome) {
     return nome === 'security_scan' || nome.startsWith('test:');
 }
-function soAVarreduraEAsLanesComRelatorio(comRelatorio, semRelatorio) {
-    return (nome, comando, cwd) => (recebeORelatorio(nome) ? comRelatorio : semRelatorio)(nome, comando, cwd);
+function soAVarreduraEAsLanesComRelatorio(comRelatorio, semRelatorio, laneComTmpdirDaRodada = comRelatorio) {
+    return (nome, comando, cwd) => (nome.startsWith('test:') ? laneComTmpdirDaRodada
+        : recebeORelatorio(nome) ? comRelatorio : semRelatorio)(nome, comando, cwd);
 }
 /**
  * RM-072 (D6): o executor do grupo do Agile. Sem executor injetado, o processo auxiliar roda os comandos ao mesmo tempo,
@@ -542,6 +629,7 @@ function soAVarreduraEAsLanesComRelatorio(comRelatorio, semRelatorio) {
 /** A evidencia publica do plano: estado, capacidade usada, amostras e, no fallback, o equivalente do Classic. */
 function pecaDoAgendadorCpu(p) {
     const medida = p.medicaoCpuIntegracao;
+    const cota = p.cotaDosContainersDaIntegracao;
     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 ` +
@@ -551,15 +639,21 @@ function pecaDoAgendadorCpu(p) {
                 ? `medida anomala (${medida.anomalia})`
                 : `medida incompleta (${medida.motivosDosAusentes.map((x) => `${x.container}: ${x.motivo}`).join('; ')})`)
         : '';
-    return { peca: 'agendador-cpu', estado: p.estado,
+    const evidenciaDaCota = cota?.estado === 'aplicada'
+        ? `; adaptador confirmou cota de ${cota.cota} CPU nos conteineres da integracao (${cota.motivo})`
+        : cota?.estado === 'fallback'
+            ? `; adaptador recuou a cota dos conteineres da integracao (${cota.motivo})`
+            : '; cota dos conteineres da integracao sem evidencia do adaptador';
+    return { peca: 'agendador-cpu', estado: !p.saturado && cota?.estado === 'fallback' ? 'degradado' : 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' } : {}) };
+                `conteineres da varredura com ${p.cpusPorContainer} CPU${evidenciaDaCota}${evidencia}`,
+        reservaIntegracao: { cpus: p.cpusIntegracaoEmUso, fonte: p.fonteCpusIntegracao },
+        ...(p.saturado ? { fallback: 'ordem do Classic para hermetica, varredura e integracao' }
+            : cota?.estado === 'fallback' ? { fallback: 'argv anterior do runtime de conteiner' } : {}) };
 }
 function executorDoGrupo(manifesto, ambienteDaRodada, instabilidade, leitor, conducao, injetado, medicaoCpu) {
     if (injetado)
@@ -572,11 +666,16 @@ function executorDoGrupo(manifesto, ambienteDaRodada, instabilidade, leitor, con
         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.ambienteFuncional ? { ambienteFuncional: true } : {}),
             ...(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])),
-                        ...(itens.length > 1 ? { [check_modo_1.ENV_VARREDURA_PARALELA_DO_CHECK]: String((0, check_agil_1.paralelismoDaVarreduraNoGrupo)()) } : {}) } : {}) } }));
+                        ...(itens.length > 1 ? { [check_modo_1.ENV_VARREDURA_PARALELA_DO_CHECK]: String((0, check_agil_1.paralelismoDaVarreduraNoGrupo)()) } : {}) } : {}),
+                ...(i.nome.startsWith('test:') ? {
+                    ...(ambienteDaRodada.TMPDIR ? { [temporario_das_lanes_1.ENV_TMPDIR_DA_RODADA]: '1' } : {}),
+                    ...(0, ambiente_funcional_1.transporteDoAmbienteFuncional)(ambienteDoVerify()),
+                } : {}) } }));
         // 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);
@@ -604,24 +703,59 @@ function executorDoGrupo(manifesto, ambienteDaRodada, instabilidade, leitor, con
     executar.pecas = [];
     return executar;
 }
+/** Um unico TMPDIR observavel por lanes e claims; o verify e o unico dono da limpeza. */
+function abrirTemporarioDaRodada() {
+    const selecao = (0, temporario_das_lanes_1.selecionarTemporario)();
+    const dir = fs.mkdtempSync(path.join(selecao.diretorio, 'ork-verify-tmp-'));
+    return {
+        dir,
+        ambiente: { TMPDIR: dir },
+        peca: { peca: 'tmpfs-das-lanes', estado: selecao.estado,
+            motivo: selecao.motivo, tmpdirDaRodada: true,
+            ...(selecao.estado === 'fallback' ? { fallback: 'disco' } : {}) },
+        fechar: () => fs.rmSync(dir, { recursive: true, force: true }),
+    };
+}
+/** O dono da rodada fecha todos os recursos mesmo quando uma execução lança exceção. */
+function fecharRecursosDaRodada(relatorio, temporario, casa = null) {
+    try {
+        relatorio?.fechar();
+    }
+    finally {
+        try {
+            temporario?.fechar();
+        }
+        finally {
+            if (casa && !temporario)
+                fs.rmSync(casa, { recursive: true, force: true });
+        }
+    }
+}
 /**
  * RM-072 (D8): le o relatorio das pecas da rodada, grava a lista inteira de cada lane em
  * `.orkastery/threads/<id>/check/<commit>-lanes.json` e devolve o resumo do Agile para o `verify_run`.
  */
 function agileNoLedger(raiz, threadId, commit, pecasDoVerify, doAgile, guarda, relatorio, claims) {
     const linhas = relatorio.ler();
-    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 usosDasLanes = claims.flatMap((c) => c.execucoes.filter((e) => e.lane).map((e) => e.lane));
+    const pecasDasClaims = claims.flatMap((c) => c.execucoes.filter((e) => e.lane).map((e) => {
+        const lane = e.lane;
+        return lane.reaproveitada
+            ? { peca: 'claim-lane', estado: 'agile', claim: e.nome,
+                motivo: `reaproveitada das lanes ${lane.lanes.join(', ')} desta rodada` }
+            : { peca: 'claim-lane', estado: 'fallback', claim: e.nome, motivo: lane.motivo, motivoTipado: lane.motivo,
+                fallback: 'claim inteira' };
+    }));
     const resumo = {
-        pecas: [...pecasDoVerify, ...doRelatorio],
+        pecas: [...pecasDoVerify, ...doRelatorio, ...pecasDasClaims],
         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,
-            lanes: usosDasLanes.length },
+            lanes: usosDasLanes.filter((u) => u.reaproveitada).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),
     };
@@ -691,63 +825,75 @@ function gravarBaselineSobConducao(carregado, threadId, base, tomada, origem, le
     exigirDependenciasDaWorktree(carregado, threadId, cwd, 'baseline', tomada, base);
     // RM-072 (D1, D2): a baseline roda e grava no modo da rodada, como o verify.
     const check = (0, check_modo_1.resolverModo)(manifesto.check?.mode, modo);
-    const relatorio = check.modo === 'agile' ? new check_agil_1.RelatorioDoCheck() : null;
-    const ambienteDaRodada = { ...ambienteDoModo(check), ...relatorio?.ambiente() };
-    const instabilidade = (0, instabilidade_1.lerRegistroDeInstabilidade)(cwd);
-    const executor = executorSobConducao(executorDaRodada(manifesto, instabilidade, base, leitor, ambienteDaRodada), manifesto, tomada);
-    // RM-072 (S-b do CHECK 2): fora do preparo, so a varredura e as lanes recebem o relatorio.
-    const executorDosComandos = relatorio
-        ? soAVarreduraEAsLanesComRelatorio(executor, executorSobConducao(executorDaRodada(manifesto, instabilidade, base, leitor, ambienteDoModo(check)), manifesto, tomada))
-        : executor;
-    // RM-072 (D4): no Agile com o produto declarado, o preparo, a guarda e o mesmo grupo do verify; sem o produto, nada
-    // 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 comandosDoManifestoExecutados = relatorio && manifesto.check?.agile?.produto?.length
-        ? (() => {
-            const p = (0, check_agil_1.prepararNoAgile)(manifesto, cwd, executor);
-            pecasDaBaseline.push(...p.pecas);
-            const r = (0, check_agil_1.comandosNoAgile)(manifesto, cwd, comandosDoManifesto(manifesto), executorDosComandos, executorDoGrupo(manifesto, ambienteDaRodada, instabilidade, leitor, tomada, base ? executor : undefined), guardaDoPreparo(manifesto, cwd, p.resultado), p.resultado);
-            pecasDaBaseline.push(...r.pecas);
-            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);
-        pecasDaBaseline.push(...(0, check_agil_1.pecasDoRelatorio)(relatorio.ler()));
-        relatorio.fechar();
+    let relatorio = null;
+    let temporarioDaRodada = null;
+    try {
+        relatorio = check.modo === 'agile' ? new check_agil_1.RelatorioDoCheck() : null;
+        temporarioDaRodada = relatorio && Object.keys(manifesto.check?.agile?.test ?? {}).length > 0
+            ? abrirTemporarioDaRodada() : null;
+        const ambienteFuncional = { ...ambienteDoModo(check), ...temporarioDaRodada?.ambiente };
+        const ambienteDaRodada = { ...ambienteFuncional, ...relatorio?.ambiente() };
+        const instabilidade = (0, instabilidade_1.lerRegistroDeInstabilidade)(cwd);
+        const executor = executorSobConducao(executorDaRodada(manifesto, instabilidade, base, leitor, ambienteDaRodada), manifesto, tomada);
+        // RM-072 (S-b do CHECK 2): fora do preparo, so a varredura e as lanes recebem o relatorio.
+        const executorDaLane = temporarioDaRodada
+            ? executorSobConducao(executorDaRodada(manifesto, instabilidade, base, leitor, { ...ambienteDaRodada, [temporario_das_lanes_1.ENV_TMPDIR_DA_RODADA]: '1', ...(0, ambiente_funcional_1.transporteDoAmbienteFuncional)(ambienteDoVerify()) }), manifesto, tomada)
+            : executor;
+        const executorDosComandos = relatorio
+            ? soAVarreduraEAsLanesComRelatorio(executor, executorSobConducao(executorDaRodada(manifesto, instabilidade, base, leitor, ambienteFuncional), manifesto, tomada), executorDaLane)
+            : executor;
+        // RM-072 (D4): no Agile com o produto declarado, o preparo, a guarda e o mesmo grupo do verify; sem o produto, nada
+        // 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 = temporarioDaRodada ? [temporarioDaRodada.peca] : [];
+        const comandosDoManifestoExecutados = relatorio && manifesto.check?.agile?.produto?.length
+            ? (() => {
+                const p = (0, check_agil_1.prepararNoAgile)(manifesto, cwd, executor);
+                pecasDaBaseline.push(...p.pecas);
+                const r = (0, check_agil_1.comandosNoAgile)(manifesto, cwd, comandosDoManifesto(manifesto), executorDosComandos, executorDoGrupo(manifesto, ambienteDaRodada, instabilidade, leitor, tomada, base ? executor : undefined), guardaDoPreparo(manifesto, cwd, p.resultado), p.resultado);
+                pecasDaBaseline.push(...r.pecas);
+                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);
+            pecasDaBaseline.push(...(0, check_agil_1.pecasDoRelatorio)(relatorio.ler()));
+        }
+        // N1 do CHECK 2: a lane que saiu com 127 tambem e dependencia ausente, como o comando so do Classic.
+        const naoEncontrado = comandos.find((c) => c.causa === 'nao-encontrado')
+            ?? comandos.flatMap((c) => (c.lanes ?? []).filter((l) => l.causa === 'nao-encontrado')
+                .map((l) => ({ nome: `${c.nome}:${l.lane}`, code: l.code, comando: l.comando })))[0];
+        if (naoEncontrado) {
+            // Uma dependencia ausente nao e divida do codigo: o comando nem chegou a existir. Gravar isso
+            // como "ja falhava" faria todo verify futuro aceitar a falta da ferramenta como baseline.
+            throw new locale_1.ErroDoCatalogo((m) => m.verify.baselineDependenciaAusente(naoEncontrado.nome, naoEncontrado.code, (0, redacao_url_1.redigirCredenciaisUrl)(naoEncontrado.comando), manifesto.worktree.dependencias ?? null));
+        }
+        const baseline = { commit: commitReal(cwd), gravadaEm: (0, util_1.agora)(), comandos, check: { modo: check.modo, origem: check.origem } };
+        thread.baseline = baseline;
+        (0, thread_1.gravarThread)(raiz, thread);
+        (0, ledger_1.registrar)((0, thread_1.dirThread)(raiz, threadId), threadId, ledger_1.TIPOS_DE_EVENTO.baselineGravada, {
+            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.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 } } : {}),
+            // RM-037 (defeito 1 de 19 e 20/10/2026): o que a baseline nao provou fica dito no proprio evento.
+            semVeredito: comandos.filter((c) => vereditoDaBaseline(c) === 'sem-veredito').map((c) => c.nome),
+            fonte: 'execucao real no HEAD, nao relatorio de fase',
+            origem,
+        });
+        return baseline;
     }
-    // N1 do CHECK 2: a lane que saiu com 127 tambem e dependencia ausente, como o comando so do Classic.
-    const naoEncontrado = comandos.find((c) => c.causa === 'nao-encontrado')
-        ?? comandos.flatMap((c) => (c.lanes ?? []).filter((l) => l.causa === 'nao-encontrado')
-            .map((l) => ({ nome: `${c.nome}:${l.lane}`, code: l.code, comando: l.comando })))[0];
-    if (naoEncontrado) {
-        // Uma dependencia ausente nao e divida do codigo: o comando nem chegou a existir. Gravar isso
-        // como "ja falhava" faria todo verify futuro aceitar a falta da ferramenta como baseline.
-        throw new locale_1.ErroDoCatalogo((m) => m.verify.baselineDependenciaAusente(naoEncontrado.nome, naoEncontrado.code, (0, redacao_url_1.redigirCredenciaisUrl)(naoEncontrado.comando), manifesto.worktree.dependencias ?? null));
+    finally {
+        fecharRecursosDaRodada(relatorio, temporarioDaRodada);
     }
-    const baseline = { commit: commitReal(cwd), gravadaEm: (0, util_1.agora)(), comandos, check: { modo: check.modo, origem: check.origem } };
-    thread.baseline = baseline;
-    (0, thread_1.gravarThread)(raiz, thread);
-    (0, ledger_1.registrar)((0, thread_1.dirThread)(raiz, threadId), threadId, ledger_1.TIPOS_DE_EVENTO.baselineGravada, {
-        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.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 } } : {}),
-        // RM-037 (defeito 1 de 19 e 20/10/2026): o que a baseline nao provou fica dito no proprio evento.
-        semVeredito: comandos.filter((c) => vereditoDaBaseline(c) === 'sem-veredito').map((c) => c.nome),
-        fonte: 'execucao real no HEAD, nao relatorio de fase',
-        origem,
-    });
-    return baseline;
 }
 function nomesUnicos(nomes) {
     return [...new Set(nomes ?? [])];
@@ -829,6 +975,71 @@ function verificarClaim(claim, cwd, executor = executar) {
         execucoes,
     };
 }
+const RECUSAS_AGENDAVEIS_DAS_LANES = new Set([
+    'evidencia-vazia', 'arquivo-nao-executado', 'head-divergente', 'ambiente-funcional-divergente', 'falha-na-lane',
+    'skip-ou-todo-na-lane', 'prefixo-divergente', 'contagem-abaixo-do-minimo', 'tap-com-test-name-pattern',
+]);
+function claimRecusadaAgendavel(planos) {
+    return planos.length > 0 && planos.every((p) => p.lane && !p.lane.reaproveitada
+        && RECUSAS_AGENDAVEIS_DAS_LANES.has(p.lane.motivo));
+}
+/**
+ * RM-074 M12: claims consecutivas que aguardavam as lanes, mas preservaram a execucao real, recebem vagas do mesmo
+ * executor paralelo. O campo canonico `claim.arquivo` encadeia o mesmo domicilio; uma claim de outra classe e barreira.
+ */
+function verificarClaimsAgendadas(claims, cwd, executor, planejar, grupo) {
+    const saida = [];
+    let indice = 0;
+    while (indice < claims.length) {
+        const planosDa = (claim) => claim.verificar.map((comando, i) => planejar(`${claim.id}.${i + 1}`, comando, cwd));
+        const primeiro = planosDa(claims[indice]);
+        if (!claimRecusadaAgendavel(primeiro)) {
+            saida.push(verificarClaim(claims[indice], cwd, executor));
+            indice++;
+            continue;
+        }
+        const lote = [
+            { claim: claims[indice], planos: primeiro },
+        ];
+        let fim = indice + 1;
+        while (fim < claims.length) {
+            const planos = planosDa(claims[fim]);
+            if (!claimRecusadaAgendavel(planos))
+                break;
+            lote.push({ claim: claims[fim], planos });
+            fim++;
+        }
+        if (new Set(lote.map((x) => x.claim.arquivo)).size < 2) {
+            for (const x of lote)
+                saida.push(verificarClaim(x.claim, cwd, executor));
+            indice = fim;
+            continue;
+        }
+        const ultimoPorArquivo = new Map();
+        const itens = lote.flatMap(({ claim, planos }) => planos.map((plano) => {
+            const anterior = ultimoPorArquivo.get(claim.arquivo);
+            ultimoPorArquivo.set(claim.arquivo, plano.nome);
+            return { nome: plano.nome, comando: plano.comandoExecutado ?? plano.comando, papelCpu: 'claim',
+                ambienteFuncional: true,
+                ...(anterior ? { apos: [anterior] } : {}) };
+        }));
+        const reais = grupo(itens, cwd);
+        const porNome = new Map();
+        let posicao = 0;
+        for (const { planos } of lote)
+            for (const plano of planos) {
+                const real = reais[posicao++];
+                porNome.set(plano.nome, { ...real, nome: plano.nome, comando: plano.comando,
+                    ...(plano.comandoExecutado ? { comandoExecutado: plano.comandoExecutado } : {}),
+                    ...(plano.preparo ? { preparo: plano.preparo } : {}), ...(plano.lane ? { lane: plano.lane } : {}) });
+            }
+        for (const { claim } of lote) {
+            saida.push(verificarClaim(claim, cwd, (nome) => porNome.get(nome)));
+        }
+        indice = fim;
+    }
+    return saida;
+}
 /**
  * `ork verify`: reexecuta claims e comandos do manifesto e classifica cada falha.
  * Nao decide pausa, decide VERDADE: quem pausa e o gate do modo de conducao.
@@ -859,338 +1070,372 @@ function verificarSobConducao(carregado, threadId, opcoes, conducao, canal, fila
     // `ork verify` roda em toda fase, e uma claim por criterio por rodada viraria
     // acumulador em vez de verificacao.
     (0, claims_1.registrarCriteriosDePronto)(raiz, threadId);
+    const claimsAtivas = (0, claims_1.lerClaims)(raiz, threadId).filter((c) => c.estado !== 'retirada');
     // RM-037 (fatia 6): o registro de instabilidade da arvore verificada e a janela de steal da rodada.
     const instabilidade = (0, instabilidade_1.lerRegistroDeInstabilidade)(cwd, opcoes.agoraMs);
     const leitor = opcoes.lerProcStat ?? steal_1.lerProcStat;
     const janelaDaRodada = (0, steal_1.abrirJanela)(leitor);
     // 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 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 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(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;
-    // I-54 (D10): o preparo roda UMA vez, antes das claims. Ele nunca e condicao para uma claim
-    // passar (cada uma roda o proprio comando inteiro); ele so deixa pronta a compilacao. A
-    // identidade do produto e tomada logo depois dele e conferida no fim da rodada.
-    // RM-072 (D4): no Agile, o preparo do Agile primeiro, com o `verify.preparo` de fallback.
-    const pecas = [];
-    const preparo = agil
-        ? (() => {
-            const p = (0, check_agil_1.prepararNoAgile)(manifesto, cwd, executor);
-            pecas.push(...p.pecas);
-            return p.resultado ? { resultado: p.resultado, identidade: identidadeDoProduto(cwd) } : null;
-        })()
-        : manifesto.verify.preparo ? (() => {
-            const resultado = executor('preparo', manifesto.verify.preparo, cwd);
-            return { resultado, identidade: identidadeDoProduto(cwd) };
-        })() : null;
-    // RM-072 (A6 do CHECK): com executor injetado (MCP, testes), o ambiente da rodada nao chega aos comandos; o ledger diz.
-    if (agil && opcoes.executor)
-        pecas.push(check_agil_1.PECA_SEM_RELATORIO);
-    // RM-072 (D5): a guarda do produto, tomada no fim do preparo.
-    const vigente = agil
-        ? { guarda: guardaDoPreparo(manifesto, cwd, preparo?.resultado ?? null), preparo: preparo?.resultado ?? null }
-        : null;
-    // RM-072 (A1, S-a, S-d e S-h do CHECK): a claim que compilou de novo (o build no meio da cadeia) muda o produto sem mudar
-    // a arvore; o preparo roda de novo antes da claim seguinte que o reaproveitaria, ate MAXIMO_DE_PREPAROS_REFEITOS vezes,
-    // e uma vez antes do grupo, e a peca diz o que aconteceu.
-    const refazer = (quando) => {
-        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, selecaoAnterior, (nome, comando, dir, filtro, testes) => executarPassagemParcial(nome, comando, dir, executorDosComandos, filtro, testes), selecaoPorMudanca.lanes)).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, executorComLanes, vigente, refazerAntesDaClaim) : executorComLanes;
-    const claims = (0, claims_1.lerClaims)(raiz, threadId)
-        .filter((c) => c.estado !== 'retirada')
-        .map((c) => verificarClaim(c, cwd, executorDaClaim));
-    for (const r of claims) {
-        // Estouro de prazo e comando que nao rodou nao julgam a alegacao: o estado anterior vale.
-        if (r.motivo === 'verify.timeout' || r.motivo === 'verify.sem-veredito')
-            continue;
-        const estado = r.verificado
-            ? 'verificado'
-            : r.motivo === 'claims.unverifiable'
-                ? 'nao-verificavel'
-                : 'reprovado';
-        if (r.claim.estado !== estado)
-            (0, claims_1.carimbarEstado)(raiz, r.claim, estado);
-    }
-    // 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, 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, 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]));
+    let relatorio = null;
+    let temporarioDaRodada = null;
+    let casaDaRodada = null;
+    try {
+        relatorio = agil ? new check_agil_1.RelatorioDoCheck() : null;
+        temporarioDaRodada = agil && Object.keys(manifesto.check?.agile?.test ?? {}).length > 0
+            ? abrirTemporarioDaRodada() : null;
+        casaDaRodada = agil && !(process.env.ORKASTERY_HOME || '').trim()
+            ? fs.mkdtempSync(path.join(temporarioDaRodada?.dir ?? os.tmpdir(), 'ork-verify-casa-')) : null;
+        const ambienteFuncional = { ...ambienteDoModo(check), ...temporarioDaRodada?.ambiente,
+            ...(casaDaRodada ? { ORKASTERY_HOME: casaDaRodada } : {}) };
+        const ambienteDaRodada = { ...ambienteFuncional, ...relatorio?.ambiente() };
+        const ambienteFuncionalDasLanes = { ...temporarioDaRodada?.ambiente,
+            ...(casaDaRodada ? { ORKASTERY_HOME: casaDaRodada } : {}) };
+        const ambienteEfetivoDasClaims = (0, ambiente_funcional_1.ambienteFuncionalDosTestes)(ambienteDoVerify(), ambienteFuncionalDasLanes);
+        // 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 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(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 baseDasClaimsComoLane = opcoes.executor
+            ?? executorDoManifesto(manifesto, undefined, ambienteEfetivoDasClaims);
+        const executorDasClaimsComoLane = relatorio
+            ? executorSobConducao(observar(executorDaRodada(manifesto, instabilidade, baseDasClaimsComoLane, leitor)), manifesto, conducao)
+            : executor;
+        const executorDaLane = relatorio && temporarioDaRodada
+            ? executorSobConducao(observar(executorDaRodada(manifesto, instabilidade, opcoes.executor, leitor, { ...ambienteDaRodada, [temporario_das_lanes_1.ENV_TMPDIR_DA_RODADA]: '1', ...(0, ambiente_funcional_1.transporteDoAmbienteFuncional)(ambienteDoVerify()) })), 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, executorDaLane) : executor;
+        // I-54 (D10): o preparo roda UMA vez, antes das claims. Ele nunca e condicao para uma claim
+        // passar (cada uma roda o proprio comando inteiro); ele so deixa pronta a compilacao. A
+        // identidade do produto e tomada logo depois dele e conferida no fim da rodada.
+        // RM-072 (D4): no Agile, o preparo do Agile primeiro, com o `verify.preparo` de fallback.
+        const pecas = temporarioDaRodada ? [temporarioDaRodada.peca] : [];
+        const preparo = agil
+            ? (() => {
+                const p = (0, check_agil_1.prepararNoAgile)(manifesto, cwd, executor);
+                pecas.push(...p.pecas);
+                return p.resultado ? { resultado: p.resultado, identidade: identidadeDoProduto(cwd) } : null;
+            })()
+            : manifesto.verify.preparo ? (() => {
+                const resultado = executor('preparo', manifesto.verify.preparo, cwd);
+                return { resultado, identidade: identidadeDoProduto(cwd) };
+            })() : null;
+        // RM-072 (A6 do CHECK): com executor injetado (MCP, testes), o ambiente da rodada nao chega aos comandos; o ledger diz.
+        if (agil && opcoes.executor)
+            pecas.push(check_agil_1.PECA_SEM_RELATORIO);
+        // RM-072 (D5): a guarda do produto, tomada no fim do preparo.
+        const vigente = agil
+            ? { guarda: guardaDoPreparo(manifesto, cwd, preparo?.resultado ?? null), preparo: preparo?.resultado ?? null }
+            : null;
+        // RM-072 (A1, S-a, S-d e S-h do CHECK): a claim que compilou de novo (o build no meio da cadeia) muda o produto sem mudar
+        // a arvore; o preparo roda de novo antes da claim seguinte que o reaproveitaria, ate MAXIMO_DE_PREPAROS_REFEITOS vezes,
+        // e uma vez antes do grupo, e a peca diz o que aconteceu.
+        const refazer = (quando) => {
+            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;
+        const planoDasClaims = grupoAntesDasClaims
+            ? (0, check_agil_1.planejarClaimsNoAgile)(manifesto, claimsAtivas, cwd, vigente.guarda, vigente.preparo) : undefined;
+        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, selecaoAnterior, (nome, comando, dir, filtro, testes) => executarPassagemParcial(nome, comando, dir, executorDosComandos, filtro, testes), selecaoPorMudanca.lanes, planoDasClaims)).comandos
+            : [];
         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 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();
-    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 ?? []);
-    const baseline = thread.baseline ?? null;
-    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) {
-        // 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 (!atual.ok && semVereditoPorTempo(atual)) {
-            estouros.push(atual);
-            continue;
+        const claimsAntecipadas = doAgile?.claimsAntecipadas ?? {};
+        if (Object.keys(claimsAntecipadas).length > 0 && vigente?.guarda.conferir())
+            lanesVigentes = false;
+        const evidenciasDasLanes = relatorio && doAgile ? (0, check_agil_1.resultadosDasLanes)(relatorio.ler()) : [];
+        const vigenciaDasLanes = () => !lanesVigentes ? 'lanes-invigentes' : vigente?.guarda.conferir() ?? null;
+        const executorComLanes = agil
+            ? (0, check_agil_1.executorDaClaimPelasLanes)(executorDasClaims, evidenciasDasLanes, { head: commit, ambiente: ambienteEfetivoDasClaims,
+                podeReaproveitar: vigenciaDasLanes, 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, executorComLanes, vigente, refazerAntesDaClaim) : executorComLanes;
+        // RM-074 M11 com M12: a claim antecipada ja tem o resultado real do grupo. O plano a devolve como esta, ela nunca
+        // entra num lote de claims recusadas pelas lanes e segue pelo caminho serial com o mesmo resultado.
+        const executorComAntecipadas = (nome, comando, dir) => claimsAntecipadas[nome] ?? executorDaClaim(nome, comando, dir);
+        const claims = vigente ? (() => {
+            const executorDePlano = (nome, comando) => ({ nome, comando, ok: true, code: 0, resumo: '', causa: 'exit',
+                prazoMs: prazoDaExecucao(manifesto, nome, comando), duracaoMs: 0, executado: true });
+            const planoComLanes = (0, check_agil_1.executorDaClaimPelasLanes)(executorDePlano, evidenciasDasLanes, { head: commit, ambiente: ambienteEfetivoDasClaims, podeReaproveitar: vigenciaDasLanes, executorEquivalente: executorDePlano });
+            // Planejar nunca refaz preparo nem toca no produto: guarda invalida vira barreira e a execucao serial decide o refazer.
+            const planejarPelasLanes = (0, check_agil_1.executorDaClaimNoAgile)(manifesto, planoComLanes, vigente);
+            const planejar = (nome, comando, dir) => claimsAntecipadas[nome] ?? planejarPelasLanes(nome, comando, dir);
+            const grupoDasClaims = executorDoGrupo(manifesto, ambienteFuncionalDasLanes, instabilidade, leitor, conducao, opcoes.executor ? executorDasClaimsComoLane : undefined);
+            return verificarClaimsAgendadas(claimsAtivas, cwd, executorComAntecipadas, planejar, grupoDasClaims);
+        })() : claimsAtivas.map((c) => verificarClaim(c, cwd, executorComAntecipadas));
+        for (const r of claims) {
+            // Estouro de prazo e comando que nao rodou nao julgam a alegacao: o estado anterior vale.
+            if (r.motivo === 'verify.timeout' || r.motivo === 'verify.sem-veredito')
+                continue;
+            const estado = r.verificado
+                ? 'verificado'
+                : r.motivo === 'claims.unverifiable'
+                    ? 'nao-verificavel'
+                    : 'reprovado';
+            if (r.claim.estado !== estado)
+                (0, claims_1.carimbarEstado)(raiz, r.claim, estado);
         }
-        const antes = baseline?.comandos.find((c) => c.nome === atual.nome);
-        if (!antes || vereditoDaBaseline(antes) === 'sem-veredito') {
-            if (!atual.ok)
-                falhasSemBaseline.push(atual);
-            continue;
+        // 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, selecaoAnterior, (nome, comando, dir, filtro, testes) => executarPassagemParcial(nome, comando, dir, executorDosComandos, filtro, testes), selecaoPorMudanca.lanes);
+            comandosDoManifestoExecutados = doAgile.comandos;
+            pecas.push(...doAgile.pecas);
         }
-        const comparacao = compararComBaseline(atual, antes);
-        if (!comparacao)
-            continue;
-        comparacoes.push(comparacao);
-        if (comparacao.granularidade === 'teste') {
-            if (comparacao.regressoes.length > 0)
+        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, 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);
+        }
+        const changelog = opcoes.soClaims ? null
+            : 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;
+        // 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 ?? []);
+        const baseline = thread.baseline ?? null;
+        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) {
+            // 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 (!atual.ok && semVereditoPorTempo(atual)) {
+                estouros.push(atual);
+                continue;
+            }
+            const antes = baseline?.comandos.find((c) => c.nome === atual.nome);
+            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);
-            if (comparacao.preExistentes.length > 0)
+            }
+            else if (comparacao.classificacaoDoComando === 'pre-existente') {
                 preExistentes.push(atual);
+            }
         }
-        else if (comparacao.classificacaoDoComando === 'regressao') {
-            regressoes.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;
+        const produtoAlterado = !!preparo && identidadeFinal !== preparo.identidade;
+        const naoExecutados = comandos.filter((c) => c.executado === false);
+        const rodadaPct = janelaDaRodada.fechar();
+        const todos = [...(preparo ? [preparo.resultado] : []), ...claims.flatMap((c) => c.execucoes), ...comandos];
+        const steal = {
+            fonte: steal_1.FONTE_STEAL,
+            medido: rodadaPct !== null,
+            rodadaPct,
+            limiarPct: steal_1.LIMIAR_STEAL_PCT,
+            porComando: Object.fromEntries(todos.map((c) => [c.nome, c.stealPct ?? null])),
+            relogioSobSteal: todos.filter((c) => c.relogioSobSteal?.length).map((c) => c.nome),
+        };
+        const motivos = [];
+        if (claims.some((c) => c.motivo === 'claims.failed'))
+            motivos.push('claims.failed');
+        if (claims.some((c) => c.motivo === 'claims.unverifiable'))
+            motivos.push('claims.unverifiable');
+        if (regressoes.length > 0)
+            motivos.push('verify.regression');
+        if (falhasSemBaseline.length > 0)
+            motivos.push('verify.failed');
+        if (estouros.length > 0 || claims.some((c) => c.motivo === 'verify.timeout'))
+            motivos.push('verify.timeout');
+        if (produtoAlterado || naoExecutados.length > 0 || claims.some((c) => c.motivo === 'verify.sem-veredito')) {
+            motivos.push('verify.sem-veredito');
         }
-        else if (comparacao.classificacaoDoComando === 'pre-existente') {
-            preExistentes.push(atual);
+        if (dadoPrivadoBloqueia.length > 0)
+            motivos.push('policy.violation');
+        const bloqueantes = motivos.filter((m) => m !== 'claims.unverifiable');
+        const ok = bloqueantes.length === 0;
+        const duracaoMs = Date.now() - inicioDaRodada;
+        (0, ledger_1.registrar)(dir, threadId, ledger_1.TIPOS_DE_EVENTO.verificacao, {
+            commit,
+            recibo: (0, recibo_prova_1.chaveDoReciboDeProva)(raiz, threadId, commit),
+            cwd,
+            claims: claims.map((c) => {
+                const falhou = c.execucoes.find((e) => !e.ok);
+                const execucoesSeguras = c.execucoes.map(resultadoDeComandoRedigido);
+                return {
+                    id: c.claim.id,
+                    verificarSha256: impressaoDosComandos(c.claim.verificar),
+                    verificado: c.verificado,
+                    motivo: c.motivo,
+                    detalhe: (0, hitl_1.redigirSegredos)(c.detalhe),
+                    // RM-072 (D2): a soma da parede dos comandos da claim.
+                    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.
+                    ...(execucoesSeguras.some((e) => e.preparo) ? { preparo: execucoesSeguras.map((e) => e.preparo ?? null) } : {}),
+                    ...(c.execucoes.some((e) => e.agendamento) ? { agendamento: c.execucoes.map((e) => e.agendamento ?? null) } : {}),
+                    ...(c.execucoes.some((e) => e.lane) ? { lane: c.execucoes.map((e) => e.lane ?? null) } : {}),
+                    ...(falhou ? { execucao: comandoNoLedger(falhou) } : {}),
+                };
+            }),
+            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),
+            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,
+            steal,
+            ...(instabilidade.presente ? { instabilidade: { contrato: 'ork.instabilidade/v1', arquivo: instabilidade.arquivo,
+                    vigentes: instabilidade.vigentes.map((e) => e.teste), vencidas: instabilidade.vencidas.map((e) => e.teste),
+                    erros: instabilidade.erros } } : {}),
+            ...(preparo ? { preparo: { ...comandoNoLedger(preparo.resultado), duracaoMs: preparo.resultado.duracaoMs,
+                    identidade: preparo.identidade.slice(0, 16), identidadeFinal: identidadeFinal.slice(0, 16), produtoAlterado } } : {}),
+            motivos,
+            veredito: ok ? 'verdade sustentada' : 'reprovado',
+            // RM-072 (D1, D2): o modo do CHECK e de onde ele veio, e a parede da rodada inteira.
+            check: checkNoLedger(check),
+            duracaoMs,
+            // RM-072 (D8): no Agile, as pecas, o grupo, o reaproveitamento e as listas das lanes.
+            ...(resumoDoAgile ? { agile: resumoDoAgile } : {}),
+            // I-36: por qual canal a verificacao chegou; a reentrada da sessao que conduz aparece aqui.
+            canal,
+            conducao: { identidade: conducao.identidade, reentrada: conducao.reentrada },
+            // RM-058 N2: se a rodada esperou a vez na fila pesada, e quanto.
+            filaPesada,
+            // RM-062 (F2): contagens, padroes e onde; nunca o valor casado nem o termo da lista local.
+            ...(dadoPrivado ? { dadoPrivado: (0, dado_privado_1.resumoNoLedger)(dadoPrivado) } : {}),
+        });
+        // RM-062 (F2): em `warn`, a barreira registra e segue, como toda policy de aviso.
+        for (const v of (0, policies_1.avisos)(dadoPrivado?.violacoes ?? [])) {
+            (0, ledger_1.registrar)(dir, threadId, ledger_1.TIPOS_DE_EVENTO.politicaAviso, { gate: 'verify', policy: v.policy, motivo: v.motivo,
+                detalhe: v.detalhe, correcao: v.correcao, modo: thread.modo });
         }
-    }
-    // I-54 (D11): o produto mudou entre o preparo e o fim da rodada? Entao nenhum veredito vale.
-    const identidadeFinal = preparo ? identidadeDoProduto(cwd) : null;
-    const produtoAlterado = !!preparo && identidadeFinal !== preparo.identidade;
-    const naoExecutados = comandos.filter((c) => c.executado === false);
-    const rodadaPct = janelaDaRodada.fechar();
-    const todos = [...(preparo ? [preparo.resultado] : []), ...claims.flatMap((c) => c.execucoes), ...comandos];
-    const steal = {
-        fonte: steal_1.FONTE_STEAL,
-        medido: rodadaPct !== null,
-        rodadaPct,
-        limiarPct: steal_1.LIMIAR_STEAL_PCT,
-        porComando: Object.fromEntries(todos.map((c) => [c.nome, c.stealPct ?? null])),
-        relogioSobSteal: todos.filter((c) => c.relogioSobSteal?.length).map((c) => c.nome),
-    };
-    const motivos = [];
-    if (claims.some((c) => c.motivo === 'claims.failed'))
-        motivos.push('claims.failed');
-    if (claims.some((c) => c.motivo === 'claims.unverifiable'))
-        motivos.push('claims.unverifiable');
-    if (regressoes.length > 0)
-        motivos.push('verify.regression');
-    if (falhasSemBaseline.length > 0)
-        motivos.push('verify.failed');
-    if (estouros.length > 0 || claims.some((c) => c.motivo === 'verify.timeout'))
-        motivos.push('verify.timeout');
-    if (produtoAlterado || naoExecutados.length > 0 || claims.some((c) => c.motivo === 'verify.sem-veredito')) {
-        motivos.push('verify.sem-veredito');
-    }
-    if (dadoPrivadoBloqueia.length > 0)
-        motivos.push('policy.violation');
-    const bloqueantes = motivos.filter((m) => m !== 'claims.unverifiable');
-    const ok = bloqueantes.length === 0;
-    const duracaoMs = Date.now() - inicioDaRodada;
-    (0, ledger_1.registrar)(dir, threadId, ledger_1.TIPOS_DE_EVENTO.verificacao, {
-        commit,
-        cwd,
-        claims: claims.map((c) => {
-            const falhou = c.execucoes.find((e) => !e.ok);
-            return {
-                id: c.claim.id,
-                verificado: c.verificado,
-                motivo: c.motivo,
-                detalhe: c.detalhe,
-                // RM-072 (D2): a soma da parede dos comandos da claim.
-                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) } : {}),
-            };
-        }),
-        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),
-        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,
-        steal,
-        ...(instabilidade.presente ? { instabilidade: { contrato: 'ork.instabilidade/v1', arquivo: instabilidade.arquivo,
-                vigentes: instabilidade.vigentes.map((e) => e.teste), vencidas: instabilidade.vencidas.map((e) => e.teste),
-                erros: instabilidade.erros } } : {}),
-        ...(preparo ? { preparo: { ...comandoNoLedger(preparo.resultado), duracaoMs: preparo.resultado.duracaoMs,
-                identidade: preparo.identidade.slice(0, 16), identidadeFinal: identidadeFinal.slice(0, 16), produtoAlterado } } : {}),
-        motivos,
-        veredito: ok ? 'verdade sustentada' : 'reprovado',
-        // RM-072 (D1, D2): o modo do CHECK e de onde ele veio, e a parede da rodada inteira.
-        check: checkNoLedger(check),
-        duracaoMs,
-        // RM-072 (D8): no Agile, as pecas, o grupo, o reaproveitamento e as listas das lanes.
-        ...(resumoDoAgile ? { agile: resumoDoAgile } : {}),
-        // I-36: por qual canal a verificacao chegou; a reentrada da sessao que conduz aparece aqui.
-        canal,
-        conducao: { identidade: conducao.identidade, reentrada: conducao.reentrada },
-        // RM-058 N2: se a rodada esperou a vez na fila pesada, e quanto.
-        filaPesada,
-        // RM-062 (F2): contagens, padroes e onde; nunca o valor casado nem o termo da lista local.
-        ...(dadoPrivado ? { dadoPrivado: (0, dado_privado_1.resumoNoLedger)(dadoPrivado) } : {}),
-    });
-    // RM-062 (F2): em `warn`, a barreira registra e segue, como toda policy de aviso.
-    for (const v of (0, policies_1.avisos)(dadoPrivado?.violacoes ?? [])) {
-        (0, ledger_1.registrar)(dir, threadId, ledger_1.TIPOS_DE_EVENTO.politicaAviso, { gate: 'verify', policy: v.policy, motivo: v.motivo,
-            detalhe: v.detalhe, correcao: v.correcao, modo: thread.modo });
-    }
-    for (const motivo of bloqueantes) {
-        (0, gates_1.registrarGateBloqueado)(dir, threadId, {
-            gate: 'verify',
-            motivo,
-            modo: thread.modo,
-            detalhe: motivo === 'claims.failed'
-                ? claims
-                    .filter((c) => c.motivo === 'claims.failed')
-                    .map((c) => `${c.claim.id}: ${c.detalhe}`)
-                    .join('; ')
-                : motivo === 'verify.regression'
-                    ? `regressao em: ${comparacoes.flatMap((c) => c.granularidade === 'teste'
-                        ? c.regressoes.map((teste) => `${c.comando}: ${teste}`)
-                        : c.classificacaoDoComando === 'regressao' ? [c.comando] : []).join(', ')}`
+        for (const motivo of bloqueantes) {
+            (0, gates_1.registrarGateBloqueado)(dir, threadId, {
+                gate: 'verify',
+                motivo,
+                modo: thread.modo,
+                detalhe: motivo === 'claims.failed'
+                    ? claims
+                        .filter((c) => c.motivo === 'claims.failed')
+                        .map((c) => `${c.claim.id}: ${c.detalhe}`)
+                        .join('; ')
+                    : motivo === 'verify.regression'
+                        ? `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.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'
+                                ? [produtoAlterado ? 'o produto mudou entre o preparo e o fim da rodada' : '',
+                                    // 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'
+                                    ? dadoPrivadoBloqueia.map((v) => `policy ${v.policy}: ${v.detalhe}`).join('; ')
+                                    : `falha sem baseline em: ${falhasSemBaseline.map((r) => r.nome).join(', ')}` + (falhasSemBaseline
+                                        .some((r) => baselineSemVeredito.includes(r.nome))
+                                        ? `; a baseline nao teve veredito de ${falhasSemBaseline.filter((r) => baselineSemVeredito.includes(r.nome))
+                                            .map((r) => r.nome).join(', ')} (estouro do prazo, sinal, relogio sob steal, comando que nao rodou ou sem ` +
+                                            'codigo de saida do proprio comando)' : ''),
+                evidencia: `reexecucao no HEAD ${commit} em ${cwd}`,
+                correcao: motivo === 'claims.failed'
+                    ? 'corrija o artefato ou a alegacao e rode `ork verify` de novo'
                     : 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.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(', ')}`
+                        ? 'rode `ork verify` de novo; se estourar sempre, suba verify.timeout_ms no manifesto ou divida o comando'
                         : motivo === 'verify.sem-veredito'
-                            ? [produtoAlterado ? 'o produto mudou entre o preparo e o fim da rodada' : '',
-                                // 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('; ')
+                            ? 'rode `ork verify` de novo, sem editar a worktree durante a rodada'
                             : motivo === 'policy.violation'
-                                ? dadoPrivadoBloqueia.map((v) => `policy ${v.policy}: ${v.detalhe}`).join('; ')
-                                : `falha sem baseline em: ${falhasSemBaseline.map((r) => r.nome).join(', ')}` + (falhasSemBaseline
-                                    .some((r) => baselineSemVeredito.includes(r.nome))
-                                    ? `; a baseline nao teve veredito de ${falhasSemBaseline.filter((r) => baselineSemVeredito.includes(r.nome))
-                                        .map((r) => r.nome).join(', ')} (estouro do prazo, sinal, relogio sob steal, comando que nao rodou ou sem ` +
-                                        'codigo de saida do proprio comando)' : ''),
-            evidencia: `reexecucao no HEAD ${commit} em ${cwd}`,
-            correcao: motivo === 'claims.failed'
-                ? 'corrija o artefato ou a alegacao e rode `ork verify` de novo'
-                : motivo === 'verify.timeout'
-                    ? 'rode `ork verify` de novo; se estourar sempre, suba verify.timeout_ms no manifesto ou divida o comando'
-                    : motivo === 'verify.sem-veredito'
-                        ? 'rode `ork verify` de novo, sem editar a worktree durante a rodada'
-                        : motivo === 'policy.violation'
-                            ? dadoPrivadoBloqueia.map((v) => v.correcao).join('; ')
-                            : 'corrija a regressao, ou grave a baseline antes do GO com `ork verify <thread> --baseline`',
-        });
+                                ? dadoPrivadoBloqueia.map((v) => v.correcao).join('; ')
+                                : 'corrija a regressao, ou grave a baseline antes do GO com `ork verify <thread> --baseline`',
+            });
+        }
+        // RM-072 (D17): o ultimo modo do CHECK fica na thread, para o status mostrar.
+        registrarModoNaThread(raiz, threadId, check, commit);
+        return {
+            thread: threadId,
+            commit,
+            cwd,
+            claims,
+            comandos,
+            baseline,
+            regressoes,
+            preExistentes,
+            falhasSemBaseline,
+            comparacoes,
+            estouros,
+            preparo: preparo ? { ...preparo, identidadeFinal: identidadeFinal, produtoAlterado } : null,
+            steal,
+            instabilidade,
+            filaPesada,
+            dadoPrivado,
+            check,
+            duracaoMs,
+            agile: resumoDoAgile,
+            motivos,
+            ok,
+            parcial,
+        };
+    }
+    finally {
+        fecharRecursosDaRodada(relatorio, temporarioDaRodada, casaDaRodada);
     }
-    // RM-072 (D17): o ultimo modo do CHECK fica na thread, para o status mostrar.
-    registrarModoNaThread(raiz, threadId, check, commit);
-    return {
-        thread: threadId,
-        commit,
-        cwd,
-        claims,
-        comandos,
-        baseline,
-        regressoes,
-        preExistentes,
-        falhasSemBaseline,
-        comparacoes,
-        estouros,
-        preparo: preparo ? { ...preparo, identidadeFinal: identidadeFinal, produtoAlterado } : null,
-        steal,
-        instabilidade,
-        filaPesada,
-        dadoPrivado,
-        check,
-        duracaoMs,
-        agile: resumoDoAgile,
-        motivos,
-        ok,
-        parcial,
-    };
 }
 /**
  * RM-072 (D17): grava o modo do ultimo `verify_run` no `thread.json`. A thread e relida na hora, para nao devolver ao
@@ -1257,15 +1502,22 @@ 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,
+    const motivoDaPeca = (p) => [p.motivo, p.tmpdirDaRodada ? m.tmpdirDaRodada : null,
         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, motivoDaPeca(p), p.fallback ?? ''));
-    for (const p of a?.pecas.filter((x) => x.estado === 'degradado') ?? [])
+    for (const p of a?.pecas.filter((x) => x.peca === 'claim-lane') ?? []) {
+        linhas.push(p.estado === 'agile' ? m.claimLaneReaproveitada(p.claim ?? '', motivoDaPeca(p))
+            : m.claimLaneRecusada(p.claim ?? '', p.motivoTipado ?? p.motivo ?? 'motivo-ausente'));
+    }
+    for (const p of a?.pecas.filter((x) => x.peca !== 'claim-lane' && x.estado === 'fallback') ?? []) {
+        linhas.push(m.agileFallback(p.peca, motivoDaPeca(p), p.tmpdirDaRodada && p.fallback === 'disco' ? m.discoComTmpdirDaRodada : p.fallback ?? ''));
+    }
+    for (const p of a?.pecas.filter((x) => x.peca !== 'claim-lane' && x.estado === 'degradado') ?? []) {
         linhas.push(m.agileDegradado(p.peca, motivoDaPeca(p)));
-    for (const p of a?.pecas.filter((x) => x.estado === 'agile' && x.reservaIntegracao) ?? [])
+    }
+    for (const p of a?.pecas.filter((x) => x.peca !== 'claim-lane' && 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;