@orkastery/cli 0.5.3 → 0.6.0

package/dist/verify.js

@@ -12,33 +12,91 @@
  *      agora falha) de DIVIDA PRE-EXISTENTE (ja falhava). Sem baseline, a falha e
  *      declarada como `verify.failed`, e nao como regressao que nao da para provar.
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PREFIXO_BLOQUEADO_NO_VERIFY = exports.TIMEOUT_VERIFY_MS = void 0;
+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.ambienteDoVerify = ambienteDoVerify;
 exports.prazoDoComando = prazoDoComando;
+exports.prazoInternoDoScan = prazoInternoDoScan;
+exports.ehComandoDoScan = ehComandoDoScan;
+exports.prazoDaExecucao = prazoDaExecucao;
+exports.executorDoManifesto = executorDoManifesto;
 exports.executar = executar;
+exports.resultadoDoProcesso = resultadoDoProcesso;
+exports.semVereditoPorTempo = semVereditoPorTempo;
+exports.executorComSteal = executorComSteal;
 exports.identidadeDoProduto = identidadeDoProduto;
 exports.causaDoEncerramento = causaDoEncerramento;
 exports.comandoNoLedger = comandoNoLedger;
 exports.comandosDoManifesto = comandosDoManifesto;
 exports.cwdDaThread = cwdDaThread;
 exports.commitReal = commitReal;
+exports.executorDaRodada = executorDaRodada;
+exports.ambienteDoModo = ambienteDoModo;
+exports.vereditoDaBaseline = vereditoDaBaseline;
 exports.gravarBaseline = gravarBaseline;
 exports.verificarClaim = verificarClaim;
 exports.verificar = verificar;
+exports.linhasDaBaseline = linhasDaBaseline;
 exports.textoDoVerify = textoDoVerify;
 const claims_1 = require("./claims");
 const gates_1 = require("./gates");
 const ledger_1 = require("./ledger");
 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 node_fs_1 = require("node:fs");
+const path = __importStar(require("node:path"));
 const node_path_1 = require("node:path");
 const node_crypto_1 = require("node:crypto");
 const util_1 = require("./util");
 const horario_1 = require("./horario");
+const locale_1 = require("./locale");
 const redacao_saida_1 = require("./redacao-saida");
+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 conducao_1 = require("./conducao");
+const procedencia_1 = require("./procedencia");
+const dado_privado_1 = require("./dado-privado");
+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");
 /** 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. */
@@ -59,14 +117,60 @@ const TIMEOUT_BIN = '/usr/bin/timeout';
  * valvula de escape: comando que precise delas vira escalacao para humano.
  */
 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]);
 function ambienteDoVerify(base = process.env) {
-    return Object.fromEntries(Object.entries(base).filter(([chave]) => !chave.startsWith(exports.PREFIXO_BLOQUEADO_NO_VERIFY)));
+    return Object.fromEntries(Object.entries(base).filter(([chave]) => !chave.startsWith(exports.PREFIXO_BLOQUEADO_NO_VERIFY)
+        && !VARIAVEIS_DA_RODADA.has(chave)));
 }
 /** I-37 (D2): o prazo de um comando, resolvido uma vez por rodada (D3). */
 function prazoDoComando(manifesto, nome) {
     const porComando = manifesto.verify.timeout_ms_por_comando;
     return porComando?.[nome] ?? manifesto.verify.timeout_ms ?? exports.TIMEOUT_VERIFY_MS;
 }
