@orkastery/cli 0.5.6 → 0.6.0

package/dist/verify.js

@@ -12,11 +12,49 @@
  *      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.ESPERA_PADRAO_DA_FILA_PESADA_MS = exports.ESPERA_DA_FILA_PESADA_MS = 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;
@@ -25,15 +63,23 @@ 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");
@@ -46,6 +92,11 @@ 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. */
@@ -66,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.
  *
@@ -83,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 = {
@@ -191,10 +294,15 @@ 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 } : {}),
@@ -207,7 +315,7 @@ function comandoNoLedger(c) {
 /** 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 });
@@ -257,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) => naFilaPesada(carregado, threadId, 'baseline', conducao, () => 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,
     });
@@ -344,10 +638,14 @@ function verificar(carregado, threadId, opcoes = {}) {
 }
 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
@@ -357,21 +655,61 @@ function verificarSobConducao(carregado, threadId, opcoes, conducao, canal, fila
     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(executorComSteal(opcoes.executor
-        ?? ((nome, comando, dirDeTrabalho) => executar(nome, comando, dirDeTrabalho, prazoDoComando(manifesto, nome))), leitor, (0, instabilidade_1.testesDeRelogioVigentes)(instabilidade)), 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')
@@ -384,14 +722,30 @@ function verificarSobConducao(carregado, threadId, opcoes, conducao, canal, fila
         if (r.claim.estado !== estado)
             (0, claims_1.carimbarEstado)(raiz, r.claim, estado);
     }
+    // RM-072 (A1 do CHECK): o produto que mudou durante as claims tem o preparo refeito antes do grupo, que segue em paralelo.
+    // S-h do CHECK 3: o grupo tem a vaga dele, fora do teto das claims.
+    if (vigente && !opcoes.soClaims && vigente.guarda.conferir() === 'produto-mudou')
+        refazer('antes do grupo');
+    // RM-072 (D4, D6): no Agile, build do preparo e o resto no grupo paralelo, com a guarda valendo.
+    let doAgile = null;
     const comandos = opcoes.soClaims
         ? []
-        : 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;
@@ -400,7 +754,7 @@ function verificarSobConducao(carregado, threadId, opcoes, conducao, canal, fila
             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);
@@ -435,8 +789,11 @@ function verificarSobConducao(carregado, threadId, opcoes, conducao, canal, fila
     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,
@@ -447,6 +804,10 @@ function verificarSobConducao(carregado, threadId, opcoes, conducao, canal, fila
                 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) } : {}),
             };
         }),
@@ -455,6 +816,7 @@ function verificarSobConducao(carregado, threadId, opcoes, conducao, canal, fila
         regressoes: regressoes.map((r) => r.nome),
         preExistentes: preExistentes.map((r) => r.nome),
         falhasSemBaseline: falhasSemBaseline.map((r) => r.nome),
+        ...(baselineSemVeredito.length > 0 ? { baselineSemVeredito } : {}),
         estouros: estouros.map((r) => r.nome),
         prazoMs: manifesto.verify.timeout_ms ?? exports.TIMEOUT_VERIFY_MS,
         steal,
@@ -465,12 +827,24 @@ function verificarSobConducao(carregado, threadId, opcoes, conducao, canal, fila
                 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',
@@ -493,7 +867,13 @@ function verificarSobConducao(carregado, threadId, opcoes, conducao, canal, fila
                                 ...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'
@@ -501,9 +881,13 @@ function verificarSobConducao(carregado, threadId, opcoes, conducao, canal, fila
                     ? '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,
@@ -519,10 +903,23 @@ function verificarSobConducao(carregado, threadId, opcoes, conducao, canal, fila
         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;
@@ -537,6 +934,21 @@ function situacaoDoComando(c) {
         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`. 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;
@@ -544,6 +956,14 @@ function textoDoVerify(r) {
     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;
@@ -588,10 +1008,33 @@ function textoDoVerify(r) {
             linhas.push(m.regressao(c.nome, c.comando));
         for (const c of r.preExistentes)
             linhas.push(m.preExistente(c.nome, c.comando));
-        for (const c of r.falhasSemBaseline)
-            linhas.push(m.falhaSemBaseline(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 ? 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;
+}