@orkastery/cli 0.5.6 → 0.6.1

package/dist/noctum-envelope.js

@@ -1,10 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ID_DO_TRABALHO = exports.ID_DO_ARCO = exports.RecusaDoArco = exports.MOTIVOS_DE_RECUSA = exports.CANAIS_DO_RELATORIO = exports.UNIDADES = exports.EXCLUSOES_FIXAS = exports.PERMISSOES = exports.JANELA_MAXIMA_H = exports.JANELA_MINIMA_H = exports.MAXIMO_DE_SESSOES_DA_MAQUINA = exports.TETO_DOS_PEDIDOS_DO_ARCO = exports.TETO_DO_PEDIDO_DO_TRABALHO = exports.MAXIMO_DE_TRABALHOS = exports.CONTRATO_ENVELOPE_V2 = exports.CONTRATO_ENVELOPE = void 0;
+exports.ID_DO_TRABALHO = exports.ID_DO_ARCO = exports.RecusaDoArco = exports.MOTIVOS_DE_RECUSA = exports.CANAIS_DO_RELATORIO = exports.UNIDADES = exports.EXCLUSOES_FIXAS = exports.PERMISSOES = exports.JANELA_MAXIMA_H = exports.JANELA_MINIMA_H = exports.MAXIMO_DE_SESSOES_DA_MAQUINA = exports.TETO_DOS_PEDIDOS_DO_ARCO = exports.TETO_DO_PEDIDO_DO_TRABALHO = exports.MAXIMO_DE_TRABALHOS = exports.MAXIMO_DE_MAQUINAS = exports.CONTRATO_ENVELOPE_V3 = exports.CONTRATO_ENVELOPE_V2 = exports.CONTRATO_ENVELOPE = void 0;
 exports.nomeDaBranch = nomeDaBranch;
 exports.exclusaoDaAcao = exclusaoDaAcao;
 exports.shaDoPedido = shaDoPedido;
+exports.chavePublicaValida = chavePublicaValida;
+exports.impressaoDaChave = impressaoDaChave;
 exports.envelopeComTrabalhos = envelopeComTrabalhos;
+exports.envelopeMultimaquina = envelopeMultimaquina;
 exports.validarPedidoDeAbertura = validarPedidoDeAbertura;
 exports.canonico = canonico;
 exports.hashDoEnvelope = hashDoEnvelope;
@@ -28,12 +31,19 @@ exports.resumoDoEnvelope = resumoDoEnvelope;
  * RM-058, fatia N2 (D1 da ork-rm058n2): a `v2` acrescenta o que a `v1` deixou para uma versão nova, a lista
  * fechada de trabalhos do arco e os limites de concorrência. A `v1` segue valendo como estava, byte a byte, e
  * um arco autorizado nela não despacha nada.
+ *
+ * RM-058, fatia N3 (D2 da ork-rm058n3): a `v3` acrescenta as máquinas do arco, cada uma com a chave pública que assina
+ * no ramo de coordenação, o limite de sessões por conta somando as máquinas e a máquina presa de um trabalho. É o que
+ * o dono autoriza que faz uma máquina confiar na outra: o retrato da rede é descoberta, nunca autorização.
  */
 const node_crypto_1 = require("node:crypto");
 const horario_1 = require("./horario");
 const runtime_profiles_1 = require("./runtime-profiles");
 exports.CONTRATO_ENVELOPE = 'ork.noctum-envelope/v1';
 exports.CONTRATO_ENVELOPE_V2 = 'ork.noctum-envelope/v2';