+/** Teto da margem que o `security_scan` reserva, dentro do proprio prazo, para os passos que ele nao limita. */
+exports.MARGEM_MAX_DO_SCAN_MS = 300_000;
+/**
+ * O prazo interno da rodada do scan (`ORK_SECURITY_SCAN_DEADLINE_MS`): o prazo do comando menos a margem
+ * `min(300 s, prazo/4)`, que cobre worktree add, sondas e `docker rm`. Assim a rodada termina, com `failed/timeout`
+ * declarado, antes de o `timeout(1)` do verify matar o comando sem relatorio.
+ */
+function prazoInternoDoScan(prazoMs) {
+    return prazoMs - Math.min(exports.MARGEM_MAX_DO_SCAN_MS, Math.floor(prazoMs / 4));
+}
+/**
+ * O comando roda o `security_scan`: pelo nome (verify, bundle do CI) ou por ser, na claim, o mesmo comando declarado em
+ * `verify.security_scan`. Sem a chave, nada e scan.
+ */
+function ehComandoDoScan(manifesto, nome, comando) {
+    if (nome === 'security_scan')
+        return true;
+    const scan = manifesto.verify.security_scan?.trim();
+    return !!scan && comando.trim() === scan;
+}
+/**
+ * O prazo de um comando do manifesto ou de uma claim: a claim que roda o scan ganha o prazo do `security_scan`. RM-072
+ * (D4): a lane do Agile (`test:<lane>`) tem o prazo do `test` que ela substitui.
+ */
+function prazoDaExecucao(manifesto, nome, comando) {
+    return prazoDoComando(manifesto, ehComandoDoScan(manifesto, nome, comando) ? 'security_scan' : nome.startsWith('test:') ? 'test' : nome);
+}
+/**
+ * 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) {
+    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);
+    };
+}
 /**
  * Executa um comando de verificacao pelo shell, no diretorio de trabalho da thread.
  *
@@ -76,14 +180,20 @@ function prazoDoComando(manifesto, nome) {
  * 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) {
+function executar(nome, comando, cwd, tetoMs = exports.TIMEOUT_VERIFY_MS, ambienteExtra) {
     const comGrupo = (0, node_fs_1.existsSync)(TIMEOUT_BIN);
     const inicio = Date.now();
-    const ambiente = ambienteDoVerify();
+    const ambiente = { ...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);
-    const duracaoMs = Date.now() - inicio;
+    return resultadoDoProcesso(nome, comando, r, comGrupo, Date.now() - inicio, tetoMs);
+}
+/**
+ * RM-072 (D6): o resultado de um comando a partir do que o processo devolveu, o mesmo para o `executar` e para o grupo
+ * paralelo do Agile (`check-paralelo.ts`), para os dois julgarem estouro, sinal e saida da mesma forma.
+ */
+function resultadoDoProcesso(nome, comando, r, comGrupo, duracaoMs, tetoMs) {
     const causa = causaDoEncerramento({ code: r.code, signal: r.signal ?? null, error: r.error, comGrupo, duracaoMs, tetoMs });
     const estourou = causa === 'timeout';
     const resultado = {
@@ -103,10 +213,39 @@ function executar(nome, comando, cwd, tetoMs = exports.TIMEOUT_VERIFY_MS) {
         const testes = (0, redacao_saida_1.testesQueCairam)(saida);
         if (testes.length > 0)
             resultado.testeQueCaiu = testes;
+        const falhas = (0, redacao_saida_1.falhasDeTeste)(saida);
+        if (falhas.length > 0)
+            resultado.falhasDeTeste = falhas;
         resultado.trecho = (0, redacao_saida_1.redigirSaida)(saida);
     }
     return resultado;
 }
+/**
+ * RM-037 (fatia 6): o comando nao tem veredito. Estouro de prazo, ou reprovacao so de teste com relogio
+ * sob steal acima de 40%: a maquina, e nao o codigo, decidiu o resultado.
+ */
+function semVereditoPorTempo(c) {
+    return c.causa === 'timeout' || (c.relogioSobSteal?.length ?? 0) > 0;
+}
+/**
+ * RM-037 (fatia 6): mede o steal na janela de cada comando e marca a reprovacao que foi so de teste com
+ * relogio sob steal alto. Os testes de relogio sao os da assinatura de prazo do runner e os do registro
+ * de instabilidade vigente. Comando que passou, estourou ou nem rodou so ganha a medida.
+ */
+function executorComSteal(base, leitor = steal_1.lerProcStat, registro = new Set()) {
+    return (nome, comando, cwd) => {
+        const janela = (0, steal_1.abrirJanela)(leitor);
+        const r = base(nome, comando, cwd);
+        const stealPct = janela.fechar();
+        const resultado = { ...r, stealPct };
+        if (!r.ok && r.causa !== 'timeout' && r.executado !== false && (0, steal_1.stealAlto)(stealPct)) {
+            const testes = (0, steal_1.reprovacaoSoDeRelogio)(r.falhasDeTeste, registro);
+            if (testes)
+                resultado.relogioSobSteal = testes;
+        }
+        return resultado;
+    };
+}
 /** I-54 (D11): erros de spawn em que o processo nem chegou a existir. */
 const NAO_LANCADO = new Set(['ENOENT', 'EACCES', 'EAGAIN', 'ENOMEM', 'EPERM', 'EMFILE']);
 /**
@@ -155,36 +294,63 @@ 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) {
+    // 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.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)
-        return { nome: c.nome, ok: true, code: c.code };
+        return { nome: c.nome, ok: true, code: c.code, ...(c.duracaoMs !== undefined ? { duracaoMs: c.duracaoMs } : {}), ...doAgile };
     return {
-        nome: c.nome, comando: (0, redacao_url_1.redigirCredenciaisUrl)(c.comando), ok: false, code: c.code,
+        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 } : {}),
     };
 }
 /** Comandos declarados em `verify:` no manifesto, na ordem canonica. */
 function comandosDoManifesto(manifesto) {
     const lista = [];
-    for (const nome of ['typecheck', 'build', 'test']) {
+    for (const nome of ['typecheck', 'build', 'test', 'security_scan']) {
         const comando = manifesto.verify[nome];
         if (comando && comando.trim() !== '')
             lista.push({ nome, comando });
     }
     return lista;
 }
-/** Diretorio onde a verificacao roda: a worktree da thread, ou a raiz do projeto. */
+/**
+ * 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`,
+ * `estado.worktree-nao-registrada`).
+ */
 function cwdDaThread(raiz, thread) {
-    return thread.worktree ?? raiz;
+    return (0, procedencia_1.diretorioDaThread)(raiz, thread);
 }
 /** HEAD real do diretorio de trabalho, carimbado em toda verificacao. */
 function commitReal(cwd) {
     const r = (0, util_1.exec)('git', ['rev-parse', 'HEAD'], cwd);
     return r.ok ? r.stdout.trim() : util_1.COMMIT_DESCONHECIDO;
 }
+/** RM-058 N2 (D10): quanto o `ork verify` do CLI espera a vez na fila pesada sem `--esperar`. */
+exports.ESPERA_DA_FILA_PESADA_MS = 60 * 60 * 1000;
+/** RM-058 N2 (GO-FIX 1, B1 e A9 do CHECK): a espera de quem verifica por dentro de outro comando e nao disse prazo. */
+exports.ESPERA_PADRAO_DA_FILA_PESADA_MS = 30_000;
+/**
+ * RM-058 N2 (D9 e D10 da ork-rm058n2): a rodada inteira na fila de recursos pesados, depois da conducao. O
+ * artefato e o diretorio de trabalho da thread; as vagas sao `concurrency.max_parallel_heavy` (0 desliga). Sem a
+ * vez no prazo, `ErroDaFilaPesada` sai antes de qualquer comando rodar e de qualquer evento ir ao ledger.
+ */
+function naFilaPesada(carregado, threadId, operacao, conducao, executar) {
+    const cwd = cwdDaThread(carregado.raiz, (0, thread_1.lerThread)(carregado.raiz, threadId));
+    const espera = conducao.filaPesada?.esperarMs ?? conducao.esperarMs ?? exports.ESPERA_PADRAO_DA_FILA_PESADA_MS;
+    return (0, fila_pesada_1.comRecursoPesado)(carregado.raiz, { artefato: cwd, operacao, thread: threadId,
+        slots: carregado.manifesto.concurrency.max_parallel_heavy, esperarMs: espera, aoEsperar: conducao.filaPesada?.aoEsperar,
+        comandoDeEsperar: conducao.filaPesada?.comandoDeEsperar }, executar);
+}
 /** O pedido de conducao de uma verificacao, com o prazo derivado dos comandos que ela vai rodar (D3). */
 function pedidoDoVerify(carregado, threadId, operacao, comandos, conducao) {
     return {
@@ -199,27 +365,213 @@ function pedidoDoVerify(carregado, threadId, operacao, comandos, conducao) {
 /** O executor que renova o prazo da conducao antes de cada comando (D3). */
 function executorSobConducao(base, manifesto, conducao) {
     return (nome, comando, cwd) => {
-        conducao.renovar(prazoDoComando(manifesto, nome));
+        conducao.renovar(prazoDaExecucao(manifesto, nome, comando));
         return base(nome, comando, cwd);
     };
 }
-/** `ork verify --baseline`: grava o estado do mundo ANTES do GO. */
-function gravarBaseline(carregado, threadId, executor = executar, conducao = {}, origem = 'cli') {
+/**
+ * RM-037 (defeitos de 19 e 20/10/2026, defeito 1): o executor de uma rodada, o mesmo no verify e na baseline. O prazo
+ * de cada comando sai do manifesto (`executorDoManifesto`, que tambem da ao scan o prazo interno), e o steal e medido na
+ * janela de cada um, com os testes de relogio do registro de instabilidade da arvore verificada. A baseline rodava pelo
+ * `executar` com o teto padrao de 600 s: em 20/10 a suite desta VPS passou disso, e o `test` foi gravado como "ja
+ * falhava" com o manifesto dando 2400 s.
+ */
+function executorDaRodada(manifesto, instabilidade, base, leitor = steal_1.lerProcStat, ambienteDaRodada) {
+    return executorComSteal(base ?? executorDoManifesto(manifesto, ambienteDaRodada), leitor, (0, instabilidade_1.testesDeRelogioVigentes)(instabilidade));
+}
+/** RM-072 (D2): o que a rodada passa a todo comando dela, nos dois modos: o modo do CHECK. */
+function ambienteDoModo(check) {
+    return { [check_modo_1.ENV_MODO_DO_CHECK]: check.modo };
+}
+/** RM-072 (D1, D2): o modo da rodada, como vai ao ledger. */
+function checkNoLedger(check) {
+    return { modo: check.modo, origem: check.origem, nome: check.nome };
+}
+/** RM-072 (D5): a guarda do produto no fim do preparo; sem preparo, ou com ele reprovado, nada e reaproveitado. */
+function guardaDoPreparo(manifesto, cwd, preparo) {
+    return new check_agil_1.GuardaDoProduto(cwd, manifesto.check?.agile?.produto, identidadeDoProduto, preparo ? (preparo.ok ? null : 'preparo-falhou') : 'sem-preparo');
+}
+/**
+ * RM-072 (S-b do CHECK 2, N5 do CHECK 3): no Agile, so quem escreve no relatorio da rodada o recebe, a varredura e as
+ * lanes; o `build`, o `typecheck` e o `verify.test` (em serie ou no grupo) recebem so o modo, como as claims. O teste que
+ * roda a varredura dentro do `verify.test` gravaria pecas de fixture no relatorio da rodada.
+ */
+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);
+}
+/**
+ * RM-072 (D6): o executor do grupo do Agile. Sem executor injetado, o processo auxiliar roda os comandos ao mesmo tempo,
+ * 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) {
+    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 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 } : {}),
+            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)()) } : {}) } : {}) } }));
+        // 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 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 };
+            // S1 do CHECK: o auxiliar que morreu sem gravar o resultado deixa o comando sem veredito, nunca uma regressao.
+            if (p.semResultado)
+                r.executado = false;
+            if (!r.ok && r.causa !== 'timeout' && r.executado !== false && (0, steal_1.stealAlto)(stealPct)) {
+                const testes = (0, steal_1.reprovacaoSoDeRelogio)(r.falhasDeTeste, relogio);
+                if (testes)
+                    r.relogioSobSteal = testes;
+            }
+            return r;
+        });
+    };
+}
+/**
+ * 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 usos = claims.flatMap((c) => c.execucoes.map((e) => e.preparo).filter((u) => !!u));
+    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 },
+        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),
+    };
+    if (listas.length > 0) {
+        // S10 do CHECK: o caminho vai relativo a raiz do estado (`.orkastery/threads/...`), nao a worktree de onde rodou.
+        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 });
+            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 */ }
+    }
+    return resumo;
+}
+/**
+ * RM-037 (defeito 1 de 19 e 20/10/2026): so a falha com veredito vale como "ja falhava". Estouro do prazo, reprovacao
+ * so de teste com relogio sob steal, morte por sinal e comando que nem rodou dizem que a maquina decidiu, e nao o
+ * codigo; uma falha atual desse comando nao pode passar por divida anterior.
+ */
+function vereditoDaBaseline(c) {
+    if (c.ok)
+        return 'passava';
+    if (semVereditoPorTempo(c) || c.executado === false)
+        return 'sem-veredito';
+    return terminoNormal(c) ? 'ja-falhava' : 'sem-veredito';
+}
+/**
+ * Achado 1 do CHECK da RM-037 (20/10/2026): o maior codigo de saida que e do proprio comando. De 124 em diante, quem fala
+ * e quem nao deixou o comando terminar: 124 e o prazo do `timeout(1)` de dentro do comando (o de fora so o conta como
+ * estouro quando o tempo dele chegou), 125 e 126 sao o `timeout(1)` ou o shell que nao rodaram o comando, 127 o comando
+ * que nao existe, e de 128 em diante vem a morte por sinal (128 + sinal, do shell e do GNU `timeout`).
+ */
+const MAIOR_CODIGO_DO_COMANDO = 123;
+/**
+ * O comando terminou sozinho e disse o codigo: `causa: exit` (ou nenhuma, na baseline de antes da I-37, em que o estouro
+ * saia como `code: -1`) com codigo de 1 a 123. Sinal, falta do codigo de saida e os codigos de quem nao deixou o
+ * comando terminar nao provam nada do codigo do HEAD. O `timeout(1)` do uutils devolve so o numero do sinal que ele
+ * trata (15 no SIGTERM), igual a uma saida do comando: esse fica de fora, como na `causaDoEncerramento`.
+ */
+function terminoNormal(c) {
+    return (c.causa === undefined || c.causa === 'exit') && Number.isInteger(c.code) && c.code >= 1
+        && c.code <= MAIOR_CODIGO_DO_COMANDO;
+}
+/**
+ * RM-037 (CHECK 3 da ork-rm037defeit2): a baseline e o verify nunca rodam sobre a worktree cujo preparo a criacao adiou
+ * (o passo do arco abre a thread sob a trava de despacho) e que ainda nao deu certo. O preparo pendente roda aqui, com a
+ * vez na fila pesada que a operacao ja segura, a conducao renovada pelo prazo dele e o executor da operacao quando ela
+ * traz um (o do sandbox do `ork_verify` do MCP, com o prazo dele). A falha recusa a operacao inteira antes do primeiro
+ * comando, porque sem as dependencias a baseline chamaria de "ja falhava" a falta de pacote, e o verify, de regressao.
+ */
+function exigirDependenciasDaWorktree(carregado, threadId, cwd, operacao, conducao, executor) {
+    const preparo = (0, thread_1.prepararDependenciasPendentes)(carregado, threadId, cwd, { antes: () => conducao.renovar(dependencias_da_worktree_1.PRAZO_DAS_DEPENDENCIAS_MS), executor });
+    if (!preparo || preparo.ok)
+        return;
+    throw new locale_1.ErroDoCatalogo((m) => m.verify.dependenciasPendentesFalharam(operacao, (0, redacao_url_1.redigirCredenciaisUrl)(preparo.comando), preparo.code, preparo.causa === 'timeout', cwd, (0, dependencias_da_worktree_1.ultimaLinhaDoPreparo)(preparo)));
+}
+/** `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);
-    return (0, conducao_1.comConducao)(carregado.raiz, threadId, pedido, (tomada) => gravarBaselineSobConducao(carregado, threadId, executorSobConducao(executor, carregado.manifesto, tomada), origem));
+    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, executor, origem) {
+function gravarBaselineSobConducao(carregado, threadId, base, tomada, origem, leitor, modo) {
     const { raiz, manifesto } = carregado;
     const thread = (0, thread_1.lerThread)(raiz, threadId);
     const cwd = cwdDaThread(raiz, thread);
-    const comandos = comandosDoManifesto(manifesto).map((c) => executor(c.nome, c.comando, cwd));
-    const baseline = { commit: commitReal(cwd), gravadaEm: (0, util_1.agora)(), comandos };
+    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 comandos = 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));
+    if (relatorio) {
+        if (base)
+            pecasDaBaseline.push(check_agil_1.PECA_SEM_RELATORIO);
+        pecasDaBaseline.push(...(0, check_agil_1.pecasDoRelatorio)(relatorio.ler()));
+        relatorio.fechar();
+    }
+    // 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 })),
+        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 }) })),
+        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,
     });
@@ -239,9 +591,7 @@ function verificarClaim(claim, cwd, executor = executar) {
             verificado: false,
             // Alegacao negativa sem comando e reprovacao (caso EvoJ6); positiva e aviso.
             motivo: negativa ? 'claims.failed' : 'claims.unverifiable',
-            detalhe: negativa
-                ? 'alegacao negativa/absoluta sem comando de verificacao: nao ha como comprova-la'
-                : 'sem comando de verificacao declarado',
+            detalhe: (0, locale_1.textoDoCatalogo)((m) => negativa ? m.verify.claimNegativaSemComando : m.verify.claimSemComando),
             execucoes: [],
         };
     }
@@ -253,22 +603,25 @@ function verificarClaim(claim, cwd, executor = executar) {
             claim,
             verificado: false,
             motivo: 'verify.sem-veredito',
-            detalhe: `comando "${(0, redacao_url_1.redigirCredenciaisUrl)(naoRodou.comando)}" nao foi executado: ${naoRodou.resumo}`,
+            detalhe: (0, locale_1.textoDoCatalogo)((m) => m.verify.claimNaoExecutada((0, redacao_url_1.redigirCredenciaisUrl)(naoRodou.comando), naoRodou.resumo)),
             execucoes,
         };
     }
     const falhou = execucoes.find((e) => !e.ok);
-    // I-37 (D1): estouro de prazo nao desmente a alegacao; a prova so nao chegou ao fim.
-    const estourou = falhou?.causa === 'timeout';
+    // I-37 (D1): estouro de prazo nao desmente a alegacao; a prova so nao chegou ao fim. RM-037 (fatia 6):
+    // nem a reprovacao so de teste com relogio sob steal acima de 40%.
+    const estourou = !!falhou && semVereditoPorTempo(falhou);
     return {
         claim,
         verificado: !falhou,
         motivo: falhou ? (estourou ? 'verify.timeout' : 'claims.failed') : null,
-        detalhe: falhou
+        detalhe: (0, locale_1.textoDoCatalogo)((m) => falhou
             ? estourou
-                ? `comando "${falhou.comando}" estourou o prazo de ${Math.round((falhou.prazoMs ?? 0) / 1000)} s sem terminar`
-                : `comando "${(0, redacao_url_1.redigirCredenciaisUrl)(falhou.comando)}" saiu com codigo ${falhou.code}`
-            : `${execucoes.length} comando(s) reexecutado(s) com sucesso`,
+                ? falhou.causa === 'timeout'
+                    ? m.verify.claimEstourou(falhou.comando, Math.round((falhou.prazoMs ?? 0) / 1000))
+                    : m.verify.claimRelogio((0, redacao_url_1.redigirCredenciaisUrl)(falhou.comando), falhou.stealPct, steal_1.LIMIAR_STEAL_PCT, falhou.relogioSobSteal.join(', '))
+                : m.verify.claimSaiu((0, redacao_url_1.redigirCredenciaisUrl)(falhou.comando), falhou.code)
+            : m.verify.claimOk(execucoes.length)),
         execucoes,
     };
 }
@@ -281,34 +634,82 @@ function verificar(carregado, threadId, opcoes = {}) {
     const planejados = (0, claims_1.lerClaims)(carregado.raiz, threadId).filter((c) => c.estado !== 'retirada')
         .reduce((n, c) => n + c.verificar.length, 0) + (opcoes.soClaims ? 0 : comandosDoManifesto(carregado.manifesto).length) + 1;
     const pedido = pedidoDoVerify(carregado, threadId, opcoes.operacao ?? 'verify', planejados, opcoes.conducao ?? {});
-    return (0, conducao_1.comConducao)(carregado.raiz, threadId, pedido, (tomada) => verificarSobConducao(carregado, threadId, opcoes, tomada, pedido.canal));
+    return (0, conducao_1.comConducao)(carregado.raiz, threadId, pedido, (tomada) => naFilaPesada(carregado, threadId, 'verify', opcoes.conducao ?? {}, (uso) => verificarSobConducao(carregado, threadId, opcoes, tomada, pedido.canal, uso)));
 }
-function verificarSobConducao(carregado, threadId, opcoes, conducao, canal) {
+function verificarSobConducao(carregado, threadId, opcoes, conducao, canal, filaPesada) {
     const { raiz, manifesto } = carregado;
+    const inicioDaRodada = Date.now();
     const thread = (0, thread_1.lerThread)(raiz, threadId);
     const cwd = cwdDaThread(raiz, thread);
+    exigirDependenciasDaWorktree(carregado, threadId, cwd, 'verify', conducao, opcoes.executor);
     const commit = commitReal(cwd);
     const dir = (0, thread_1.dirThread)(raiz, threadId);
+    // RM-072 (D1): o modo da rodada; a opcao vence o manifesto, que vence o padrao.
+    const check = (0, check_modo_1.resolverModo)(manifesto.check?.mode, opcoes.check);
     // I-43 (D4, viga b): os criterios de pronto da thread viram claims do nucleo ANTES
     // da reexecucao, para entrarem no MESMO veredito das demais alegacoes. Idempotente:
     // `ork verify` roda em toda fase, e uma claim por criterio por rodada viraria
     // acumulador em vez de verificacao.
     (0, claims_1.registrarCriteriosDePronto)(raiz, threadId);
+    // 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 ambienteDaRodada = { ...ambienteDoModo(check), ...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(opcoes.executor
-        ?? ((nome, comando, dirDeTrabalho) => executar(nome, comando, dirDeTrabalho, prazoDoComando(manifesto, nome))), manifesto, conducao);
+    const executor = executorSobConducao(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)
+        : 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.
-    const preparo = manifesto.verify.preparo ? (() => {
-        const resultado = executor('preparo', manifesto.verify.preparo, cwd);
-        return { resultado, identidade: identidadeDoProduto(cwd) };
-    })() : null;
+    // 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;
+    const refazerAntesDaClaim = (nome) => {
+        if (!vigente || preparosRefeitos >= check_agil_1.MAXIMO_DE_PREPAROS_REFEITOS)
+            return false;
+        preparosRefeitos++;
+        refazer(`antes da claim ${nome}`);
+        return true;
+    };
     // 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 claims = (0, claims_1.lerClaims)(raiz, threadId)
         .filter((c) => c.estado !== 'retirada')
-        .map((c) => verificarClaim(c, cwd, executor));
+        .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')
@@ -321,23 +722,39 @@ function verificarSobConducao(carregado, threadId, opcoes, conducao, canal) {
         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
         ? []
-        : comandosDoManifesto(manifesto).map((c) => executor(c.nome, c.comando, cwd));
+        : 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)
+        pecas.push(...doAgile.pecas);
+    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 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)
             continue;
-        if (atual.causa === 'timeout') {
+        if (semVereditoPorTempo(atual)) {
             estouros.push(atual);
             continue;
         }
         const antes = baseline?.comandos.find((c) => c.nome === atual.nome);
-        if (!antes)
+        if (!antes || vereditoDaBaseline(antes) === 'sem-veredito')
             falhasSemBaseline.push(atual);
         else if (antes.ok)
             regressoes.push(atual);
@@ -348,6 +765,16 @@ function verificarSobConducao(carregado, threadId, opcoes, conducao, canal) {
     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');
@@ -362,8 +789,11 @@ function verificarSobConducao(carregado, threadId, opcoes, conducao, canal) {
     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,
@@ -374,6 +804,10 @@ function verificarSobConducao(carregado, threadId, opcoes, conducao, canal) {
                 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) } : {}),
                 ...(falhou ? { execucao: comandoNoLedger(falhou) } : {}),
             };
         }),
@@ -382,16 +816,35 @@ function verificarSobConducao(carregado, threadId, opcoes, conducao, canal) {
         regressoes: regressoes.map((r) => r.nome),
         preExistentes: preExistentes.map((r) => r.nome),
         falhasSemBaseline: falhasSemBaseline.map((r) => r.nome),
+        ...(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',
@@ -405,14 +858,22 @@ function verificarSobConducao(carregado, threadId, opcoes, conducao, canal) {
                 : motivo === 'verify.regression'
                     ? `regressao em: ${regressoes.map((r) => r.nome).join(', ')}`
                     : motivo === 'verify.timeout'
-                        ? `estourou o prazo sem terminar: ${[...estouros.map((r) => r.nome),
-                            ...claims.filter((c) => c.motivo === 'verify.timeout').map((c) => c.claim.id)].join(', ')}`
+                        ? `sem veredito por tempo (prazo estourado, ou teste com relogio sob steal acima de ${steal_1.LIMIAR_STEAL_PCT}%): ${[
+                            ...estouros.map((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`),
                                 ...claims.filter((c) => c.motivo === 'verify.sem-veredito').map((c) => `${c.claim.id}: ${c.detalhe}`)]
                                 .filter(Boolean).join('; ')
-                            : `falha sem baseline em: ${falhasSemBaseline.map((r) => r.nome).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'
@@ -420,9 +881,13 @@ function verificarSobConducao(carregado, threadId, opcoes, conducao, canal) {
                     ? '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'
-                        : 'corrija a regressao, ou grave a baseline antes do GO com `ork verify <thread> --baseline`',
+                        : motivo === 'policy.violation'
+                            ? 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,
@@ -435,74 +900,141 @@ function verificarSobConducao(carregado, threadId, opcoes, conducao, canal) {
         falhasSemBaseline,
         estouros,
         preparo: preparo ? { ...preparo, identidadeFinal: identidadeFinal, produtoAlterado } : null,
+        steal,
+        instabilidade,
+        filaPesada,
+        dadoPrivado,
+        check,
+        duracaoMs,
+        agile: resumoDoAgile,
         motivos,
         ok,
     };
 }
+/**
+ * RM-072 (D17): grava o modo do ultimo `verify_run` no `thread.json`. A thread e relida na hora, para nao devolver ao
+ * disco uma copia lida no comeco da rodada; o status mostra a linha so quando o campo existe.
+ */
+function registrarModoNaThread(raiz, threadId, check, commit) {
+    const atual = (0, thread_1.lerThread)(raiz, threadId);
+    atual.check = { modo: check.modo, origem: check.origem, commit, em: (0, util_1.agora)() };
+    (0, thread_1.gravarThread)(raiz, atual);
+}
 /** `FALHOU (codigo 1)`, ou `ESTOUROU O PRAZO (600 s, rodou 612 s)`: a causa e dita pelo nome. */
 function situacaoDoComando(c) {
+    const m = (0, locale_1.msg)().verify;
     const s = (ms) => `${Math.round((ms ?? 0) / 1000)} s`;
     if (c.causa === 'timeout')
-        return `ESTOUROU O PRAZO (${s(c.prazoMs)}, rodou ${s(c.duracaoMs)})`;
+        return m.estourou(s(c.prazoMs), s(c.duracaoMs));
+    if (c.relogioSobSteal?.length)
+        return m.relogioSobSteal(c.stealPct, steal_1.LIMIAR_STEAL_PCT);
     if (c.causa === 'nao-encontrado')
-        return `NAO EXECUTOU (comando nao encontrado, codigo ${c.code})`;
+        return m.naoExecutou(c.code);
     if (c.causa === 'sinal')
-        return `MORTO POR SINAL (codigo ${c.code})`;
-    return `FALHOU (codigo ${c.code})`;
+        return m.mortoPorSinal(c.code);
+    return m.falhou(c.code);
+}
+/**
+ * RM-037 (defeito 1 de 19 e 20/10/2026): as linhas de cada comando de `ork verify --baseline`, com o veredito dele, e a
+ * linha que diz o que a baseline nao provou e como regravar.
+ */
+function linhasDaBaseline(b, id) {
+    const m = (0, locale_1.msg)().verify;
+    const linhas = b.comandos.map((c) => m.baselineComando(c.nome, vereditoDaBaseline(c), c.code, c.comando, situacaoDoComando(c)));
+    // RM-072 (D1): o modo que gravou a baseline (a baseline anterior a RM-072 nao tem o campo).
+    if (b.check)
+        linhas.unshift(m.baselineCheck(check_modo_1.NOME_DO_MODO[b.check.modo], b.check.modo, b.check.origem));
+    const semVeredito = b.comandos.filter((c) => vereditoDaBaseline(c) === 'sem-veredito').map((c) => c.nome);
+    if (semVeredito.length > 0)
+        linhas.push(m.baselineSemVeredito(semVeredito.join(', '), id));
+    return linhas;
 }
-/** Texto de `ork verify`. */
+/** Texto de `ork verify`. O detalhe da claim veio do catalogo em pt-BR e sai remontado no locale ativo. */
 function textoDoVerify(r) {
+    const m = (0, locale_1.msg)().verify;
     const linhas = [];
-    linhas.push(`ork verify da thread ${r.thread}`);
-    linhas.push(`  HEAD real   ${r.commit}`);
-    linhas.push(`  diretorio   ${r.cwd}`);
-    linhas.push(`  baseline    ${r.baseline ? `${(0, util_1.shaCurto)(r.baseline.commit)} de ${(0, horario_1.formatarDataHoraRotulada)(r.baseline.gravadaEm)}` : '(nao gravada: falha nao pode ser chamada de regressao)'}`);
+    linhas.push(m.titulo(r.thread));
+    linhas.push(m.head(r.commit));
+    linhas.push(m.diretorio(r.cwd));
+    linhas.push(m.check(r.check.nome, r.check.modo, r.check.origem));
+    // RM-072 (D8): no Agile, o reaproveitamento, o grupo e as pecas em fallback, quando ha o que dizer.
+    const a = r.agile;
+    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));
+    }
+    for (const p of a?.pecas.filter((x) => x.estado === 'fallback') ?? [])
+        linhas.push(m.agileFallback(p.peca, p.motivo ?? '', p.fallback ?? ''));
+    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;
-        linhas.push(`  preparo     ${p.resultado.ok ? 'ok' : situacaoDoComando(p.resultado)} em ` +
-            `${Math.round((p.resultado.duracaoMs ?? 0) / 1000)} s, uma vez para a rodada; produto ` +
-            `${p.produtoAlterado ? 'MUDOU no meio da rodada: nenhum veredito vale' : 'conferido do preparo ao fim'}`);
+        linhas.push(m.preparo(p.resultado.ok ? m.comandoOk : situacaoDoComando(p.resultado), Math.round((p.resultado.duracaoMs ?? 0) / 1000), p.produtoAlterado));
+    }
+    linhas.push(r.steal.medido ? m.stealMedido(r.steal.rodadaPct, r.steal.fonte, r.steal.limiarPct) : m.stealNaoMedido(r.steal.fonte));
+    if (r.instabilidade.erros.length > 0) {
+        linhas.push(m.instabilidadeForaDoContrato(r.instabilidade.arquivo, r.instabilidade.erros.join('; ')));
+    }
+    else if (r.instabilidade.vencidas.length > 0) {
+        linhas.push(m.instabilidadeVencidas(r.instabilidade.vencidas.length, r.instabilidade.vencidas.map((e) => e.teste).join(', ')));
     }
     linhas.push('');
