@orkastery/cli 0.5.6 → 0.6.1

package/dist/noctum-coordenacao.js

@@ -0,0 +1,1225 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.motivoDaReservaDeFora = exports.conferirCoordenacao = exports.TETO_DE_VAGAS_NO_CHECKPOINT = exports.ordemViva = exports.notaDaReserva = exports.BATIDA_VENCIDA_MS = void 0;
+exports.motivoPublico = motivoPublico;
+exports.chaveDoDestino = chaveDoDestino;
+exports.seloDaGeracao = seloDaGeracao;
+exports.ordemDaRaiz = ordemDaRaiz;
+exports.derivarCoordenacao = derivarCoordenacao;
+exports.lerCoordenacao = lerCoordenacao;
+exports.gravarNaCoordenacao = gravarNaCoordenacao;
+exports.situacaoDoTrabalho = situacaoDoTrabalho;
+exports.entreguesNaRede = entreguesNaRede;
+exports.encerradosNaRede = encerradosNaRede;
+exports.batidaRecente = batidaRecente;
+exports.assumirAutoridade = assumirAutoridade;
+exports.cederAutoridade = cederAutoridade;
+exports.reservasDoArco = reservasDoArco;
+exports.vistasDasReservas = vistasDasReservas;
+exports.emitirOrdem = emitirOrdem;
+exports.distribuirOrdens = distribuirOrdens;
+exports.registrosDaDistribuicao = registrosDaDistribuicao;
+exports.registrosDosAbandonos = registrosDosAbandonos;
+exports.cancelarOrdem = cancelarOrdem;
+exports.respostaAOrdem = respostaAOrdem;
+exports.registrosDasRespostas = registrosDasRespostas;
+exports.responderOrdem = responderOrdem;
+exports.concluirOrdem = concluirOrdem;
+exports.encerrarOrdem = encerrarOrdem;
+exports.bater = bater;
+exports.revogarNaRede = revogarNaRede;
+exports.contasSemVagaGlobal = contasSemVagaGlobal;
+exports.tomarVagaGlobal = tomarVagaGlobal;
+exports.soltarVagaGlobal = soltarVagaGlobal;
+exports.reservaDoItem = reservaDoItem;
+exports.tomarReservaDoTrabalho = tomarReservaDoTrabalho;
+exports.soltarReservaDoArco = soltarReservaDoArco;
+exports.planejarReconciliacao = planejarReconciliacao;
+exports.reconciliarCoordenacao = reconciliarCoordenacao;
+/**
+ * RM-058, fatia N3 (D3, D4 e D8 a D12 da ork-rm058n3): a coordenação entre as máquinas de um arco #Noctum.
+ *
+ * Tudo aqui é regra sobre o ramo de coordenação que o transporte (`noctum-transporte.ts`) lê conferido e grava por troca
+ * atômica. O estado é derivado dos registros a cada leitura, nada fica em memória:
+ *
+ * - **autoridade por geração** (D8, D15): a primeira máquina que assume fica com a geração 1; a troca vem por cessão
+ *   assinada da autoridade vigente ou por tomada forçada, com motivo, quando ela não dá sinal há 15 min ou saiu do
+ *   envelope. A geração nova sela os registros da anterior, e o que a autoridade vencida gravar depois reprova a leitura;
+ * - **ordens, recibos e cancelamento** (D9, D10): uma ordem viva por trabalho, emitida só pela autoridade vigente, com a
+ *   reserva do item lida agora (D19); o executor não age antes do aceite gravado no remoto, e o aceite e o cancelamento
+ *   disputam a mesma troca atômica;
+ * - **transferência só com prova** (D4, D20): cancelada antes do aceite, recusada, concluída ou encerrada pelo executor, a
+ *   ordem libera o trabalho; aceita e cancelada sem o fim confirmado, o trabalho fica isolado. Falta de sinal nunca solta
+ *   ordem, vaga nem reserva; a vez de integrar de quem não dá sinal é abandonada pela autoridade, sem transferir nada;
+ * - **revogação em todas as máquinas** (D21): a revogação do dono numa máquina vai ao ramo, e nada novo começa em nenhuma;
+ * - **vagas e orçamento somando as máquinas** (D3, D12): cada despacho toma uma vaga global, que é também o consumo do
+ *   arco, da conta e do runtime; a recusa antes do lançamento devolve. A conta vai ao remoto pela posição dela na lista do
+ *   envelope (D14), nunca pelo nome;
+ * - **reserva do item** (D11, D19): a da RM-047, tomada depois do aceite, sem forçar, e revalidada com leitura nova; o
+ *   motivo gravado leva só o item, nunca quem reservou.
+ *
+ * Ninguém chama estas funções ainda: o passo da máquina (`noctum-maquinas.ts`) as junta, e quem chama o passo é o vigia
+ * da N4. A N4 usa a mesma interface para a retomada em outra máquina (seção N3 da página da RM-058).
+ */
+const noctum_arco_1 = require("./noctum-arco");
+const noctum_envelope_1 = require("./noctum-envelope");
+const noctum_fila_1 = require("./noctum-fila");
+const node_crypto_1 = require("node:crypto");
+const maquina_1 = require("./maquina");
+const noctum_transporte_1 = require("./noctum-transporte");
+const roadmap_reservas_1 = require("./roadmap-reservas");
+/** D8: a batida de outra máquina vence depois de três cadências do vigia (D3 do dono), 15 min. */
+exports.BATIDA_VENCIDA_MS = 3 * noctum_fila_1.CADENCIA_MS;
+/** A nota da reserva da RM-047 que o arco toma: é por ela que a reconciliação sabe qual reserva é do arco. */
+const notaDaReserva = (arco) => `noctum:${arco}`;
+exports.notaDaReserva = notaDaReserva;
+const DESFECHOS = ['entregue', 'invalidado', 'desistiu', 'abandonada', 'sem-prova'];
+const VIVAS = ['emitida', 'aceita', 'isolada'];
+const ordemViva = (o) => VIVAS.includes(o.estado);
+exports.ordemViva = ordemViva;
+const adulterado = (detalhe) => new noctum_envelope_1.RecusaDoArco('noctum.coordenacao.adulterado', `${detalhe}; o ramo de coordenação exige inspeção`);
+const recusa = (motivo, detalhe) => new noctum_envelope_1.RecusaDoArco(motivo, detalhe);
+const objeto = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+const inteiro = (v, minimo = 1) => typeof v === 'number' && Number.isSafeInteger(v) && v >= minimo;
+const linha = (v, teto = 300) => typeof v === 'string' && v.length <= teto && !/[\r\n]/.test(v);
+const sha = (v) => typeof v === 'string' && /^[0-9a-f]{40,64}$/.test(v);
+/**
+ * A3 da rodada 3: o motivo de quem chama a interface vai ao ramo de coordenação, que mora no remoto do projeto e pode ser
+ * público. Ele vai numa linha de até 300 caracteres e sem caminho absoluto, e-mail, id de sessão nem segredo nomeado; quem
+ * chama manda um motivo tipado, como os que a N3 grava (`noctum.*` e um detalhe só com ids).
+ */
+const FORA_DO_RAMO = [
+    [/(^|[\s"'(=:,;])~?\/[\w.-]/, 'um caminho absoluto'],
+    [/[\w.+-]+@[\w-]+\.[\w.-]+/, 'um e-mail'],
+    [/\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/i, 'um id de sessão'],
+    [/\b(token|secret|senha|password|passwd|api[_-]?key)\b\s*[=:]|\bbearer\s+\S{8,}/i, 'um segredo'],
+];
+function motivoPublico(motivo, oQue) {
+    const m = String(motivo ?? '').replace(/[\r\n]+/g, ' ').trim().slice(0, 300);
+    if (!m)
+        throw recusa('noctum.envelope.invalido', `${oQue} exige motivo`);
+    const fora = FORA_DO_RAMO.find(([re]) => re.test(m));
+    if (fora) {
+        throw recusa('noctum.envelope.invalido', `${oQue}: o motivo vai ao ramo de coordenação, que pode ser público, e traz ${fora[1]}; ` +
+            'mande um motivo tipado, só com ids');
+    }
+    return m;
+}
+const COMUNS = ['contrato', 'tipo', 'arco', 'envelopeSha256', 'por', 'em'];
+/** A chave do destino de integração no ramo: o repositório sem caixa e a base. */
+function chaveDoDestino(destino) {
+    return (0, node_crypto_1.createHash)('sha256').update(`ork.noctum-destino/v1|${destino.repositorio.toLowerCase()}|${destino.base}`).digest('hex').slice(0, 16);
+}
+/** Os campos do registro são exatamente os comuns, os obrigatórios e os opcionais presentes; cada um confere. */
+function campos(d, caminho, obrigatorios, opcionais = {}) {
+    for (const k of Object.keys(d)) {
+        if (COMUNS.includes(k))
+            continue;
+        const regra = obrigatorios[k] ?? opcionais[k];
+        if (!regra)
+            throw adulterado(`${caminho} com campo fora do contrato (${k.slice(0, 40)})`);
+        if (!regra(d[k]))
+            throw adulterado(`${caminho} com ${k} fora do formato`);
+    }
+    for (const k of Object.keys(obrigatorios))
+        if (!(k in d))
+            throw adulterado(`${caminho} sem ${k}`);
+}
+const maquinasDe = (c) => (0, noctum_envelope_1.envelopeMultimaquina)(c) ? c.maquinas : [];
+const trabalhoDe = (c, id) => c.trabalhos?.find(t => t.id === id);
+/** O selo de uma geração: quantos e quais registros a autoridade dela assinou, pelo sha256 da lista ordenada (B1 da revisão). */
+function seloDaGeracao(ids) {
+    const lista = [...ids].sort();
+    return { registros: lista.length, sha256: (0, node_crypto_1.createHash)('sha256').update(JSON.stringify(lista)).digest('hex') };
+}
+const seloValido = (v) => objeto(v) && Object.keys(v).sort().join(',') === 'registros,sha256' &&
+    inteiro(v.registros, 0) && typeof v.sha256 === 'string' && /^[0-9a-f]{64}$/.test(v.sha256);
+exports.TETO_DE_VAGAS_NO_CHECKPOINT = 64;
+const checkpointValido = (v) => objeto(v) && Object.keys(v).every(k => k === 'thread' || k === 'vagasSoltas') &&
+    (v.thread === undefined || v.thread === null || linha(v.thread, 80)) &&
+    (v.vagasSoltas === undefined || (Array.isArray(v.vagasSoltas) && v.vagasSoltas.length <= exports.TETO_DE_VAGAS_NO_CHECKPOINT &&
+        v.vagasSoltas.every(x => typeof x === 'string' && noctum_transporte_1.ID_DA_VAGA.test(x))));
+/**
+ * G8-6 do CHECK de 15/10: a continuidade da chave nos registros presos a uma ordem (recibo, vaga, vaga solta, vez, fim da vez
+ * e entrega). Assinado sob uma versão anterior à da ordem, o registro só vale com a chave que a versão da ordem dá ao executor:
+ * a chave que uma emenda aposentou ainda fecha o que é dela sob a versão antiga (D18), mas não fecha, solta nem entrega a
+ * ordem emitida depois da troca. Sob a versão da ordem ou uma posterior vale a sucessão: a raiz que a emenda pôs no lugar
+ * fecha o que a chave antiga deixou. A ordem das versões é a das autorizações, a mesma que dá a vigente.
+ */
+function chaveContinua(versoes, registro, ordem) {
+    const i = versoes.findIndex(v => v.envelopeSha256 === registro.envelopeSha256);
+    const j = versoes.findIndex(v => v.envelopeSha256 === ordem.envelopeSha256);
+    if (i < 0 || j < 0)
+        return false;
+    if (i >= j)
+        return true;
+    const chave = maquinasDe(versoes[i].conteudo).find(m => m.nome === registro.por)?.chave;
+    return chave !== undefined && chave === maquinasDe(versoes[j].conteudo).find(m => m.nome === ordem.maquina)?.chave;
+}
+/**
+ * A ordem é desta raiz, que assina como `eu`? A máquina dela tem o mesmo nome, e o que esta raiz assinar sobre ela passa na
+ * continuidade da chave (G8-6): a raiz assina sob a última versão em que está com a mesma chave, a vigente ou, depois de uma
+ * emenda que a tirou, a anterior (D18). A raiz antiga que volta depois de uma troca de chave deixa a ordem da nova para ela.
+ */
+function ordemDaRaiz(estado, o, eu) {
+    if (o.maquina !== eu.nome)
+        return false;
+    const assina = [...estado.versoes].reverse().find(v => maquinasDe(v.conteudo).some(m => m.nome === eu.nome && m.chave === eu.chave));
+    return !!assina && chaveContinua(estado.versoes, { envelopeSha256: assina.envelopeSha256, por: eu.nome }, o);
+}
+/**
+ * G8-1: o que a vez de integrar diz do fim de uma ordem, a mesma regra no `encerrarOrdem` e no plano da reconciliação. A
+ * vez ativa espera, porque o merge pode ter chegado à base; sem entrega do trabalho, a fonte que chegou sem prova espera a
+ * inspeção do dono, e a vez abandonada espera a reconciliação ler a base sem a fonte (`conferidas`, que só ela tem).
+ */
+function esperaDaVez(estado, o, conferidas, semProva) {
+    const dasVezes = [...estado.vezes.values()].flat().filter(v => v.ordem === o.ordem);
+    if (dasVezes.some(v => !v.fim))
+        return 'ativa';
+    if (estado.entregas.has(o.trabalho))
+        return null;
+    if (dasVezes.some(v => v.fim?.desfecho === 'sem-prova' || semProva?.has(`${v.chave}/${v.n}`)))
+        return 'sem-prova';
+    if (dasVezes.some(v => v.fim?.desfecho === 'abandonada' && !conferidas?.has(`${v.chave}/${v.n}`)))
+        return 'abandonada';
+    return null;
+}
+/**
+ * O estado da coordenação, derivado da leitura conferida. Confere o contrato de cada tipo e a coerência entre eles (quem
+ * assina o quê, gerações contíguas e seladas, uma ordem viva por trabalho, uma vez ativa por destino, recibos que não se
+ * contradizem); qualquer falha é `noctum.coordenacao.adulterado`. A mesma leitura deriva uma vez só.
+ */
+function derivarCoordenacao(leitura) {
+    const ja = derivadas.get(leitura);
+    if (ja)
+        return ja;
+    const estado = derivar(leitura);
+    derivadas.set(leitura, estado);
+    return estado;
+}
+const derivadas = new WeakMap();
+function derivar(leitura) {
+    const versoes = new Map(leitura.versoes.map(v => [v.envelopeSha256, v]));
+    const vigente = leitura.versoes.at(-1);
+    const daVersao = (d) => versoes.get(d.envelopeSha256).conteudo;
+    const exigirChaveDaOrdem = (d, caminho, o) => {
+        if (!chaveContinua(leitura.versoes, d, o)) {
+            throw adulterado(`${caminho} assinado sob uma versão anterior à da ordem ${o.ordem}, por uma chave diferente da que o envelope ` +
+                `dela dá ao executor ${o.maquina}`);
+        }
+    };
+    const porTipo = (tipo) => leitura.registros.filter(r => r.dados.tipo === tipo);
+    const daGeracao = new Map();
+    const selar = (g, id) => daGeracao.set(g, [...(daGeracao.get(g) ?? []), id]);
+    // Autoridade e cessões.
+    const cessoes = new Map();
+    for (const { caminho, dados: d } of porTipo('cessao')) {
+        campos(d, caminho, { geracao: v => inteiro(v), para: v => typeof v === 'string' && noctum_transporte_1.NOME_DE_MAQUINA.test(v), motivo: v => linha(v) });
+        cessoes.set(d.geracao, { para: d.para, em: d.em, motivo: d.motivo, por: d.por });
+    }
+    const brutas = porTipo('autoridade').map(({ caminho, dados: d }) => {
+        campos(d, caminho, { geracao: v => inteiro(v), modo: v => v === 'primeira' || v === 'cessao' || v === 'forcada', motivo: v => linha(v),
+            anterior: v => v === null || (objeto(v) && inteiro(v.geracao) && typeof v.maquina === 'string' && Object.keys(v).length === 2),
+            selo: v => v === null || seloValido(v) }, { batidaDaAnterior: v => v === null || (typeof v === 'string' && Number.isFinite(Date.parse(v))) });
+        return d;
+    }).sort((a, b) => a.geracao - b.geracao);
+    const autoridades = [];
+    brutas.forEach((d, i) => {
+        const g = d.geracao, anterior = d.anterior;
+        if (g !== i + 1)
+            throw adulterado(`as gerações da autoridade não são contíguas (falta a ${i + 1})`);
+        if (g === 1 ? d.modo !== 'primeira' || anterior !== null : anterior?.geracao !== g - 1 || anterior.maquina !== autoridades[g - 2].maquina) {
+            throw adulterado(`a geração ${g} da autoridade não aponta a anterior`);
+        }
+        if ((g === 1) !== (d.selo === null))
+            throw adulterado(`a geração ${g} da autoridade ${g === 1 ? 'traz selo' : 'não traz o selo da anterior'}`);
+        if (d.modo === 'cessao' && cessoes.get(g - 1)?.para !== d.por)
+            throw adulterado(`a geração ${g} diz cessão sem a cessão da ${g - 1} para ${d.por}`);
+        if (d.modo === 'forcada' && !d.motivo.trim())
+            throw adulterado(`a geração ${g} foi tomada à força sem motivo`);
+        autoridades.push({ geracao: g, maquina: d.por, desde: d.em, modo: d.modo, motivo: d.motivo });
+    });
+    for (const [g, c] of cessoes) {
+        if (!autoridades[g - 1] || autoridades[g - 1].maquina !== c.por)
+            throw adulterado(`cessão da geração ${g} assinada por quem não era a autoridade`);
+    }
+    const autoridadeDa = (g) => autoridades[g - 1];
+    const daAutoridade = (d, caminho, oque) => {
+        if (!autoridadeDa(d.geracao) || autoridadeDa(d.geracao).maquina !== d.por) {
+            throw adulterado(`${caminho} ${oque} por quem não era a autoridade da geração ${String(d.geracao)}`);
+        }
+    };
+    // Ordens, cancelamentos e recibos.
+    const ordens = new Map();
+    for (const { caminho, dados: d } of porTipo('ordem')) {
+        campos(d, caminho, { ordem: v => typeof v === 'string' && noctum_transporte_1.ID_DA_ORDEM.test(v), trabalho: v => typeof v === 'string' && noctum_envelope_1.ID_DO_TRABALHO.test(v),
+            item: v => typeof v === 'string' && /^RM-\d{3}$/.test(v), maquina: v => typeof v === 'string' && noctum_transporte_1.NOME_DE_MAQUINA.test(v),
+            geracao: v => inteiro(v), n: v => inteiro(v) });
+        if (d.ordem !== `O-${String(d.trabalho)}-${String(d.n)}`)
+            throw adulterado(`${caminho} com id que não é o do trabalho e do número`);
+        daAutoridade(d, caminho, 'assinada');
+        selar(d.geracao, `ordem:${String(d.ordem)}`);
+        const conteudo = daVersao(d), t = trabalhoDe(conteudo, d.trabalho);
+        if (!t || t.item !== d.item)
+            throw adulterado(`${caminho} para um trabalho fora do envelope dela`);
+        if (!maquinasDe(conteudo).some(m => m.nome === d.maquina) || (t.maquina && t.maquina !== d.maquina)) {
+            throw adulterado(`${caminho} para uma máquina que o envelope dela não admite nesse trabalho`);
+        }
+        ordens.set(d.ordem, { ordem: d.ordem, trabalho: d.trabalho, item: d.item, maquina: d.maquina,
+            geracao: d.geracao, n: d.n, envelopeSha256: d.envelopeSha256, emitidaEm: d.em, cancelada: null, recibos: {},
+            estado: 'emitida', resultado: null });
+    }
+    for (const { caminho, dados: d } of porTipo('cancelamento')) {
+        campos(d, caminho, { ordem: v => typeof v === 'string' && noctum_transporte_1.ID_DA_ORDEM.test(v), motivo: v => linha(v), geracao: v => inteiro(v) });
+        const o = ordens.get(d.ordem);
+        if (!o)
+            throw adulterado(`${caminho} de uma ordem que não existe`);
+        daAutoridade(d, caminho, 'assinado');
+        selar(d.geracao, `cancelamento:${String(d.ordem)}`);
+        o.cancelada = { em: d.em, motivo: d.motivo, por: d.por };
+    }
+    for (const { caminho, dados: d } of porTipo('recibo')) {
+        campos(d, caminho, { ordem: v => typeof v === 'string' && noctum_transporte_1.ID_DA_ORDEM.test(v), recibo: v => noctum_transporte_1.RECIBOS.includes(v),
+            motivo: v => linha(v) }, { resultado: v => v === 'entregue' || v === 'encerrado-sem-entrega', thread: v => v === null || linha(v, 80),
+            checkpoint: v => checkpointValido(v) });
+        const o = ordens.get(d.ordem);
+        if (!o)
+            throw adulterado(`${caminho} de uma ordem que não existe`);
+        if (o.maquina !== d.por)
+            throw adulterado(`${caminho} assinado por quem não é o executor da ordem`);
+        exigirChaveDaOrdem(d, caminho, o);
+        if ((d.recibo === 'concluida') !== (d.resultado !== undefined))
+            throw adulterado(`${caminho}: só a conclusão traz resultado, e sempre`);
+        o.recibos[d.recibo] = d;
+    }
+    for (const o of ordens.values()) {
+        const r = o.recibos;
+        if ((r.aceita && r.recusada) || (r.concluida && r.encerrada) || ((r.concluida || r.encerrada) && !r.aceita)) {
+            throw adulterado(`os recibos da ordem ${o.ordem} se contradizem`);
+        }
+        o.estado = r.concluida ? 'concluida' : r.encerrada ? 'encerrada' : r.recusada ? 'recusada'
+            : r.aceita ? (o.cancelada ? 'isolada' : 'aceita') : o.cancelada ? 'cancelada-antes' : 'emitida';
+        o.resultado = r.concluida?.resultado ?? null;
+    }
+    // Uma ordem viva por trabalho, e os números de cada trabalho contíguos (D9).
+    const doTrabalho = new Map();
+    for (const o of ordens.values())
+        doTrabalho.set(o.trabalho, [...(doTrabalho.get(o.trabalho) ?? []), o]);
+    for (const [trabalho, lista] of doTrabalho) {
+        lista.sort((a, b) => a.n - b.n);
+        if (lista.some((o, i) => o.n !== i + 1))
+            throw adulterado(`as ordens do trabalho ${trabalho} não são contíguas`);
+        if (lista.filter(exports.ordemViva).length > 1)
+            throw adulterado(`o trabalho ${trabalho} tem duas ordens vivas`);
+    }
+    // Entregas.
+    const entregas = new Map();
+    for (const { caminho, dados: d } of porTipo('entrega')) {
+        campos(d, caminho, { trabalho: v => typeof v === 'string' && noctum_envelope_1.ID_DO_TRABALHO.test(v), ordem: v => typeof v === 'string' && noctum_transporte_1.ID_DA_ORDEM.test(v),
+            destino: v => objeto(v) && typeof v.repositorio === 'string' && typeof v.base === 'string' && Object.keys(v).length === 2,
+            fonte: v => sha(v), base: v => sha(v), merge: v => sha(v) });
+        const o = ordens.get(d.ordem);
+        if (!o || o.maquina !== d.por || o.trabalho !== d.trabalho || !o.recibos.aceita) {
+            throw adulterado(`${caminho} de outra máquina, de outro trabalho ou de uma ordem que ela não aceitou`);
+        }
+        exigirChaveDaOrdem(d, caminho, o);
+        entregas.set(d.trabalho, d);
+    }
+    // Vagas.
+    const vagas = [];
+    const porVaga = new Map();
+    for (const { caminho, dados: d } of porTipo('vaga')) {
+        campos(d, caminho, { vaga: v => typeof v === 'string' && noctum_transporte_1.ID_DA_VAGA.test(v), conta: v => inteiro(v, 0), runtime: v => linha(v, 40),
+            ordem: v => typeof v === 'string' && noctum_transporte_1.ID_DA_ORDEM.test(v), trabalho: v => typeof v === 'string' && noctum_envelope_1.ID_DO_TRABALHO.test(v), reserva: v => inteiro(v) });
+        if (d.vaga !== `V-${d.por}-${String(d.reserva)}`)
+            throw adulterado(`${caminho} com id que não é o da máquina e da reserva`);
+        const o = ordens.get(d.ordem);
+        // Nenhum efeito antes do aceite (D10): vaga de ordem que o executor não aceitou só existe num ramo escrito à mão.
+        if (!o || o.maquina !== d.por || o.trabalho !== d.trabalho || !o.recibos.aceita) {
+            throw adulterado(`${caminho} de quem não é o executor da ordem, ou de uma ordem que ele não aceitou`);
+        }
+        exigirChaveDaOrdem(d, caminho, o);
+        const conteudo = daVersao(d);
+        const conta = (0, noctum_envelope_1.envelopeMultimaquina)(conteudo) ? conteudo.capacidadeGlobal.porConta[d.conta]?.conta : undefined;
+        if (!conta || !conteudo.orcamento.porRuntime.some(r => r.runtime === d.runtime))
+            throw adulterado(`${caminho} com conta ou runtime fora do envelope dela`);
+        const v = { vaga: d.vaga, maquina: d.por, conta, runtime: d.runtime, ordem: d.ordem,
+            trabalho: d.trabalho, reserva: d.reserva, chave: maquinasDe(conteudo).find(m => m.nome === d.por).chave, desde: d.em,
+            solta: null };
+        vagas.push(v);
+        porVaga.set(v.vaga, v);
+    }
+    for (const { caminho, dados: d } of porTipo('vaga-solta')) {
+        campos(d, caminho, { vaga: v => typeof v === 'string' && noctum_transporte_1.ID_DA_VAGA.test(v), consumiu: v => typeof v === 'boolean', motivo: v => linha(v) });
+        const v = porVaga.get(d.vaga);
+        if (!v || v.maquina !== d.por)
+            throw adulterado(`${caminho} de uma vaga que não existe ou não é de quem solta`);
+        exigirChaveDaOrdem(d, caminho, ordens.get(v.ordem));
+        v.solta = { em: d.em, consumiu: d.consumiu, motivo: d.motivo };
+    }
+    const consumo = { arco: 0, porConta: {}, porRuntime: {} };
+    for (const v of vagas) {
+        if (v.solta && !v.solta.consumiu)
+            continue;
+        consumo.arco += 1;
+        consumo.porConta[v.conta] = (consumo.porConta[v.conta] ?? 0) + 1;
+        consumo.porRuntime[v.runtime] = (consumo.porRuntime[v.runtime] ?? 0) + 1;
+    }
+    // Vezes de integrar.
+    const vezes = new Map();
+    for (const { caminho, dados: d } of porTipo('vez')) {
+        campos(d, caminho, { chave: v => typeof v === 'string' && noctum_transporte_1.CHAVE_DO_DESTINO.test(v), n: v => inteiro(v),
+            destino: v => objeto(v) && typeof v.repositorio === 'string' && typeof v.base === 'string' && Object.keys(v).length === 2,
+            ordem: v => typeof v === 'string' && noctum_transporte_1.ID_DA_ORDEM.test(v), trabalho: v => typeof v === 'string' && noctum_envelope_1.ID_DO_TRABALHO.test(v),
+            candidato: v => objeto(v) && typeof v.branch === 'string' && sha(v.fonte) && sha(v.base) && typeof v.provas === 'string' &&
+                /^[0-9a-f]{64}$/.test(v.provas) && Object.keys(v).length === 4 });
+        const destino = d.destino;
+        if (chaveDoDestino(destino) !== d.chave)
+            throw adulterado(`${caminho} com chave que não é a do destino`);
+        const o = ordens.get(d.ordem);
+        if (!o || o.maquina !== d.por || o.trabalho !== d.trabalho || !o.recibos.aceita) {
+            throw adulterado(`${caminho} de quem não é o executor da ordem, ou de uma ordem que ele não aceitou`);
+        }
+        exigirChaveDaOrdem(d, caminho, o);
+        vezes.set(d.chave, [...(vezes.get(d.chave) ?? []), { chave: d.chave, n: d.n, maquina: d.por,
+                ordem: d.ordem, trabalho: d.trabalho, destino, candidato: d.candidato, desde: d.em, fim: null }]);
+    }
+    for (const { caminho, dados: d } of porTipo('vez-fim')) {
+        campos(d, caminho, { chave: v => typeof v === 'string' && noctum_transporte_1.CHAVE_DO_DESTINO.test(v), n: v => inteiro(v),
+            desfecho: v => DESFECHOS.includes(v), motivo: v => linha(v) }, { merge: v => v === null || sha(v), geracao: v => inteiro(v), sinalDoDono: v => v === null || (typeof v === 'string' && Number.isFinite(Date.parse(v))) });
+        const vez = vezes.get(d.chave)?.find(x => x.n === d.n);
+        if (!vez)
+            throw adulterado(`${caminho} de uma vez que não existe`);
+        if (d.desfecho === 'abandonada') {
+            // A7 da revisão: só a autoridade da geração abandona a vez de outra máquina, e o abandono entra no selo da geração.
+            daAutoridade(d, caminho, 'assinado');
+            if (vez.maquina === d.por || d.merge !== undefined)
+                throw adulterado(`${caminho}: o abandono é da vez de outra máquina, sem merge`);
+            selar(d.geracao, `abandono:${String(d.chave)}/${String(d.n)}`);
+        }
+        else if (vez.maquina !== d.por || d.geracao !== undefined || d.sinalDoDono !== undefined) {
+            throw adulterado(`${caminho} de uma vez que não é de quem a encerra`);
+        }
+        else {
+            exigirChaveDaOrdem(d, caminho, ordens.get(vez.ordem));
+        }
+        vez.fim = { em: d.em, desfecho: d.desfecho, motivo: d.motivo, merge: d.merge ?? null, por: d.por };
+    }
+    for (const [chave, lista] of vezes) {
+        lista.sort((a, b) => a.n - b.n);
+        if (lista.some((v, i) => v.n !== i + 1))
+            throw adulterado(`as vezes do destino ${chave} não são contíguas`);
+        if (lista.filter(v => !v.fim).length > 1)
+            throw adulterado(`o destino ${chave} tem duas vezes ativas`);
+    }
+    // B1 da revisão: cada geração vencida tem exatamente os registros que a autoridade seguinte selou ao assumir. A
+    // autoridade antiga que grava depois de perder a vez (um núcleo divergente, um agente com a chave dela) reprova a leitura.
+    for (let g = 1; g < autoridades.length; g++) {
+        const esperado = brutas[g].selo;
+        const visto = seloDaGeracao(daGeracao.get(g) ?? []);
+        if (visto.registros !== esperado.registros || visto.sha256 !== esperado.sha256) {
+            throw adulterado(`a geração ${g} tem ${visto.registros} registro(s) da autoridade, e a geração ${g + 1} selou ${esperado.registros}: ` +
+                'a autoridade vencida gravou depois de perder a vez');
+        }
+    }
+    // Batidas, sinais de vida e revogação.
+    const batidas = new Map();
+    for (const { caminho, dados: d } of porTipo('batida')) {
+        campos(d, caminho, {});
+        batidas.set(d.por, d.em);
+    }
+    const sinais = new Map();
+    for (const { dados: d } of leitura.registros) {
+        const antes = sinais.get(d.por);
+        if (!antes || Date.parse(d.em) > Date.parse(antes))
+            sinais.set(d.por, d.em);
+    }
+    let revogada = null;
+    for (const { caminho, dados: d } of porTipo('revogacao')) {
+        campos(d, caminho, { motivo: v => linha(v) });
+        if (!revogada || Date.parse(d.em) < Date.parse(revogada.em))
+            revogada = { por: d.por, em: d.em, motivo: d.motivo };
+    }
+    // A situação de cada trabalho do envelope vigente.
+    const trabalhos = new Map();
+    for (const t of vigente.conteudo.trabalhos ?? []) {
+        const lista = doTrabalho.get(t.id) ?? [];
+        const ultima = lista.at(-1) ?? null;
+        const entregue = entregas.get(t.id)?.em ?? lista.find(o => o.resultado === 'entregue')?.recibos.concluida?.em ?? null;
+        const estado = entregue ? 'entregue' : lista.some(o => o.resultado === 'encerrado-sem-entrega') ? 'encerrado'
+            : !ultima || !(0, exports.ordemViva)(ultima) ? 'livre' : ultima.estado === 'emitida' ? 'ordenado' : ultima.estado === 'aceita' ? 'em-execucao' : 'isolado';
+        trabalhos.set(t.id, { trabalho: t.id, estado, ordem: ultima, entregueEm: entregue });
+    }
+    return { arco: leitura.arco, remoto: leitura.remoto, ponta: leitura.ponta, lidoEm: leitura.lidoEm, versoes: leitura.versoes, vigente,
+        autoridade: autoridades.at(-1) ?? null, autoridades,
+        cessoes: new Map([...cessoes].map(([g, c]) => [g, { para: c.para, em: c.em, motivo: c.motivo }])),
+        ordens, trabalhos, vagas, consumo, vezes, entregas, batidas, sinais, revogada, daGeracao };
+}
+/** A2 da revisão: a coerência inteira confere antes de a leitura avançar a última ponta vista desta máquina. */
+const conferirCoordenacao = (leitura) => { derivarCoordenacao(leitura); };
+exports.conferirCoordenacao = conferirCoordenacao;
+/** A leitura conferida e derivada, nova do remoto. */
+function lerCoordenacao(carregado, arco, opcoes = {}) {
+    return derivarCoordenacao((0, noctum_transporte_1.lerRamo)(carregado, arco, opcoes, exports.conferirCoordenacao));
+}
+/** A gravação no ramo com a coerência conferida em toda leitura: é a única que a coordenação, a integração e o passo usam. */
+function gravarNaCoordenacao(carregado, arco, opcoes, regra) {
+    return (0, noctum_transporte_1.gravarNoRamo)(carregado, arco, opcoes, regra, exports.conferirCoordenacao);
+}
+/** A situação de um trabalho na rede: é por ela que a N4 sabe se pode transferir (só `livre`). */
+function situacaoDoTrabalho(estado, trabalho) {
+    return estado.trabalhos.get(trabalho) ?? null;
+}
+/** Os trabalhos entregues em qualquer máquina, com o instante: a N2 os conta como entregues nas dependências. */
+function entreguesNaRede(estado) {
+    return new Map([...estado.trabalhos.values()].filter(s => s.estado === 'entregue').map(s => [s.trabalho, s.entregueEm]));
+}
+/** Os trabalhos encerrados sem entrega em alguma máquina do arco (S1 da rodada 3): terminais em todas, como os entregues. */
+function encerradosNaRede(estado) {
+    return new Set([...estado.trabalhos.values()].filter(s => s.estado === 'encerrado').map(s => s.trabalho));
+}
+/**
+ * A máquina deu sinal de vida há pouco, no instante dado? O sinal é o registro mais novo que ela assinou, inclusive a
+ * autoridade que ela acabou de assumir e a vez que ela tomou (S2 da revisão). A própria máquina, rodando agora, sempre deu.
+ */
+function batidaRecente(estado, maquina, eu, quando) {
+    if (maquina === eu)
+        return true;
+    const em = estado.sinais.get(maquina);
+    return !!em && Date.parse(quando) - Date.parse(em) <= exports.BATIDA_VENCIDA_MS;
+}
+// ---------------------------------------------------------------------------
+// As conferências comuns.
+// ---------------------------------------------------------------------------
+/** O arco está vigente aqui (autorizado, na janela, não revogado)? Senão, a recusa da N1 que diz por quê. */
+function exigirArcoVigente(carregado, arco, quando) {
+    const e = (0, noctum_arco_1.lerArco)(carregado.raiz, arco, quando);
+    if (!e || !e.conteudo)
+        throw recusa('noctum.efeito.sem-autorizacao', `arco ${arco} sem envelope autorizado nesta máquina`);
+    if (e.situacao === 'revogado')
+        throw recusa('noctum.efeito.revogado', `arco ${arco} revogado pelo dono`);
+    // RM-058 N6: o arco que o fechamento encerrou nesta máquina é terminal, como o revogado; nada novo começa aqui.
+    if (e.situacao === 'encerrado') {
+        throw recusa('noctum.efeito.encerrado', `arco ${arco} encerrado nesta máquina (${e.encerramento?.motivo ?? 'fechado'}); nada novo começa aqui`);
+    }
+    if (e.situacao === 'expirado')
+        throw recusa('noctum.efeito.expirado', `a janela do arco ${arco} terminou em ${e.conteudo.janela.fim}`);
+    if (e.situacao !== 'vigente')
+        throw recusa('noctum.efeito.fora-da-janela', `a janela do arco ${arco} só começa em ${e.conteudo.janela.inicio}`);
+}
+/** A8 da revisão: a revogação gravada no ramo por uma máquina do arco vale aqui também; nada novo começa. */
+function exigirNaoRevogada(estado) {
+    if (estado.revogada) {
+        throw recusa('noctum.coordenacao.revogada', `o arco ${estado.arco} foi revogado na máquina ${estado.revogada.por} em ${estado.revogada.em}; ` +
+            'nenhuma ordem, vaga ou vez nova sai, e cada máquina só fecha o que é dela');
+    }
+}
+/** Esta máquina é a autoridade vigente? Senão, `geracao-vencida` (já foi) ou `autoridade-ativa`. */
+function exigirAutoridade(estado, eu) {
+    const a = estado.autoridade;
+    if (a?.maquina === eu)
+        return a;
+    if (estado.autoridades.some(x => x.maquina === eu)) {
+        throw recusa('noctum.coordenacao.geracao-vencida', `esta máquina já foi a autoridade; a vigente é ${a.maquina}, geração ${a.geracao}`);
+    }
+    throw recusa('noctum.coordenacao.autoridade-ativa', a ? `a autoridade vigente é ${a.maquina}, geração ${a.geracao}` : 'o arco ainda não tem autoridade: assuma antes');
+}
+function exigirOrdem(estado, ordem) {
+    const o = estado.ordens.get(ordem);
+    if (!o)
+        throw recusa('noctum.coordenacao.ordem-vencida', `a ordem ${ordem} não existe neste arco`);
+    return o;
+}
+const nomeDe = (opcoes) => (0, maquina_1.nomeDaMaquina)(opcoes.maquina);
+// ---------------------------------------------------------------------------
+// Autoridade por geração (D8).
+// ---------------------------------------------------------------------------
+/**
+ * Assume a autoridade do arco. Sem autoridade, a geração 1 (dois que disputam: um vence pela troca atômica). A própria é
+ * idempotente. A de outra máquina só com a cessão dela para esta, ou com `forcar` e motivo quando ela não dá sinal há
+ * mais de 15 min ou saiu do envelope vigente; senão, `noctum.coordenacao.autoridade-ativa`. A geração nova sela os
+ * registros da anterior (B1 da revisão): o que a autoridade antiga gravar depois reprova a leitura de todos.
+ */
+function assumirAutoridade(carregado, arco, opcoes = {}) {
+    const quando = opcoes.quando ?? new Date().toISOString();
+    const motivoForcado = opcoes.forcar ? motivoPublico(opcoes.forcar.motivo, 'a tomada forçada da autoridade') : null;
+    exigirArcoVigente(carregado, arco, quando);
+    const r = gravarNaCoordenacao(carregado, arco, { ...opcoes, quando }, (leitura) => {
+        const estado = derivarCoordenacao(leitura);
+        const { eu, vigente } = (0, noctum_transporte_1.euNaVersaoVigente)(carregado.raiz, leitura, opcoes);
+        const a = estado.autoridade;
+        const nova = (geracao, modo, motivo) => ({ geracao, maquina: eu.nome, desde: quando, modo, motivo });
+        if (!a) {
+            return { novos: [{ tipo: 'autoridade', geracao: 1, modo: 'primeira', motivo: 'primeira autoridade do arco', anterior: null, selo: null }],
+                resultado: nova(1, 'primeira', 'primeira autoridade do arco') };
+        }
+        if (a.maquina === eu.nome)
+            return { novos: [], resultado: a };
+        const anterior = { geracao: a.geracao, maquina: a.maquina };
+        const selo = seloDaGeracao(estado.daGeracao.get(a.geracao) ?? []);
+        if (estado.cessoes.get(a.geracao)?.para === eu.nome) {
+            const motivo = estado.cessoes.get(a.geracao).motivo;
+            return { novos: [{ tipo: 'autoridade', geracao: a.geracao + 1, modo: 'cessao', motivo, anterior, selo }], resultado: nova(a.geracao + 1, 'cessao', motivo) };
+        }
+        if (motivoForcado) {
+            const motivo = motivoForcado;
+            const fora = !(0, noctum_envelope_1.envelopeMultimaquina)(vigente.conteudo) || !vigente.conteudo.maquinas.some(m => m.nome === a.maquina);
+            if (!fora && batidaRecente(estado, a.maquina, eu.nome, quando)) {
+                throw recusa('noctum.coordenacao.autoridade-ativa', `a autoridade ${a.maquina} deu sinal há menos de ${exports.BATIDA_VENCIDA_MS / 60000} min; tomar à força exige o sinal vencido`);
+            }
+            return { novos: [{ tipo: 'autoridade', geracao: a.geracao + 1, modo: 'forcada', motivo, anterior, selo,
+                        batidaDaAnterior: estado.sinais.get(a.maquina) ?? null }], resultado: nova(a.geracao + 1, 'forcada', motivo) };
+        }
+        throw recusa('noctum.coordenacao.autoridade-ativa', `a autoridade vigente é ${a.maquina}, geração ${a.geracao}; troca só por cessão dela ou tomada forçada`);
+    });
+    return r.resultado;
+}
+/** A autoridade vigente cede a vez a outra máquina do envelope; a outra assume com `assumirAutoridade`. */
+function cederAutoridade(carregado, arco, para, motivo, opcoes = {}) {
+    const doCedente = motivoPublico(motivo, 'a cessão');
+    gravarNaCoordenacao(carregado, arco, opcoes, (leitura) => {
+        const estado = derivarCoordenacao(leitura);
+        const { eu, vigente } = (0, noctum_transporte_1.euNaVersaoVigente)(carregado.raiz, leitura, opcoes);
+        const a = exigirAutoridade(estado, eu.nome);
+        if (para === eu.nome || !maquinasDe(vigente.conteudo).some(m => m.nome === para)) {
+            throw recusa('noctum.coordenacao.fora-do-envelope', `a cessão vai a outra máquina do envelope vigente, não a ${para}`);
+        }
+        if (estado.cessoes.get(a.geracao)?.para === para)
+            return { novos: [], resultado: null };
+        if (estado.cessoes.has(a.geracao))
+            throw recusa('noctum.coordenacao.concorrencia', `a geração ${a.geracao} já foi cedida`);
+        return { novos: [{ tipo: 'cessao', geracao: a.geracao, para, motivo: doCedente }], resultado: null };
+    });
+}
+/**
+ * As reservas da branch da RM-047 lidas agora do remoto, vistas pela coordenação; `null` quando a leitura não veio. A
+ * reserva de uma máquina do envelope (a do arco ou a que o dono tomou à mão nela, como na N2) leva a ordem só para ela; a
+ * de fora do arco segura a ordem até ser solta. Só o item, a máquina e o instante saem daqui: o nome de quem reservou nunca
+ * vai ao ramo de coordenação.
+ */
+function reservasDoArco(carregado, opcoes = {}) {
+    let painel;
+    try {
+        painel = (0, roadmap_reservas_1.listarReservas)(carregado.raiz, { remoto: opcoes.remoto ?? carregado.manifesto.fabrica.remoto, rede: opcoes.rede });
+    }
+    catch {
+        return null;
+    }
+    return painel.atualizado ? vistasDasReservas(painel.reservas) : null;
+}
+/** As reservas de um painel lido agora, vistas pela coordenação (a mesma de `reservasDoArco`, sem ler de novo). */
+function vistasDasReservas(reservas) {
+    return new Map(reservas.map(r => [r.item, { maquina: r.maquina, atualizadaEm: r.atualizadaEm }]));
+}
+// ---------------------------------------------------------------------------
+// Ordens, cancelamento e recibos (D9 e D10).
+// ---------------------------------------------------------------------------
+/** As vagas de execução de uma máquina: as da máquina menos as que só o CHECK usa. */
+const vagasDeExecucao = (c) => (c.capacidade?.maquina ?? 0) - (c.capacidade?.revisao ?? 0);
+const comMotivo = (r, motivo) => String(r?.motivo ?? '').startsWith(motivo);
+/**
+ * A máquina já recusou este trabalho nesta versão do envelope, ou o encerrou porque o roadmap dela não tem o item? Ela não
+ * recebe a mesma ordem de novo: sem isso, a ordem iria e voltaria a cada passo. A recusa e o fim pela reserva não contam
+ * aqui (A1 da revisão): solta ou trocada a reserva, o trabalho sai de novo (`recusouPelaReserva`).
+ */
+function recusou(estado, trabalho, maquina) {
+    return [...estado.ordens.values()].some(o => o.trabalho === trabalho && o.maquina === maquina &&
+        o.envelopeSha256 === estado.vigente.envelopeSha256 &&
+        ((o.estado === 'recusada' && !comMotivo(o.recibos.recusada, 'noctum.reserva.de-outra-maquina')) ||
+            (o.estado === 'encerrada' && comMotivo(o.recibos.encerrada, 'noctum.reserva.item-invalido'))));
+}
+/**
+ * A2 da rodada 3: a autoridade cancelou a ordem deste trabalho nesta máquina, nesta versão do envelope? A distribuição
+ * automática não a devolve à mesma máquina (a retomada é em outra); a emissão explícita (`emitirOrdem`, da N4) escolhe.
+ */
+function canceladaNela(estado, trabalho, maquina) {
+    return [...estado.ordens.values()].some(o => o.trabalho === trabalho && o.maquina === maquina && !!o.cancelada &&
+        o.envelopeSha256 === estado.vigente.envelopeSha256);
+}
+/**
+ * A máquina recusou ou encerrou este trabalho pela reserva do item, e a reserva continua a mesma desde então (nem solta,
+ * nem trocada)? A mesma ordem voltaria a cair nela: espera a reserva mudar.
+ */
+function recusouPelaReserva(estado, trabalho, maquina, dono) {
+    return [...estado.ordens.values()].some(o => {
+        if (o.trabalho !== trabalho || o.maquina !== maquina || o.envelopeSha256 !== estado.vigente.envelopeSha256)
+            return false;
+        const fim = o.estado === 'recusada' ? o.recibos.recusada : o.estado === 'encerrada' ? o.recibos.encerrada : undefined;
+        return !!fim && comMotivo(fim, 'noctum.reserva.de-outra-maquina') && Date.parse(fim.em) >= Date.parse(dono.atualizadaEm);
+    });
+}
+/** Por que a ordem do trabalho para a máquina não sai agora; `null` quando ela pode sair. */
+function porQueNaoOrdenar(estado, trabalho, maquina, eu, quando, reservas, emitidasAgora = []) {
+    if (estado.revogada)
+        return recusa('noctum.coordenacao.revogada', `o arco foi revogado na máquina ${estado.revogada.por}`);
+    const c = estado.vigente.conteudo;
+    const t = trabalhoDe(c, trabalho);
+    if (!t)
+        return recusa('noctum.despacho.fora-do-envelope', `o trabalho ${trabalho} não está no envelope vigente`);
+    if (!maquinasDe(c).some(m => m.nome === maquina))
+        return recusa('noctum.coordenacao.fora-do-envelope', `a máquina ${maquina} não está no envelope vigente`);
+    if (t.maquina && t.maquina !== maquina)
+        return recusa('noctum.coordenacao.fora-do-envelope', `o trabalho ${trabalho} está preso à máquina ${t.maquina}`);
+    const s = estado.trabalhos.get(trabalho);
+    if (s.estado !== 'livre')
+        return recusa('noctum.coordenacao.ordem-viva', `o trabalho ${trabalho} está ${s.estado}${s.ordem ? ` (ordem ${s.ordem.ordem})` : ''}`);
+    if (emitidasAgora.some(x => x.trabalho === trabalho))
+        return recusa('noctum.coordenacao.ordem-viva', `o trabalho ${trabalho} acabou de receber ordem`);
+    const faltam = t.dependeDe.filter(d => estado.trabalhos.get(d)?.estado !== 'entregue');
+    if (faltam.length)
+        return recusa('noctum.coordenacao.dependencia-pendente', `o trabalho ${trabalho} depende de ${faltam.join(', ')}, ainda não entregue(s)`);
+    const doItem = [...[...estado.ordens.values()].filter(exports.ordemViva).map(o => ({ trabalho: o.trabalho, item: o.item, maquina: o.maquina })),
+        ...emitidasAgora].find(o => o.item === t.item && o.trabalho !== trabalho);
+    if (doItem && doItem.maquina !== maquina) {
+        return recusa('noctum.coordenacao.ordem-viva', `o item ${t.item} está com a máquina ${doItem.maquina} (trabalho ${doItem.trabalho}); a reserva é de uma máquina só`);
+    }
+    // A1 da revisão: a reserva da RM-047, lida agora, decide para onde a ordem vai, ou se ela espera.
+    const dono = reservas.get(t.item);
+    if (dono && !maquinasDe(c).some(m => m.nome === dono.maquina)) {
+        return recusa('noctum.reserva.de-outra-maquina', `o item ${t.item} está reservado fora do arco; a ordem espera a reserva ser solta`);
+    }
+    if (dono && dono.maquina !== maquina) {
+        return recusa('noctum.reserva.de-outra-maquina', `o item ${t.item} está reservado pela máquina ${dono.maquina} do arco; a ordem vai para ela`);
+    }
+    if (dono && recusouPelaReserva(estado, trabalho, maquina, dono)) {
+        return recusa('noctum.reserva.de-outra-maquina', `a máquina ${maquina} não pôde usar a reserva do item ${t.item}; a ordem espera a reserva mudar`);
+    }
+    if (!batidaRecente(estado, maquina, eu, quando)) {
+        return recusa('noctum.coordenacao.maquina-sem-batida', `a máquina ${maquina} não dá sinal há mais de ${exports.BATIDA_VENCIDA_MS / 60000} min; ela não recebe ordem nova`);
+    }
+    if (recusou(estado, trabalho, maquina)) {
+        return recusa('noctum.coordenacao.maquina-recusou', `a máquina ${maquina} já recusou o trabalho ${trabalho} nesta versão do envelope`);
+    }
+    return null;
+}
+function camposDaOrdem(estado, trabalho, maquina, geracao) {
+    const t = trabalhoDe(estado.vigente.conteudo, trabalho);
+    const n = [...estado.ordens.values()].filter(o => o.trabalho === trabalho).length + 1;
+    return { tipo: 'ordem', ordem: `O-${trabalho}-${n}`, trabalho, item: t.item, maquina, geracao, n };
+}
+/**
+ * Emite a ordem de um trabalho para uma máquina; só a autoridade vigente, com o arco vigente aqui e as reservas lidas agora
+ * (o item reservado fora do arco, ou por outra máquina dele, segura a ordem).
+ */
+function emitirOrdem(carregado, arco, pedido, opcoes = {}) {
+    const quando = opcoes.quando ?? new Date().toISOString();
+    exigirArcoVigente(carregado, arco, quando);
+    return gravarNaCoordenacao(carregado, arco, { ...opcoes, quando }, (leitura) => {
+        const estado = derivarCoordenacao(leitura);
+        const { eu } = (0, noctum_transporte_1.euNaVersaoVigente)(carregado.raiz, leitura, opcoes);
+        const a = exigirAutoridade(estado, eu.nome);
+        // S3 da rodada 2: a ordem viva deste trabalho para a mesma máquina, emitida por esta geração e não cancelada, é a mesma
+        // ordem: repetir depois de um push de resultado incerto devolve o id dela, sem gravar de novo.
+        const ja = estado.trabalhos.get(pedido.trabalho)?.ordem;
+        if (ja && (ja.estado === 'emitida' || ja.estado === 'aceita') && ja.maquina === pedido.maquina && ja.geracao === a.geracao &&
+            ja.envelopeSha256 === estado.vigente.envelopeSha256) {
+            return { novos: [], resultado: ja.ordem };
+        }
+        const reservas = reservasDoArco(carregado, opcoes);
+        if (!reservas)
+            throw recusa('noctum.coordenacao.sem-remoto', 'as reservas não se leram agora; sem elas, nenhuma ordem sai');
+        const nao = porQueNaoOrdenar(estado, pedido.trabalho, pedido.maquina, eu.nome, quando, reservas);
+        if (nao)
+            throw nao;
+        const campos = camposDaOrdem(estado, pedido.trabalho, pedido.maquina, a.geracao);
+        return { novos: [campos], resultado: campos.ordem };
+    }).resultado;
+}
+/**
+ * D9: a política da autoridade, pura. Na ordem do dono (prioridade e posição no envelope), cada trabalho `livre` com as
+ * dependências entregues vai à máquina presa, à do mesmo item (pela ordem viva ou pela reserva lida agora) ou à máquina
+ * com sinal recente e menos ordens vivas, até as vagas de execução dela; desempate pela ordem das máquinas no envelope. O
+ * item reservado fora do arco espera, e nada sai com o arco revogado (A1 e A8 da revisão, em `porQueNaoOrdenar`).
+ */
+function distribuirOrdens(estado, eu, quando, reservas) {
+    const a = estado.autoridade;
+    if (!a || a.maquina !== eu)
+        return [];
+    const c = estado.vigente.conteudo;
+    if (!(0, noctum_envelope_1.envelopeMultimaquina)(c))
+        return [];
+    const limite = vagasDeExecucao(c);
+    const vivas = new Map(c.maquinas.map(m => [m.nome, [...estado.ordens.values()].filter(o => (0, exports.ordemViva)(o) && o.maquina === m.nome).length]));
+    const emitidas = [];
+    const fila = c.trabalhos.map((t, i) => ({ t, i })).sort((x, y) => x.t.prioridade - y.t.prioridade || x.i - y.i);
+    for (const { t } of fila) {
+        if (estado.trabalhos.get(t.id)?.estado !== 'livre')
+            continue;
+        const doItem = [...[...estado.ordens.values()].filter(exports.ordemViva).map(o => ({ item: o.item, maquina: o.maquina })), ...emitidas]
+            .find(o => o.item === t.item)?.maquina;
+        const candidatas = t.maquina ? [t.maquina] : doItem ? [doItem]
+            : c.maquinas.map(m => m.nome).sort((x, y) => vivas.get(x) - vivas.get(y) || c.maquinas.findIndex(m => m.nome === x) - c.maquinas.findIndex(m => m.nome === y));
+        const alvo = candidatas.find(m => !canceladaNela(estado, t.id, m) && (vivas.get(m) ?? limite) < limite &&
+            porQueNaoOrdenar(estado, t.id, m, eu, quando, reservas, emitidas) === null);
+        if (!alvo)
+            continue;
+        emitidas.push({ trabalho: t.id, item: t.item, maquina: alvo });
+        vivas.set(alvo, vivas.get(alvo) + 1);
+    }
+    return emitidas.map(({ trabalho, maquina }) => ({ trabalho, maquina }));
+}
+/** Os registros das ordens que a política distribui agora, com os números certos mesmo para vários do mesmo trabalho. */
+function registrosDaDistribuicao(estado, eu, quando, reservas) {
+    const a = estado.autoridade;
+    if (!a || a.maquina !== eu)
+        return [];
+    return distribuirOrdens(estado, eu, quando, reservas).map(({ trabalho, maquina }) => camposDaOrdem(estado, trabalho, maquina, a.geracao));
+}
+/**
+ * A7 da revisão: a autoridade abandona a vez de integrar da máquina que não dá sinal há mais de 15 min, para o destino
+ * voltar a andar. O trabalho dela não muda de máquina sem prova; na volta, a reconciliação dela registra a entrega se o
+ * merge tiver chegado à base.
+ */
+function registrosDosAbandonos(estado, eu, quando) {
+    const a = estado.autoridade;
+    if (!a || a.maquina !== eu)
+        return [];
+    return [...estado.vezes.values()].flat().filter(v => !v.fim && v.maquina !== eu && !batidaRecente(estado, v.maquina, eu, quando))
+        .map(v => ({ tipo: 'vez-fim', chave: v.chave, n: v.n, desfecho: 'abandonada', geracao: a.geracao, sinalDoDono: estado.sinais.get(v.maquina) ?? null,
+        motivo: `a máquina ${v.maquina} não dá sinal há mais de ${exports.BATIDA_VENCIDA_MS / 60000} min; o destino volta a andar, e o trabalho dela não muda de máquina sem prova` }));
+}
+/** Cancela uma ordem viva; só a autoridade vigente. Antes do aceite, o trabalho fica livre na hora; depois, isolado. */
+function cancelarOrdem(carregado, arco, ordem, motivo, opcoes = {}) {
+    const doCancelamento = motivoPublico(motivo, 'o cancelamento');
+    return gravarNaCoordenacao(carregado, arco, opcoes, (leitura) => {
+        const estado = derivarCoordenacao(leitura);
+        const { eu } = (0, noctum_transporte_1.euNaVersaoVigente)(carregado.raiz, leitura, opcoes);
+        const a = exigirAutoridade(estado, eu.nome);
+        const o = exigirOrdem(estado, ordem);
+        if (o.cancelada)
+            return { novos: [], resultado: o.estado };
+        if (!(0, exports.ordemViva)(o))
+            throw recusa('noctum.coordenacao.ordem-vencida', `a ordem ${ordem} já terminou (${o.estado})`);
+        return { novos: [{ tipo: 'cancelamento', ordem, motivo: doCancelamento, geracao: a.geracao }],
+            resultado: o.estado === 'emitida' ? 'cancelada-antes' : 'isolada' };
+    }).resultado;
+}
+/** O motivo tipado da reserva de fora, igual em todo registro: só o item, nunca quem reservou (A1 da revisão). */
+const motivoDaReservaDeFora = (item) => `noctum.reserva.de-outra-maquina: o item ${item} está reservado por outra máquina ou pessoa`;
+exports.motivoDaReservaDeFora = motivoDaReservaDeFora;
+/** A resposta desta máquina a uma ordem emitida para ela: aceita ou recusada com o motivo (D10). */
+function respostaAOrdem(estado, o, eu, fatos) {
+    if (o.envelopeSha256 !== estado.vigente.envelopeSha256)
+        return { recibo: 'recusada', motivo: 'noctum.efeito.hash-antigo: a ordem é de outra versão do envelope' };
+    if (estado.revogada)
+        return { recibo: 'recusada', motivo: `noctum.coordenacao.revogada: o arco foi revogado na máquina ${estado.revogada.por}` };
+    if (fatos.arcoEncerrado)
+        return { recibo: 'recusada', motivo: 'noctum.efeito.encerrado: o arco encerrou nesta máquina' };
+    if (!fatos.arcoVigente)
+        return { recibo: 'recusada', motivo: 'noctum.efeito.fora-da-janela: o arco não está vigente nesta máquina' };
+    const t = trabalhoDe(estado.vigente.conteudo, o.trabalho);
+    if (!t)
+        return { recibo: 'recusada', motivo: 'noctum.despacho.fora-do-envelope: o trabalho não está no envelope vigente' };
+    if (t.maquina && t.maquina !== eu)
+        return { recibo: 'recusada', motivo: `noctum.coordenacao.fora-do-envelope: o trabalho está preso à máquina ${t.maquina}` };
+    if (fatos.itensDeOutros?.has(t.item))
+        return { recibo: 'recusada', motivo: (0, exports.motivoDaReservaDeFora)(t.item) };
+    if (t.thread) {
+        // A thread que o trabalho nomeia precisa morar aqui, ser do item dele e de #Auto: senão a fila da N2 nunca a despacharia.
+        const th = fatos.threadsLocais.get(t.thread);
+        if (!th)
+            return { recibo: 'recusada', motivo: `noctum.despacho.fora-do-envelope: a thread ${t.thread} não existe nesta máquina` };
+        if (th.roadmap !== t.item)
+            return { recibo: 'recusada', motivo: `noctum.despacho.fora-do-envelope: a thread ${t.thread} é do item ${th.roadmap ?? 'nenhum'}, não do ${t.item}` };
+        if (th.modo !== 'auto')
+            return { recibo: 'recusada', motivo: `noctum.despacho.fora-do-envelope: a thread ${t.thread} está em ${th.modo}; o arco só conduz #Auto` };
+    }
+    return { recibo: 'aceita', motivo: 'ordem aceita' };
+}
+/** Os recibos de aceite ou recusa das ordens emitidas para esta máquina que ainda não têm resposta. */
+function registrosDasRespostas(estado, eu, fatos) {
+    return [...estado.ordens.values()].filter(o => o.maquina === eu && o.estado === 'emitida')
+        .map(o => ({ tipo: 'recibo', ordem: o.ordem, ...respostaAOrdem(estado, o, eu, fatos) }));
+}
+/** Responde uma ordem desta máquina. Só a ordem dela, emitida e não cancelada; o aceite exige o arco vigente aqui e na rede. */
+function responderOrdem(carregado, arco, ordem, resposta, motivo, opcoes = {}) {
+    const quando = opcoes.quando ?? new Date().toISOString();
+    const doRecibo = motivo ? motivoPublico(motivo, 'o recibo') : '';
+    if (resposta === 'aceita')
+        exigirArcoVigente(carregado, arco, quando);
+    return gravarNaCoordenacao(carregado, arco, { ...opcoes, quando }, (leitura) => {
+        const estado = derivarCoordenacao(leitura);
+        const { eu } = (0, noctum_transporte_1.euNaVersaoVigente)(carregado.raiz, leitura, opcoes);
+        const o = exigirOrdem(estado, ordem);
+        if (o.maquina !== eu.nome)
+            throw recusa('noctum.coordenacao.ordem-vencida', `a ordem ${ordem} é da máquina ${o.maquina}`);
+        if (o.recibos[resposta])
+            return { novos: [], resultado: o.estado };
+        if (o.estado !== 'emitida')
+            throw recusa('noctum.coordenacao.ordem-vencida', `a ordem ${ordem} está ${o.estado}`);
+        if (resposta === 'aceita' && o.envelopeSha256 !== estado.vigente.envelopeSha256) {
+            throw recusa('noctum.efeito.hash-antigo', `a ordem ${ordem} é de outra versão do envelope`);
+        }
+        if (resposta === 'aceita')
+            exigirNaoRevogada(estado);
+        return { novos: [{ tipo: 'recibo', ordem, recibo: resposta, motivo: doRecibo }], resultado: resposta === 'aceita' ? 'aceita' : 'recusada' };
+    }).resultado;
+}
+/**
+ * G8-6: a vaga que outra chave da máquina tomou tem o despacho no log de outra raiz; daqui não se prova a parada dela. Vale
+ * no fim e na conclusão (N1 da terceira passada do CHECK-REVERIFY): os dois podem tirar a última ordem viva do item, e
+ * outro trabalho dele iria a outra máquina.
+ */
+function exigirSemVagaDeOutraChave(estado, o, chave, eu) {
+    const deOutra = estado.vagas.find(v => v.ordem === o.ordem && !v.solta && v.chave !== chave);
+    if (deOutra) {
+        throw recusa('noctum.coordenacao.ordem-vencida', `a vaga ${deOutra.vaga} da ordem ${o.ordem} é de outra chave da máquina ${eu}; ` +
+            'só a raiz dela prova a parada da sessão');
+    }
+}
+/**
+ * O executor conclui a ordem pela thread local: entregue ou fechada sem entrega. Vale também depois do cancelamento e
+ * depois de uma emenda que tirou esta máquina do arco (A4 da revisão: o fim sai sob a versão em que ela estava).
+ */
+function concluirOrdem(carregado, arco, ordem, conclusao, opcoes = {}) {
+    if (conclusao.resultado !== 'entregue' && conclusao.resultado !== 'encerrado-sem-entrega') {
+        throw recusa('noctum.envelope.invalido', 'a conclusão é entregue ou encerrado-sem-entrega');
+    }
+    if (conclusao.thread !== null && !linha(conclusao.thread, 80))
+        throw recusa('noctum.envelope.invalido', 'a thread da conclusão vai em uma linha de até 80 caracteres');
+    const chave = (0, noctum_transporte_1.identidadeDaMaquina)(carregado.raiz, opcoes.maquina).chave;
+    gravarNaCoordenacao(carregado, arco, opcoes, (leitura) => {
+        const estado = derivarCoordenacao(leitura);
+        const eu = nomeDe(opcoes);
+        const o = exigirOrdem(estado, ordem);
+        if (o.maquina !== eu)
+            throw recusa('noctum.coordenacao.ordem-vencida', `a ordem ${ordem} é da máquina ${o.maquina}`);
+        if (!ordemDaRaiz(estado, o, { nome: eu, chave }))
+            throw recusa('noctum.coordenacao.ordem-vencida', `a ordem ${ordem} é de outra chave da máquina ${eu}`);
+        if (o.estado === 'concluida')
+            return { novos: [], resultado: null };
+        if (o.estado !== 'aceita' && o.estado !== 'isolada')
+            throw recusa('noctum.coordenacao.ordem-vencida', `a ordem ${ordem} está ${o.estado}`);
+        exigirSemVagaDeOutraChave(estado, o, chave, eu);
+        return { novos: [{ tipo: 'recibo', ordem, recibo: 'concluida', motivo: 'thread local ' + conclusao.resultado, resultado: conclusao.resultado,
+                    thread: conclusao.thread }], resultado: null };
+    });
+}
+/**
+ * O executor confirma o fim da ordem (cancelada, de outra versão, com o arco fora da janela ou revogado, ou sem a reserva
+ * do item) com o checkpoint do que soltou. Só depois de nenhuma sessão dela viver nesta máquina: é este recibo que prova
+ * que o executor antigo parou.
+ */
+function encerrarOrdem(carregado, arco, ordem, fim, opcoes = {}) {
+    if (!checkpointValido(fim.checkpoint)) {
+        throw recusa('noctum.envelope.invalido', `o checkpoint do fim leva só a thread (uma linha de até 80 caracteres) e as vagas soltas (até ${exports.TETO_DE_VAGAS_NO_CHECKPOINT}); ` +
+            'sessão, caminho e texto livre não vão ao ramo');
+    }
+    const checkpoint = { thread: fim.checkpoint.thread ?? null, vagasSoltas: fim.checkpoint.vagasSoltas ?? [] };
+    const doFim = motivoPublico(fim.motivo, 'o fim da ordem');
+    const chave = (0, noctum_transporte_1.identidadeDaMaquina)(carregado.raiz, opcoes.maquina).chave;
+    gravarNaCoordenacao(carregado, arco, opcoes, (leitura) => {
+        const estado = derivarCoordenacao(leitura);
+        const eu = nomeDe(opcoes);
+        const o = exigirOrdem(estado, ordem);
+        if (o.maquina !== eu)
+            throw recusa('noctum.coordenacao.ordem-vencida', `a ordem ${ordem} é da máquina ${o.maquina}`);
+        if (!ordemDaRaiz(estado, o, { nome: eu, chave }))
+            throw recusa('noctum.coordenacao.ordem-vencida', `a ordem ${ordem} é de outra chave da máquina ${eu}`);
+        if (o.estado === 'encerrada')
+            return { novos: [], resultado: null };
+        if (o.estado !== 'aceita' && o.estado !== 'isolada')
+            throw recusa('noctum.coordenacao.ordem-vencida', `a ordem ${ordem} está ${o.estado}`);
+        exigirSemVagaDeOutraChave(estado, o, chave, eu);
+        const espera = esperaDaVez(estado, o);
+        if (espera === 'ativa') {
+            throw recusa('noctum.integracao.nao-provada', `a ordem ${ordem} tem uma vez de integrar ativa; o merge pode ter chegado à base, e a reconciliação decide antes do fim`);
+        }
+        if (espera === 'sem-prova') {
+            throw recusa('noctum.integracao.base-nao-provada', `a ordem ${ordem} tem uma fonte que chegou à base fora da cerca; o trabalho espera a inspeção do dono`);
+        }
+        if (espera === 'abandonada') {
+            throw recusa('noctum.integracao.nao-provada', `a ordem ${ordem} tem uma vez abandonada cuja base ainda precisa ser conferida pela reconciliação`);
+        }
+        return { novos: [{ tipo: 'recibo', ordem, recibo: 'encerrada', motivo: doFim, checkpoint }], resultado: null };
+    });
+}
+/** A batida desta máquina: é ela que diz à autoridade que a máquina está viva para receber ordem nova. */
+function bater(carregado, arco, opcoes = {}) {
+    gravarNaCoordenacao(carregado, arco, opcoes, () => ({ novos: [{ tipo: 'batida' }], resultado: null }));
+}
+/**
+ * A8 da revisão: o dono revogou o arco nesta máquina, e a revogação vai ao ramo para valer em todas. Só com o arco revogado
+ * aqui pela N1; uma vez por máquina. Vale para sempre: nenhuma ordem, aceite, vaga ou vez nova sai depois dela.
+ */
+function revogarNaRede(carregado, arco, opcoes = {}) {
+    const quando = opcoes.quando ?? new Date().toISOString();
+    if ((0, noctum_arco_1.lerArco)(carregado.raiz, arco, quando)?.situacao !== 'revogado') {
+        throw recusa('noctum.envelope.invalido', `o arco ${arco} não foi revogado pelo dono nesta máquina; a revogação na rede sai só depois da dela`);
+    }
+    return gravarNaCoordenacao(carregado, arco, { ...opcoes, quando }, (leitura) => {
+        const eu = nomeDe(opcoes);
+        if (leitura.registros.some(r => r.dados.tipo === 'revogacao' && r.dados.por === eu))
+            return { novos: [], resultado: false };
+        return { novos: [{ tipo: 'revogacao', motivo: 'o dono revogou o arco nesta máquina' }], resultado: true };
+    }).resultado;
+}
+/** Por que a vaga não cabe agora, somando as máquinas; `null` quando cabe. */
+function porQueSemVaga(estado, p) {
+    const c = estado.vigente.conteudo;
+    if (!(0, noctum_envelope_1.envelopeMultimaquina)(c))
+        return recusa('noctum.coordenacao.fora-do-envelope', 'o envelope vigente não é de várias máquinas');
+    const limite = c.capacidadeGlobal.porConta.find(x => x.conta === p.conta)?.sessoes;
+    if (limite === undefined)
+        return recusa('noctum.coordenacao.fora-do-envelope', `a conta ${p.conta} não está no envelope vigente`);
+    if (!c.orcamento.porRuntime.some(r => r.runtime === p.runtime))
+        return recusa('noctum.coordenacao.fora-do-envelope', `o runtime ${p.runtime} não está no envelope vigente`);
+    const ativas = estado.vagas.filter(v => !v.solta && v.conta === p.conta);
+    if (ativas.length >= limite) {
+        return recusa('noctum.coordenacao.vaga-global', `${ativas.length} sessão(ões) na conta ${p.conta} somando as máquinas, e o limite é ${limite}` +
+            ` (${[...new Set(ativas.map(v => v.maquina))].join(', ')})`);
+    }
+    const tetos = [['do arco', c.orcamento.arco, estado.consumo.arco],
+        [`da conta ${p.conta}`, c.orcamento.porConta.find(x => x.conta === p.conta)?.teto, estado.consumo.porConta[p.conta] ?? 0],
+        [`do runtime ${p.runtime}`, c.orcamento.porRuntime.find(x => x.runtime === p.runtime)?.teto, estado.consumo.porRuntime[p.runtime] ?? 0]];
+    for (const [nome, teto, usado] of tetos) {
+        if (!teto)
+            return recusa('noctum.coordenacao.fora-do-envelope', `sem teto ${nome} no envelope vigente`);
+        if (teto.unidade !== 'sessoes') {
+            // RM-058 N6: a medição das outras unidades é desta máquina; somar as máquinas só sabe contar sessões.
+            return recusa('noctum.orcamento.sem-medicao', `o teto ${nome} está em ${teto.unidade}, e a soma entre máquinas só mede sessoes: consumo desconhecido nunca vale zero`);
+        }
+        if (usado + 1 > teto.valor)
+            return recusa('noctum.orcamento.esgotado', `o teto ${nome} é de ${teto.valor} sessoes e ${usado} já foram reservadas somando as máquinas`);
+    }
+    return null;
+}
+/** As contas sem vaga global agora, somando as máquinas: o passo da máquina as tira da escolha da N2. */
+function contasSemVagaGlobal(estado) {
+    const c = estado.vigente.conteudo;
+    if (!(0, noctum_envelope_1.envelopeMultimaquina)(c))
+        return new Set();
+    return new Set(c.capacidadeGlobal.porConta.filter(x => estado.vagas.filter(v => !v.solta && v.conta === x.conta).length >= x.sessoes).map(x => x.conta));
+}
+/**
+ * Toma a vaga global de um despacho desta máquina, depois da reserva local (o `seq` dela) e antes do lançamento: a ordem é
+ * desta máquina, aceita e não cancelada, o arco está vigente aqui e não revogado na rede, a conta tem vaga somando as
+ * máquinas e os tetos do arco, da conta e do runtime cabem mais uma sessão. Idempotente pela reserva local.
+ */
+function tomarVagaGlobal(carregado, arco, p, opcoes = {}) {
+    const quando = opcoes.quando ?? new Date().toISOString();
+    exigirArcoVigente(carregado, arco, quando);
+    return gravarNaCoordenacao(carregado, arco, { ...opcoes, quando }, (leitura) => {
+        const estado = derivarCoordenacao(leitura);
+        const { eu, vigente } = (0, noctum_transporte_1.euNaVersaoVigente)(carregado.raiz, leitura, opcoes);
+        const vaga = `V-${eu.nome}-${p.reserva}`;
+        const ja = estado.vagas.find(v => v.vaga === vaga);
+        if (ja) {
+            if (ja.ordem !== p.ordem || ja.conta !== p.conta || ja.runtime !== p.runtime) {
+                throw recusa('noctum.coordenacao.concorrencia', `a vaga ${vaga} já existe para outro despacho`);
+            }
+            // S2 da rodada 2: a vaga já solta com o mesmo `seq` é um `seq` local repetido (raiz de estado nova), não esta reserva.
+            if (ja.solta)
+                throw recusa('noctum.coordenacao.concorrencia', `a vaga ${vaga} já foi tomada e solta; o seq local ${p.reserva} se repetiu`);
+            return { novos: [], resultado: vaga };
+        }
+        exigirNaoRevogada(estado);
+        const o = exigirOrdem(estado, p.ordem);
+        if (o.maquina !== eu.nome || o.estado !== 'aceita') {
+            throw recusa('noctum.coordenacao.ordem-vencida', `a ordem ${p.ordem} não é uma ordem aceita e viva desta máquina (${o.estado})`);
+        }
+        if (o.envelopeSha256 !== vigente.envelopeSha256)
+            throw recusa('noctum.efeito.hash-antigo', `a ordem ${p.ordem} é de outra versão do envelope`);
+        const nao = porQueSemVaga(estado, p);
+        if (nao)
+            throw nao;
+        const c = vigente.conteudo;
+        return { novos: [{ tipo: 'vaga', vaga, conta: c.capacidadeGlobal.porConta.findIndex(x => x.conta === p.conta), runtime: p.runtime,
+                    ordem: p.ordem, trabalho: o.trabalho, reserva: p.reserva }], resultado: vaga };
+    }).resultado;
+}
+/** Solta a vaga global desta máquina, dizendo se a sessão consumiu (a recusa antes do lançamento não consome). */
+function soltarVagaGlobal(carregado, arco, vaga, soltura, opcoes = {}) {
+    const daSoltura = motivoPublico(soltura.motivo, 'a soltura da vaga');
+    const chave = (0, noctum_transporte_1.identidadeDaMaquina)(carregado.raiz, opcoes.maquina).chave;
+    gravarNaCoordenacao(carregado, arco, opcoes, (leitura) => {
+        const estado = derivarCoordenacao(leitura);
+        const eu = nomeDe(opcoes);
+        const v = estado.vagas.find(x => x.vaga === vaga);
+        if (!v || v.maquina !== eu)
+            throw recusa('noctum.coordenacao.ordem-vencida', `a vaga ${vaga} não é desta máquina`);
+        // G8-6: só a raiz da chave que tomou a vaga tem o despacho dela no log local, e só ela a solta.
+        if (v.chave !== chave)
+            throw recusa('noctum.coordenacao.ordem-vencida', `a vaga ${vaga} é de outra chave da máquina ${eu}; só a raiz dela a solta`);
+        if (v.solta)
+            return { novos: [], resultado: null };
+        return { novos: [{ tipo: 'vaga-solta', vaga, consumiu: soltura.consumiu, motivo: daSoltura }], resultado: null };
+    });
+}
+/**
+ * A reserva do item, lida do remoto agora: livre, desta máquina e de quem a usa (`minha`, com qualquer nota, como na N2:
+ * a que o dono tomou à mão aqui também vale para o arco daqui), e se é a do arco (`doArco`, pela nota). `null` quando a
+ * leitura não veio.
+ */
+function reservaDoItem(carregado, arco, item, opcoes = {}) {
+    const { raiz } = carregado;
+    const eu = (0, roadmap_reservas_1.quemSouEu)(raiz, { maquina: opcoes.maquina });
+    let painel;
+    try {
+        painel = (0, roadmap_reservas_1.listarReservas)(raiz, { remoto: opcoes.remoto ?? carregado.manifesto.fabrica.remoto, rede: opcoes.rede });
+    }
+    catch {
+        return null;
+    }
+    if (!painel.atualizado)
+        return null;
+    const r = painel.reservas.find(x => x.item === item);
+    const minha = !!r && r.maquina === eu.maquina && r.por === eu.por;
+    return { livre: !r, minha, doArco: minha && r.nota === (0, exports.notaDaReserva)(arco) };
+}
+/** O erro do `pegarItem`, tipado (A6 da revisão): reserva de fora, item que o roadmap daqui não tem, ou rede. */
+function motivoDoPegar(e) {
+    const msg = String(e?.message ?? e).split('\n')[0].slice(0, 300);
+    if (msg.startsWith('roadmap.reservado'))
+        return { motivo: 'noctum.reserva.de-outra-maquina', detalhe: 'o item está com outra máquina ou pessoa' };
+    if (msg.startsWith('roadmap.item'))
+        return { motivo: 'noctum.reserva.item-invalido', detalhe: msg };
+    return { motivo: 'noctum.coordenacao.sem-remoto', detalhe: msg };
+}
+/**
+ * Toma a reserva do item da ordem aceita desta máquina e a revalida com leitura nova. Nunca força: a reserva de outra
+ * máquina ou pessoa volta `noctum.reserva.de-outra-maquina`, e quem chama encerra a ordem que nunca despachou. A que já é
+ * desta máquina vale como está, sem regravar (a nota do dono fica, e a reconciliação não a solta). O item que o roadmap
+ * desta máquina não tem volta `noctum.reserva.item-invalido`.
+ */
+function tomarReservaDoTrabalho(carregado, arco, ordem, thread, opcoes = {}) {
+    const estado = lerCoordenacao(carregado, arco, opcoes);
+    const eu = nomeDe(opcoes);
+    const o = exigirOrdem(estado, ordem);
+    if (o.maquina !== eu || o.estado !== 'aceita')
+        throw recusa('noctum.coordenacao.ordem-vencida', `a ordem ${ordem} não é uma ordem aceita e viva desta máquina`);
+    const antes = reservaDoItem(carregado, arco, o.item, opcoes);
+    if (antes === null)
+        return { ok: false, motivo: 'noctum.coordenacao.sem-remoto', detalhe: 'as reservas não se leram agora' };
+    let acao = 'revalidada';
+    if (!antes.minha) {
+        if (!antes.livre)
+            return { ok: false, motivo: 'noctum.reserva.de-outra-maquina', detalhe: `o item ${o.item} está com outra máquina ou pessoa` };
+        try {
+            // `threadEsperada: null`: quem tomou o item com thread entre a leitura e a gravação faz o pegar voltar sem gravar.
+            acao = (0, roadmap_reservas_1.pegarItem)(carregado.raiz, o.item, { remoto: opcoes.remoto ?? carregado.manifesto.fabrica.remoto, maquina: eu, thread,
+                nota: (0, exports.notaDaReserva)(arco), rede: opcoes.rede, threadEsperada: null }).acao;
+        }
+        catch (e) {
+            return { ok: false, ...motivoDoPegar(e) };
+        }
+    }
+    const agora = reservaDoItem(carregado, arco, o.item, opcoes);
+    if (agora === null)
+        return { ok: false, motivo: 'noctum.coordenacao.sem-remoto', detalhe: 'a revalidação da reserva não leu o remoto' };
+    if (!agora.minha)
+        return { ok: false, motivo: 'noctum.reserva.de-outra-maquina', detalhe: `o item ${o.item} está com outra máquina ou pessoa depois de tomar` };
+    return { ok: true, acao };
+}
+/** Solta a reserva do item quando ela é desta máquina e do arco (pela nota); a de outra máquina ou do dono fica. */
+function soltarReservaDoArco(carregado, arco, item, opcoes = {}) {
+    const agora = reservaDoItem(carregado, arco, item, opcoes);
+    if (!agora?.doArco)
+        return false;
+    const eu = nomeDe(opcoes);
+    // A sonda D do CHECK de 15/10: o item que ganhou ordem viva desta máquina depois do plano da reconciliação fica com a
+    // reserva, mesmo para quem compõe a reconciliação fora da trava da máquina; a leitura é nova.
+    if ([...lerCoordenacao(carregado, arco, opcoes).ordens.values()].some(o => o.maquina === eu && o.item === item && (0, exports.ordemViva)(o)))
+        return false;
+    return (0, roadmap_reservas_1.soltarItem)(carregado.raiz, item, { remoto: opcoes.remoto ?? carregado.manifesto.fabrica.remoto, maquina: eu, rede: opcoes.rede }).acao === 'soltou';
+}
+/** A vaga ainda tem sessão viva (ou incerta) nesta máquina? */
+function vagaViva(v, fatos) {
+    const d = fatos.despachos.get(v.reserva);
+    if (!d || d.desfecho === 'pendente')
+        return true;
+    if (d.desfecho === 'recusado')
+        return false;
+    // A2 da rodada 2: o despacho idempotente não abriu sessão (a fase já corria); a vaga dele não espera sessão nenhuma e é
+    // solta com consumo, como a N2 conta a reserva concluída.
+    if (d.idempotente)
+        return false;
+    return fatos.sessoesVivas === null || d.sessionId === null || fatos.sessoesVivas.has(d.sessionId);
+}
+/**
+ * O plano puro da reconciliação desta máquina: conclui as ordens cuja thread local terminou, encerra as vencidas sem sessão
+ * viva (soltando as vagas delas) e solta as vagas cujo despacho local foi recusado ou cuja sessão acabou. A pendente fica,
+ * contada, até a N4, e a vaga que outra chave da máquina tomou conta como viva (G8-6), também na conclusão. Os itens para
+ * soltar a reserva são os das ordens desta máquina, de qualquer versão do envelope.
+ */
+function planejarReconciliacao(estado, eu, fatos) {
+    const plano = { novos: [], encerradas: [], concluidas: [], soltas: [], aguardando: [], itensSemOrdemViva: [] };
+    const daRaiz = (o) => o.maquina === eu && (fatos.chave === undefined || ordemDaRaiz(estado, o, { nome: eu, chave: fatos.chave }));
+    // G8-6: a vaga que outra chave da máquina tomou (a da raiz antiga, depois de uma troca de chave) tem o despacho no log de
+    // outra raiz: aqui ela conta como viva, e só a raiz dela a solta.
+    const daChave = (v) => v.maquina === eu && (fatos.chave === undefined || v.chave === fatos.chave);
+    const minhas = estado.vagas.filter(v => daChave(v) && !v.solta);
+    const soltar = (v, motivo) => {
+        if (plano.soltas.includes(v.vaga))
+            return;
+        const d = fatos.despachos.get(v.reserva);
+        plano.novos.push({ tipo: 'vaga-solta', vaga: v.vaga, consumiu: d?.desfecho !== 'recusado', motivo });
+        plano.soltas.push(v.vaga);
+    };
+    for (const o of estado.ordens.values()) {
+        if (!daRaiz(o) || (o.estado !== 'aceita' && o.estado !== 'isolada'))
+            continue;
+        const th = fatos.threads.get(o.trabalho);
+        if (th && (th.entregue || th.fechada)) {
+            // N1 da terceira passada do CHECK-REVERIFY: a conclusão também libera o item, e a vaga viva de outra chave da máquina
+            // espera a raiz dela, como no fim.
+            const deOutraChave = estado.vagas.filter(v => v.ordem === o.ordem && !v.solta && !daChave(v));
+            if (deOutraChave.length) {
+                plano.aguardando.push({ ordem: o.ordem, porque: `a thread local terminou, e a ordem tem ${deOutraChave.length} vaga(s) viva(s) de outra raiz desta máquina` });
+                continue;
+            }
+            plano.novos.push({ tipo: 'recibo', ordem: o.ordem, recibo: 'concluida', motivo: `thread local ${th.entregue ? 'entregue' : 'fechada sem entrega'}`,
+                resultado: th.entregue ? 'entregue' : 'encerrado-sem-entrega', thread: th.id });
+            plano.concluidas.push(o.ordem);
+            continue;
+        }
+        const porque = o.cancelada ? `cancelada pela autoridade: ${o.cancelada.motivo}`
+            : o.envelopeSha256 !== estado.vigente.envelopeSha256 ? 'a ordem é de uma versão anterior do envelope'
+                : estado.revogada ? `o arco foi revogado na máquina ${estado.revogada.por}`
+                    : !fatos.arcoVigente ? 'o arco não está vigente nesta máquina' : null;
+        if (!porque)
+            continue;
+        // Uma vez de integrar ativa é um merge que pode ter acontecido: a reconciliação da integração decide antes (D13). B-R2A-1
+        // da rodada 2: a fonte que chegou à base sem prova sobre a base provada não é refeita em outra máquina, e o trabalho espera
+        // a inspeção do dono. A vez abandonada espera a base lida sem a fonte (A7 da revisão).
+        const espera = esperaDaVez(estado, o, fatos.vezesConferidas, fatos.vezesSemProva);
+        if (espera) {
+            const daVez = { ativa: 'a vez de integrar dela está ativa, e o merge pode ter chegado à base',
+                'sem-prova': 'a fonte dela chegou à base por um merge fora da base provada, e o trabalho espera a inspeção',
+                abandonada: 'a vez de integrar dela foi abandonada pela autoridade, e o merge pode ter chegado à base' }[espera];
+            plano.aguardando.push({ ordem: o.ordem, porque: `${porque}; ${daVez}` });
+            continue;
+        }
+        const dela = estado.vagas.filter(v => v.ordem === o.ordem && !v.solta);
+        const vivas = dela.filter(v => !daChave(v) || vagaViva(v, fatos));
+        if (vivas.length) {
+            plano.aguardando.push({ ordem: o.ordem, porque: `${porque}; ${vivas.length} sessão(ões) dela ainda viva(s), incerta(s) ou de outra raiz desta máquina` });
+            continue;
+        }
+        for (const v of dela)
+            soltar(v, 'fim da ordem');
+        plano.novos.push({ tipo: 'recibo', ordem: o.ordem, recibo: 'encerrada', motivo: porque.slice(0, 300),
+            checkpoint: { thread: th?.id ?? null, vagasSoltas: dela.map(v => v.vaga).slice(0, exports.TETO_DE_VAGAS_NO_CHECKPOINT) } });
+        plano.encerradas.push(o.ordem);
+    }
+    for (const v of minhas) {
+        const d = fatos.despachos.get(v.reserva);
+        if (d && !vagaViva(v, fatos))
+            soltar(v, d.desfecho === 'recusado' ? 'o despacho local foi recusado antes do lançamento' : 'a sessão do despacho acabou');
+    }
+    const fim = new Set([...plano.concluidas, ...plano.encerradas]);
+    // A5 da revisão: os itens de todas as ordens desta máquina, de qualquer versão do envelope (a reserva do arco só nasce de
+    // uma ordem aceita dela); o item que uma emenda tirou do envelope também é solto.
+    const minhasOrdens = [...estado.ordens.values()].filter(o => o.maquina === eu);
+    const itensVivos = new Set(minhasOrdens.filter(o => (0, exports.ordemViva)(o) && !fim.has(o.ordem)).map(o => o.item));
+    plano.itensSemOrdemViva = [...new Set(minhasOrdens.map(o => o.item))].filter(i => !itensVivos.has(i)).sort();
+    return plano;
+}
+/** Grava o plano da reconciliação, refeito sobre a leitura nova a cada tentativa. */
+function reconciliarCoordenacao(carregado, arco, fatos, opcoes = {}) {
+    const chave = fatos.chave ?? (0, noctum_transporte_1.identidadeDaMaquina)(carregado.raiz, opcoes.maquina).chave;
+    return gravarNaCoordenacao(carregado, arco, opcoes, (leitura) => {
+        const plano = planejarReconciliacao(derivarCoordenacao(leitura), nomeDe(opcoes), { ...fatos, chave });
+        return { novos: plano.novos, resultado: plano };
+    }).resultado;
+}