@orkastery/cli 0.5.3 → 0.6.0

package/dist/noctum-aceite.js

@@ -0,0 +1,789 @@
+"use strict";
+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.CHAVES_DOS_LIMIARES = exports.FALHAS_DO_M5 = exports.RecusaDoAceite = exports.ARQUIVO_DO_ACEITE = exports.MAQUINA_DO_ENSAIO = exports.CONTRATO_LIMIARES = exports.CONTRATO_PILOTO = void 0;
+exports.gitDaRaiz = gitDaRaiz;
+exports.remotoLocal = remotoLocal;
+exports.limiaresDaProposta = limiaresDaProposta;
+exports.lerLimiares = lerLimiares;
+exports.lerInjecoes = lerInjecoes;
+exports.aceiteDoPiloto = aceiteDoPiloto;
+exports.hashDoAceite = hashDoAceite;
+exports.gravarAceite = gravarAceite;
+exports.publicavel = publicavel;
+exports.sensiveisDoArco = sensiveisDoArco;
+/**
+ * RM-058, integração (T8 da ork-rm058integra, D12): o aceite do piloto. `aceiteDoPiloto` lê o log do arco, a supervisão, o
+ * registro do relatório, os ledgers das threads do arco, o remoto (a ponta da base pelo `git ls-remote` e a ancestralidade
+ * de cada merge) e a forja (os PRs da branch, quando o remoto é do GitHub), e dá o contrato `ork.noctum-piloto/v1`: as
+ * medidas M1 a M10 (valor, unidade, fonte e lacunas), os critérios A1 a A8 e I1 a I6 com o limiar e a origem dele (`dono`
+ * ou `proposta`), e o veredito (`aprovado`, `reprovado`, `incompleto` ou `simulado`).
+ *
+ * Medida que não se lê é lacuna, nunca zero, e o critério com lacuna fica incompleto. Qualquer marca de simulação (a máquina
+ * do ensaio, o remoto de fixture, evento marcado `simulado`, o canal que grava num arquivo local, o despacho cuja sessão o
+ * runtime não confirmou) dá `simulado`, e o veredito
+ * nunca é `aprovado`: o ensaio não vale como piloto. O resultado não traz o instante de quem roda: o mesmo arco dá o mesmo
+ * hash. `publicavel` troca caminho absoluto, e-mail, id de sessão, conta, máquina e o dono do repositório por rótulos
+ * estáveis; o arquivo completo fica no estado, ao lado do log do arco.
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const branch_de_estado_1 = require("./branch-de-estado");
+const ci_1 = require("./ci");
+const horario_1 = require("./horario");
+const ledger_1 = require("./ledger");
+const master_1 = require("./master");
+const noctum_arco_1 = require("./noctum-arco");
+const noctum_envelope_1 = require("./noctum-envelope");
+const noctum_fila_1 = require("./noctum-fila");
+const noctum_medicao_1 = require("./noctum-medicao");
+const noctum_registro_1 = require("./noctum-registro");
+const noctum_relatorio_1 = require("./noctum-relatorio");
+const noctum_supervisao_1 = require("./noctum-supervisao");
+const parado_no_condutor_1 = require("./parado-no-condutor");
+const estado_thread_1 = require("./estado-thread");
+const thread_1 = require("./thread");
+const util_1 = require("./util");
+const worktree_1 = require("./worktree");
+exports.CONTRATO_PILOTO = 'ork.noctum-piloto/v1';
+exports.CONTRATO_LIMIARES = 'ork.noctum-limiares/v1';
+/** A máquina do ensaio (`core/scripts/ensaio-noctum.cjs`): o arco que ela conduziu é simulado. */
+exports.MAQUINA_DO_ENSAIO = 'maquina-do-ensaio';
+/** O arquivo completo do aceite, no estado, ao lado do log do arco. */
+exports.ARQUIVO_DO_ACEITE = 'aceite-piloto.json';
+class RecusaDoAceite extends Error {
+    motivo;
+    constructor(motivo, detalhe) {
+        super(`${motivo}: ${detalhe}`);
+        this.motivo = motivo;
+        this.name = 'RecusaDoAceite';
+    }
+}
+exports.RecusaDoAceite = RecusaDoAceite;
+const HORA = 3_600_000;
+/** As falhas que o plano mede pelo tempo de recuperação (M5): a sessão morta, o condutor morto e a máquina perdida. */
+exports.FALHAS_DO_M5 = ['F1', 'F2', 'F11'];
+const MIN = 60_000;
+const arred = (x, casas = 2) => Math.round(x * 10 ** casas) / 10 ** casas;
+const sha256 = (texto) => (0, node_crypto_1.createHash)('sha256').update(texto).digest('hex');
+const objeto = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+/** O git da raiz: a URL do remoto, a ponta da base pelo `ls-remote` e a ancestralidade pelo `merge-base`. */
+function gitDaRaiz(raiz) {
+    return {
+        url: (remoto) => { const r = (0, util_1.exec)('git', ['remote', 'get-url', '--', remoto], raiz, 15_000); return r.ok ? r.stdout.trim() : null; },
+        ponta: (remoto, base) => {
+            const r = (0, util_1.exec)('git', ['ls-remote', '--', remoto, `refs/heads/${base}`], raiz, 60_000);
+            return r.ok ? r.stdout.trim().split(/\s+/)[0] || null : null;
+        },
+        ancestral: (sha, ponta) => {
+            const r = (0, util_1.exec)('git', ['merge-base', '--is-ancestor', sha, ponta], raiz, 30_000);
+            return r.code === 0 ? true : r.code === 1 ? false : null;
+        },
+        reversoes: (sha, ponta) => {
+            // O sha vem do ledger: só hexadecimal chega ao `git log`, como na detecção do `ship`.
+            if (!(0, branch_de_estado_1.shaValido)(sha) || !(0, branch_de_estado_1.shaValido)(ponta))
+                return null;
+            const r = (0, util_1.exec)('git', ['log', '--fixed-strings', `--grep=This reverts commit ${sha}`, '--format=%H%x1f%cI%x1e', '--end-of-options', `${sha}..${ponta}`], raiz, 60_000);
+            if (!r.ok)
+                return null;
+            return r.stdout.split('\x1e').map(x => x.trim().split('\x1f')).filter(([h, d]) => h && d).map(([h, d]) => ({ sha: h, em: d }));
+        },
+    };
+}
+/** O remoto que não é um endereço de rede: caminho local ou `file://`. É o remoto de fixture do ensaio. */
+function remotoLocal(url) {
+    return /^file:/i.test(url) || /^(\/|\.{1,2}\/|[A-Za-z]:[\\/])/.test(url) || (!/^[a-z][a-z0-9+.-]*:\/\//i.test(url) && !/^[^@\s]+@[^:\s]+:/.test(url));
+}
+/** Os limiares da proposta, pela janela do piloto. */
+function limiaresDaProposta(horas) {
+    return { m1MinimoHoras: arred(horas), m5MaximoMin: 15, entregasMinimas: horas < 12 ? 2 : 4, margemDoTeto: 0, atrasoDoRelatorioMin: noctum_fila_1.CADENCIA_MS / MIN };
+}
+/** As chaves dos limiares do dono, no contrato `ork.noctum-limiares/v1`. */
+exports.CHAVES_DOS_LIMIARES = ['m1MinimoHoras', 'm5MaximoMin', 'entregasMinimas', 'margemDoTeto', 'atrasoDoRelatorioMin'];
+/** Confere os limiares do dono (`--limiares`): o contrato, só as chaves conhecidas e números não negativos; o que falta fica com a proposta. */
+function lerLimiares(bruto) {
+    if (!objeto(bruto) || bruto.contrato !== exports.CONTRATO_LIMIARES) {
+        throw new RecusaDoAceite('noctum.aceite.limiares-invalidos', `os limiares do dono são um JSON com contrato ${exports.CONTRATO_LIMIARES}`);
+    }
+    const saida = {};
+    // M8 do CHECK 2: a chave com erro de digitação não some em silêncio, deixando o critério com a proposta.
+    const desconhecidas = Object.keys(bruto).filter(k => k !== 'contrato' && !exports.CHAVES_DOS_LIMIARES.includes(k));
+    if (desconhecidas.length) {
+        throw new RecusaDoAceite('noctum.aceite.limiares-invalidos', `chave(s) desconhecida(s): ${desconhecidas.join(', ')}; as válidas: ${exports.CHAVES_DOS_LIMIARES.join(', ')}`);
+    }
+    for (const chave of exports.CHAVES_DOS_LIMIARES) {
+        const v = bruto[chave];
+        if (v === undefined)
+            continue;
+        if (typeof v !== 'number' || !Number.isFinite(v) || v < 0)
+            throw new RecusaDoAceite('noctum.aceite.limiares-invalidos', `${chave} não é um número não negativo`);
+        saida[chave] = v;
+    }
+    return saida;
+}
+/** Lê a agenda de injeções: uma linha JSON por falha, com `falha` (F1 a F11) e `instante` (ISO). */
+function lerInjecoes(texto) {
+    const saida = [];
+    for (const [i, linha] of texto.split('\n').entries()) {
+        if (!linha.trim())
+            continue;
+        let v;
+        try {
+            v = JSON.parse(linha);
+        }
+        catch {
+            throw new RecusaDoAceite('noctum.aceite.injecoes-invalidas', `a linha ${i + 1} da agenda não é JSON`);
+        }
+        if (!objeto(v) || typeof v.falha !== 'string' || !/^F([1-9]|1[01])$/.test(v.falha) || typeof v.instante !== 'string' || !Number.isFinite(Date.parse(v.instante))) {
+            throw new RecusaDoAceite('noctum.aceite.injecoes-invalidas', `a linha ${i + 1} da agenda precisa de falha (F1 a F11) e instante (ISO)`);
+        }
+        // N7 do CHECK 3: a chave com erro de digitação ("Alvo") ou o alvo que não é texto não viram injeção sem alvo em silêncio.
+        const desconhecidas = Object.keys(v).filter(k => !['falha', 'instante', 'alvo'].includes(k));
+        // M4 do CHECK 4: o alvo vazio também, que valeria como o arco inteiro.
+        if (desconhecidas.length || (v.alvo !== undefined && (typeof v.alvo !== 'string' || !v.alvo.trim()))) {
+            throw new RecusaDoAceite('noctum.aceite.injecoes-invalidas', `a linha ${i + 1} da agenda só aceita falha, instante e alvo (texto)` +
+                `${desconhecidas.length ? `; chave(s) desconhecida(s): ${desconhecidas.join(', ')}` : ''}`);
+        }
+        saida.push({ falha: v.falha, instante: new Date(v.instante).toISOString(), ...(typeof v.alvo === 'string' ? { alvo: v.alvo } : {}) });
+    }
+    return saida;
+}
+/** O primeiro instante, depois da injeção, de um evento que a falha deve provocar; e o evento, como fonte. */
+function sinalDe(eventos, desde) {
+    return eventos.filter(e => Date.parse(e.em) >= desde).sort((a, b) => Date.parse(a.em) - Date.parse(b.em))[0] ?? null;
+}
+/**
+ * O aceite de um arco, pelos registros do núcleo. Recusa só o arco que não existe; toda leitura que falha vira lacuna da
+ * medida que dependia dela.
+ */
+function aceiteDoPiloto(carregado, arco, opcoes = {}) {
+    const { raiz } = carregado;
+    let estado;
+    try {
+        estado = (0, noctum_arco_1.lerArco)(raiz, arco);
+    }
+    catch (e) {
+        if (e instanceof noctum_envelope_1.RecusaDoArco)
+            throw new RecusaDoAceite('noctum.aceite.sem-arco', `o log do arco ${arco} não se lê (${e.motivo})`);
+        throw e;
+    }
+    if (!estado?.conteudo || !estado.autorizadoPor)
+        throw new RecusaDoAceite('noctum.aceite.sem-arco', `o arco ${arco} nunca foi autorizado pelo dono`);
+    const conteudo = estado.conteudo;
+    const janela = conteudo.janela;
+    // A condução começa no início da janela ou na primeira autorização, o que vier depois; as autorizações seguintes, dentro
+    // da janela, são emendas do dono.
+    let autorizacoes = [];
+    try {
+        autorizacoes = (0, noctum_arco_1.versoesAutorizadas)(raiz, arco).map(v => ({ versao: v.versao, autorizadoEm: v.autorizadoEm }));
+    }
+    catch (e) {
+        if (!(e instanceof noctum_envelope_1.RecusaDoArco))
+            throw e;
+    }
+    const primeiraAutorizacao = autorizacoes[0]?.autorizadoEm ?? estado.autorizadoPor.recebidoEm;
+    const inicioMs = Math.max(Date.parse(janela.inicio), Date.parse(primeiraAutorizacao));
+    const fim = estado.encerramento?.em ?? janela.fim;
+    const fimMs = Date.parse(fim);
+    const horasDaJanela = (Date.parse(janela.fim) - Date.parse(janela.inicio)) / HORA;
+    const git = opcoes.git ?? gitDaRaiz(raiz);
+    const remoto = opcoes.remoto ?? carregado.manifesto.fabrica?.remoto ?? 'origin';
+    // As leituras: a supervisão, o relatório e os ledgers das threads do arco.
+    let supervisao = null;
+    let erroDaSupervisao = null;
+    try {
+        supervisao = (0, noctum_supervisao_1.eventosDaSupervisao)(raiz, arco);
+    }
+    catch (e) {
+        if (!(e instanceof noctum_supervisao_1.RecusaDaSupervisao))
+            throw e;
+        erroDaSupervisao = `o log da supervisão não se lê (${e.motivo})`;
+    }
+    let relatorio = null;
+    let erroDoRelatorio = null;
+    try {
+        relatorio = (0, noctum_registro_1.lerRegistro)(raiz, arco, 'relatorio');
+    }
+    catch (e) {
+        if (!(e instanceof noctum_registro_1.RecusaDoRegistro))
+            throw e;
+        erroDoRelatorio = `o registro do relatório não se lê (${e.motivo})`;
+    }
+    // N1 do CHECK 3: o recibo que o reenvio do dono trouxe (a tentativa anterior da mesma página com `forcado`) não é do envio
+    // automático: não conta no M10 nem como sinal da F7.
+    const confirmacoesAutomaticas = [];
+    {
+        const forcada = new Map();
+        for (const l of relatorio ?? []) {
+            const chave = `${String(l.evento.versao)} ${String(l.evento.pagina)} ${String(l.evento.canal)}`;
+            if (l.evento.tipo === 'envio_tentado')
+                forcada.set(chave, l.evento.forcado === true);
+            else if (l.evento.tipo === 'envio_confirmado' && forcada.get(chave) !== true)
+                confirmacoesAutomaticas.push(l);
+        }
+    }
+    const comTrabalhos = 'trabalhos' in conteudo && Array.isArray(conteudo.trabalhos);
+    const porTrabalho = comTrabalhos ? (0, noctum_supervisao_1.threadsDoArco)(raiz, conteudo, estado) : new Map();
+    const ledgers = [...porTrabalho].map(([trabalho, thread]) => {
+        try {
+            return { trabalho, thread, eventos: (0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, thread)), erro: null };
+        }
+        catch (e) {
+            return { trabalho, thread, eventos: null, erro: `o ledger da thread ${thread} não se lê (${e.message.slice(0, 120)})` };
+        }
+    });
+    // M7 do CHECK 2: a linha que não se lê vira `ledger_corrupted` na leitura, e o ato do dono ou a entrega podem estar nela.
+    const ilegiveis = [...ledgers.filter(l => l.erro).map(l => l.erro),
+        ...ledgers.filter(l => l.eventos?.some(e => e.tipo === 'ledger_corrupted')).map(l => `o ledger da thread ${l.thread} tem linha corrompida`)];
+    const eventosDasThreads = ledgers.flatMap(l => (l.eventos ?? []).map(e => ({ ...e, threadDoArco: l.thread })));
+    // As marcas de simulação.
+    const marcas = [];
+    const urlDoRemoto = git.url(remoto);
+    if (urlDoRemoto && remotoLocal(urlDoRemoto))
+        marcas.push(`o remoto ${remoto} é de fixture (caminho local), não um endereço de rede`);
+    const maquinas = new Set((supervisao ?? []).map(l => objeto(l.evento) && 'quem' in l.evento ? l.evento.quem.maquina : null).filter((x) => !!x));
+    if (maquinas.has(exports.MAQUINA_DO_ENSAIO))
+        marcas.push(`a máquina do ensaio (${exports.MAQUINA_DO_ENSAIO}) conduziu o arco`);
+    const simulados = eventosDasThreads.filter(e => e.simulado === true).length;
+    if (simulados)
+        marcas.push(`${simulados} evento(s) marcado(s) simulado nos ledgers das threads do arco`);
+    // I3 do CHECK 4: o despacho sem sessão do runtime. Cada sessão que o arco diz ter despachado tem, no ledger da thread, o
+    // `phase_dispatch_verified` que o `phase run` grava quando o runtime a lista (`encontrada: true`), por uma fonte que não
+    // se diz simulada. O ledger que não se lê já é lacuna, e não marca.
+    const confirmadas = new Set(eventosDasThreads.filter(e => e.tipo === ledger_1.TIPOS_DE_EVENTO.despachoVerificado && e.encontrada === true &&
+        typeof e.sessionId === 'string' && !(typeof e.fonte === 'string' && /simulad/i.test(e.fonte))).map(e => `${e.threadDoArco} ${String(e.sessionId)}`));
+    const lidas = new Set(ledgers.filter(l => l.eventos).map(l => l.thread));
+    const semSessao = [...new Set(estado.despachos.filter(d => d.sessionId && lidas.has(d.threadDespachada ?? d.thread ?? '') &&
+            !confirmadas.has(`${d.threadDespachada ?? d.thread} ${d.sessionId}`)).map(d => d.seq))];
+    if (semSessao.length)
+        marcas.push(`${semSessao.length} despacho(s) do arco sem a sessão confirmada pelo runtime (reserva ${semSessao.join(', ')})`);
+    // O transporte do canal, de onde o relatório o lê (a raiz do estado). Só o nome diz que ele é simulado: o transporte que
+    // grava num arquivo com outro nome não aparece aqui, e a confirmação do dono (A8) o cobre.
+    try {
+        const transporte = fs.readFileSync(path.join((0, estado_thread_1.raizDoEstado)(raiz), '.orkastery', 'monitor', noctum_relatorio_1.ARQUIVO_DO_TRANSPORTE), 'utf8');
+        if (/simulad/i.test(transporte))
+            marcas.push('o transporte do canal do relatório é simulado (grava num arquivo local)');
+    }
+    catch { /* sem transporte configurado: o relatório diz a lacuna */ }
+    const medidas = [];
+    const medida = (m) => { medidas.push(m); return m; };
+    /**
+     * I1 do CHECK 2: a entrega do arco é o `ship_done` que a entrega dele gravou (o arco na evidência), e não a reconciliação
+     * de um merge feito por fora (`incorporadaPor: 'outro-caminho'`) nem o ship do dono depois do arco.
+     */
+    const doArco = (e) => {
+        const ev = e.evidencia;
+        return ev?.arco === arco && ev.incorporadaPor !== 'outro-caminho';
+    };
+    /** N6 do CHECK 3: o MASTER por omissão do arco é o que a entrega dele marca com o arco na evidência. */
+    const masterDoArco = (e) => e.evidencia?.arco === arco;
+    const ponta = new Map();
+    const pontaDa = (base) => { if (!ponta.has(base))
+        ponta.set(base, git.ponta(remoto, base)); return ponta.get(base); };
+    const baseDoShip = (ship) => typeof ship.para === 'string' && ship.para ? ship.para : comTrabalhos ? conteudo.destinos[0]?.base ?? 'main' : 'main';
+    /**
+     * I2 do CHECK 4: a reversão de uma entrega do arco (o `mergeSha` de um `ship_done` dele; a de uma entrega anterior ao arco
+     * não conta), com o instante do commit que reverte. O núcleo grava o `rollback_done` quando a detecta (no `ork ship` e no
+     * MASTER), e esse instante pode vir depois do arco; o aceite procura também no git a reversão que ninguém detectou ainda.
+     * A detectada depois do arco, sem a data do commit no git, é lacuna: não se sabe se foi na condução.
+     */
+    const mergesDoArco = new Map();
+    for (const l of ledgers) {
+        for (const e of l.eventos ?? []) {
+            if (e.tipo === ledger_1.TIPOS_DE_EVENTO.shipConcluido && doArco(e) && typeof e.mergeSha === 'string' && e.mergeSha && !mergesDoArco.has(e.mergeSha)) {
+                mergesDoArco.set(e.mergeSha, { thread: l.thread, base: baseDoShip(e) });
+            }
+        }
+    }
+    const reversoes = new Map();
+    const lacunasDaReversao = [];
+    for (const [mergeSha, { thread, base }] of mergesDoArco) {
+        const p = git.reversoes ? pontaDa(base) : null;
+        const achadas = p ? git.reversoes(mergeSha, p) : [];
+        if (achadas === null) {
+            lacunasDaReversao.push(`as reversões do merge ${mergeSha.slice(0, 12)} não se leram no git`);
+            continue;
+        }
+        for (const r of achadas) {
+            const t = Date.parse(r.em);
+            if (Number.isFinite(t))
+                reversoes.set(r.sha, { em: new Date(t).toISOString(), detectadaEm: null, thread, mergeSha });
+        }
+    }
+    for (const [i, e] of eventosDasThreads.entries()) {
+        if (e.tipo !== ledger_1.TIPOS_DE_EVENTO.rollbackConcluido || typeof e.mergeSha !== 'string' || !mergesDoArco.has(e.mergeSha))
+            continue;
+        // O registro sem o sha do revert é uma reversão por si: a chave é a posição dele na leitura.
+        const chave = typeof e.revertSha === 'string' && e.revertSha ? e.revertSha : `registro-${i}`;
+        reversoes.set(chave, { em: reversoes.get(chave)?.em ?? null, detectadaEm: e.ts, thread: e.threadDoArco, mergeSha: e.mergeSha });
+    }
+    // M1: condução sem intervenção.
+    const atos = [];
+    for (const [revertSha, r] of reversoes) {
+        // Sem a data do commit, a detecção até o fim do arco prova que a reversão foi nele; a de depois não prova nada.
+        const em = r.em ?? (r.detectadaEm && Date.parse(r.detectadaEm) <= fimMs ? r.detectadaEm : null);
+        if (em === null) {
+            lacunasDaReversao.push(`a reversão ${revertSha.slice(0, 12)} do merge ${r.mergeSha.slice(0, 12)} não tem a data do commit no git`);
+            continue;
+        }
+        const t = Date.parse(em);
+        if (t >= inicioMs && t <= fimMs)
+            atos.push({ em, ato: `reversão de entrega na thread ${r.thread}` });
+    }
+    if (estado.revogadoPor)
+        atos.push({ em: estado.revogadoPor.recebidoEm, ato: 'revogação do envelope pelo dono' });
+    for (const a of autorizacoes.slice(1)) {
+        if (Date.parse(a.autorizadoEm) > Date.parse(janela.inicio))
+            atos.push({ em: a.autorizadoEm, ato: `emenda do envelope (versão ${a.versao}) durante a janela` });
+    }
+    for (const e of eventosDasThreads) {
+        const t = Date.parse(e.ts);
+        if (!(t >= inicioMs && t <= fimMs))
+            continue;
+        if (e.tipo === 'human_gate' && e.source === 'human')
+            atos.push({ em: e.ts, ato: `gate respondido pelo dono na thread ${e.threadDoArco}` });
+        else if (e.tipo === 'session_answered')
+            atos.push({ em: e.ts, ato: `sessão respondida pelo dono na thread ${e.threadDoArco}` });
+        else if (e.tipo === ledger_1.TIPOS_DE_EVENTO.threadFechadaAdmin)
+            atos.push({ em: e.ts, ato: `thread ${e.threadDoArco} fechada à mão` });
+        else if (e.tipo === ledger_1.TIPOS_DE_EVENTO.masterConcluido && (0, master_1.autoriaHumana)(e.por) && e.regime !== 'omissao') {
+            atos.push({ em: e.ts, ato: `MASTER do dono na thread ${e.threadDoArco}` });
+        }
+        else if (e.tipo === ledger_1.TIPOS_DE_EVENTO.faseDespachada && e.correlacao !== (0, noctum_supervisao_1.correlacaoDoArco)(arco)) {
+            atos.push({ em: e.ts, ato: `despacho de fora do arco na thread ${e.threadDoArco}` });
+        }
+        else if (e.tipo === ledger_1.TIPOS_DE_EVENTO.shipConcluido && !doArco(e)) {
+            atos.push({ em: e.ts, ato: `entrega de fora do arco na thread ${e.threadDoArco}` });
+        }
+        else if (e.tipo === ledger_1.TIPOS_DE_EVENTO.aceitePorOmissao && !masterDoArco(e)) {
+            atos.push({ em: e.ts, ato: `MASTER por omissão de fora do arco na thread ${e.threadDoArco}` });
+        }
+    }
+    atos.sort((a, b) => Date.parse(a.em) - Date.parse(b.em));
+    const primeiroAto = atos[0] ?? null;
+    const ateOAto = primeiroAto ? Math.max(inicioMs, Date.parse(primeiroAto.em)) : fimMs;
+    // O arco aberto ainda não tem a condução inteira: M1 é lacuna, e o aceite nunca aprova um piloto em curso.
+    const lacunasDoM1 = [...(estado.encerramento ? [] : ['o arco ainda não fechou: a condução se mede no arco encerrado']), ...ilegiveis, ...lacunasDaReversao];
+    medida({ id: 'M1', nome: 'Condução sem intervenção', valor: lacunasDoM1.length ? null : arred(Math.max(0, ateOAto - inicioMs) / HORA), unidade: 'h',
+        fonte: 'log do arco e ledgers das threads do arco', lacunas: lacunasDoM1, evidencia: { inicio: new Date(inicioMs).toISOString(), fim, atos } });
+    // M2 e M3: as entregas com prova e o MASTER delas.
+    const entregas = [];
+    const lacunasDaEntrega = [...ilegiveis];
+    for (const l of ledgers) {
+        const ships = (l.eventos ?? []).filter(e => e.tipo === ledger_1.TIPOS_DE_EVENTO.shipConcluido && doArco(e));
+        if (!ships.length)
+            continue;
+        const ship = ships[0];
+        const sha = typeof ship.mergeSha === 'string' && ship.mergeSha ? ship.mergeSha : typeof ship.shaRemoto === 'string' ? ship.shaRemoto : null;
+        const base = baseDoShip(ship);
+        let provada = false, motivo = '';
+        if (ship.pushVerificado !== true || !sha)
+            motivo = 'ship_done sem a prova do push';
+        else {
+            const p = pontaDa(base);
+            const anc = p ? git.ancestral(sha, p) : null;
+            if (!p) {
+                provada = null;
+                motivo = `a ponta de ${base} no remoto ${remoto} não se leu`;
+                lacunasDaEntrega.push(`${l.thread}: ${motivo}`);
+            }
+            else if (anc === null) {
+                provada = null;
+                motivo = `o merge ${sha.slice(0, 12)} não está nesta cópia`;
+                lacunasDaEntrega.push(`${l.thread}: ${motivo}`);
+            }
+            else {
+                provada = anc;
+                motivo = anc ? `merge ${sha.slice(0, 12)} na ponta de ${base}` : `o merge ${sha.slice(0, 12)} não está na base do remoto`;
+            }
+        }
+        let fechada = false;
+        try {
+            fechada = (0, thread_1.lerThread)(raiz, l.thread).status === 'fechada';
+        }
+        catch { /* a thread ilegível não tem MASTER provado */ }
+        // O MASTER do arco é o por omissão que a entrega dele grava antes do fim; o da fábrica ou do dono depois do arco não conta.
+        const master = fechada && (l.eventos ?? []).some(e => e.tipo === ledger_1.TIPOS_DE_EVENTO.aceitePorOmissao && masterDoArco(e) && Date.parse(e.ts) <= fimMs);
+        entregas.push({ trabalho: l.trabalho, thread: l.thread, ship, provada, motivo, master, duplicadas: ships.length - 1 });
+    }
+    const provadas = entregas.filter(e => e.provada === true);
+    const semLeitura = entregas.some(e => e.provada === null) || ilegiveis.length > 0;
+    medida({ id: 'M2', nome: 'Entregas com prova', valor: semLeitura ? null : provadas.length, unidade: `entregas provadas de ${entregas.length} alegadas`,
+        fonte: 'ship_done dos ledgers, ponta da base pelo git ls-remote e ancestralidade do merge', lacunas: lacunasDaEntrega,
+        evidencia: { alegadas: entregas.length, entregas: entregas.map(e => ({ trabalho: e.trabalho, thread: e.thread, provada: e.provada, motivo: e.motivo })) } });
+    medida({ id: 'M3', nome: 'MASTER por omissão', valor: semLeitura ? null : provadas.filter(e => e.master).length, unidade: `entregas com MASTER de ${provadas.length} provadas`,
+        fonte: 'aceite_por_omissao com o arco na evidência, antes do fim do arco, e a thread fechada', lacunas: semLeitura ? ['as entregas não se provaram todas'] : [],
+        evidencia: { semMaster: provadas.filter(e => !e.master).map(e => e.thread) } });
+    // M4 e M5: as falhas injetadas e a recuperação delas.
+    // Cada sinal leva os alvos que ele toca (o trabalho, a thread, a conta); a injeção com `alvo` só se recupera pelo sinal
+    // dele. O sinal sem alvo (a geração nova, o tique, o recibo) vale para a falha do arco inteiro.
+    const sup = supervisao ?? [];
+    const alvosDe = (e) => ['trabalho', 'thread', 'conta'].map(k => e[k]).filter((x) => typeof x === 'string');
+    const daSupervisao = (tipos) => sup.filter(l => tipos.includes(l.evento.tipo))
+        .map(l => ({ em: l.em, fonte: `supervisão: ${l.evento.tipo}`, alvos: alvosDe(l.evento) }));
+    const dosLedgers = (tipos) => eventosDasThreads.filter(e => tipos.includes(e.tipo))
+        .map(e => ({ em: e.ts, fonte: `ledger da ${e.threadDoArco}: ${e.tipo}`, alvos: [e.threadDoArco, ...[...porTrabalho].filter(([, t]) => t === e.threadDoArco).map(([w]) => w)] }));
+    const SINAIS = {
+        F1: () => erroDaSupervisao ?? daSupervisao(['retomada_autorizada']),
+        F2: () => erroDaSupervisao ?? daSupervisao(['conducao_assumida']),
+        F3: () => erroDaSupervisao ?? daSupervisao(['vigia_interrompido']),
+        F4: () => dosLedgers([ledger_1.TIPOS_DE_EVENTO.verificacao, ledger_1.TIPOS_DE_EVENTO.shipPublicado, ledger_1.TIPOS_DE_EVENTO.shipConcluido]),
+        F5: () => dosLedgers([ledger_1.TIPOS_DE_EVENTO.shipConcluido]),
+        F6: () => erroDaSupervisao ?? daSupervisao(['conta_fora']),
+        F7: () => erroDoRelatorio ?? confirmacoesAutomaticas.map(l => ({ em: l.em, fonte: 'relatório: envio_confirmado', alvos: [] })),
+        F8: () => erroDaSupervisao ?? daSupervisao(['efeito_reconciliado']),
+        F9: () => erroDaSupervisao ?? daSupervisao(['tique_concluido']),
+        F10: () => 'a partição entre máquinas é medida com a coordenação da N3 (bloco B)',
+        F11: () => 'a máquina perdida é medida com a coordenação da N3 (bloco B)',
+    };
+    const injecoes = opcoes.injecoes ?? null;
+    const recuperacoes = (injecoes ?? []).map(i => {
+        const fontes = SINAIS[i.falha]?.() ?? `falha desconhecida: ${i.falha}`;
+        if (typeof fontes === 'string')
+            return { ...i, lacuna: fontes, sinal: null };
+        const doAlvo = i.alvo ? fontes.filter(f => !f.alvos.length || f.alvos.includes(i.alvo)) : fontes;
+        const sinal = sinalDe(doAlvo, Date.parse(i.instante));
+        return { ...i, lacuna: null, sinal: sinal ? { em: sinal.em, fonte: sinal.fonte } : null };
+    });
+    // A agenda vazia não prova recuperação nenhuma: é lacuna, como a agenda que falta.
+    const lacunasDaAgenda = injecoes === null ? ['sem a agenda de injeções (--injecoes)']
+        : !injecoes.length ? ['a agenda de injeções está vazia: nenhuma falha foi injetada']
+            : recuperacoes.filter(r => r.lacuna).map(r => `${r.falha}: ${r.lacuna}`);
+    const recuperadas = recuperacoes.filter(r => r.sinal);
+    medida({ id: 'M4', nome: 'Falhas recuperadas', valor: lacunasDaAgenda.length ? null : recuperadas.length, unidade: `recuperadas de ${recuperacoes.length} injetadas`,
+        fonte: 'agenda de injeções, log da supervisão, registro do relatório e ledgers', lacunas: lacunasDaAgenda,
+        evidencia: { injecoes: recuperacoes.map(r => ({ falha: r.falha, instante: r.instante, sinal: r.sinal, lacuna: r.lacuna })) } });
+    // M5 é das falhas que o plano mede pelo tempo (a sessão morta, o condutor morto e a máquina perdida); as outras, como o
+    // tique parado de propósito por 20 min, contam só em M4.
+    const tempos = recuperadas.filter(r => exports.FALHAS_DO_M5.includes(r.falha)).map(r => (Date.parse(r.sinal.em) - Date.parse(r.instante)) / MIN)
+        .sort((a, b) => a - b);
+    const mediana = tempos.length ? (tempos.length % 2 ? tempos[(tempos.length - 1) / 2] : (tempos[tempos.length / 2 - 1] + tempos[tempos.length / 2]) / 2) : null;
+    medida({ id: 'M5', nome: 'Tempo de recuperação', valor: lacunasDaAgenda.length || !tempos.length ? null : arred(tempos.at(-1)), unidade: 'min (máximo)',
+        fonte: 'da injeção ao primeiro sinal de retomada no log', lacunas: lacunasDaAgenda.length ? lacunasDaAgenda : tempos.length ? []
+            : [`nenhuma falha recuperada de ${exports.FALHAS_DO_M5.join(', ')} para medir`],
+        evidencia: { mediana: mediana === null ? null : arred(mediana), maximo: tempos.length ? arred(tempos.at(-1)) : null } });
+    // M6: violações do envelope.
+    const contas = new Set([...conteudo.orcamento.porConta.map(c => c.conta), ...(comTrabalhos ? conteudo.capacidade.porConta.map(c => c.conta) : [])]);
+    const bases = new Set(conteudo.destinos.map(d => d.base));
+    const violacoes = [];
+    for (const d of estado.despachos) {
+        const t = Date.parse(d.reservadoEm);
+        if (t < Date.parse(janela.inicio) || t > fimMs)
+            violacoes.push(`despacho ${d.seq} (${d.trabalho}) fora da janela vigente`);
+        if (!contas.has(d.conta))
+            violacoes.push(`despacho ${d.seq} (${d.trabalho}) pela conta fora do envelope`);
+    }
+    for (const e of entregas) {
+        if (typeof e.ship.para === 'string' && e.ship.para && !bases.has(e.ship.para))
+            violacoes.push(`a entrega de ${e.trabalho} foi para uma base fora do destino`);
+        if (Date.parse(e.ship.ts) > fimMs)
+            violacoes.push(`a entrega de ${e.trabalho} saiu depois da janela`);
+    }
+    medida({ id: 'M6', nome: 'Violações do envelope', valor: violacoes.length || !ilegiveis.length ? violacoes.length : null, unidade: 'violações',
+        fonte: 'log do arco e ship_done dos ledgers', lacunas: [...ilegiveis], evidencia: { violacoes } });
+    // M7: efeitos duplicados.
+    const duplicados = [];
+    for (const e of entregas)
+        if (e.duplicadas)
+            duplicados.push(`${e.duplicadas} ship_done a mais na thread ${e.thread}`);
+    const pushes = new Map();
+    // Só os pushes do arco, entre o início da condução e o fim dele: o push do dono antes ou depois do arco não é efeito dele.
+    for (const e of eventosDasThreads) {
+        const t = Date.parse(e.ts);
+        if (e.tipo !== ledger_1.TIPOS_DE_EVENTO.shipPublicado || e.pushFeito !== true || typeof e.head !== 'string' || !(t >= inicioMs && t <= fimMs))
+            continue;
+        const chave = `${e.threadDoArco} ${e.head}`;
+        pushes.set(chave, (pushes.get(chave) ?? 0) + 1);
+    }
+    for (const [chave, n] of pushes)
+        if (n > 1)
+            duplicados.push(`${n} pushes do mesmo SHA (${chave})`);
+    const porSessao = new Map();
+    // O despacho idempotente devolveu a sessão em curso: não abriu outra, e não é efeito duplicado.
+    for (const d of estado.despachos)
+        if (d.sessionId && !d.idempotente)
+            porSessao.set(d.sessionId, (porSessao.get(d.sessionId) ?? 0) + 1);
+    for (const [s, n] of porSessao)
+        if (n > 1)
+            duplicados.push(`${n} despachos para a mesma sessão ${s}`);
+    const paginas = new Map();
+    for (const l of relatorio ?? []) {
+        if (l.evento.tipo !== 'envio_confirmado')
+            continue;
+        const chave = `versão ${String(l.evento.versao)}, página ${String(l.evento.pagina)}, canal ${String(l.evento.canal)}`;
+        paginas.set(chave, (paginas.get(chave) ?? 0) + 1);
+    }
+    for (const [chave, n] of paginas)
+        if (n > 1)
+            duplicados.push(`${n} envios confirmados da ${chave}`);
+    const lacunasDaForja = [];
+    const repositorio = urlDoRemoto && !remotoLocal(urlDoRemoto) ? (0, ci_1.repositorioGitHub)(urlDoRemoto) : null;
+    if (repositorio) {
+        const gh = opcoes.executorGh ?? parado_no_condutor_1.ghPadrao;
+        for (const e of entregas) {
+            let branch = null;
+            try {
+                branch = (0, worktree_1.branchDaWorktree)((0, thread_1.lerThread)(raiz, e.thread));
+            }
+            catch {
+                branch = null;
+            }
+            if (!branch)
+                continue;
+            const r = gh(['pr', 'list', `--repo=${repositorio}`, `--head=${branch}`, '--state=all', '--json=number,state,headRefOid,createdAt'], 30_000);
+            let prs = null;
+            try {
+                prs = r.status === 0 ? JSON.parse(r.stdout) : null;
+            }
+            catch {
+                prs = null;
+            }
+            if (!Array.isArray(prs)) {
+                lacunasDaForja.push(`os PRs da branch ${branch} não se leram na forja`);
+                continue;
+            }
+            // N5 do CHECK 3: o PR que o dono abriu depois do arco não é efeito dele.
+            const validos = prs.filter(x => x.state !== 'CLOSED' && !(typeof x.createdAt === 'string' && Date.parse(x.createdAt) > fimMs));
+            if (validos.length > 1)
+                duplicados.push(`${validos.length} PRs da mesma branch ${branch}`);
+        }
+    }
+    const lacunasDoM7 = [...(erroDoRelatorio ? [erroDoRelatorio] : []), ...lacunasDaForja, ...ilegiveis];
+    medida({ id: 'M7', nome: 'Efeitos duplicados', valor: lacunasDoM7.length && !duplicados.length ? null : duplicados.length, unidade: 'efeitos duplicados',
+        fonte: 'ledgers (ship_done e ship_published), log do arco, registro do relatório e PRs da forja', lacunas: lacunasDoM7, evidencia: { duplicados } });
+    // M8: evidência perdida.
+    const perdidas = [...ilegiveis, ...(erroDaSupervisao ? [erroDaSupervisao] : []), ...(erroDoRelatorio ? [erroDoRelatorio] : [])];
+    for (const e of entregas)
+        if (e.motivo === 'ship_done sem a prova do push')
+            perdidas.push(`a entrega de ${e.trabalho} (${e.thread}) não tem a prova do push`);
+    medida({ id: 'M8', nome: 'Evidência perdida', valor: perdidas.length, unidade: 'evidências perdidas', fonte: 'ledgers, log da supervisão e registro do relatório',
+        lacunas: [], evidencia: { perdidas } });
+    // M9: consumo contra o teto, por escopo e unidade.
+    let medicao = null;
+    let erroDaMedicao = null;
+    const tetos = [];
+    const consumoDe = (escopo, unidade) => {
+        if (unidade === 'sessoes') {
+            const v = escopo === 'arco' ? estado.consumo.arco : 'conta' in escopo ? estado.consumo.porConta[escopo.conta] ?? 0 : estado.consumo.porRuntime[escopo.runtime] ?? 0;
+            return { valor: v, lacuna: null };
+        }
+        if (!medicao && !erroDaMedicao) {
+            try {
+                medicao = (opcoes.medir ?? ((r, e, q) => (0, noctum_medicao_1.medirArco)(r, e, { quando: q })))(raiz, estado, fim);
+            }
+            catch (e) {
+                erroDaMedicao = `a medição falhou (${e.message.slice(0, 120)})`;
+            }
+        }
+        if (!medicao)
+            return { valor: null, lacuna: erroDaMedicao };
+        const c = (0, noctum_medicao_1.consumoDoEscopoNaUnidade)(medicao, escopo, unidade);
+        return { valor: c.valor, lacuna: c.valor === null ? c.lacunas.join('; ') || 'consumo desconhecido' : null };
+    };
+    const o = conteudo.orcamento;
+    const listaDeTetos = [
+        ['arco', 'arco', o.arco], ...o.porConta.map(c => [`conta ${c.conta}`, { conta: c.conta }, c.teto]),
+        ...o.porRuntime.map(r => [`runtime ${r.runtime}`, { runtime: r.runtime }, r.teto])
+    ];
+    for (const [nome, escopo, teto] of listaDeTetos) {
+        const c = consumoDe(escopo, teto.unidade);
+        tetos.push({ escopo: nome, unidade: teto.unidade, teto: teto.valor, consumo: c.valor, lacuna: c.lacuna });
+    }
+    const lacunasDoTeto = tetos.filter(t => t.lacuna).map(t => `${t.escopo}: ${t.lacuna}`);
+    const acima = tetos.filter(t => t.consumo !== null && t.consumo > t.teto);
+    medida({ id: 'M9', nome: 'Consumo contra o teto', valor: lacunasDoTeto.length ? null : acima.length, unidade: 'escopos acima do teto',
+        fonte: 'consumo do log do arco e a medição das unidades', lacunas: lacunasDoTeto, evidencia: { tetos } });
+    // M10: o relatório da manhã.
+    const lacunasDoRelatorio = erroDoRelatorio ? [erroDoRelatorio] : [];
+    const vencimento = (0, noctum_relatorio_1.vencimentoDoRelatorio)(conteudo);
+    const composicoes = (relatorio ?? []).filter(l => l.evento.tipo === 'composto');
+    const v1 = composicoes.find(l => l.evento.versao === 1) ?? null;
+    const paginasDaV1 = v1 && Array.isArray(v1.evento.paginas) ? v1.evento.paginas.length : 0;
+    const confirmadasDaV1 = confirmacoesAutomaticas.filter(l => l.evento.versao === 1);
+    const recibos = new Set(confirmadasDaV1.map(l => l.evento.pagina));
+    const ultimoRecibo = confirmadasDaV1.map(l => Date.parse(l.em)).sort((a, b) => a - b).at(-1) ?? null;
+    // N5 do CHECK 3: a reversão que o núcleo detectou depois da janela de entrega do relatório não é falha dele (a correção já
+    // não sai). I2 do CHECK 4: só a reversão de uma entrega do arco pede a correção.
+    const revertidas = [...reversoes.values()].filter(r => r.detectadaEm !== null && v1 && Date.parse(r.detectadaEm) >= Date.parse(v1.em) &&
+        Date.parse(r.detectadaEm) <= Date.parse(vencimento) + noctum_relatorio_1.JANELA_DE_ENTREGA_MS);
+    const corrigida = composicoes.some(l => l.evento.motivo === 'correcao');
+    const falhasDoRelatorio = [];
+    if (!v1)
+        falhasDoRelatorio.push('a versão 1 não foi composta');
+    else {
+        const tolerancia = (opcoes.limiares?.atrasoDoRelatorioMin ?? noctum_fila_1.CADENCIA_MS / MIN) * MIN;
+        if (Date.parse(v1.em) > Date.parse(vencimento) + tolerancia)
+            falhasDoRelatorio.push('a versão 1 foi composta depois do vencimento e de um tique');
+        if (recibos.size < paginasDaV1)
+            falhasDoRelatorio.push(`${paginasDaV1 - recibos.size} página(s) da versão 1 sem recibo do envio automático`);
+        // I2 do CHECK 2 e N1 do CHECK 3: com a F7 na agenda (o canal fora no horário), o recibo vem pelo reenvio automático, no
+        // ciclo dele (as tentativas a cada 5 min, cada uma até um tique depois); sem ela, no horário, até um tique depois. O
+        // reenvio que o dono pede já ficou de fora dos recibos.
+        const comF7 = (opcoes.injecoes ?? []).some(i => i.falha === 'F7');
+        const cicloAutomatico = tolerancia + (noctum_relatorio_1.MAXIMO_DE_TENTATIVAS - 1) * (noctum_relatorio_1.INTERVALO_ENTRE_TENTATIVAS_MS + tolerancia);
+        if (ultimoRecibo !== null && ultimoRecibo > Date.parse(vencimento) + (comF7 ? cicloAutomatico : tolerancia)) {
+            falhasDoRelatorio.push(comF7 ? 'o último recibo da versão 1 chegou depois do ciclo de reenvio automático'
+                : 'o último recibo da versão 1 chegou depois do vencimento e de um tique');
+        }
+    }
+    if (revertidas.length && !corrigida)
+        falhasDoRelatorio.push(`${revertidas.length} entrega(s) revertida(s) sem a correção explícita`);
+    if ([...paginas.values()].some(n => n > 1))
+        falhasDoRelatorio.push('página enviada duas vezes ao mesmo canal');
+    medida({ id: 'M10', nome: 'Relatório da manhã', valor: lacunasDoRelatorio.length ? null : falhasDoRelatorio.length ? 0 : 1, unidade: '1 no horário com recibo, 0 fora',
+        fonte: 'registro do relatório do arco', lacunas: lacunasDoRelatorio,
+        evidencia: { vencimento, versao1: v1 ? { compostoEm: v1.em, paginas: paginasDaV1, recibos: recibos.size } : null, falhas: falhasDoRelatorio } });
+    // Os critérios.
+    const proposta = limiaresDaProposta(horasDaJanela);
+    const doDono = opcoes.limiares ?? {};
+    const limiar = (k) => doDono[k] !== undefined ? { valor: doDono[k], origem: 'dono' } : { valor: proposta[k], origem: 'proposta' };
+    const m = (id) => medidas.find(x => x.id === id);
+    const criterios = [];
+    const criterio = (id, texto, usados, lacuna, ok, detalhe) => {
+        const ls = usados.map(k => [k, limiar(k)]);
+        criterios.push({ id, texto, limiar: ls.length ? Object.fromEntries(ls.map(([k, l]) => [k, l.valor])) : null,
+            origemDoLimiar: ls.length ? (ls.every(([, l]) => l.origem === 'dono') ? 'dono' : 'proposta') : null,
+            veredito: lacuna ? 'incompleto' : ok ? 'aprovado' : 'reprovado', detalhe });
+    };
+    const nulo = (...ids) => ids.some(id => m(id).valor === null);
+    criterio('A1', 'M1 de ao menos a janela do piloto', ['m1MinimoHoras'], nulo('M1'), (m('M1').valor ?? 0) >= limiar('m1MinimoHoras').valor, `${m('M1').valor ?? 'lacuna'} h sem ato do dono`);
+    criterio('A2', 'M6, M7 e M8 em zero', [], nulo('M6', 'M7', 'M8'), m('M6').valor === 0 && m('M7').valor === 0 && m('M8').valor === 0, `violações ${m('M6').valor ?? 'lacuna'}, duplicados ${m('M7').valor ?? 'lacuna'}, evidências perdidas ${m('M8').valor ?? 'lacuna'}`);
+    criterio('A3', 'M9 dentro do teto em todo escopo', [], nulo('M9'), m('M9').valor === 0, `${m('M9').valor ?? 'lacuna'} escopo(s) acima do teto`);
+    const doM5 = recuperadas.some(r => exports.FALHAS_DO_M5.includes(r.falha));
+    criterio('A4', 'M4 em todas as injeções e M5 com máximo dentro do limiar', ['m5MaximoMin'], nulo('M4') || (doM5 && nulo('M5')), m('M4').valor === recuperacoes.length && (!doM5 || m('M5').valor <= limiar('m5MaximoMin').valor), `${m('M4').valor ?? 'lacuna'} de ${recuperacoes.length} recuperadas; máximo ${m('M5').valor ?? '-'} min`);
+    criterio('A5', 'M2 com toda entrega alegada provada e o mínimo de entregas', ['entregasMinimas'], nulo('M2'), m('M2').valor === entregas.length && (m('M2').valor ?? 0) >= limiar('entregasMinimas').valor, `${m('M2').valor ?? 'lacuna'} provadas de ${entregas.length} alegadas`);
+    criterio('A6', 'M3 em todas as entregas provadas', [], nulo('M3'), m('M3').valor === provadas.length, `${m('M3').valor ?? 'lacuna'} de ${provadas.length} com MASTER`);
+    criterio('A7', 'M10 entregue no horário, com recibo, sem duplicação', ['atrasoDoRelatorioMin'], nulo('M10'), m('M10').valor === 1, falhasDoRelatorio.join('; ') || 'a versão 1 saiu no horário com recibo de todas as páginas');
+    criterios.push({ id: 'A8', texto: 'o dono confirma o aceite pelo ingresso tipado', limiar: null, origemDoLimiar: null, veredito: 'do-dono',
+        detalhe: 'a ratificação do dono vai no aceite.json, com a referência do recibo do ingresso' });
+    criterio('I1', 'nenhuma violação do envelope (M6)', [], nulo('M6'), m('M6').valor === 0, violacoes.join('; ') || 'nenhuma');
+    criterio('I2', 'nenhum efeito duplicado (M7)', [], nulo('M7'), m('M7').valor === 0, duplicados.join('; ') || 'nenhum');
+    criterio('I3', 'nenhuma evidência perdida (M8)', [], nulo('M8'), m('M8').valor === 0, perdidas.join('; ') || 'nenhuma');
+    const alemDaMargem = tetos.filter(t => t.consumo !== null && t.consumo > t.teto * (1 + limiar('margemDoTeto').valor));
+    criterio('I4', 'nenhum teto excedido além da margem (M9)', ['margemDoTeto'], nulo('M9'), alemDaMargem.length === 0, alemDaMargem.map(t => `${t.escopo}: ${t.consumo} de ${t.teto} ${t.unidade}`).join('; ') || 'nenhum');
+    criterios.push({ id: 'I5', texto: 'nenhuma escrita fora do repositório do piloto ou da raiz de estado dele', limiar: null, origemDoLimiar: null,
+        veredito: 'do-dono', detalhe: 'o núcleo não mede a escrita fora do repositório: o dono confere' });
+    criterio('I6', 'o dono não revogou o envelope', [], false, !estado.revogadoPor && estado.encerramento?.motivo !== 'revogado', estado.revogadoPor ? `revogado em ${(0, horario_1.formatarDataHora)(estado.revogadoPor.recebidoEm, { fuso: janela.fuso, agora: fim, locale: 'pt-BR' })} (${janela.fuso})`
+        : 'sem revogação');
+    const veredito = marcas.length ? 'simulado' : criterios.some(c => c.veredito === 'reprovado') ? 'reprovado'
+        : criterios.some(c => c.veredito === 'incompleto') ? 'incompleto' : 'aprovado';
+    return {
+        contrato: exports.CONTRATO_PILOTO, arco,
+        envelope: { contrato: conteudo.contrato ?? null, versao: estado.versao, sha256: estado.envelopeSha256 },
+        janela: { inicio: janela.inicio, fim: janela.fim, fuso: janela.fuso, horas: arred(horasDaJanela) },
+        encerramento: estado.encerramento ? { motivo: estado.encerramento.motivo, em: estado.encerramento.em } : null,
+        simulacao: { simulado: marcas.length > 0, marcas },
+        medidas, criterios, veredito,
+        lacunas: medidas.flatMap(x => x.lacunas.map(l => `${x.id}: ${l}`)),
+    };
+}
+/** O texto canônico do resultado e o sha256 dele: o mesmo arco dá o mesmo hash. */
+function hashDoAceite(r) {
+    const texto = `${JSON.stringify(r, null, 2)}\n`;
+    return { texto, sha256: sha256(texto) };
+}
+/** Grava o arquivo completo no estado, ao lado do log do arco; devolve o caminho e o sha256. */
+function gravarAceite(raiz, r) {
+    const { texto, sha256: hash } = hashDoAceite(r);
+    const arquivo = path.join((0, noctum_supervisao_1.dirDaSupervisao)(raiz, r.arco), exports.ARQUIVO_DO_ACEITE);
+    fs.writeFileSync(arquivo, texto, { mode: 0o600 });
+    fs.chmodSync(arquivo, 0o600);
+    return { arquivo, sha256: hash };
+}
+/**
+ * A versão publicável: o mesmo resultado com caminho absoluto, e-mail, id de sessão, conta, máquina e o dono do repositório
+ * trocados por rótulos estáveis (`caminho-1`, `email-1`, `sessao-1`, `conta-1`, `maquina-1`, `repositorio-do-piloto`), e o
+ * sha256 do arquivo completo, que fica no estado. `sensiveis` são as contas e máquinas que o arco conhece.
+ */
+function publicavel(r, sha256DoCompleto, sensiveis) {
+    const rotulos = new Map();
+    const contagem = new Map();
+    const rotulo = (tipo, valor) => {
+        const chave = `${tipo}\u0000${valor}`;
+        if (!rotulos.has(chave)) {
+            const n = (contagem.get(tipo) ?? 0) + 1;
+            contagem.set(tipo, n);
+            rotulos.set(chave, `${tipo}-${n}`);
+        }
+        return rotulos.get(chave);
+    };
+    const fixos = [
+        ...sensiveis.repositorios.filter(Boolean).map(x => [x, 'repositorio-do-piloto']),
+        ...sensiveis.contas.filter(Boolean).map(x => [x, rotulo('conta', x)]),
+        ...sensiveis.maquinas.filter(Boolean).map(x => [x, rotulo('maquina', x)]),
+    ].sort((a, b) => b[0].length - a[0].length);
+    const escapar = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const limpar = (s) => {
+        let x = s;
+        x = x.replace(/[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}/g, (e) => rotulo('email', e));
+        x = x.replace(/\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/gi, (e) => rotulo('sessao', e.toLowerCase()));
+        x = x.replace(/(^|[\s(`'"=:,])((?:\/[^\s/`'"),:]+)+\/?)/g, (_m, antes, c) => `${antes}${rotulo('caminho', c)}`);
+        for (const [valor, novo] of fixos)
+            x = x.replace(new RegExp(`(?<![A-Za-z0-9_-])${escapar(valor)}(?![A-Za-z0-9_-])`, 'g'), novo);
+        return x;
+    };
+    const andar = (v) => typeof v === 'string' ? limpar(v) : Array.isArray(v) ? v.map(andar)
+        : objeto(v) ? Object.fromEntries(Object.entries(v).map(([k, x]) => [k, andar(x)])) : v;
+    return { ...andar(r), publicavel: true, sha256DoCompleto };
+}
+/** As contas, as máquinas e os repositórios que o arco conhece: o que o publicável troca por rótulos. */
+function sensiveisDoArco(carregado, arco) {
+    const estado = (0, noctum_arco_1.lerArco)(carregado.raiz, arco);
+    const conteudo = estado?.conteudo;
+    const contas = new Set();
+    const maquinas = new Set();
+    const repositorios = new Set();
+    for (const c of conteudo?.orcamento.porConta ?? [])
+        contas.add(c.conta);
+    for (const d of estado?.despachos ?? [])
+        contas.add(d.conta);
+    for (const d of conteudo?.destinos ?? []) {
+        repositorios.add(d.repositorio);
+        repositorios.add(d.repositorio.split('/')[0]);
+    }
+    try {
+        for (const l of (0, noctum_supervisao_1.eventosDaSupervisao)(carregado.raiz, arco)) {
+            const e = l.evento;
+            const quem = e.quem;
+            if (typeof quem?.maquina === 'string')
+                maquinas.add(quem.maquina);
+            if (typeof e.conta === 'string')
+                contas.add(e.conta);
+        }
+    }
+    catch { /* o log ilegível já é lacuna no aceite */ }
+    return { contas: [...contas], maquinas: [...maquinas], repositorios: [...repositorios] };
+}