+exports.CONTRATO_ENVELOPE_V3 = 'ork.noctum-envelope/v3';
+/** D2 da ork-rm058n3: as máquinas de um arco são poucas e todas do dono. */
+exports.MAXIMO_DE_MAQUINAS = 8;
 /**
  * D1 da ork-rm058n2: a lista do arco é fechada e curta. O dono lê cada pedido inteiro no resumo que autoriza (A7 do
  * CHECK), então o pedido é texto curto: cada um e a soma deles cabem numa leitura.
@@ -88,6 +98,24 @@ exports.MOTIVOS_DE_RECUSA = [
     'noctum.estado.adulterado',
     // RM-058 N2 (D11 e D12 da ork-rm058n2): o despacho fora da lista, conta ou runtime do envelope, e o orçamento.
     'noctum.despacho.fora-do-envelope', 'noctum.orcamento.esgotado', 'noctum.orcamento.sem-medicao',
+    // RM-058 N3 (ork-rm058n3): a coordenação entre máquinas, a reserva do item e a vez de integrar.
+    'noctum.coordenacao.sem-remoto', 'noctum.coordenacao.adulterado', 'noctum.coordenacao.fora-do-envelope',
+    'noctum.coordenacao.autoridade-ativa', 'noctum.coordenacao.geracao-vencida', 'noctum.coordenacao.ordem-viva',
+    'noctum.coordenacao.ordem-vencida', 'noctum.coordenacao.maquina-sem-batida', 'noctum.coordenacao.vaga-global',
+    'noctum.coordenacao.concorrencia', 'noctum.coordenacao.exige-passo-da-maquina', 'noctum.reserva.de-outra-maquina',
+    'noctum.integracao.ocupada', 'noctum.integracao.base-mudou', 'noctum.integracao.fonte-mudou',
+    'noctum.integracao.ja-entregue', 'noctum.integracao.nao-provada',
+    // GO-FIX da revisão da ork-rm058n3: a emenda ainda não autorizada aqui, a máquina revogada, a dependência e a recusa
+    // da ordem com motivo próprio, e o item que o roadmap não reconhece.
+    'noctum.coordenacao.versao-nao-autorizada', 'noctum.coordenacao.revogada', 'noctum.coordenacao.dependencia-pendente',
+    'noctum.coordenacao.maquina-recusou', 'noctum.reserva.item-invalido',
+    // Rodada 2 da revisão da ork-rm058n3: a fonte que chegou à base por um merge fora da base provada.
+    'noctum.integracao.base-nao-provada',
+    // RM-058 N6 (D1 e D2 da ork-rm058n6): o arco encerrado e o #Noctum pedido sem envelope vigente ou como modo de thread.
+    'noctum.efeito.encerrado', 'noctum.modo.sem-envelope', 'noctum.modo.lista-fechada',
+    // RM-057 (resposta curta, ork-rm057respost): a resposta curta a uma pergunta que o arco não tem, que outra substituiu ou
+    // que venceu. Nenhuma delas autoriza nem revoga nada.
+    'noctum.pergunta.desconhecida', 'noctum.pergunta.substituida', 'noctum.pergunta.vencida',
 ];
 class RecusaDoArco extends Error {
     motivo;
@@ -349,7 +377,7 @@ function lerOrcamento(v, p) {
     chavesConhecidas(v, ['arco', 'porConta', 'porRuntime'], 'orcamento', p);
     const arco = lerTeto(v.arco, 'orcamento.arco', p);
     const porConta = lerSubtetos(v.porConta, 'conta', 'orcamento.porConta', x => ID_DE_CONTA.test(x), 'id de perfil de conta já autenticado', p);
-    const porRuntime = lerSubtetos(v.porRuntime, 'runtime', 'orcamento.porRuntime', x => runtime_profiles_1.RUNTIMES_COM_PERFIL.includes(x), `runtime de assinatura: ${runtime_profiles_1.RUNTIMES_COM_PERFIL.join(', ')}`, p);
+    const porRuntime = lerSubtetos(v.porRuntime, 'runtime', 'orcamento.porRuntime', x => runtime_profiles_1.RUNTIMES_COM_INVENTARIO.includes(x), `runtime de assinatura: ${runtime_profiles_1.RUNTIMES_COM_INVENTARIO.join(', ')}`, p);
     // Subteto acima do teto do arco, na mesma unidade, não limita nada: é teto do arco disfarçado.
     for (const [nome, teto] of [...(porConta ?? []).map(s => [`conta ${s.conta}`, s.teto]),
         ...(porRuntime ?? []).map(s => [`runtime ${s.runtime}`, s.teto])]) {
@@ -418,11 +446,170 @@ function caractereQueEsconde(texto) {
     return null;
 }
 const codigoDoCaractere = (cp) => `U+${cp.toString(16).toUpperCase().padStart(4, '0')}`;
+/** O nome de uma máquina, a mesma regra do `maquina.json` (`gravarConfigDaMaquina`). */
+const NOME_DE_MAQUINA = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
+const BASE64 = /^[A-Za-z0-9+/]{1,200}={0,2}$/;
+/**
+ * D2 da ork-rm058n3: a chave pública Ed25519 em SPKI DER base64, só na forma canônica que o Node exporta, ou nada. Duas
+ * escritas da mesma chave dariam dois hashes para o mesmo envelope e driblariam a regra da chave repetida.
+ */
+function chavePublicaValida(v) {
+    if (typeof v !== 'string' || !BASE64.test(v))
+        return undefined;
+    try {
+        const k = (0, node_crypto_1.createPublicKey)({ key: Buffer.from(v, 'base64'), format: 'der', type: 'spki' });
+        if (k.asymmetricKeyType !== 'ed25519')
+            return undefined;
+        return k.export({ format: 'der', type: 'spki' }).toString('base64') === v ? v : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** O que o resumo mostra da chave de uma máquina: o começo do sha256 dos bytes dela, para o dono conferir. */
+function impressaoDaChave(chave) {
+    return (0, node_crypto_1.createHash)('sha256').update(Buffer.from(chave, 'base64')).digest('hex').slice(0, 16);
+}
+/** D2 da ork-rm058n3: as máquinas do arco, na ordem do dono (desempata a distribuição), sem nome nem chave repetidos. */
+function lerMaquinas(v, p) {
+    if (ausente(v) || (Array.isArray(v) && v.length === 0)) {
+        p.faltas.push('maquinas (cada máquina do arco: nome e chave pública)');
+        return undefined;
+    }
+    if (!Array.isArray(v)) {
+        p.invalidos.push('maquinas: precisa ser lista');
+        return undefined;
+    }
+    if (v.length > exports.MAXIMO_DE_MAQUINAS) {
+        p.invalidos.push(`maquinas: até ${exports.MAXIMO_DE_MAQUINAS} por arco`);
+        return undefined;
+    }
+    const lidas = [];
+    const nomes = new Set(), chaves = new Set();
+    v.forEach((m, i) => {
+        const onde = `maquinas[${i}]`;
+        if (!objeto(m)) {
+            p.invalidos.push(`${onde}: precisa ser { nome, chave }`);
+            return;
+        }
+        chavesConhecidas(m, ['nome', 'chave'], onde, p);
+        let ok = true;
+        if (ausente(m.nome)) {
+            p.faltas.push(`${onde}.nome`);
+            ok = false;
+        }
+        else if (typeof m.nome !== 'string' || !NOME_DE_MAQUINA.test(m.nome)) {
+            p.invalidos.push(`${onde}.nome: letras, dígitos, ponto, _ ou -, até 64`);
+            ok = false;
+        }
+        else if (nomes.has(m.nome.toLowerCase())) {
+            p.invalidos.push(`${onde}.nome: repetido`);
+            ok = false;
+        }
+        else
+            nomes.add(m.nome.toLowerCase());
+        if (ausente(m.chave)) {
+            p.faltas.push(`${onde}.chave (a chave pública da máquina)`);
+            ok = false;
+        }
+        else if (chavePublicaValida(m.chave) === undefined) {
+            p.invalidos.push(`${onde}.chave: chave pública Ed25519 em SPKI DER base64, na forma canônica`);
+            ok = false;
+        }
+        else if (chaves.has(m.chave)) {
+            p.invalidos.push(`${onde}.chave: a mesma chave em duas máquinas`);
+            ok = false;
+        }
+        else
+            chaves.add(m.chave);
+        if (ok)
+            lidas.push({ nome: m.nome, chave: m.chave });
+    });
+    return lidas.length === v.length ? lidas : undefined;
+}
+/**
+ * D2 da ork-rm058n3: o limite de cada conta somando as máquinas. Toda conta do orçamento tem o seu e nenhuma outra entra;
+ * acima da soma dos limites locais ele não limita nada, como o subteto acima do teto.
+ */
+function lerCapacidadeGlobal(v, orcamento, capacidade, quantasMaquinas, p) {
+    const falta = 'capacidadeGlobal.porConta (sessões ao mesmo tempo por conta, somando as máquinas)';
+    if (ausente(v)) {
+        p.faltas.push(falta);
+        return undefined;
+    }
+    if (!objeto(v)) {
+        p.invalidos.push('capacidadeGlobal: precisa ser { porConta }');
+        return undefined;
+    }
+    chavesConhecidas(v, ['porConta'], 'capacidadeGlobal', p);
+    const bruto = v.porConta;
+    if (ausente(bruto) || (Array.isArray(bruto) && bruto.length === 0)) {
+        p.faltas.push(falta);
+        return undefined;
+    }
+    if (!Array.isArray(bruto)) {
+        p.invalidos.push('capacidadeGlobal.porConta: precisa ser lista');
+        return undefined;
+    }
+    const doOrcamento = orcamento?.porConta.map(s => s.conta);
+    const itens = [];
+    const vistos = new Set();
+    bruto.forEach((s, i) => {
+        const aqui = `capacidadeGlobal.porConta[${i}]`;
+        if (!objeto(s)) {
+            p.invalidos.push(`${aqui}: precisa ser { conta, sessoes }`);
+            return;
+        }
+        chavesConhecidas(s, ['conta', 'sessoes'], aqui, p);
+        let ok = true;
+        if (ausente(s.conta)) {
+            p.faltas.push(`${aqui}.conta`);
+            ok = false;
+        }
+        else if (typeof s.conta !== 'string') {
+            p.invalidos.push(`${aqui}.conta: texto`);
+            ok = false;
+        }
+        else if (vistos.has(s.conta.toLowerCase())) {
+            p.invalidos.push(`${aqui}.conta: repetida`);
+            ok = false;
+        }
+        else if (doOrcamento && !doOrcamento.includes(s.conta)) {
+            p.invalidos.push(`${aqui}.conta: ${s.conta} não está no orçamento, e só entra aqui quem tem teto`);
+            ok = false;
+        }
+        else
+            vistos.add(s.conta.toLowerCase());
+        const local = typeof s.conta === 'string' ? capacidade?.porConta.find(x => x.conta === s.conta)?.sessoes : undefined;
+        const soma = local !== undefined && quantasMaquinas !== undefined ? local * quantasMaquinas : exports.MAXIMO_DE_SESSOES_DA_MAQUINA * exports.MAXIMO_DE_MAQUINAS;
+        if (ausente(s.sessoes)) {
+            p.faltas.push(`${aqui}.sessoes`);
+            ok = false;
+        }
+        else if (typeof s.sessoes !== 'number' || !Number.isSafeInteger(s.sessoes) || s.sessoes < 1) {
+            p.invalidos.push(`${aqui}.sessoes: inteiro a partir de 1`);
+            ok = false;
+        }
+        else if (s.sessoes > soma) {
+            p.invalidos.push(`${aqui}.sessoes: passa da soma dos limites locais da conta (${soma}) e não limita nada`);
+            ok = false;
+        }
+        if (ok)
+            itens.push({ conta: s.conta, sessoes: s.sessoes });
+    });
+    for (const conta of (doOrcamento ?? []).filter(n => !vistos.has(n.toLowerCase()))) {
+        p.faltas.push(`capacidadeGlobal.porConta (${conta}, que está no orçamento)`);
+    }
+    return itens.length === bruto.length ? { porConta: itens.sort((a, b) => a.conta.localeCompare(b.conta, 'en')) } : undefined;
+}
 /**
  * D1 e D2 da ork-rm058n2: a lista fechada de trabalhos. A ordem da lista é do dono e entra no hash, porque a
  * posição desempata a fila (D3); a ordem dentro de `dependeDe` não muda nada e é normalizada.
+ *
+ * D2 da ork-rm058n3: na `v3`, `v3.maquinas` traz os nomes do envelope (ou `null`, quando eles não se leram) e o trabalho
+ * pode prender uma máquina; o de `thread` precisa dela, e o mesmo item preso a duas máquinas é recusado.
  */
-function lerTrabalhos(v, p) {
+function lerTrabalhos(v, p, v3 = null) {
     if (ausente(v) || (Array.isArray(v) && v.length === 0)) {
         p.faltas.push('trabalhos (a lista fechada do arco: id, item, prioridade, dependeDe e thread ou pedido)');
         return undefined;
@@ -443,7 +630,7 @@ function lerTrabalhos(v, p) {
             p.invalidos.push(`${onde}: precisa ser { id, item, prioridade, dependeDe, thread ou pedido }`);
             return;
         }
-        chavesConhecidas(t, ['id', 'item', 'prioridade', 'dependeDe', 'thread', 'pedido'], onde, p);
+        chavesConhecidas(t, ['id', 'item', 'prioridade', 'dependeDe', 'thread', 'pedido', ...(v3 ? ['maquina'] : [])], onde, p);
         let ok = true;
         if (ausente(t.id)) {
             p.faltas.push(`${onde}.id`);
@@ -529,14 +716,45 @@ function lerTrabalhos(v, p) {
         }
         else if (typeof t.item === 'string')
             pedidos.add(`${t.item}|${shaDoPedido(t.pedido)}`);
+        let maquina;
+        if (v3) {
+            if (ausente(t.maquina)) {
+                if (comThread) {
+                    p.faltas.push(`${onde}.maquina (a máquina em que a thread mora)`);
+                    ok = false;
+                }
+            }
+            else if (typeof t.maquina !== 'string' || !NOME_DE_MAQUINA.test(t.maquina)) {
+                p.invalidos.push(`${onde}.maquina: nome de uma das máquinas do arco`);
+                ok = false;
+            }
+            else if (v3.maquinas && !v3.maquinas.has(t.maquina)) {
+                p.invalidos.push(`${onde}.maquina: ${t.maquina} não está em maquinas`);
+                ok = false;
+            }
+            else
+                maquina = t.maquina;
+        }
         if (ok) {
             lidos.push({ id: t.id, item: t.item, prioridade: t.prioridade,
                 dependeDe: [...t.dependeDe].sort(),
-                ...(comThread ? { thread: t.thread } : { pedido: t.pedido.trim() }) });
+                ...(comThread ? { thread: t.thread } : { pedido: t.pedido.trim() }),
+                ...(maquina ? { maquina } : {}) });
         }
     });
     if (lidos.length !== v.length)
         return undefined;
+    if (v3) {
+        // A reserva da RM-047 é do item numa máquina só: o mesmo item preso a duas máquinas nunca andaria nas duas.
+        const presas = new Map();
+        for (const t of lidos)
+            if (t.maquina)
+                presas.set(t.item, (presas.get(t.item) ?? new Set()).add(t.maquina));
+        for (const [item, maquinas] of presas) {
+            if (maquinas.size > 1)
+                p.invalidos.push(`trabalhos: o item ${item} está preso a ${[...maquinas].join(' e ')}; a reserva do item é de uma máquina só`);
+        }
+    }
     const somaDosPedidos = lidos.reduce((n, t) => n + (t.pedido ? Buffer.byteLength(t.pedido, 'utf8') : 0), 0);
     if (somaDosPedidos > exports.TETO_DOS_PEDIDOS_DO_ARCO) {
         p.invalidos.push(`trabalhos: os pedidos somam ${somaDosPedidos} bytes; até ${exports.TETO_DOS_PEDIDOS_DO_ARCO} por arco`);
@@ -666,9 +884,13 @@ function lerCapacidade(v, orcamento, p) {
     const porRuntime = lerLimites(v.porRuntime, 'runtime', 'capacidade.porRuntime', orcamento?.porRuntime.map(s => s.runtime));
     return maquina !== undefined && revisao !== undefined && porConta && porRuntime ? { maquina, porConta, porRuntime, revisao } : undefined;
 }
-/** O conteúdo traz a lista e os limites da `v2`? Só ele despacha (D1 da ork-rm058n2). */
+/** O conteúdo traz a lista e os limites da `v2` (ou da `v3`, que os mantém)? Só ele despacha (D1 da ork-rm058n2). */
 function envelopeComTrabalhos(c) {
-    return c.contrato === exports.CONTRATO_ENVELOPE_V2 && Array.isArray(c.trabalhos) && !!c.capacidade;
+    return (c.contrato === exports.CONTRATO_ENVELOPE_V2 || c.contrato === exports.CONTRATO_ENVELOPE_V3) && Array.isArray(c.trabalhos) && !!c.capacidade;
+}
+/** RM-058 N3: o conteúdo é de um arco entre máquinas (`v3`, com as máquinas e o limite global)? */
+function envelopeMultimaquina(c) {
+    return c.contrato === exports.CONTRATO_ENVELOPE_V3 && envelopeComTrabalhos(c) && Array.isArray(c.maquinas) && !!c.capacidadeGlobal;
 }
 /**
  * Valida o pedido de abertura e devolve o conteúdo normalizado que o dono autoriza.
@@ -681,11 +903,14 @@ function validarPedidoDeAbertura(v) {
     const p = { faltas: [], ilimitados: [], excluidas: [], invalidos: [] };
     if (!objeto(v))
         throw new RecusaDoArco('noctum.envelope.invalido', 'o pedido de abertura precisa ser um objeto');
-    // Na `v1`, `trabalhos` e `capacidade` continuam campo desconhecido, como antes da N2.
-    const v2 = v.contrato === exports.CONTRATO_ENVELOPE_V2;
-    chavesConhecidas(v, ['contrato', 'arco', 'janela', 'destinos', 'orcamento', 'relatorio', ...(v2 ? ['trabalhos', 'capacidade'] : [])], 'pedido', p);
-    if (v.contrato !== exports.CONTRATO_ENVELOPE && !v2)
-        p.invalidos.push(`contrato: precisa ser ${exports.CONTRATO_ENVELOPE} ou ${exports.CONTRATO_ENVELOPE_V2}`);
+    // Na `v1`, `trabalhos` e `capacidade` continuam campo desconhecido, como antes da N2; fora da `v3`, as máquinas também.
+    const v3 = v.contrato === exports.CONTRATO_ENVELOPE_V3;
+    const v2 = v.contrato === exports.CONTRATO_ENVELOPE_V2 || v3;
+    chavesConhecidas(v, ['contrato', 'arco', 'janela', 'destinos', 'orcamento', 'relatorio', ...(v2 ? ['trabalhos', 'capacidade'] : []),
+        ...(v3 ? ['maquinas', 'capacidadeGlobal'] : [])], 'pedido', p);
+    if (v.contrato !== exports.CONTRATO_ENVELOPE && !v2) {
+        p.invalidos.push(`contrato: precisa ser ${exports.CONTRATO_ENVELOPE}, ${exports.CONTRATO_ENVELOPE_V2} ou ${exports.CONTRATO_ENVELOPE_V3}`);
+    }
     let arco;
     if (ausente(v.arco))
         p.faltas.push('arco (identificador do arco)');
@@ -697,8 +922,10 @@ function validarPedidoDeAbertura(v) {
     const destinos = lerDestinos(v.destinos, p);
     const orcamento = lerOrcamento(v.orcamento, p);
     const relatorio = lerRelatorio(v.relatorio, p);
-    const trabalhos = v2 ? lerTrabalhos(v.trabalhos, p) : undefined;
+    const maquinas = v3 ? lerMaquinas(v.maquinas, p) : undefined;
+    const trabalhos = v2 ? lerTrabalhos(v.trabalhos, p, v3 ? { maquinas: maquinas ? new Set(maquinas.map(m => m.nome)) : null } : null) : undefined;
     const capacidade = v2 ? lerCapacidade(v.capacidade, orcamento, p) : undefined;
+    const capacidadeGlobal = v3 ? lerCapacidadeGlobal(v.capacidadeGlobal, orcamento, capacidade, maquinas?.length, p) : undefined;
     const partes = [
         p.excluidas.length ? `ação excluída: ${p.excluidas.join('; ')}` : '',
         p.ilimitados.length ? `teto ilimitado não é aceito: ${p.ilimitados.join('; ')}` : '',
@@ -711,9 +938,10 @@ function validarPedidoDeAbertura(v) {
                 : p.faltas.length ? 'noctum.envelope.valores-ausentes' : 'noctum.envelope.invalido';
         throw new RecusaDoArco(motivo, `${partes.join(' | ')}. Nenhum valor do dono é presumido.`);
     }
-    return { contrato: v2 ? exports.CONTRATO_ENVELOPE_V2 : exports.CONTRATO_ENVELOPE, arco: arco, janela: janela, destinos: destinos,
-        orcamento: orcamento, relatorio: relatorio, exclusoes: [...exports.EXCLUSOES_FIXAS],
-        ...(v2 ? { trabalhos: trabalhos, capacidade: capacidade } : {}) };
+    return { contrato: v3 ? exports.CONTRATO_ENVELOPE_V3 : v2 ? exports.CONTRATO_ENVELOPE_V2 : exports.CONTRATO_ENVELOPE, arco: arco, janela: janela,
+        destinos: destinos, orcamento: orcamento, relatorio: relatorio, exclusoes: [...exports.EXCLUSOES_FIXAS],
+        ...(v2 ? { trabalhos: trabalhos, capacidade: capacidade } : {}),
+        ...(v3 ? { maquinas: maquinas, capacidadeGlobal: capacidadeGlobal } : {}) };
 }
 /** JSON com as chaves em ordem: o mesmo conteúdo dá o mesmo hash, qualquer que seja a ordem de entrada. */
 function canonico(v) {
@@ -784,6 +1012,7 @@ function resumoDoEnvelope(conteudo, envelopeSha256) {
         ...conteudo.orcamento.porRuntime.map(s => `Subteto do runtime ${s.runtime}: ${teto(s.teto)}`),
         `Relatório da manhã: ${conteudo.relatorio.horario} (${conteudo.janela.fuso}) por ${conteudo.relatorio.canal}`,
         ...(envelopeComTrabalhos(conteudo) ? linhasDaV2(conteudo) : []),
+        ...(envelopeMultimaquina(conteudo) ? linhasDaV3(conteudo) : []),
         `Nunca entram: ${conteudo.exclusoes.join(', ')}`,
         `Hash do envelope: ${envelopeSha256}`,
     ];
@@ -796,7 +1025,7 @@ function linhasDaV2(c) {
     return [
         ...c.trabalhos.flatMap(t => {
             const cabeca = `Trabalho ${t.id} (${t.item}), prioridade ${t.prioridade}` +
-                `${t.dependeDe.length ? `, depois de ${t.dependeDe.join(', ')}` : ''}: `;
+                `${t.dependeDe.length ? `, depois de ${t.dependeDe.join(', ')}` : ''}${t.maquina ? `, na máquina ${t.maquina}` : ''}: `;
             if (t.thread)
                 return [`${cabeca}thread ${t.thread}`];
             const linhas = t.pedido.split('\n');
@@ -808,3 +1037,10 @@ function linhasDaV2(c) {
         ...c.capacidade.porRuntime.map(s => `Sessões ao mesmo tempo no runtime ${s.runtime}: ${s.sessoes}`),
     ];
 }
+/** O que a `v3` acrescenta: cada máquina com a impressão da chave, para o dono conferir, e o limite global de cada conta. */
+function linhasDaV3(c) {
+    return [
+        ...c.maquinas.map(m => `Máquina ${m.nome}: chave ${impressaoDaChave(m.chave)}`),
+        ...c.capacidadeGlobal.porConta.map(s => `Sessões ao mesmo tempo na conta ${s.conta}, somando as máquinas: ${s.sessoes}`),
+    ];
+}

package/dist/noctum-execucao.js

@@ -33,7 +33,8 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ESPERA_DA_VEZ_DE_DESPACHAR_MS = void 0;
+exports.MOTIVO_DA_BASELINE_FALHA = exports.ESPERA_DA_VEZ_DE_DESPACHAR_MS = void 0;
+exports.baselineDoArcoPendente = baselineDoArcoPendente;
 exports.passoDoArco = passoDoArco;
 /**
  * RM-058, fatia N2 (D11 da ork-rm058n2): o passo do arco.
@@ -45,9 +46,12 @@ exports.passoDoArco = passoDoArco;
  * `rodarFase`, que toma o lease de condução e é idempotente para a mesma fase e o mesmo prompt. O desfecho volta ao log do
  * arco (`concluirDespacho`): a recusa do núcleo devolve a sessão ao orçamento.
  *
- * A baseline que o bloco com GO no codex pede nunca roda entre a reserva e o lançamento (A1 do CHECK da ork-rm058n2): o
- * despacho recusa com `baseline.pendente`, a reserva volta, a trava de despacho é solta e só então a baseline é gravada;
- * o passo seguinte confere o envelope de novo e despacha. A falha de um candidato antes de lançar (abrir a thread, ler o
+ * A baseline que o bloco com GO pede nunca roda entre a reserva e o lançamento (A1 do CHECK da ork-rm058n2): o despacho
+ * recusa com `baseline.pendente`, a reserva volta, a trava de despacho é solta e só então a baseline é gravada; o passo
+ * seguinte confere o envelope de novo e despacha. Desde a integração (D6 da ork-rm058integra), vale em qualquer runtime,
+ * não só no codex: a entrega da N5 cobra a baseline de toda thread do arco. RM-037 (CHECK 3 da ork-rm037defeit2): o preparo
+ * de `worktree.dependencias` (até 10 min) também nunca roda ali: a thread nova nasce com ele pendente (`adiarDependencias`),
+ * e a baseline o roda antes dos comandos dela, fora da trava e na fila pesada. A falha de um candidato antes de lançar (abrir a thread, ler o
  * pedido) devolve a reserva e o passo segue para o próximo (A4). Do núcleo, só a recusa de antes do lançamento devolve a
  * reserva: a recusa dos portões, e a da conta, do limite de uso ou do impedimento do dono quando nenhuma sessão foi dita.
  * Quando o runtime pode ter aberto a sessão (a falha seca dele, o id dito antes da falha, o núcleo que voltou sem sessão
@@ -56,6 +60,10 @@ exports.passoDoArco = passoDoArco;
  *
  * A revogação nunca espera um despacho: ela usa o lock do arco, e a trava de despacho é outra. Quem chama decide quando
  * chamar de novo (o vigia é da N4); a decisão da fila diz até quando esperar. Nada aqui liga o modo.
+ *
+ * RM-058, fatia N4 (D8, D14 e D21 da ork-rm058n4): o passo aceita as decisões da supervisão, que vão à fila (isolados e
+ * retomadas), e os alvos de runtime da fase, em ordem: o primeiro com conta do envelope disponível e com folga leva o
+ * despacho, com o modelo e o esforço dele. Sem essas entradas, o passo é o da N2.
  */
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
@@ -67,7 +75,9 @@ const fila_pesada_1 = require("./fila-pesada");
 const noctum_arco_1 = require("./noctum-arco");
 const noctum_capacidade_1 = require("./noctum-capacidade");
 const noctum_envelope_1 = require("./noctum-envelope");
+const noctum_medicao_1 = require("./noctum-medicao");
 const noctum_fila_1 = require("./noctum-fila");
+const noctum_guarda_1 = require("./noctum-guarda");
 const phase_1 = require("./phase");
 const runtime_profiles_1 = require("./runtime-profiles");
 const setup_1 = require("./setup");
@@ -123,6 +133,24 @@ function eventosDaThread(raiz, threadId) {
         return null;
     }
 }
+/**
+ * RM-058, integração (D6 da ork-rm058integra): a baseline do arco, em qualquer runtime. Fora do arco, o despacho só a
+ * exige no codex (`baselineDoDespachoNecessaria`, em `phase.ts`, que não muda); no arco, a entrega da N5 a cobra sempre
+ * (`noctum.entrega.baseline-ausente`), então o bloco que tem GO a partir da fase do despacho não sai sem ela. O ledger que
+ * não se lê não prova a baseline: o despacho espera.
+ */
+function baselineDoArcoPendente(raiz, thread, fase) {
+    const bloco = (0, thread_1.blocoDaThread)(thread, fase);
+    if (!bloco.fases.slice(bloco.fases.indexOf(fase)).includes('GO'))
+        return false;
+    const eventos = eventosDaThread(raiz, thread.id);
+    return eventos === null || !eventos.some(e => e.tipo === ledger_1.TIPOS_DE_EVENTO.baselineGravada);
+}
+/**
+ * RM-058, integração (N1 do CHECK 2): a baseline do arco que falhou sem ser espera (o comando que não existe na worktree nova,
+ * a worktree quebrada). O passo devolve a recusa tipada deste trabalho, e a supervisão o isola com a causa.
+ */
+exports.MOTIVO_DA_BASELINE_FALHA = 'noctum.baseline.falhou';
 /**
  * Um passo do arco: no máximo um despacho, pelo núcleo, com o envelope conferido imediatamente antes. Lança só o erro
  * que não é recusa (disco, git); toda recusa tipada volta como resultado.
@@ -144,7 +172,8 @@ function passoDoArco(carregado, arco, opcoes = {}) {
     try {
         let fatos;
         try {
-            fatos = (0, noctum_fila_1.fatosDaFila)(carregado, arco, { quando, maquina: opcoes.maquina, lerReservas: opcoes.lerReservas });
+            fatos = (0, noctum_fila_1.fatosDaFila)(carregado, arco, { quando, maquina: opcoes.maquina, lerReservas: opcoes.lerReservas, coordenacao: opcoes.coordenacao,
+                supervisao: opcoes.supervisao });
         }
         catch (e) {
             // S6 do CHECK: a recusa tipada do arco (o log adulterado, por exemplo) volta como resultado, e não como exceção.
@@ -152,6 +181,11 @@ function passoDoArco(carregado, arco, opcoes = {}) {
                 throw e;
             return { acao: 'aguardar', ate: cadencia, motivo: e.motivo, detalhe: e.message, fila: null };
         }
+        // N3: o arco entre máquinas só despacha pelo passo da máquina, que confere ordem, reserva e vaga global antes.
+        if (fatos.estado?.conteudo && (0, noctum_envelope_1.envelopeMultimaquina)(fatos.estado.conteudo) && typeof opcoes.coordenacao?.reservar !== 'function') {
+            return { acao: 'aguardar', ate: cadencia, motivo: 'noctum.coordenacao.exige-passo-da-maquina', fila: null,
+                detalhe: 'o envelope vigente é de várias máquinas: o despacho passa pelo passo da máquina, com a ordem, a reserva e a vaga global' };
+        }
         const fila = (0, noctum_fila_1.montarFila)(fatos);
         if (fila.decisao.acao === 'encerrar')
             return { acao: 'encerrar', motivo: fila.decisao.motivo, fila };
@@ -164,6 +198,9 @@ function passoDoArco(carregado, arco, opcoes = {}) {
         }
         const capacidade = (0, noctum_capacidade_1.fatosDeCapacidade)(carregado, { quando, consultar: opcoes.consultarSessoes });
         const perfis = (opcoes.perfis ?? (() => perfisDisponiveis(raiz, Date.parse(quando))))();
+        // N6 (D5): fora da trava do arco e sob a de despacho; a reserva confere o medido de cada teto sob o lock do arco.
+        const medicao = (0, noctum_medicao_1.precisaMedir)(conteudo) && fatos.estado
+            ? (opcoes.medir ?? ((r, e, q) => (0, noctum_medicao_1.medirArco)(r, e, { quando: q })))(raiz, fatos.estado, quando) : null;
         let recusa = null;
         let doCandidato = null;
         for (const candidato of fila.candidatos) {
@@ -179,24 +216,43 @@ function passoDoArco(carregado, arco, opcoes = {}) {
                     detalhe: mensagem(e), reserva: null, fila };
                 continue;
             }
-            const doRuntime = perfis.filter(p => p.runtime === runtime).map(p => p.id);
-            // A conta com mais folga; sem folga em nenhuma, a primeira do envelope no runtime, para `admitir` dizer o motivo na
-            // ordem dele (a máquina cheia antes da conta).
-            const conta = (0, noctum_capacidade_1.escolherConta)(conteudo.capacidade, capacidade, doRuntime)
-                ?? conteudo.capacidade.porConta.find(c => doRuntime.includes(c.conta))?.conta ?? null;
+            // RM-058 N4 (D14): os alvos da fase, em ordem; sem eles, só o runtime do bloco, como na N2.
+            const alvos = opcoes.alvos ? opcoes.alvos(fase, runtime, thread?.modo ?? 'auto') : [{ runtime }];
+            const doRuntime = (r) => perfis.filter(p => p.runtime === r).map(p => p.id);
+            // A conta com mais folga no primeiro alvo que tem uma; sem folga em nenhum, a primeira do envelope no primeiro alvo com
+            // perfil, para `admitir` dizer o motivo na ordem dele (a máquina cheia antes da conta).
+            let alvo = alvos[0] ?? { runtime }, conta = null;
+            for (const a of alvos) {
+                const c = (0, noctum_capacidade_1.escolherConta)(conteudo.capacidade, capacidade, doRuntime(a.runtime));
+                if (c) {
+                    alvo = a;
+                    conta = c;
+                    break;
+                }
+            }
+            for (const a of conta === null ? alvos : []) {
+                const c = conteudo.capacidade.porConta.find(x => doRuntime(a.runtime).includes(x.conta))?.conta;
+                if (c) {
+                    alvo = a;
+                    conta = c;
+                    break;
+                }
+            }
             const vaga = (0, board_1.vagaDoDespacho)(carregado, thread?.id ?? '', quando);
             const admissao = conta === null
                 ? { ok: false, motivo: 'capacidade.conta-nao-autorizada',
-                    detalhe: `nenhuma conta do envelope é perfil disponível do runtime ${runtime}` }
-                : (0, noctum_capacidade_1.admitir)({ runtime, conta, revisao: fase === 'CHECK' }, conteudo.capacidade, capacidade, vaga);
+                    detalhe: `nenhuma conta do envelope é perfil disponível do runtime ${alvos.map(a => a.runtime).join(' ou ') || runtime}` }
+                : (0, noctum_capacidade_1.admitir)({ runtime: alvo.runtime, conta, revisao: fase === 'CHECK' }, conteudo.capacidade, capacidade, vaga);
             if (!admissao.ok) {
                 recusa = admissao;
                 if (MOTIVOS_DE_MAQUINA.includes(admissao.motivo))
                     break;
                 continue;
             }
-            const r = despacharCandidato(carregado, arco, fila, { trabalho: candidato.id, thread, item: candidato.item, fase, runtime,
-                conta: conta, quando, pedido: conteudo.trabalhos.find(t => t.id === candidato.id)?.pedido ?? null }, opcoes);
+            const r = despacharCandidato(carregado, arco, fila, { trabalho: candidato.id, thread, item: candidato.item, fase, runtime: alvo.runtime,
+                conta: conta, quando, pedido: conteudo.trabalhos.find(t => t.id === candidato.id)?.pedido ?? null,
+                trio: alvo.runtime === runtime ? null : alvo,
+                medido: medicao ? (0, noctum_medicao_1.medidoParaReserva)(medicao, conteudo, conta, alvo.runtime) : undefined }, opcoes);
             if (r.acao === 'baseline') {
                 pendente = r;
                 break;
@@ -213,7 +269,8 @@ function passoDoArco(carregado, arco, opcoes = {}) {
             if (doCandidato && !recusa)
                 return doCandidato;
             return { acao: 'aguardar', ate: new Date(Math.min(Date.parse(quando) + 5 * 60_000, Date.parse(conteudo.janela.fim))).toISOString(),
-                motivo: recusa?.motivo ?? 'capacidade', detalhe: recusa?.detalhe ?? 'nenhum candidato coube', fila };
+                motivo: recusa?.motivo ?? 'capacidade', detalhe: recusa?.detalhe ?? 'nenhum candidato coube', fila,
+                ocupantes: capacidade.ocupantes.map(o => ({ origem: o.origem, runtime: o.runtime, revisao: o.revisao })) };
         }
     }
     finally {
@@ -231,8 +288,12 @@ function baselineForaDaTrava(carregado, arco, p, cadencia, opcoes) {
         (opcoes.gravarBaseline ?? ((k, t, c) => { (0, verify_1.gravarBaseline)(k, t, undefined, c, 'phase.run'); }))(carregado, p.thread, conducao);
     }
     catch (e) {
-        if (!(e instanceof fila_pesada_1.ErroDaFilaPesada) && !(e instanceof conducao_1.ErroDeConducao))
-            throw e;
+        // N1 do CHECK 2: a falha que não é espera não derruba o passo (nem o condutor, nem o CLI): volta como a recusa deste
+        // trabalho, que não passa sozinha, e a supervisão o isola; os outros trabalhos seguem.
+        if (!(e instanceof fila_pesada_1.ErroDaFilaPesada) && !(e instanceof conducao_1.ErroDeConducao)) {
+            return { acao: 'recusado', trabalho: p.trabalho, thread: p.thread, fase: p.fase, motivo: exports.MOTIVO_DA_BASELINE_FALHA, detalhe: mensagem(e),
+                reserva: null, fila: p.fila };
+        }
         return { acao: 'aguardar', ate: cadencia, motivo: 'baseline-pendente', detalhe: mensagem(e), fila: p.fila };
     }
     return { acao: 'aguardar', ate: new Date().toISOString(), motivo: 'baseline-gravada', fila: p.fila,
@@ -243,8 +304,9 @@ function despacharCandidato(carregado, arco, fila, c, opcoes) {
     const { raiz } = carregado;
     let reserva;
     try {
-        reserva = (opcoes.reservar ?? noctum_arco_1.reservarDespacho)(raiz, { arco, envelopeSha256: fila.envelopeSha256 ?? '', trabalho: c.trabalho,
-            thread: c.thread?.id ?? null, fase: c.fase, runtime: c.runtime, conta: c.conta, revisao: c.fase === 'CHECK' }, c.quando).seq;
+        reserva = (opcoes.coordenacao?.reservar ?? opcoes.reservar ?? noctum_arco_1.reservarDespacho)(raiz, { arco, envelopeSha256: fila.envelopeSha256 ?? '', trabalho: c.trabalho,
+            thread: c.thread?.id ?? null, fase: c.fase, runtime: c.runtime, conta: c.conta, revisao: c.fase === 'CHECK',
+            ...(c.medido ? { medido: c.medido } : {}) }, c.quando).seq;
     }
     catch (e) {
         if (!(e instanceof noctum_envelope_1.RecusaDoArco))
@@ -263,8 +325,13 @@ function despacharCandidato(carregado, arco, fila, c, opcoes) {
         if (!thread) {
             if (!c.pedido)
                 return { ...recusar('noctum.despacho.pedido-ausente', `o trabalho ${c.trabalho} não traz pedido para abrir a thread`, null), seguir: true };
-            thread = (opcoes.abrirThread ?? ((k, o) => (0, thread_1.novaThread)(k, o).thread))(carregado, { nome: `${c.item.toLowerCase()} ${c.trabalho}`,
-                modo: 'auto', roadmap: c.item, pedido: c.pedido, criarWorktree: true });
+            // RM-037 (CHECK 3 da ork-rm037defeit2): sob a trava de despacho, o preparo das dependências só fica pendente.
+            const base = `${c.item.toLowerCase()} ${c.trabalho}`;
+            const numero = opcoes.coordenacao?.ordens?.get(c.trabalho)?.numero;
+            const sufixo = numero === undefined ? '' : ` o${numero}`;
+            const nome = sufixo ? `${base.slice(0, Math.max(1, 12 - sufixo.length)).trimEnd()}${sufixo}` : base;
+            thread = (opcoes.abrirThread ?? ((k, o) => (0, thread_1.novaThread)(k, o).thread))(carregado, { nome,
+                modo: 'auto', roadmap: c.item, pedido: c.pedido, criarWorktree: true, adiarDependencias: true });
         }
         pedido = (0, thread_1.pedidoDaThread)(raiz, thread);
     }
@@ -274,13 +341,22 @@ function despacharCandidato(carregado, arco, fila, c, opcoes) {
     }
     if (!pedido)
         return { ...recusar('noctum.despacho.pedido-ausente', `a thread ${thread.id} não guardou o pedido`, thread.id), seguir: true };
+    // RM-058, integração (D6): sem a baseline do bloco com GO, em qualquer runtime, a reserva volta antes do lançamento, e a
+    // baseline roda fora da trava de despacho (`baselineForaDaTrava`); o vigia nunca a grava: ela fica para o condutor.
+    if (baselineDoArcoPendente(raiz, thread, c.fase)) {
+        (0, noctum_arco_1.concluirDespacho)(raiz, arco, reserva, { motivo: 'baseline.pendente' });
+        return { acao: 'baseline', trabalho: c.trabalho, thread: thread.id, fase: c.fase, fila };
+    }
     // S5 do CHECK: a falha de dentro do núcleo pode ter aberto a sessão; ela sobe, e a reserva fica pendente e conta.
     const antes = eventosDaThread(raiz, thread.id)?.length ?? 0;
-    const r = (opcoes.despachar ?? phase_1.rodarFase)(carregado, thread.id, { fase: c.fase, prompt: pedido.texto, perfil: c.conta,
-        canal: (0, conducao_1.canalDoProcesso)(), correlacao: `noctum:${arco}`, baselinePeloDespacho: false });
+    const trio = c.trio ? { runtime: c.trio.runtime, ...(c.trio.model ? { model: c.trio.model } : {}), ...(c.trio.effort ? { effort: c.trio.effort } : {}) } : {};
+    // RM-058, integração (D5 da ork-rm058integra): a sessão sabe que o SHIP e o MASTER da thread são do arco. A linha é fixa,
+    // e o mesmo pedido dá o mesmo prompt em toda chamada: o `rodarFase` segue idempotente.
+    const r = (opcoes.despachar ?? phase_1.rodarFase)(carregado, thread.id, { fase: c.fase, prompt: (0, noctum_guarda_1.pedidoDoArco)(pedido.texto, arco), perfil: c.conta,
+        canal: (0, conducao_1.canalDoProcesso)(), correlacao: `noctum:${arco}`, baselinePeloDespacho: false, ...trio });
     if (r.motivo === 'baseline.pendente') {
         (0, noctum_arco_1.concluirDespacho)(raiz, arco, reserva, { motivo: 'baseline.pendente' });
-        return { acao: 'baseline', thread: thread.id, fila };
+        return { acao: 'baseline', trabalho: c.trabalho, thread: thread.id, fase: c.fase, fila };
     }
     // A recusa dos portões do núcleo vem antes de chamar o runtime: nada abriu, e a sessão volta ao orçamento.
     if (r.bloqueado)