-    linhas.push('Claims reexecutadas no HEAD real:');
+    linhas.push(m.claimsReexecutadas);
     if (r.claims.length === 0) {
-        linhas.push('  (nenhuma claim registrada nesta thread)');
+        linhas.push(m.nenhumaClaim);
     }
     for (const c of r.claims) {
-        linhas.push(`  ${c.claim.id}  verificado: ${c.verificado ? 'sim' : 'NAO'}  ${c.claim.alegacao}`);
-        linhas.push(`      arquivo: ${c.claim.arquivo}`);
-        linhas.push(`      ${c.claim.verificar.length > 0 ? `comando(s): ${c.claim.verificar.join(' && ')}` : 'sem comando de verificacao'}`);
+        linhas.push(m.claim(c.claim.id, c.verificado, c.claim.alegacao));
+        linhas.push(m.arquivo(c.claim.arquivo));
+        linhas.push(c.claim.verificar.length > 0 ? m.comandos(c.claim.verificar.join(' && ')) : m.semComando);
         if (!c.verificado)
-            linhas.push(`      motivo tipado: ${c.motivo} (${c.detalhe})`);
+            linhas.push(m.motivoTipado(String(c.motivo), (0, locale_1.remontar)(c.detalhe)));
     }
     if (r.comandos.length > 0) {
         linhas.push('');
-        linhas.push('Comandos de verify do manifesto:');
+        linhas.push(m.comandosDoManifesto);
         for (const c of r.comandos) {
-            linhas.push(`  ${c.nome.padEnd(10)} ${c.ok ? 'ok' : situacaoDoComando(c)}  ${c.comando}`);
+            linhas.push(m.comando(c.nome, c.ok ? m.comandoOk : situacaoDoComando(c), c.comando));
             if (!c.ok && c.testeQueCaiu?.length)
-                linhas.push(`             teste(s) que caiu(ram): ${c.testeQueCaiu.join('; ')}`);
+                linhas.push(m.testesQueCairam(c.testeQueCaiu.join('; ')));
         }
     }
     if (r.estouros.length > 0) {
         linhas.push('');
-        linhas.push(`Estouro de prazo (nao e reprovacao, a prova nao terminou): ${r.estouros.map((c) => c.nome).join(', ')}`);
+        linhas.push(m.semVeredito(r.estouros.map((c) => c.nome).join(', ')));
     }
     if (r.regressoes.length > 0 || r.preExistentes.length > 0 || r.falhasSemBaseline.length > 0) {
         linhas.push('');
-        linhas.push(`Classificacao: ${r.regressoes.length} regressao(oes), ` +
-            `${r.preExistentes.length} pre-existente(s), ` +
-            `${r.falhasSemBaseline.length} falha(s) sem baseline`);
+        linhas.push(m.classificacao(r.regressoes.length, r.preExistentes.length, r.falhasSemBaseline.length));
         for (const c of r.regressoes)
-            linhas.push(`  regressao      ${c.nome}: ${c.comando}`);
+            linhas.push(m.regressao(c.nome, c.comando));
         for (const c of r.preExistentes)
-            linhas.push(`  pre-existente  ${c.nome}: ${c.comando}`);
-        for (const c of r.falhasSemBaseline)
-            linhas.push(`  sem baseline   ${c.nome}: ${c.comando}`);
+            linhas.push(m.preExistente(c.nome, c.comando));
+        // 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) {
+            linhas.push(semVeredito.has(c.nome) ? m.falhaComBaselineSemVeredito(c.nome, c.comando) : m.falhaSemBaseline(c.nome, c.comando));
+        }
     }
