@orkastery/cli 0.6.0 → 0.6.2

package/dist/noctum-aceite.js

@@ -65,9 +65,11 @@ const branch_de_estado_1 = require("./branch-de-estado");
 const ci_1 = require("./ci");
 const horario_1 = require("./horario");
 const ledger_1 = require("./ledger");
+const maquina_1 = require("./maquina");
 const master_1 = require("./master");
 const noctum_arco_1 = require("./noctum-arco");
 const noctum_envelope_1 = require("./noctum-envelope");
+const noctum_coordenacao_1 = require("./noctum-coordenacao");
 const noctum_fila_1 = require("./noctum-fila");
 const noctum_medicao_1 = require("./noctum-medicao");
 const noctum_registro_1 = require("./noctum-registro");
@@ -76,6 +78,8 @@ const noctum_supervisao_1 = require("./noctum-supervisao");
 const parado_no_condutor_1 = require("./parado-no-condutor");
 const estado_thread_1 = require("./estado-thread");
 const thread_1 = require("./thread");
+const noctum_coordenacao_2 = require("./noctum-coordenacao");
+const noctum_transporte_1 = require("./noctum-transporte");
 const util_1 = require("./util");
 const worktree_1 = require("./worktree");
 exports.CONTRATO_PILOTO = 'ork.noctum-piloto/v1';