+    if (r.dadoPrivado)
+        linhas.push('', ...textoDaBarreira(r.dadoPrivado));
     linhas.push('');
-    linhas.push(r.ok
-        ? 'Veredito: VERDADE SUSTENTADA (nenhum motivo bloqueante).'
-        : `Veredito: REPROVADO. Motivos tipados: ${r.motivos.join(', ')}`);
+    linhas.push(r.ok ? m.verdade : m.reprovado(r.motivos.join(', ')));
     return linhas.join('\n');
 }
+/** RM-062 (F2): a secao da barreira de dado privado, sem valor casado nem termo; ate 20 achados. */
+function textoDaBarreira(b) {
+    const m = (0, locale_1.msg)().verify;
+    const v = b.varredura;
+    const escopo = v.escopo.map((e) => e.tipo === 'diff' ? m.dadoPrivadoEscopoDiff(e.base.slice(0, 12), e.ref)
+        : e.tipo === 'arvore' ? m.dadoPrivadoEscopoArvore : m.dadoPrivadoEscopoTexto(e.nome)).join(' + ');
+    const linhas = [m.dadoPrivadoTitulo(b.severidade), m.dadoPrivadoEscopo(escopo, v.arquivos, v.linhas, v.nomes),
+        v.listaLocal.presente ? m.dadoPrivadoListaPresente(v.listaLocal.termos, v.listaLocal.lidos.join(', '))
+            : m.dadoPrivadoListaAusente(v.listaLocal.procurada.join(', '))];
+    if (v.erro)
+        return [...linhas, m.dadoPrivadoErro(v.erro)];
+    linhas.push(m.dadoPrivadoAchados(v.achados.length));
+    for (const a of v.achados.slice(0, 20))
+        linhas.push(m.dadoPrivadoAchado(a.arquivo, a.linha, a.coluna, a.padrao, a.termo));
+    if (v.achados.length > 20)
+        linhas.push(m.dadoPrivadoMais(v.achados.length - 20));
+    return linhas;
+}