@@ -128,8 +132,9 @@ function remotoLocal(url) {
     return /^file:/i.test(url) || /^(\/|\.{1,2}\/|[A-Za-z]:[\\/])/.test(url) || (!/^[a-z][a-z0-9+.-]*:\/\//i.test(url) && !/^[^@\s]+@[^:\s]+:/.test(url));
 }
 /** Os limiares da proposta, pela janela do piloto. */
-function limiaresDaProposta(horas) {
-    return { m1MinimoHoras: arred(horas), m5MaximoMin: 15, entregasMinimas: horas < 12 ? 2 : 4, margemDoTeto: 0, atrasoDoRelatorioMin: noctum_fila_1.CADENCIA_MS / MIN };
+function limiaresDaProposta(horas, multimaquina = false) {
+    return { m1MinimoHoras: arred(horas), m5MaximoMin: multimaquina ? 25 : 15, entregasMinimas: horas < 12 ? 2 : 4,
+        margemDoTeto: 0, atrasoDoRelatorioMin: noctum_fila_1.CADENCIA_MS / MIN };
 }
 /** As chaves dos limiares do dono, no contrato `ork.noctum-limiares/v1`. */
 exports.CHAVES_DOS_LIMIARES = ['m1MinimoHoras', 'm5MaximoMin', 'entregasMinimas', 'margemDoTeto', 'atrasoDoRelatorioMin'];
@@ -203,12 +208,29 @@ function aceiteDoPiloto(carregado, arco, opcoes = {}) {
     if (!estado?.conteudo || !estado.autorizadoPor)
         throw new RecusaDoAceite('noctum.aceite.sem-arco', `o arco ${arco} nunca foi autorizado pelo dono`);
     const conteudo = estado.conteudo;
+    const multimaquina = (0, noctum_envelope_1.envelopeMultimaquina)(conteudo);
+    const maquinaAtual = (0, maquina_1.nomeDaMaquina)(opcoes.maquina);
+    let rede = null;
+    let erroDaRede = null;
+    if (multimaquina) {
+        try {
+            if (opcoes.rede)
+                rede = opcoes.rede;
+            else {
+                const leitura = (0, noctum_transporte_1.lerRamo)(carregado, arco, { remoto: opcoes.remoto, maquina: maquinaAtual }, noctum_coordenacao_2.conferirCoordenacao);
+                rede = { registros: leitura.registros.map(r => r.dados), estado: (0, noctum_coordenacao_1.derivarCoordenacao)(leitura) };
+            }
+        }
+        catch (e) {
+            erroDaRede = `a coordenação não se lê (${e instanceof noctum_envelope_1.RecusaDoArco ? e.motivo : e.message.slice(0, 120)})`;
+        }
+    }
     const janela = conteudo.janela;
     // A condução começa no início da janela ou na primeira autorização, o que vier depois; as autorizações seguintes, dentro
     // da janela, são emendas do dono.
     let autorizacoes = [];
     try {
-        autorizacoes = (0, noctum_arco_1.versoesAutorizadas)(raiz, arco).map(v => ({ versao: v.versao, autorizadoEm: v.autorizadoEm }));
+        autorizacoes = (0, noctum_arco_1.versoesAutorizadas)(raiz, arco).map(v => ({ versao: v.versao, autorizadoEm: v.autorizadoEm, envelopeSha256: v.envelopeSha256 }));
     }
     catch (e) {
         if (!(e instanceof noctum_envelope_1.RecusaDoArco))
@@ -221,6 +243,19 @@ function aceiteDoPiloto(carregado, arco, opcoes = {}) {
     const horasDaJanela = (Date.parse(janela.fim) - Date.parse(janela.inicio)) / HORA;
     const git = opcoes.git ?? gitDaRaiz(raiz);
     const remoto = opcoes.remoto ?? carregado.manifesto.fabrica?.remoto ?? 'origin';
+    const outras = [];
+    for (const outra of opcoes.outrasMaquinas ?? []) {
+        const r = outra.resultado;
+        const envelope = objeto(r) && objeto(r.envelope) ? r.envelope : null;
+        const maquina = objeto(r) && typeof r.maquina === 'string' ? r.maquina : null;
+        const valida = objeto(r) && r.contrato === exports.CONTRATO_PILOTO && r.arco === arco && envelope && typeof envelope.sha256 === 'string' &&
+            autorizacoes.some(v => v.envelopeSha256 === envelope.sha256) && maquina && multimaquina && conteudo.maquinas.some(m => m.nome === maquina) &&
+            Array.isArray(r.medidas) && Array.isArray(r.criterios) && typeof r.veredito === 'string';
+        if (!valida) {
+            throw new RecusaDoAceite('noctum.aceite.outra-maquina-invalida', `${outra.fonte}: o arquivo precisa ser um ${exports.CONTRATO_PILOTO} completo do arco ${arco}, de uma máquina e envelope autorizados aqui`);
+        }
+        outras.push({ ...outra, resultado: r });
+    }
     // As leituras: a supervisão, o relatório e os ledgers das threads do arco.
     let supervisao = null;
     let erroDaSupervisao = null;
@@ -300,6 +335,8 @@ function aceiteDoPiloto(carregado, arco, opcoes = {}) {
     catch { /* sem transporte configurado: o relatório diz a lacuna */ }
     const medidas = [];
     const medida = (m) => { medidas.push(m); return m; };
+    const nomesDasMaquinas = multimaquina ? conteudo.maquinas.map(m => m.nome) : [maquinaAtual];
+    const porMaquina = (valor) => Object.fromEntries(nomesDasMaquinas.map(maquina => [maquina, valor(maquina)]));
     /**
      * I1 do CHECK 2: a entrega do arco é o `ship_done` que a entrega dele gravou (o arco na evidência), e não a reconciliação
      * de um merge feito por fora (`incorporadaPor: 'outro-caminho'`) nem o ship do dono depois do arco.
@@ -443,7 +480,8 @@ function aceiteDoPiloto(carregado, arco, opcoes = {}) {
     const semLeitura = entregas.some(e => e.provada === null) || ilegiveis.length > 0;
     medida({ id: 'M2', nome: 'Entregas com prova', valor: semLeitura ? null : provadas.length, unidade: `entregas provadas de ${entregas.length} alegadas`,
         fonte: 'ship_done dos ledgers, ponta da base pelo git ls-remote e ancestralidade do merge', lacunas: lacunasDaEntrega,
-        evidencia: { alegadas: entregas.length, entregas: entregas.map(e => ({ trabalho: e.trabalho, thread: e.thread, provada: e.provada, motivo: e.motivo })) } });
+        evidencia: { alegadas: entregas.length, entregas: entregas.map(e => ({ trabalho: e.trabalho, thread: e.thread, provada: e.provada, motivo: e.motivo })),
+            ...(multimaquina ? { porMaquina: porMaquina(maquina => (rede?.registros ?? []).filter(r => r.tipo === 'entrega' && r.por === maquina).length) } : {}) } });
     medida({ id: 'M3', nome: 'MASTER por omissão', valor: semLeitura ? null : provadas.filter(e => e.master).length, unidade: `entregas com MASTER de ${provadas.length} provadas`,
         fonte: 'aceite_por_omissao com o arco na evidência, antes do fim do arco, e a thread fechada', lacunas: semLeitura ? ['as entregas não se provaram todas'] : [],
         evidencia: { semMaster: provadas.filter(e => !e.master).map(e => e.thread) } });
@@ -456,6 +494,37 @@ function aceiteDoPiloto(carregado, arco, opcoes = {}) {
         .map(l => ({ em: l.em, fonte: `supervisão: ${l.evento.tipo}`, alvos: alvosDe(l.evento) }));
     const dosLedgers = (tipos) => eventosDasThreads.filter(e => tipos.includes(e.tipo))
         .map(e => ({ em: e.ts, fonte: `ledger da ${e.threadDoArco}: ${e.tipo}`, alvos: [e.threadDoArco, ...[...porTrabalho].filter(([, t]) => t === e.threadDoArco).map(([w]) => w)] }));
+    const ordensDaRede = new Map((rede?.registros ?? []).filter(r => r.tipo === 'ordem' && typeof r.ordem === 'string')
+        .map(r => [String(r.ordem), { maquina: String(r.maquina), trabalho: String(r.trabalho) }]));
+    const vezesDaRede = new Map((rede?.registros ?? []).filter(r => r.tipo === 'vez' && typeof r.chave === 'string' && typeof r.n === 'number')
+        .map(r => [`${String(r.chave)}/${String(r.n)}`, { maquina: String(r.por), trabalho: ordensDaRede.get(String(r.ordem))?.trabalho ?? '' }]));
+    const daRede = (i, falha) => {
+        if (!i.alvo)
+            return `${falha} exige o alvo (a máquina afetada) na agenda`;
+        if (erroDaRede)
+            return erroDaRede;
+        if (!rede)
+            return 'a coordenação da rede não foi lida';
+        if (falha === 'F10') {
+            return rede.registros.filter(r => r.por === i.alvo)
+                .map(r => ({ em: r.em, fonte: `coordenação: ${r.tipo} assinado por ${r.por}`, alvos: [i.alvo], maquina: r.por }));
+        }
+        const isoladas = rede.ordensIsoladas?.filter(o => o.maquina === i.alvo) ??
+            [...(rede.estado?.ordens.values() ?? [])].filter(o => o.maquina === i.alvo && o.estado === 'isolada');
+        if (isoladas.length)
+            return [];
+        return rede.registros.filter(r => {
+            if (r.por === i.alvo)
+                return false;
+            if (r.tipo === 'autoridade' && r.modo === 'forcada')
+                return objeto(r.anterior) && r.anterior.maquina === i.alvo;
+            if (r.tipo === 'cancelamento')
+                return ordensDaRede.get(String(r.ordem))?.maquina === i.alvo;
+            if (r.tipo === 'vez-fim' && r.desfecho === 'abandonada')
+                return vezesDaRede.get(`${String(r.chave)}/${String(r.n)}`)?.maquina === i.alvo;
+            return false;
+        }).map(r => ({ em: r.em, fonte: `coordenação: ${r.tipo} de ${i.alvo} por ${r.por}`, alvos: [i.alvo], maquina: r.por }));
+    };
     const SINAIS = {
         F1: () => erroDaSupervisao ?? daSupervisao(['retomada_autorizada']),
         F2: () => erroDaSupervisao ?? daSupervisao(['conducao_assumida']),
@@ -466,26 +535,33 @@ function aceiteDoPiloto(carregado, arco, opcoes = {}) {
         F7: () => erroDoRelatorio ?? confirmacoesAutomaticas.map(l => ({ em: l.em, fonte: 'relatório: envio_confirmado', alvos: [] })),
         F8: () => erroDaSupervisao ?? daSupervisao(['efeito_reconciliado']),
         F9: () => erroDaSupervisao ?? daSupervisao(['tique_concluido']),
-        F10: () => 'a partição entre máquinas é medida com a coordenação da N3 (bloco B)',
-        F11: () => 'a máquina perdida é medida com a coordenação da N3 (bloco B)',
+        F10: (i) => daRede(i, 'F10'),
+        F11: (i) => daRede(i, 'F11'),
     };
     const injecoes = opcoes.injecoes ?? null;
     const recuperacoes = (injecoes ?? []).map(i => {
-        const fontes = SINAIS[i.falha]?.() ?? `falha desconhecida: ${i.falha}`;
+        const fontes = SINAIS[i.falha]?.(i) ?? `falha desconhecida: ${i.falha}`;
         if (typeof fontes === 'string')
             return { ...i, lacuna: fontes, sinal: null };
         const doAlvo = i.alvo ? fontes.filter(f => !f.alvos.length || f.alvos.includes(i.alvo)) : fontes;
         const sinal = sinalDe(doAlvo, Date.parse(i.instante));
-        return { ...i, lacuna: null, sinal: sinal ? { em: sinal.em, fonte: sinal.fonte } : null };
+        return { ...i, lacuna: null, sinal: sinal ? { em: sinal.em, fonte: sinal.fonte, ...(sinal.maquina ? { maquina: sinal.maquina } : {}) } : null };
     });
     // A agenda vazia não prova recuperação nenhuma: é lacuna, como a agenda que falta.
     const lacunasDaAgenda = injecoes === null ? ['sem a agenda de injeções (--injecoes)']
         : !injecoes.length ? ['a agenda de injeções está vazia: nenhuma falha foi injetada']
             : recuperacoes.filter(r => r.lacuna).map(r => `${r.falha}: ${r.lacuna}`);
     const recuperadas = recuperacoes.filter(r => r.sinal);
+    const aguardamRecibo = (rede?.ordensIsoladas ?? [...(rede?.estado?.ordens.values() ?? [])]
+        .filter(o => o.estado === 'isolada').map(o => ({ maquina: o.maquina, trabalho: o.trabalho })))
+        .filter(o => (injecoes ?? []).some(i => i.falha === 'F11' && i.alvo === o.maquina));
+    const retomados = [...(rede?.estado?.trabalhos.values() ?? [])].filter(t => t.ordem && t.estado !== 'isolado' &&
+        (injecoes ?? []).some(i => i.falha === 'F11' && i.alvo && t.ordem.maquina !== i.alvo)).map(t => t.trabalho);
     medida({ id: 'M4', nome: 'Falhas recuperadas', valor: lacunasDaAgenda.length ? null : recuperadas.length, unidade: `recuperadas de ${recuperacoes.length} injetadas`,
         fonte: 'agenda de injeções, log da supervisão, registro do relatório e ledgers', lacunas: lacunasDaAgenda,
-        evidencia: { injecoes: recuperacoes.map(r => ({ falha: r.falha, instante: r.instante, sinal: r.sinal, lacuna: r.lacuna })) } });
+        evidencia: { injecoes: recuperacoes.map(r => ({ falha: r.falha, instante: r.instante, sinal: r.sinal, lacuna: r.lacuna })),
+            ...(multimaquina ? { porMaquina: porMaquina(maquina => recuperadas.filter(r => r.sinal && 'maquina' in r.sinal && r.sinal.maquina === maquina).length),
+                retomados, aguardamRecibo } : {}) } });
     // M5 é das falhas que o plano mede pelo tempo (a sessão morta, o condutor morto e a máquina perdida); as outras, como o
     // tique parado de propósito por 20 min, contam só em M4.
     const tempos = recuperadas.filter(r => exports.FALHAS_DO_M5.includes(r.falha)).map(r => (Date.parse(r.sinal.em) - Date.parse(r.instante)) / MIN)
@@ -494,7 +570,12 @@ function aceiteDoPiloto(carregado, arco, opcoes = {}) {
     medida({ id: 'M5', nome: 'Tempo de recuperação', valor: lacunasDaAgenda.length || !tempos.length ? null : arred(tempos.at(-1)), unidade: 'min (máximo)',
         fonte: 'da injeção ao primeiro sinal de retomada no log', lacunas: lacunasDaAgenda.length ? lacunasDaAgenda : tempos.length ? []
             : [`nenhuma falha recuperada de ${exports.FALHAS_DO_M5.join(', ')} para medir`],
-        evidencia: { mediana: mediana === null ? null : arred(mediana), maximo: tempos.length ? arred(tempos.at(-1)) : null } });
+        evidencia: { mediana: mediana === null ? null : arred(mediana), maximo: tempos.length ? arred(tempos.at(-1)) : null,
+            ...(multimaquina ? { porMaquina: porMaquina(maquina => {
+                    const t = recuperadas.filter(r => exports.FALHAS_DO_M5.includes(r.falha) && r.sinal && 'maquina' in r.sinal && r.sinal.maquina === maquina)
+                        .map(r => arred((Date.parse(r.sinal.em) - Date.parse(r.instante)) / MIN));
+                    return t.length ? Math.max(...t) : null;
+                }) } : {}) } });
     // M6: violações do envelope.
     const contas = new Set([...conteudo.orcamento.porConta.map(c => c.conta), ...(comTrabalhos ? conteudo.capacidade.porConta.map(c => c.conta) : [])]);
     const bases = new Set(conteudo.destinos.map(d => d.base));
@@ -549,6 +630,22 @@ function aceiteDoPiloto(carregado, arco, opcoes = {}) {
     for (const [chave, n] of paginas)
         if (n > 1)
             duplicados.push(`${n} envios confirmados da ${chave}`);
+    const vagasSobrepostas = [];
+    const vagasDaRede = rede?.vagas ?? rede?.estado?.vagas ?? [];
+    for (let i = 0; i < vagasDaRede.length; i++) {
+        for (let j = i + 1; j < vagasDaRede.length; j++) {
+            const a = vagasDaRede[i], b = vagasDaRede[j];
+            if (a.trabalho !== b.trabalho || a.maquina === b.maquina)
+                continue;
+            const inicio = Math.max(Date.parse(a.desde), Date.parse(b.desde));
+            const fimA = a.solta ? Date.parse(a.solta.em) : Number.POSITIVE_INFINITY;
+            const fimB = b.solta ? Date.parse(b.solta.em) : Number.POSITIVE_INFINITY;
+            if (inicio < Math.min(fimA, fimB)) {
+                vagasSobrepostas.push({ trabalho: a.trabalho, maquinas: [a.maquina, b.maquina], vagas: [a.vaga, b.vaga] });
+                duplicados.push(`o trabalho ${a.trabalho} teve vagas ativas ao mesmo tempo em ${a.maquina} e ${b.maquina}`);
+            }
+        }
+    }
     const lacunasDaForja = [];
     const repositorio = urlDoRemoto && !remotoLocal(urlDoRemoto) ? (0, ci_1.repositorioGitHub)(urlDoRemoto) : null;
     if (repositorio) {
@@ -583,7 +680,8 @@ function aceiteDoPiloto(carregado, arco, opcoes = {}) {
     }
     const lacunasDoM7 = [...(erroDoRelatorio ? [erroDoRelatorio] : []), ...lacunasDaForja, ...ilegiveis];
     medida({ id: 'M7', nome: 'Efeitos duplicados', valor: lacunasDoM7.length && !duplicados.length ? null : duplicados.length, unidade: 'efeitos duplicados',
-        fonte: 'ledgers (ship_done e ship_published), log do arco, registro do relatório e PRs da forja', lacunas: lacunasDoM7, evidencia: { duplicados } });
+        fonte: 'ledgers (ship_done e ship_published), log do arco, registro do relatório, coordenação e PRs da forja', lacunas: lacunasDoM7,
+        evidencia: { duplicados, ...(multimaquina ? { vagasSobrepostas, porMaquina: porMaquina(maquina => vagasSobrepostas.filter(v => v.maquinas.includes(maquina)).length) } : {}) } });
     // M8: evidência perdida.
     const perdidas = [...ilegiveis, ...(erroDaSupervisao ? [erroDaSupervisao] : []), ...(erroDoRelatorio ? [erroDoRelatorio] : [])];
     for (const e of entregas)
@@ -625,7 +723,9 @@ function aceiteDoPiloto(carregado, arco, opcoes = {}) {
     const lacunasDoTeto = tetos.filter(t => t.lacuna).map(t => `${t.escopo}: ${t.lacuna}`);
     const acima = tetos.filter(t => t.consumo !== null && t.consumo > t.teto);
     medida({ id: 'M9', nome: 'Consumo contra o teto', valor: lacunasDoTeto.length ? null : acima.length, unidade: 'escopos acima do teto',
-        fonte: 'consumo do log do arco e a medição das unidades', lacunas: lacunasDoTeto, evidencia: { tetos } });
+        fonte: 'consumo do log do arco, da coordenação e a medição das unidades', lacunas: lacunasDoTeto,
+        evidencia: { tetos, ...(multimaquina ? { porMaquina: porMaquina(maquina => (rede?.vagas ?? rede?.estado?.vagas ?? [])
+                    .filter(v => v.maquina === maquina && (!v.solta || v.solta.consumiu)).length) } : {}) } });
     // M10: o relatório da manhã.
     const lacunasDoRelatorio = erroDoRelatorio ? [erroDoRelatorio] : [];
     const vencimento = (0, noctum_relatorio_1.vencimentoDoRelatorio)(conteudo);
@@ -666,8 +766,39 @@ function aceiteDoPiloto(carregado, arco, opcoes = {}) {
     medida({ id: 'M10', nome: 'Relatório da manhã', valor: lacunasDoRelatorio.length ? null : falhasDoRelatorio.length ? 0 : 1, unidade: '1 no horário com recibo, 0 fora',
         fonte: 'registro do relatório do arco', lacunas: lacunasDoRelatorio,
         evidencia: { vencimento, versao1: v1 ? { compostoEm: v1.em, paginas: paginasDaV1, recibos: recibos.size } : null, falhas: falhasDoRelatorio } });
+    // No v3, cinco medidas são a composição dos aceites completos de todas as máquinas. A ausência de uma fonte é lacuna,
+    // nunca zero. As demais já trazem em `evidencia.porMaquina` a divisão derivada do ramo conferido.
+    const porFonte = new Map([[maquinaAtual, medidas]]);
+    for (const outra of outras) {
+        if (porFonte.has(outra.resultado.maquina)) {
+            throw new RecusaDoAceite('noctum.aceite.outra-maquina-invalida', `${outra.fonte}: a máquina ${outra.resultado.maquina} apareceu mais de uma vez`);
+        }
+        porFonte.set(outra.resultado.maquina, outra.resultado.medidas);
+    }
+    if (multimaquina) {
+        const ausentes = conteudo.maquinas.map(m => m.nome).filter(m => !porFonte.has(m));
+        const combinadas = new Set(['M1', 'M3', 'M6', 'M8', 'M10']);
+        for (const medidaLocal of medidas.filter(m => combinadas.has(m.id))) {
+            const valores = Object.fromEntries(conteudo.maquinas.map(({ nome }) => [nome,
+                porFonte.get(nome)?.find(m => m.id === medidaLocal.id)?.valor ?? null]));
+            medidaLocal.evidencia = { ...medidaLocal.evidencia, porMaquina: valores };
+            if (ausentes.length) {
+                medidaLocal.valor = null;
+                medidaLocal.lacunas.push(`sem o aceite completo da(s) máquina(s): ${ausentes.join(', ')}`);
+            }
+            else if (Object.values(valores).some(v => v === null)) {
+                medidaLocal.valor = null;
+                medidaLocal.lacunas.push('ao menos uma máquina deixou a medida como lacuna');
+            }
+            else {
+                const vs = Object.values(valores);
+                medidaLocal.valor = medidaLocal.id === 'M1' ? Math.min(...vs) : medidaLocal.id === 'M10' ? (vs.every(v => v === 1) ? 1 : 0)
+                    : vs.reduce((a, b) => a + b, 0);
+            }
+        }
+    }
     // Os critérios.
-    const proposta = limiaresDaProposta(horasDaJanela);
+    const proposta = limiaresDaProposta(horasDaJanela, multimaquina);
     const doDono = opcoes.limiares ?? {};
     const limiar = (k) => doDono[k] !== undefined ? { valor: doDono[k], origem: 'dono' } : { valor: proposta[k], origem: 'proposta' };
     const m = (id) => medidas.find(x => x.id === id);
@@ -700,11 +831,17 @@ function aceiteDoPiloto(carregado, arco, opcoes = {}) {
         : 'sem revogação');
     const veredito = marcas.length ? 'simulado' : criterios.some(c => c.veredito === 'reprovado') ? 'reprovado'
         : criterios.some(c => c.veredito === 'incompleto') ? 'incompleto' : 'aprovado';
+    const maquinasDoResultado = [
+        { maquina: maquinaAtual, fonte: 'estado local', sha256: sha256(JSON.stringify({ arco, maquina: maquinaAtual, medidas })), veredito },
+        ...outras.map(o => ({ maquina: o.resultado.maquina, fonte: o.fonte, sha256: o.sha256, veredito: o.resultado.veredito })),
+    ];
     return {
         contrato: exports.CONTRATO_PILOTO, arco,
         envelope: { contrato: conteudo.contrato ?? null, versao: estado.versao, sha256: estado.envelopeSha256 },
         janela: { inicio: janela.inicio, fim: janela.fim, fuso: janela.fuso, horas: arred(horasDaJanela) },
         encerramento: estado.encerramento ? { motivo: estado.encerramento.motivo, em: estado.encerramento.em } : null,
+        maquina: maquinaAtual,
+        maquinas: maquinasDoResultado,
         simulacao: { simulado: marcas.length > 0, marcas },
         medidas, criterios, veredito,
         lacunas: medidas.flatMap(x => x.lacunas.map(l => `${x.id}: ${l}`)),
@@ -756,7 +893,7 @@ function publicavel(r, sha256DoCompleto, sensiveis) {
         return x;
     };
     const andar = (v) => typeof v === 'string' ? limpar(v) : Array.isArray(v) ? v.map(andar)
-        : objeto(v) ? Object.fromEntries(Object.entries(v).map(([k, x]) => [k, andar(x)])) : v;
+        : objeto(v) ? Object.fromEntries(Object.entries(v).map(([k, x]) => [limpar(k), andar(x)])) : v;
     return { ...andar(r), publicavel: true, sha256DoCompleto };
 }
 /** As contas, as máquinas e os repositórios que o arco conhece: o que o publicável troca por rótulos. */
@@ -768,6 +905,9 @@ function sensiveisDoArco(carregado, arco) {
     const repositorios = new Set();
     for (const c of conteudo?.orcamento.porConta ?? [])
         contas.add(c.conta);
+    if (conteudo && (0, noctum_envelope_1.envelopeMultimaquina)(conteudo))
+        for (const m of conteudo.maquinas)
+            maquinas.add(m.nome);
     for (const d of estado?.despachos ?? [])
         contas.add(d.conta);
     for (const d of conteudo?.destinos ?? []) {

package/dist/noctum-cli.js

@@ -41,6 +41,8 @@ exports.comandoNoctum = comandoNoctum;
  * RM-058, fatia N6 (D1, D12 e D13 da ork-rm058n6): o comando `ork noctum`, a porta do CLI para o arco.
  *
  *   ork noctum propor --arquivo <envelope.json> [--json]   o pedido de abertura vira proposta e pergunta ao dono; nada é autorizado
+ *   ork noctum maquina [--json]                            a entrada desta máquina em `maquinas` do envelope `v3`: o nome, a
+ *                                                          chave pública e a impressão (RM-058, bloco B, D5)
  *   ork noctum revogar <arco> [--json]                     a pergunta de revogação ao dono (RM-057); nada é revogado
  *   ork noctum responder <arco> --resposta-stdin ...       o envelope assinado do gateway (autorizar ou revogar)
  *   ork noctum terminal --hook-stdin                       o ingresso do terminal, que o hook UserPromptSubmit chama (RM-057);
@@ -57,6 +59,7 @@ exports.comandoNoctum = comandoNoctum;
  * aqui pelo `responder`, ou o diálogo nativo do host pelo MCP). Recusa tipada sai na saída de erro, com código 2.
  */
 const fs = __importStar(require("node:fs"));
+const node_crypto_1 = require("node:crypto");
 const fila_pesada_1 = require("./fila-pesada");
 const hitl_gates_1 = require("./hitl-gates");
 const hitl_public_receipt_1 = require("./hitl-public-receipt");
@@ -73,14 +76,17 @@ const noctum_modo_1 = require("./noctum-modo");
 const noctum_relatorio_1 = require("./noctum-relatorio");
 const noctum_registro_1 = require("./noctum-registro");
 const noctum_supervisao_1 = require("./noctum-supervisao");
+const noctum_transporte_1 = require("./noctum-transporte");
 const noctum_vigia_1 = require("./noctum-vigia");
+const maquina_1 = require("./maquina");
 const runtime_profiles_1 = require("./runtime-profiles");
 const noctum_terminal_1 = require("./noctum-terminal");
 const transporte_do_canal_1 = require("./transporte-do-canal");
-exports.USO_DO_NOCTUM = 'uso: ork noctum propor --arquivo <envelope.json> | revogar <arco> [--json] | responder <arco> --resposta-stdin ' +
+exports.USO_DO_NOCTUM = 'uso: ork noctum propor --arquivo <envelope.json> | maquina [--json] | revogar <arco> [--json] | ' +
+    'responder <arco> --resposta-stdin ' +
     '--origem O --canal C --por P --mensagem M [--conta X] | terminal --hook-stdin | status [<arco>] [--json] | tique <arco> [--json] | ' +
     'relatorio <arco> [--json] [--reenviar <canal>] | conduzir <arco> [--json] | aceite <arco> [--json] [--injecoes <arquivo>] ' +
-    '[--limiares <arquivo>] [--publicar <arquivo>]';
+    '[--limiares <arquivo>] [--outra-maquina <arquivo>[,<arquivo>]] [--publicar <arquivo>]';
 /** A linha da entrega da pergunta ao canal do dono, sem caminho de máquina. */
 function linhaDaEntrega(e) {
     if (e.entregue)
@@ -115,13 +121,31 @@ function lerEntradaDoHookStdin() {
 const TETO_DO_ARQUIVO_DO_ENVELOPE = 64 * 1024;
 const texto = (v) => typeof v === 'string' ? v : undefined;
 /**
- * Pré-voo informativo da proposta: antecipa três causas que fariam o arco esperar, mas não autoriza nem bloqueia nada.
- * As dependências opcionais deixam os testes usar perfis e trust simulados sem ler contas reais.
+ * RM-058, bloco B (D22): no `v3`, esta máquina só entra no arco se está em `maquinas` com o nome e a chave desta raiz,
+ * a mesma conferência do `euNaVersaoVigente`. O aviso só antecipa a recusa: a proposta segue.
+ */
+function avisosDaMaquina(maquinas, eu) {
+    const listada = maquinas.find(m => m.nome === eu.nome);
+    const correcao = 'rode ork noctum maquina --json nesta máquina e ponha a saída em maquinas do envelope';
+    if (!listada) {
+        return [{ motivo: 'noctum.proposta.maquina-ausente', correcao,
+                detalhe: `esta máquina (${eu.nome}) não está em maquinas do envelope v3: fica fora do arco, sem ordem, despacho nem entrega` }];
+    }
+    if (listada.chave === eu.chave)
+        return [];
+    return [{ motivo: 'noctum.proposta.maquina-outra-chave', correcao,
+            detalhe: `o envelope dá à máquina ${eu.nome} a chave de impressão ${(0, noctum_envelope_1.impressaoDaChave)(listada.chave)}, e a desta raiz é ` +
+                `${(0, noctum_envelope_1.impressaoDaChave)(eu.chave)}: a máquina fica fora do arco` }];
+}
+/**
+ * Pré-voo informativo da proposta: antecipa as causas que fariam o arco esperar, mas não autoriza nem bloqueia nada.
+ * As dependências opcionais deixam os testes usar perfis, trust e a identidade da máquina simulados sem ler contas reais.
  */
 function avisosDaProposta(carregado, conteudo, opcoes = {}) {
     if (!(0, noctum_envelope_1.envelopeComTrabalhos)(conteudo))
         return [];
-    const avisos = [];
+    const avisos = (0, noctum_envelope_1.envelopeMultimaquina)(conteudo)
+        ? avisosDaMaquina(conteudo.maquinas, (opcoes.identidade ?? (() => (0, noctum_transporte_1.identidadeDaMaquina)(carregado.raiz)))()) : [];
     let store = null;
     try {
         store = opcoes.store ?? (0, runtime_profiles_1.lerPerfisComContas)(carregado.raiz);
@@ -130,7 +154,7 @@ function avisosDaProposta(carregado, conteudo, opcoes = {}) {
         avisos.push({ motivo: 'noctum.proposta.contas-sem-leitura', detalhe: 'as contas do envelope não puderam ser conferidas',
             correcao: 'rode ork accounts check e proponha de novo depois de corrigir a leitura' });
     }
-    const confiar = opcoes.confianca ?? ((raiz, p) => (0, impedimento_1.impedimentoResolvido)('runtime.workspace-untrusted', { cwd: raiz, runtime: p.runtime, configDir: p.runtime === 'claude-bg' ? p.configDir : p.codexHome }));
+    const confiar = opcoes.confianca ?? ((raiz, p) => (0, impedimento_1.impedimentoResolvido)('runtime.workspace-untrusted', { cwd: raiz, runtime: p.runtime, configDir: (0, runtime_profiles_1.diretorioDoPerfil)(p) }));
     if (store) {
         for (const { conta } of conteudo.capacidade.porConta) {
             const p = store.perfis.find(x => x.id === conta);
@@ -267,9 +291,11 @@ function comandoNoctum(args) {
             const { raiz } = carregado;
             const quando = new Date().toISOString();
             const r = (0, noctum_arco_1.proporEnvelope)(raiz, pedido, quando, (0, pulse_resposta_1.codigosEmUso)(raiz));
-            const conteudo = (0, noctum_arco_1.lerArco)(raiz, r.arco)?.conteudo;
-            const fuso = conteudo?.janela.fuso ?? pedido?.janela?.fuso;
-            const avisos = conteudo ? avisosDaProposta(carregado, conteudo) : [];
+            // Os avisos olham o envelope que o dono vai autorizar, já validado pelo proporEnvelope: o vigente (lerArco) só
+            // existe depois da autorização, e na primeira proposta os avisos sumiam (RM-058, bloco B).
+            const proposto = (0, noctum_envelope_1.validarPedidoDeAbertura)(pedido);
+            const fuso = proposto.janela.fuso;
+            const avisos = avisosDaProposta(carregado, proposto);
             // RM-057 (resposta curta, D4 e D9): a proposta é a pergunta ao dono, que sai também pelo canal dele quando ele tem um.
             const q = r.codigo ? (0, noctum_arco_1.perguntasDoArco)(raiz, r.arco, quando).find(x => x.codigo === r.codigo && x.situacao === 'pendente') : undefined;
             const entrega = q ? (0, noctum_pergunta_canal_1.entregarPerguntaDoArco)(raiz, q, { quando }) : null;
@@ -288,6 +314,32 @@ function comandoNoctum(args) {
             }
             return 0;
         }
+        if (sub === 'maquina') {
+            // RM-058, bloco B (B4, D5): o que o dono copia de cada máquina para `maquinas` do envelope `v3`. O nome vem antes da
+            // chave: o recusado não cria a chave local. A chave privada nunca sai desta raiz.
+            if (args.posicionais.length !== 2) {
+                console.error(exports.USO_DO_NOCTUM);
+                return 2;
+            }
+            const { raiz } = (0, manifest_1.exigirManifesto)();
+            const nome = (0, maquina_1.nomeDaMaquina)();
+            if (!noctum_transporte_1.NOME_DE_MAQUINA.test(nome)) {
+                console.error(`noctum.maquina.nome-invalido: o nome desta máquina ("${nome}") não serve no envelope v3: letras, dígitos, ` +
+                    'ponto, _ ou -, até 64, começando por letra ou dígito. Correção: grave um nome válido em ~/.orkastery/maquina.json ' +
+                    '(o campo nome) ou defina ORK_MAQUINA em todo processo do ork desta máquina, o cron e os gateways inclusive');
+                return 2;
+            }
+            const { chave } = (0, noctum_transporte_1.identidadeDaMaquina)(raiz, nome);
+            const impressao = (0, noctum_envelope_1.impressaoDaChave)(chave);
+            if (json)
+                console.log(JSON.stringify({ nome, chave, impressao }, null, 2));
+            else {
+                console.log(['Esta máquina no envelope v3:', `  nome       ${nome}`, `  chave      ${chave}`, `  impressão  ${impressao}`, '',
+                    'A entrada para maquinas do envelope:', JSON.stringify({ nome, chave }), '',
+                    'A chave privada não sai desta raiz; o dono confere a impressão no resumo da proposta.'].join('\n'));
+            }
+            return 0;
+        }
         if (sub === 'revogar') {
             // RM-057 (resposta curta, D10): abre a pergunta de revogação e a entrega; quem revoga é a resposta do dono.
             const arco = args.posicionais[2];
@@ -443,17 +495,22 @@ function comandoNoctum(args) {
         if (sub === 'aceite') {
             const arco = args.posicionais[2];
             const arquivo = (nome) => args.opcoes[nome] === undefined ? null : texto(args.opcoes[nome]) ?? false;
-            const [injecoes, limiares, publicar] = [arquivo('injecoes'), arquivo('limiares'), arquivo('publicar')];
-            if (!arco || args.posicionais.length !== 3 || injecoes === false || limiares === false || publicar === false) {
+            const [injecoes, limiares, outraMaquina, publicar] = [arquivo('injecoes'), arquivo('limiares'), arquivo('outra-maquina'), arquivo('publicar')];
+            if (!arco || args.posicionais.length !== 3 || injecoes === false || limiares === false || outraMaquina === false || publicar === false) {
                 console.error(exports.USO_DO_NOCTUM);
                 return 2;
             }
             let agenda = null, doDono = null;
+            const outrasMaquinas = [];
             try {
                 if (injecoes)
                     agenda = (0, noctum_aceite_1.lerInjecoes)(fs.readFileSync(injecoes, 'utf8'));
                 if (limiares)
                     doDono = (0, noctum_aceite_1.lerLimiares)(JSON.parse(fs.readFileSync(limiares, 'utf8')));
+                for (const fonte of (outraMaquina ? outraMaquina.split(',') : []).map(x => x.trim()).filter(Boolean)) {
+                    const bruto = fs.readFileSync(fonte, 'utf8');
+                    outrasMaquinas.push({ fonte, sha256: (0, node_crypto_1.createHash)('sha256').update(bruto).digest('hex'), resultado: JSON.parse(bruto) });
+                }
             }
             catch (e) {
                 if (e instanceof noctum_aceite_1.RecusaDoAceite)
@@ -463,7 +520,7 @@ function comandoNoctum(args) {
             }
             const carregado = (0, manifest_1.exigirManifesto)();
             // RM-058, integração (T8, D12): o arquivo completo fica no estado; o publicável vai aonde o dono pedir.
-            const r = (0, noctum_aceite_1.aceiteDoPiloto)(carregado, arco, { injecoes: agenda, limiares: doDono });
+            const r = (0, noctum_aceite_1.aceiteDoPiloto)(carregado, arco, { injecoes: agenda, limiares: doDono, outrasMaquinas });
             const gravado = (0, noctum_aceite_1.gravarAceite)(carregado.raiz, r);
             if (publicar)
                 fs.writeFileSync(publicar, `${JSON.stringify((0, noctum_aceite_1.publicavel)(r, gravado.sha256, (0, noctum_aceite_1.sensiveisDoArco)(carregado, arco)), null, 2)}\n`);

package/dist/noctum-entrega.js

@@ -97,6 +97,8 @@ const ship_publicar_1 = require("./ship-publicar");
 const thread_1 = require("./thread");
 const verify_1 = require("./verify");
 const worktree_1 = require("./worktree");
+const noctum_integracao_1 = require("./noctum-integracao");
+const noctum_rede_1 = require("./noctum-rede");
 exports.CONTRATO_DA_ENTREGA = 'ork.noctum-entrega/v1';
 /** D2: quantas vezes o arco despacha o CHECK independente de um trabalho antes de bloquear. */
 exports.LIMITE_DE_REVISOES = 4;
@@ -374,8 +376,15 @@ function passoDaEntrega(carregado, arco, opcoes = {}) {
     }
     if (sup.parada)
         return { acao: 'nada', motivo: 'arco-encerrado', detalhe: `a supervisão parou o arco (${sup.parada.motivo}): nenhum efeito novo` };
+    const multimaquina = (0, noctum_envelope_1.envelopeMultimaquina)(conteudo);
+    const rede = multimaquina ? opcoes.projecaoDaRede ?? (0, noctum_rede_1.lerRede)(carregado, arco, { quando, maquina: opcoes.maquina, remoto, rede: opcoes.redeDaCoordenacao }) : null;
+    if (rede?.lacuna) {
+        return { acao: 'aguardar', trabalho: null, thread: null, motivo: rede.lacuna.motivo, detalhe: rede.lacuna.detalhe,
+            ate: depoisDe(quando, exports.ESPERA_DO_CI_MS) };
+    }
+    const coordenacao = rede ? (0, noctum_rede_1.coordenacaoDaFila)(rede) : null;
     const fila = (0, noctum_fila_1.montarFila)((0, noctum_fila_1.fatosDaFila)(carregado, arco, { quando, maquina: opcoes.maquina, lerReservas: opcoes.lerReservas,
-        supervisao: decisoesDaEntrega(sup) }));
+        ...(coordenacao ? { coordenacao } : {}), supervisao: decisoesDaEntrega(sup) }));
     const naEntrega = fila.trabalhos.filter(t => t.thread && (t.estado === 'aguardando-entrega' || t.estado === 'entregue'))
         .sort((a, b) => a.prioridade - b.prioridade || a.posicao - b.posicao);
     if (!naEntrega.length)
@@ -392,11 +401,14 @@ function passoDaEntrega(carregado, arco, opcoes = {}) {
                 detalhe: `o trabalho ${trabalho.id} foi isolado pela supervisão (${isoladoDepois.motivo}): ${isoladoDepois.detalhe}` });
             continue;
         }
-        // D9: com outro contrato (a v3 da N3), a integração é da vez entre máquinas; aqui nada se decide por ela.
-        if (conteudo.contrato !== noctum_envelope_1.CONTRATO_ENVELOPE_V2) {
-            bloqueios.push({ trabalho: trabalho.id, thread: trabalho.thread, motivo: 'noctum.entrega.exige-vez-da-n3',
-                detalhe: `o envelope ${conteudo.contrato} integra pela vez entre máquinas (integrarComVez da N3), com integradorDaEntrega` });
-            continue;
+        if (multimaquina && rede?.trabalhos.find(t => t.id === trabalho.id)?.estado === 'entregue') {
+            let entregueAqui = false;
+            try {
+                entregueAqui = (0, ledger_1.lerLedger)((0, thread_1.dirThread)(carregado.raiz, trabalho.thread)).some(e => e.tipo === ledger_1.TIPOS_DE_EVENTO.shipConcluido);
+            }
+            catch { /* a leitura normal abaixo dará a lacuna se este trabalho ainda couber aqui */ }
+            if (!entregueAqui)
+                continue;
         }
         let lido;
         try {
@@ -421,7 +433,41 @@ function passoDaEntrega(carregado, arco, opcoes = {}) {
             bloqueios.push({ ...ids, motivo: decisao.motivo, detalhe: decisao.porque });
             continue;
         }
-        const { resultado, efeito } = executar(carregado, arco, estado, trabalho, lido, decisao.acao, opcoes, remoto, quando);
+        let executado;
+        if (multimaquina && decisao.acao === 'integrar') {
+            const ordem = coordenacao?.ordens?.get(trabalho.id);
+            const candidato = lido.entrada.provas ? candidatoDaEntrega(lido.entrada.provas) : null;
+            if (!ordem || !candidato || !lido.destino) {
+                bloqueios.push({ trabalho: trabalho.id, thread: trabalho.thread, motivo: 'noctum.coordenacao.ordem-vencida',
+                    detalhe: `o trabalho ${trabalho.id} não tem ordem aceita desta máquina e candidato provado para a vez` });
+                continue;
+            }
+            try {
+                const feita = (opcoes.integrarPelaRede ?? noctum_integracao_1.integrarComVez)(carregado, arco, { ordem: ordem.ordem,
+                    destino: { repositorio: lido.destino.repositorio, base: lido.destino.base }, candidato }, integradorDaEntrega(carregado, arco, lido.t.id, opcoes), { quando, maquina: opcoes.maquina, remoto, rede: opcoes.redeDaCoordenacao });
+                executado = { resultado: { acao: 'integrou', trabalho: trabalho.id, thread: lido.t.id, mergeSha: feita.merge,
+                        pontaDaBase: feita.merge, docs: null, provas: candidato.provas }, efeito: true };
+            }
+            catch (e) {
+                if (!(e instanceof noctum_envelope_1.RecusaDoArco))
+                    throw e;
+                const ids = { trabalho: trabalho.id, thread: lido.t.id };
+                if (['noctum.integracao.ja-entregue', 'noctum.coordenacao.ordem-vencida'].includes(e.motivo)) {
+                    executado = { resultado: { acao: 'nada', motivo: 'sem-entrega', detalhe: e.message }, efeito: false };
+                }
+                else if (e.motivo === 'noctum.integracao.base-nao-provada') {
+                    executado = { resultado: { acao: 'bloqueado', ...ids, motivo: e.motivo, detalhe: e.message, outros: [] }, efeito: false };
+                }
+                else {
+                    executado = { resultado: { acao: 'aguardar', ...ids, motivo: e.motivo, detalhe: e.message,
+                            ate: depoisDe(quando, exports.ESPERA_DO_CI_MS) }, efeito: false };
+                }
+            }
+        }
+        else {
+            executado = executar(carregado, arco, estado, trabalho, lido, decisao.acao, opcoes, remoto, quando);
+        }
+        const { resultado, efeito } = executado;
         // Um efeito por chamada (A1 da rodada 1): o efeito feito, ou de resultado incerto, encerra o passo; a recusa de antes de
         // qualquer efeito deixa o trabalho seguinte tentar, e o trabalho travado não prende a fila.
         if (efeito)
@@ -434,6 +480,8 @@ function passoDaEntrega(carregado, arco, opcoes = {}) {
             bloqueios.push({ trabalho: resultado.trabalho, thread: resultado.thread, motivo: resultado.motivo, detalhe: resultado.detalhe });
             continue;
         }
+        if (resultado.acao === 'nada')
+            continue;
         return resultado;
     }
     if (espera)

package/dist/noctum-envelope.js

@@ -377,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])]) {

package/dist/noctum-execucao.js

@@ -326,7 +326,11 @@ function despacharCandidato(carregado, arco, fila, c, opcoes) {
             if (!c.pedido)
                 return { ...recusar('noctum.despacho.pedido-ausente', `o trabalho ${c.trabalho} não traz pedido para abrir a thread`, null), seguir: true };
             // RM-037 (CHECK 3 da ork-rm037defeit2): sob a trava de despacho, o preparo das dependências só fica pendente.
-            thread = (opcoes.abrirThread ?? ((k, o) => (0, thread_1.novaThread)(k, o).thread))(carregado, { nome: `${c.item.toLowerCase()} ${c.trabalho}`,
+            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);