@orkastery/cli 0.6.0 → 0.6.2

package/dist/noctum-fechamento.js

@@ -48,6 +48,7 @@ const master_1 = require("./master");
 const noctum_arco_1 = require("./noctum-arco");
 const noctum_envelope_1 = require("./noctum-envelope");
 const noctum_fila_1 = require("./noctum-fila");
+const noctum_rede_1 = require("./noctum-rede");
 const noctum_medicao_1 = require("./noctum-medicao");
 const noctum_registro_1 = require("./noctum-registro");
 const noctum_supervisao_1 = require("./noctum-supervisao");
@@ -115,8 +116,6 @@ function condicaoDeFechamento(estado, fila, medicao, quando, emVoo = 0, parada =
  * a thread aberta e sem MASTER ratificado. A thread que não se lê não segura o fechamento: a fila já a mostra.
  */
 function mastersDevidos(raiz, estado, fila, sup) {
-    if (estado.conteudo?.contrato !== noctum_envelope_1.CONTRATO_ENVELOPE_V2)
-        return [];
     const devidos = [];
     for (const t of fila.trabalhos) {
         if (t.estado !== 'entregue' || !t.thread || sup.isolados.has(t.id))
@@ -219,7 +218,10 @@ function gravarRetrato(carregado, arco, estado, encerramento, quando, o) {
     const { raiz } = carregado;
     let trabalhosDaFila = null;
     try {
-        trabalhosDaFila = trabalhosDoArco((0, noctum_fila_1.fatosDaFila)(carregado, arco, { quando, maquina: o.maquina, lerReservas: o.lerReservas }));
+        const rede = estado.conteudo && (0, noctum_envelope_1.envelopeMultimaquina)(estado.conteudo)
+            ? o.projecaoDaRede ?? (0, noctum_rede_1.lerRede)(carregado, arco, { quando, maquina: o.maquina, remoto: o.remoto, rede: o.redeDaCoordenacao }) : null;
+        const coordenacao = rede ? (0, noctum_rede_1.coordenacaoDaFila)(rede) : null;
+        trabalhosDaFila = rede?.lacuna ? null : trabalhosDoArco((0, noctum_fila_1.fatosDaFila)(carregado, arco, { quando, maquina: o.maquina, lerReservas: o.lerReservas, ...(coordenacao ? { coordenacao } : {}) }));
     }
     catch (e) {
         if (!(e instanceof noctum_envelope_1.RecusaDoArco))
@@ -286,6 +288,14 @@ function fecharSeDevido(carregado, arco, opcoes = {}) {
     let agora = false;
     if (!estado.encerramento) {
         const emVooAgora = (0, noctum_sessoes_em_voo_1.sessoesEmVooDoArco)(raiz, estado).length;
+        const multimaquina = (0, noctum_envelope_1.envelopeMultimaquina)(estado.conteudo);
+        const rede = multimaquina
+            ? opcoes.projecaoDaRede ?? (0, noctum_rede_1.lerRede)(carregado, arco, { quando, maquina: opcoes.maquina, remoto: opcoes.remoto, rede: opcoes.redeDaCoordenacao })
+            : null;
+        // Com rede íntegra, o teto em sessões é global. Sem leitura, o consumo local ainda pode provar sozinho que o teto caiu.
+        const estadoDoCusto = rede && !rede.lacuna
+            ? { ...estado, consumo: { ...estado.consumo, arco: rede.consumo.arco } }
+            : estado;
         // RM-058, integração (D7): a parada da supervisão; o log dela que não se lê não segura o fechamento pelas outras condições.
         let sup = null;
         try {
@@ -297,19 +307,20 @@ function fecharSeDevido(carregado, arco, opcoes = {}) {
         }
         const parada = sup?.parada ?? null;
         // Revogado, hora, a parada e o teto em sessões vêm primeiro e sem a fila nem a medição: nenhuma falha delas segura esse fechamento.
-        let condicao = condicaoDeFechamento(estado, null, null, quando, emVooAgora, parada);
+        let condicao = condicaoDeFechamento(estadoDoCusto, null, null, quando, emVooAgora, parada);
         let falhaDaMedicao = '';
         if (!condicao) {
             let fila = null;
             try {
-                fila = (0, noctum_fila_1.montarFila)((0, noctum_fila_1.fatosDaFila)(carregado, arco, { quando, maquina: opcoes.maquina, lerReservas: opcoes.lerReservas }));
+                const coordenacao = rede ? (0, noctum_rede_1.coordenacaoDaFila)(rede) : null;
+                fila = rede?.lacuna ? null : (0, noctum_fila_1.montarFila)((0, noctum_fila_1.fatosDaFila)(carregado, arco, { quando, maquina: opcoes.maquina, lerReservas: opcoes.lerReservas, ...(coordenacao ? { coordenacao } : {}) }));
             }
             catch (e) {
                 if (!(e instanceof noctum_envelope_1.RecusaDoArco))
                     throw e;
             }
             let medicao = null;
-            if (estado.conteudo.orcamento.arco.unidade !== 'sessoes') {
+            if (estado.conteudo.orcamento.arco.unidade !== 'sessoes' && !rede?.lacuna) {
                 // A medição que falha não prova o teto alcançado: o custo não fecha, e a fila vazia ainda pode fechar.
                 try {
                     medicao = medir(raiz, estado, quando);
@@ -318,7 +329,7 @@ function fecharSeDevido(carregado, arco, opcoes = {}) {
                     falhaDaMedicao = `; a medição falhou (${e.message.slice(0, 200)})`;
                 }
             }
-            condicao = condicaoDeFechamento(estado, fila, medicao, quando, emVooAgora, parada);
+            condicao = condicaoDeFechamento(estadoDoCusto, fila, medicao, quando, emVooAgora, parada);
             // RM-058, integração (T4, D8): a fila vazia não fecha o arco por cima do MASTER por omissão que a entrega dele ainda
             // deve; o passo seguinte o faz, e o fechamento vem depois. A hora, a parada e o teto fecharam antes, sem esperar.
             const devidos = condicao?.motivo === 'fila-vazia' && fila && sup ? mastersDevidos(raiz, estado, fila, sup) : [];

package/dist/noctum-fila.js

@@ -81,6 +81,9 @@ function classificar(t, posicao, f, fatos, entregues, semSaida, estado) {
     if (fatos.coordenacao?.encerrados?.has(t.id)) {
         return { ...base, thread: f?.threads[0]?.id ?? null, estado: 'encerrado-sem-entrega', detalhe: 'encerrado sem entrega em outra máquina do arco' };
     }
+    if ((0, noctum_envelope_1.envelopeMultimaquina)(estado.conteudo) && fatos.coordenacao?.emOutraMaquina?.has(t.id)) {
+        return bloqueado('em-outra-maquina', 'o trabalho tem ordem viva em outra máquina do arco');
+    }
     if (!f)
         return bloqueado('thread-ilegivel', 'o trabalho não foi lido');
     if (f.ilegivel)
@@ -278,7 +281,9 @@ function fatosDaFila(carregado, arco, opcoes = {}) {
         }
         else {
             const alvo = (0, noctum_envelope_1.shaDoPedido)(t.pedido);
-            casam = threads.filter(x => x.roadmap === t.item && x.pedido?.sha256 === alvo);
+            const ordem = opcoes.coordenacao?.ordens?.get(t.id);
+            casam = threads.filter(x => x.roadmap === t.item && x.pedido?.sha256 === alvo &&
+                (!ordem || x.assunto.endsWith(`o${ordem.numero}`)));
             // Sem casar e com thread ilegível, ela pode ser a do trabalho: abrir outra duplicaria a thread.
             if (!casam.length && fatos.threadsIlegiveis.length)
                 ilegivel = fatos.threadsIlegiveis[0];

package/dist/noctum-guarda.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.pedidoDoArco = exports.linhaDoArco = exports.MOTIVO_DO_ARCO_ILEGIVEL = exports.MOTIVO_DA_GUARDA = void 0;
+exports.pedidoDoArco = exports.linhaDoArco = exports.MOTIVO_DA_REDE_ILEGIVEL = exports.MOTIVO_DO_ARCO_ILEGIVEL = exports.MOTIVO_DA_GUARDA = void 0;
 exports.lerArcosDaRaiz = lerArcosDaRaiz;
 exports.arcoDosEventos = arcoDosEventos;
 exports.arcoDoUltimoDespacho = arcoDoUltimoDespacho;
@@ -70,12 +70,14 @@ const path = __importStar(require("node:path"));
 const estado_thread_1 = require("./estado-thread");
 const ledger_1 = require("./ledger");
 const locale_1 = require("./locale");
+const manifest_1 = require("./manifest");
 const noctum_arco_1 = require("./noctum-arco");
 const noctum_sessoes_em_voo_1 = require("./noctum-sessoes-em-voo");
 const noctum_envelope_1 = require("./noctum-envelope");
 const thread_1 = require("./thread");
 exports.MOTIVO_DA_GUARDA = 'noctum.guarda.thread-do-arco';
 exports.MOTIVO_DO_ARCO_ILEGIVEL = 'noctum.guarda.arco-ilegivel';
+exports.MOTIVO_DA_REDE_ILEGIVEL = 'noctum.guarda.rede-ilegivel';
 /** A recusa com os três textos do catálogo, cada um remontável no locale de quem imprime. */
 function recusa(motivo, thread, arco, situacao, origem, detalhe, correcao) {
     return { motivo, thread, arco, situacao, origem, detalhe: (0, locale_1.textoDoCatalogo)(detalhe), correcao: (0, locale_1.textoDoCatalogo)(correcao),
@@ -92,7 +94,7 @@ function nomesDosArcos(raiz) {
 }
 /** Lê cada arco desta raiz uma vez. O arco que não se lê fica com o motivo, e os outros seguem. */
 function lerArcosDaRaiz(raiz, quando = new Date().toISOString()) {
-    const arcos = { quando, lidos: new Map(), ilegiveis: new Map() };
+    const arcos = { quando, lidos: new Map(), ilegiveis: new Map(), redes: new Map(), redesIlegiveis: new Map() };
     for (const arco of nomesDosArcos(raiz)) {
         try {
             const lido = (0, noctum_arco_1.lerArcoComProposta)(raiz, arco, quando);
@@ -127,8 +129,51 @@ function arcoDoUltimoDespacho(raiz, thread) {
 }
 /** A thread está na lista? A fixada no trabalho, ou a que casa com o item e o sha256 do pedido dele. */
 function naLista(conteudo, thread, dados) {
-    return !!conteudo?.trabalhos?.some(w => w.thread !== undefined ? w.thread === thread
-        : w.pedido !== undefined && dados().roadmap === w.item && dados().pedido === (0, noctum_envelope_1.shaDoPedido)(w.pedido));
+    return !!trabalhoNaLista(conteudo, thread, dados);
+}
+/** O trabalho da thread na lista, pela fixação ou pelo pedido, quando existe. */
+function trabalhoNaLista(conteudo, thread, dados) {
+    return conteudo?.trabalhos?.find(w => w.thread !== undefined ? w.thread === thread
+        : w.pedido !== undefined && dados().roadmap === w.item && dados().pedido === (0, noctum_envelope_1.shaDoPedido)(w.pedido)) ?? null;
+}
+/** O id do trabalho que liga esta thread ao arco, na lista vigente ou no despacho mais recente. */
+function trabalhoDaThread(estado, thread, dados) {
+    const listado = trabalhoNaLista(estado.conteudo, thread, dados);
+    if (listado)
+        return listado.id;
+    for (let i = estado.despachos.length - 1; i >= 0; i--) {
+        const d = estado.despachos[i];
+        if (d.thread === thread || d.threadDespachada === thread)
+            return d.trabalho;
+    }
+    return null;
+}
+/** A rede do arco, uma vez por `ArcosDaRaiz`; falha inesperada também fica cacheada e falha fechada. */
+function redeDoArco(arco, arcos, ler) {
+    const pronta = arcos.redes.get(arco);
+    if (pronta)
+        return pronta;
+    const falha = arcos.redesIlegiveis.get(arco);
+    if (falha !== undefined)
+        return falha;
+    try {
+        const rede = ler(arco);
+        arcos.redes.set(arco, rede);
+        return rede;
+    }
+    catch (e) {
+        const detalhe = (e instanceof Error ? e.message : String(e)).split('\n')[0].slice(0, 200);
+        arcos.redesIlegiveis.set(arco, detalhe);
+        return detalhe;
+    }
+}
+/**
+ * A fila carrega a Sentinela, que carrega esta guarda. Resolver a projeção só quando uma thread de arco v3 encerrado
+ * realmente precisar dela evita o ciclo de inicialização fila -> guarda -> rede -> coordenação -> fila.
+ */
+function lerRedePadrao(raiz, arco, quando) {
+    const { lerRede } = require('./noctum-rede');
+    return lerRede((0, manifest_1.exigirManifesto)(raiz), arco, { quando });
 }
 /**
  * Os vínculos da thread com os arcos lidos, um por arco, na ordem das origens: a lista do envelope vigente, a da proposta
@@ -183,6 +228,38 @@ function guardaDaThread(raiz, thread, quando = new Date().toISOString(), opcoes
     const vinculos = vinculosDaThread(raiz, arcos, thread, ultimo);
     const v = vinculos.find(x => x.arco !== opcoes.doArco && guardaOsCaminhosManuais(x));
     if (!v) {
+        let dadosLidos = null;
+        const dados = () => {
+            if (dadosLidos)
+                return dadosLidos;
+            try {
+                const t = (0, thread_1.lerThread)(raiz, thread);
+                dadosLidos = { roadmap: t.roadmap ?? null, pedido: t.pedido?.sha256 ?? null };
+            }
+            catch {
+                dadosLidos = { roadmap: null, pedido: null };
+            }
+            return dadosLidos;
+        };
+        // Num v3 encerrado localmente, o trabalho pode seguir em outra máquina. A rede só é lida depois de provar o vínculo,
+        // e a leitura fica no `ArcosDaRaiz` para o registrar-pr --todas não consultar o mesmo arco de novo.
+        for (const t of vinculos.filter(x => x.arco !== opcoes.doArco && x.situacao === 'encerrado')) {
+            const lido = arcos.lidos.get(t.arco);
+            if (!lido?.estado.conteudo || !(0, noctum_envelope_1.envelopeMultimaquina)(lido.estado.conteudo))
+                continue;
+            const trabalho = trabalhoDaThread(lido.estado, thread, dados);
+            if (!trabalho)
+                continue;
+            const rede = redeDoArco(t.arco, arcos, opcoes.lerRede ?? ((arco) => lerRedePadrao(raiz, arco, arcos.quando)));
+            if (typeof rede === 'string' || rede.lacuna) {
+                const falha = typeof rede === 'string' ? rede : `${rede.lacuna.motivo}: ${rede.lacuna.detalhe}`;
+                return recusa(exports.MOTIVO_DA_REDE_ILEGIVEL, thread, t.arco, t.situacao, 'rede', (m) => m.ship.guarda.redeIlegivel(thread, t.arco, falha), (m) => m.ship.guarda.redeIlegivelCorrecao(t.arco));
+            }
+            const naRede = rede.trabalhos.find(x => x.id === trabalho);
+            if (!rede.revogada && naRede && naRede.estado !== 'entregue' && naRede.estado !== 'encerrado') {
+                return recusa(exports.MOTIVO_DA_GUARDA, thread, t.arco, t.situacao, 'rede', (m) => m.ship.guarda.redeDoArco(thread, t.arco, naRede.estado, trabalho), (m) => m.ship.guarda.redeDoArcoCorrecao(t.arco));
+            }
+        }
         // A2 do CHECK: no arco que terminou (revogado, expirado ou encerrado), a sessão que ele despachou e que ainda conduz a
         // thread não entrega fora dele; sem sessão dele em voo, a thread se entrega à mão, como antes.
         for (const t of vinculos.filter(x => x.arco !== opcoes.doArco && TERMINAIS.includes(x.situacao))) {

package/dist/noctum-maquinas.js

@@ -351,6 +351,9 @@ function passoDaMaquina(carregado, arco, opcoes = {}) {
         const perfisDaN2 = opcoes.n2?.perfis ?? (() => perfisDoStore(raiz, Date.parse(quando)));
         // 4. O passo da N2, só com o que o ramo deu a esta máquina, e a vaga global no gancho da reserva da coordenação.
         const ordemDoTrabalho = new Map(minhas.filter(o => permitidos.has(o.trabalho)).map(o => [o.trabalho, o.ordem]));
+        const ordensDaFila = new Map(minhas.filter(o => permitidos.has(o.trabalho)).map(o => [o.trabalho, { ordem: o.ordem, numero: o.n }]));
+        const emOutraMaquina = new Set([...estado.ordens.values()]
+            .filter(o => o.maquina !== eu && (0, noctum_coordenacao_1.ordemViva)(o)).map(o => o.trabalho));
         const reservar = (raizDoPasso, pedido, q) => {
             const ordem = ordemDoTrabalho.get(pedido.trabalho);
             if (!ordem)
@@ -369,7 +372,8 @@ function passoDaMaquina(carregado, arco, opcoes = {}) {
         const passo = (0, noctum_execucao_1.passoDoArco)(carregado, arco, { ...opcoes.n2, quando, maquina: opcoes.maquina,
             perfis: () => perfisDaN2().filter(p => !semVaga.has(p.id)),
             lerReservas: () => ({ leitura: 'copia-local', reservas: reservadas.map(x => ({ item: x.item, maquina: eu, thread: x.thread })) }),
-            coordenacao: { trabalhos: permitidos, entregues: (0, noctum_coordenacao_1.entreguesNaRede)(estado), encerrados: (0, noctum_coordenacao_1.encerradosNaRede)(estado), reservar } });
+            coordenacao: { trabalhos: permitidos, entregues: (0, noctum_coordenacao_1.entreguesNaRede)(estado), encerrados: (0, noctum_coordenacao_1.encerradosNaRede)(estado),
+                emOutraMaquina, ordens: ordensDaFila, reservar } });
         return { acao: 'passo', passo, relatorio };
     }
     catch (e) {

package/dist/noctum-modo.js

@@ -79,6 +79,7 @@ const noctum_relatorio_1 = require("./noctum-relatorio");
 const noctum_registro_1 = require("./noctum-registro");
 const noctum_supervisao_1 = require("./noctum-supervisao");
 const noctum_vigia_1 = require("./noctum-vigia");
+const noctum_rede_1 = require("./noctum-rede");
 exports.CONTRATO_INGRESSO_DO_ARCO = 'ork.noctum-ingresso/v1';
 exports.CONTRATO_RETRATO_DO_ARCO = 'ork.noctum-retrato/v1';
 exports.CONTRATO_TIQUE = 'ork.noctum-tique/v1';
@@ -175,18 +176,25 @@ function retratoDoArco(carregado, arco, opcoes = {}) {
         return null;
     const lacunas = [];
     const conteudo = estado.conteudo;
+    const rede = conteudo && (0, noctum_envelope_1.envelopeMultimaquina)(conteudo) ? opcoes.projecaoDaRede ?? (0, noctum_rede_1.lerRede)(carregado, arco, { quando, maquina: opcoes.maquina, remoto: opcoes.remoto, rede: opcoes.redeDaCoordenacao }) : null;
+    if (rede?.lacuna)
+        lacunas.push(`a rede do arco não pôde ser lida (${rede.lacuna.motivo}: ${rede.lacuna.detalhe})`);
     let consumo = [];
     let fila = null;
     if (conteudo && estado.autorizadoPor) {
         // As unidades dos tetos só: com todos em sessões, nenhuma transcrição nem rollout é lido para o retrato.
-        const medicao = (0, noctum_relatorio_1.medidorDoRelatorio)(opcoes, conteudo)(raiz, estado, quando);
+        const estadoDoCusto = rede && !rede.lacuna ? { ...estado, consumo: { ...estado.consumo, arco: rede.consumo.arco } } : estado;
+        const medicao = (0, noctum_relatorio_1.medidorDoRelatorio)(opcoes, conteudo)(raiz, estadoDoCusto, quando);
         const o = conteudo.orcamento;
         const linha = (escopo, unidade, teto, c) => ({ escopo, unidade, teto, texto: (0, noctum_medicao_1.textoDoConsumo)(c), valor: c.valor });
         consumo = [linha('do arco', o.arco.unidade, o.arco.valor, (0, noctum_medicao_1.consumoDoEscopoNaUnidade)(medicao, 'arco', o.arco.unidade)),
             ...o.porConta.map(s => linha(`da conta ${s.conta}`, s.teto.unidade, s.teto.valor, (0, noctum_medicao_1.consumoDoEscopoNaUnidade)(medicao, { conta: s.conta }, s.teto.unidade))),
             ...o.porRuntime.map(s => linha(`do runtime ${s.runtime}`, s.teto.unidade, s.teto.valor, (0, noctum_medicao_1.consumoDoEscopoNaUnidade)(medicao, { runtime: s.runtime }, s.teto.unidade)))];
         try {
-            const f = (0, noctum_fechamento_1.trabalhosDoArco)((0, noctum_fila_1.fatosDaFila)(carregado, arco, { quando, maquina: opcoes.maquina, lerReservas: opcoes.lerReservas }));
+            const coordenacao = rede ? (0, noctum_rede_1.coordenacaoDaFila)(rede) : null;
+            if (rede?.lacuna)
+                throw new noctum_envelope_1.RecusaDoArco(rede.lacuna.motivo, rede.lacuna.detalhe);
+            const f = (0, noctum_fechamento_1.trabalhosDoArco)((0, noctum_fila_1.fatosDaFila)(carregado, arco, { quando, maquina: opcoes.maquina, lerReservas: opcoes.lerReservas, ...(coordenacao ? { coordenacao } : {}) }));
             fila = { situacao: f.situacao, trabalhos: f.trabalhos.map(t => ({ id: t.id, item: t.item, thread: t.thread, estado: t.estado, fase: t.fase,
                     motivo: t.motivo })) };
             lacunas.push(...f.lacunas);
@@ -224,7 +232,8 @@ function retratoDoArco(carregado, arco, opcoes = {}) {
     }
     return { contrato: exports.CONTRATO_RETRATO_DO_ARCO, arco, quando, situacao: estado.situacao, versao: estado.versao, envelopeSha256: estado.envelopeSha256,
         janela: conteudo ? { inicio: conteudo.janela.inicio, fim: conteudo.janela.fim, fuso: conteudo.janela.fuso } : null,
-        propostaPendente: estado.propostaPendente, consumo, fila, fechamento, relatorio, supervisao, decisoesPendentes: estado.decisoes.length, lacunas };
+        propostaPendente: estado.propostaPendente, consumo, fila, ...(rede ? { rede } : {}), fechamento, relatorio, supervisao,
+        decisoesPendentes: estado.decisoes.length, lacunas };
 }
 /** O retrato em texto para pessoa, em pt-BR, com os horários no fuso da janela. */
 function textoDoRetrato(r) {
@@ -243,6 +252,13 @@ function textoDoRetrato(r) {
         l.push(`Fila: ${r.fila.situacao}`, ...r.fila.trabalhos.map(t => `  • ${t.id} (${t.item}): ${t.estado}${t.fase ? `, fase ${t.fase}` : ''}` +
             `${t.thread ? `, thread ${t.thread}` : ''}${t.motivo ? ` (${t.motivo})` : ''}`));
     }
+    if (r.rede) {
+        if (r.rede.lacuna)
+            l.push(`Rede: sem leitura (${r.rede.lacuna.motivo}: ${r.rede.lacuna.detalhe})`);
+        else
+            l.push(`Rede: autoridade ${r.rede.autoridade?.maquina ?? 'ainda não assumida'}; máquina desta composição ${r.rede.maquina}`, ...r.rede.maquinas.map(m => `  • ${m.nome}: último sinal ${m.ultimoSinal ? formatarNoFuso(m.ultimoSinal) : 'ausente'}, ` +
+                `${m.ordensVivas.length} ordem(ns), ${m.vagasAtivas.length} vaga(s), consumo ${m.consumo}`));
+    }
     if (r.fechamento) {
         l.push(`Fechamento: ${r.fechamento.motivo} em ${formatarNoFuso(r.fechamento.em)}: ${r.fechamento.detalhe}`, ...r.fechamento.paradas.map(p => `  • ${p}`));
     }
@@ -267,11 +283,17 @@ function textoDoRetrato(r) {
  * vencimento) acabada, quando o relatório não tenta mais (A3 do CHECK: o canal sem transporte, o terminal nunca mostrado).
  * O vigia não roda mais, e o log dele não cresce.
  */
-function terminalQuieto(carregado, arco, estado, quando) {
+function terminalQuieto(carregado, arco, estado, quando, rede) {
     if (!['expirado', 'revogado', 'encerrado'].includes(estado.situacao))
         return false;
     if (estado.despachos.some(d => d.desfecho === 'pendente'))
         return false;
+    if (estado.conteudo && (0, noctum_envelope_1.envelopeMultimaquina)(estado.conteudo)) {
+        if (!rede || rede.lacuna)
+            return false;
+        if (rede.obrigacoes.ordens.length || rede.obrigacoes.vagas.length || rede.obrigacoes.vezes.length)
+            return false;
+    }
     try {
         const r = (0, noctum_relatorio_1.retratoDoRelatorio)(carregado.raiz, arco, estado.conteudo, quando);
         if (r.versoes.at(-1)?.entregue === true)
@@ -299,8 +321,11 @@ function tiqueDoArco(carregado, arco, opcoes = {}) {
     if (!estado?.autorizadoPor) {
         throw new noctum_envelope_1.RecusaDoArco('noctum.modo.sem-envelope', `o arco ${arco} nunca foi autorizado pelo dono: o #Noctum não vale; ${COMO_ABRIR}`);
     }
+    const rede = estado.conteudo && (0, noctum_envelope_1.envelopeMultimaquina)(estado.conteudo)
+        ? opcoes.projecaoDaRede ?? (0, noctum_rede_1.lerRede)(carregado, arco, { quando, maquina: opcoes.maquina, remoto: opcoes.remoto, rede: opcoes.redeDaCoordenacao }) : null;
     const deFechamento = { quando, maquina: opcoes.maquina, lerReservas: opcoes.lerReservas, medir: opcoes.medir,
-        parar: opcoes.parar, listarSessoes: opcoes.listarSessoes, git: opcoes.git };
+        parar: opcoes.parar, listarSessoes: opcoes.listarSessoes, git: opcoes.git, projecaoDaRede: rede ?? undefined,
+        remoto: opcoes.remoto, redeDaCoordenacao: opcoes.redeDaCoordenacao };
     const falhas = [];
     let erro = null;
     const isolada = (etapa, fn) => {
@@ -338,8 +363,10 @@ function tiqueDoArco(carregado, arco, opcoes = {}) {
                 fechamento = isolada('fechamento', () => (0, noctum_fechamento_1.fecharSeDevido)(carregado, arco, deFechamento)) ?? queFalhou();
         }
     }
-    else if (agora && agora.situacao !== 'agendado' && !terminalQuieto(carregado, arco, agora, quando)) {
+    else if (agora && agora.situacao !== 'agendado' && !terminalQuieto(carregado, arco, agora, quando, rede)) {
         const deVigia = { ...opcoes.opcoesDoVigia, quando, maquina: opcoes.maquina ?? opcoes.opcoesDoVigia?.maquina,
+            coordenacao: { remoto: opcoes.remoto ?? opcoes.opcoesDoVigia?.coordenacao?.remoto,
+                rede: opcoes.redeDaCoordenacao ?? opcoes.opcoesDoVigia?.coordenacao?.rede },
             passo: { maquina: opcoes.maquina, lerReservas: opcoes.lerReservas, ...opcoes.opcoesDoPasso, ...opcoes.opcoesDoVigia?.passo } };
         vigia = isolada('vigia', () => (opcoes.vigia ?? noctum_vigia_1.vigiarArco)(carregado, arco, deVigia));
         const doVigia = vigia?.acao === 'tique' ? vigia.passo : null;
@@ -351,7 +378,8 @@ function tiqueDoArco(carregado, arco, opcoes = {}) {
     let relatorio;
     try {
         relatorio = (0, noctum_relatorio_1.entregarRelatorioSeDevido)(carregado, arco, { quando, maquina: opcoes.maquina, lerReservas: opcoes.lerReservas,
-            medir: opcoes.medir, supervisao: opcoes.supervisao, enviar: opcoes.enviar });
+            medir: opcoes.medir, supervisao: opcoes.supervisao, enviar: opcoes.enviar, projecaoDaRede: rede ?? undefined,
+            remoto: opcoes.remoto, redeDaCoordenacao: opcoes.redeDaCoordenacao });
     }
     catch (e) {
         throw erro ?? e;

package/dist/noctum-reconciliacao.js

@@ -335,7 +335,7 @@ const recusaDoNucleo = (motivo) => !!motivo && !motivo.startsWith('noctum.') &&
  * isolamento. Trabalho isolado, entregue, fechado, esperando o dono, com reserva pendente ou com retomada autorizada e
  * ainda não atendida (B1) fica de fora.
  */
-function decidirSessoes(raiz, arco, conteudo, estado, sup, leitura, quando) {
+function decidirSessoes(raiz, arco, conteudo, estado, sup, leitura, quando, ordensCanceladas = new Set()) {
     const parametros = sup.parametros;
     if (!parametros)
         return [];
@@ -346,6 +346,9 @@ function decidirSessoes(raiz, arco, conteudo, estado, sup, leitura, quando) {
     const decisoes = [];
     const aposReserva = (0, exports.ultimaReservaDoArco)(estado);
     for (const [trabalho, thread] of (0, noctum_supervisao_1.threadsDoArco)(raiz, conteudo, estado)) {
+        // A sessão da ordem cancelada na rede é encerrada pelo vigia, mas nunca autorizada a retomar nesta máquina.
+        if (ordensCanceladas.has(trabalho))
+            continue;
         if (sup.isolados.has(trabalho) || pendentes.has(trabalho))
             continue;
         let t, eventos;

package/dist/noctum-rede.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONTRATO_REDE_DO_ARCO = void 0;
+exports.lerRede = lerRede;
+exports.coordenacaoDaFila = coordenacaoDaFila;
+const maquina_1 = require("./maquina");
+const noctum_arco_1 = require("./noctum-arco");
+const noctum_coordenacao_1 = require("./noctum-coordenacao");
+const noctum_envelope_1 = require("./noctum-envelope");
+exports.CONTRATO_REDE_DO_ARCO = 'ork.noctum-rede/v1';
+const consumoVazio = () => ({ arco: 0, porConta: {}, porRuntime: {} });
+function vazia(arco, maquina, multimaquina, envelopeSha256, lidaEm, lacuna) {
+    return { contrato: exports.CONTRATO_REDE_DO_ARCO, arco, multimaquina, maquina, envelopeSha256, lidaEm, autoridade: null, revogada: null,
+        maquinas: [], trabalhos: [], consumo: consumoVazio(), obrigacoes: { ordens: [], vagas: [], vezes: [] }, lacuna };
+}
+function ordemProjetada(o) {
+    return { ordem: o.ordem, numero: o.n, maquina: o.maquina, estado: o.estado, emitidaEm: o.emitidaEm };
+}
+function projetar(estado, maquina, quando) {
+    const conteudo = estado.vigente.conteudo;
+    if (!(0, noctum_envelope_1.envelopeMultimaquina)(conteudo))
+        return vazia(estado.arco, maquina, false, estado.vigente.envelopeSha256, estado.lidoEm, null);
+    const vezes = [...estado.vezes.values()].flat();
+    const maquinas = conteudo.maquinas.map(({ nome }) => ({
+        nome,
+        ultimoSinal: estado.sinais.get(nome) ?? null,
+        sinalRecente: (0, noctum_coordenacao_1.batidaRecente)(estado, nome, maquina, quando),
+        ordensVivas: [...estado.ordens.values()].filter(o => o.maquina === nome && (0, noctum_coordenacao_1.ordemViva)(o)).map(o => o.ordem).sort(),
+        vagasAtivas: estado.vagas.filter(v => v.maquina === nome && !v.solta).map(v => v.vaga).sort(),
+        vezesAtivas: vezes.filter(v => v.maquina === nome && !v.fim).map(v => `${v.chave}/${v.n}`).sort(),
+        consumo: estado.vagas.filter(v => v.maquina === nome && (!v.solta || v.solta.consumiu)).length,
+    }));
+    const trabalhos = conteudo.trabalhos.map(t => {
+        const situacao = estado.trabalhos.get(t.id);
+        const ordem = situacao.ordem ? ordemProjetada(situacao.ordem) : null;
+        const registro = estado.entregas.get(t.id);
+        const entrega = registro ? { em: registro.em, maquina: registro.por, merge: String(registro.merge) } : null;
+        return { id: t.id, estado: situacao.estado, maquina: ordem?.maquina ?? null, ordem, maquinaPresa: t.maquina ?? null, entrega };
+    });
+    return {
+        contrato: exports.CONTRATO_REDE_DO_ARCO,
+        arco: estado.arco,
+        multimaquina: true,
+        maquina,
+        envelopeSha256: estado.vigente.envelopeSha256,
+        lidaEm: estado.lidoEm,
+        autoridade: estado.autoridade ? { maquina: estado.autoridade.maquina, geracao: estado.autoridade.geracao, desde: estado.autoridade.desde } : null,
+        revogada: estado.revogada,
+        maquinas,
+        trabalhos,
+        consumo: estado.consumo,
+        obrigacoes: {
+            ordens: [...estado.ordens.values()].filter(o => o.maquina === maquina && (0, noctum_coordenacao_1.ordemViva)(o)).map(o => o.ordem).sort(),
+            vagas: estado.vagas.filter(v => v.maquina === maquina && !v.solta).map(v => v.vaga).sort(),
+            vezes: vezes.filter(v => v.maquina === maquina && !v.fim).map(v => `${v.chave}/${v.n}`).sort(),
+        },
+        lacuna: null,
+    };
+}
+/** Lê a rede de um v3. Em v1/v2 não toca o remoto; recusa tipada vira lacuna, sem inventar estado. */
+function lerRede(carregado, arco, opcoes = {}) {
+    const quando = opcoes.quando ?? new Date().toISOString();
+    const maquina = (0, maquina_1.nomeDaMaquina)(opcoes.maquina);
+    const local = (0, noctum_arco_1.lerArco)(carregado.raiz, arco, quando);
+    if (!local?.conteudo || !(0, noctum_envelope_1.envelopeMultimaquina)(local.conteudo)) {
+        return vazia(arco, maquina, false, local?.envelopeSha256 ?? null, quando, null);
+    }
+    try {
+        return projetar((0, noctum_coordenacao_1.lerCoordenacao)(carregado, arco, { ...opcoes, quando }), maquina, quando);
+    }
+    catch (e) {
+        if (!(e instanceof noctum_envelope_1.RecusaDoArco))
+            throw e;
+        return vazia(arco, maquina, true, local.envelopeSha256, quando, { motivo: e.motivo, detalhe: e.message });
+    }
+}
+/** Adapta a projeção íntegra para a fila. Rede local ou ilegível não vira coordenação vazia. */
+function coordenacaoDaFila(rede) {
+    if (!rede.multimaquina || rede.lacuna)
+        return null;
+    const trabalhos = new Set();
+    const entregues = new Map();
+    const encerrados = new Set();
+    const emOutraMaquina = new Set();
+    const ordens = new Map();
+    for (const t of rede.trabalhos) {
+        if (t.entrega)
+            entregues.set(t.id, t.entrega.em);
+        else if (t.estado === 'entregue')
+            entregues.set(t.id, t.ordem?.emitidaEm ?? rede.lidaEm);
+        if (t.estado === 'encerrado')
+            encerrados.add(t.id);
+        if (t.ordem?.maquina === rede.maquina && t.ordem.estado === 'aceita') {
+            trabalhos.add(t.id);
+            ordens.set(t.id, { ordem: t.ordem.ordem, numero: t.ordem.numero });
+        }
+        else if (t.ordem && ['emitida', 'aceita', 'isolada'].includes(t.ordem.estado) && t.ordem.maquina !== rede.maquina) {
+            emOutraMaquina.add(t.id);
+        }
+    }
+    return { trabalhos, entregues, encerrados, emOutraMaquina, ordens };
+}

package/dist/noctum-relatorio.js

@@ -98,6 +98,7 @@ const noctum_registro_1 = require("./noctum-registro");
 const noctum_supervisao_1 = require("./noctum-supervisao");
 const procedencia_1 = require("./procedencia");
 const thread_1 = require("./thread");
+const noctum_rede_1 = require("./noctum-rede");
 exports.CONTRATO_RELATORIO = 'ork.noctum-relatorio/v1';
 /** O teto de uma mensagem do Telegram é 4.096; a página fica abaixo, com folga, como o digest do MASTER. */
 exports.TETO_DA_PAGINA = 3900;
@@ -231,9 +232,14 @@ function fatosDoRelatorio(carregado, arco, opcoes = {}, modo = {}) {
     const conteudo = estado.conteudo;
     const fuso = conteudo.janela.fuso;
     const lacunas = [];
+    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: opcoes.remoto, rede: opcoes.redeDaCoordenacao }) : null;
+    if (rede?.lacuna)
+        lacunas.push(`a rede do arco não pôde ser lida (${rede.lacuna.motivo}: ${rede.lacuna.detalhe})`);
     let fila = null;
     try {
-        fila = (0, noctum_fechamento_1.trabalhosDoArco)((0, noctum_fila_1.fatosDaFila)(carregado, arco, { quando, maquina: opcoes.maquina, lerReservas: opcoes.lerReservas }));
+        const coordenacao = rede ? (0, noctum_rede_1.coordenacaoDaFila)(rede) : null;
+        fila = rede?.lacuna ? null : (0, noctum_fechamento_1.trabalhosDoArco)((0, noctum_fila_1.fatosDaFila)(carregado, arco, { quando, maquina: opcoes.maquina, lerReservas: opcoes.lerReservas, ...(coordenacao ? { coordenacao } : {}) }));
     }
     catch (e) {
         if (!(e instanceof noctum_envelope_1.RecusaDoArco))
@@ -274,7 +280,22 @@ function fatosDoRelatorio(carregado, arco, opcoes = {}, modo = {}) {
         const pendente = estado.despachos.find(d => d.trabalho === t.id && d.desfecho === 'pendente');
         const base = { trabalho: t.id, item: t.item, thread: t.thread };
         const isolado = supervisao?.isolados.find(i => i.trabalho === t.id);
-        if (t.estado === 'entregue' && t.thread && eventos) {
+        const naRede = rede?.trabalhos.find(x => x.id === t.id);
+        if (multimaquina && naRede?.entrega) {
+            const master = eventos ? [...eventos].reverse().find(x => x.tipo === ledger_1.TIPOS_DE_EVENTO.masterConcluido) : null;
+            entregues.push({ ...base, pr: null, merge: naRede.entrega.merge, maquina: naRede.entrega.maquina,
+                push: `registro de entrega da N3 na máquina ${naRede.entrega.maquina}`,
+                master: master && typeof master.score === 'number' ? `MASTER ${master.score}/5` : 'MASTER pendente' });
+            continue;
+        }
+        if (multimaquina && naRede?.ordem && naRede.ordem.maquina !== rede?.maquina &&
+            ['emitida', 'aceita', 'isolada'].includes(naRede.ordem.estado)) {
+            emCurso.push({ ...base, estado: naRede.estado, maquina: naRede.ordem.maquina,
+                checkpoint: `ordem ${naRede.ordem.ordem} viva na máquina ${naRede.ordem.maquina}`,
+                retomada: `na máquina ${naRede.ordem.maquina}`, proximo: 'acompanhar a ordem e seus recibos na rede', reserva: null });
+            continue;
+        }
+        if (!multimaquina && t.estado === 'entregue' && t.thread && eventos) {
             const e = entregaDaThread(eventos);
             if (e.provada && e.ship) {
                 const master = [...eventos].reverse().find(x => x.tipo === ledger_1.TIPOS_DE_EVENTO.masterConcluido);
@@ -293,6 +314,12 @@ function fatosDoRelatorio(carregado, arco, opcoes = {}, modo = {}) {
                 retomada: 'a entrega (N5), com a prova no SHA exato', proximo: 'provar o push e o merge', reserva: null });
             continue;
         }
+        if (multimaquina && t.estado === 'entregue') {
+            emCurso.push({ ...base, estado: t.estado, maquina: naRede?.maquina ?? null,
+                checkpoint: 'a entrega local ainda não tem registro de entrega na rede', retomada: 'a reconciliação da máquina',
+                proximo: 'publicar ou reconciliar o recibo da N3', reserva: null });
+            continue;
+        }
         if (isolado || t.estado === 'bloqueado' || t.estado === 'encerrado-sem-entrega') {
             const doDono = t.motivo === 'decisao-no-lote' || t.motivo === 'dono';
             const lote = doDono && t.thread ? estado.decisoes.find(d => d.thread === t.thread || d.dependentes.includes(t.thread))?.id ?? null : null;
@@ -330,11 +357,13 @@ function fatosDoRelatorio(carregado, arco, opcoes = {}, modo = {}) {
         }
     }
     decisoes.sort((a, b) => a.em.localeCompare(b.em));
-    const custo = modo.semCusto ? [] : linhasDeCusto(conteudo, medidorDoRelatorio(opcoes, conteudo)(raiz, estado, quando));
+    const estadoDoCusto = rede && !rede.lacuna ? { ...estado, consumo: { ...estado.consumo, arco: rede.consumo.arco } } : estado;
+    const custo = modo.semCusto ? [] : linhasDeCusto(conteudo, medidorDoRelatorio(opcoes, conteudo)(raiz, estadoDoCusto, quando));
     const candidato = fila?.candidatos[0];
     return {
         arco, quando, fuso, vencimentoEm: vencimentoDoRelatorio(conteudo), janela: { inicio: conteudo.janela.inicio, fim: conteudo.janela.fim },
         situacao: estado.situacao, envelopeSha256: estado.envelopeSha256,
+        ...(multimaquina ? { maquina: rede?.maquina ?? opcoes.maquina ?? 'desconhecida', ...(rede ? { rede } : {}) } : {}),
         encerramento: estado.encerramento ? { motivo: estado.encerramento.motivo, detalhe: estado.encerramento.detalhe, em: estado.encerramento.em } : null,
         entregues, emCurso, impedidos, decisoes, custo,
         sessoesDespachadas: estado.despachos.filter(d => d.desfecho === 'concluido' && !d.idempotente).length,
@@ -371,15 +400,20 @@ function linhasDoRelatorio(f, versao) {
         l.push(`O arco segue até ${hora(f.janela.fim)}.`);
     else
         l.push(`O arco está ${f.situacao}.`);
+    if (f.rede && !f.rede.lacuna) {
+        l.push(`Rede: autoridade ${f.rede.autoridade?.maquina ?? 'ainda não assumida'}; composta na máquina ${f.maquina}.`, ...f.rede.maquinas.map(m => `• Máquina ${m.nome}: último sinal ${m.ultimoSinal ? hora(m.ultimoSinal) : 'ausente'}; ` +
+            `${m.ordensVivas.length} ordem(ns), ${m.vagasAtivas.length} vaga(s), consumo ${m.consumo}.`));
+    }
     if (f.lacunas.length)
         l.push(`Não lido: ${f.lacunas.join('; ')}.`);
-    l.push('', '✅ Entregue', ...(f.entregues.length ? f.entregues.map(e => `• ${e.trabalho} (${e.item}): thread ${e.thread}` +
+    l.push('', '✅ Entregue', ...(f.entregues.length ? f.entregues.map(e => `• ${e.trabalho} (${e.item}): ` +
+        `${e.thread ? `thread ${e.thread}` : 'sem thread local'}${e.maquina ? `, máquina ${e.maquina}` : ''}` +
         `${e.pr !== null ? `, PR #${e.pr}` : ''}${e.merge ? `, merge ${e.merge.slice(0, 8)}` : ''}, push provado (${e.push}), ${e.master}`) : nada));
     const daSupervisao = [...f.retomadas.map(r => `• retomada autorizada pela supervisão: ${r}`),
         ...f.sessoesParadas.map(s => `• pela supervisão, ${s}`)];
     l.push('', '🔄 Em curso', ...(f.emCurso.length || f.paradas.length || daSupervisao.length ? [...f.emCurso.map(e => `• ${e.trabalho} (${e.item}): ` +
             `${e.thread ? `thread ${e.thread}, ` : ''}checkpoint: ${e.checkpoint}; retoma: ${e.retomada}; próximo passo: ${e.proximo}` +
-            `${e.reserva ? `; ${e.reserva}` : ''}`), ...f.paradas.map(p => `• no fechamento, ${p}`), ...daSupervisao] : nada));
+            `${e.maquina ? `; máquina ${e.maquina}` : ''}${e.reserva ? `; ${e.reserva}` : ''}`), ...f.paradas.map(p => `• no fechamento, ${p}`), ...daSupervisao] : nada));
     // A parada da supervisão que ainda não fechou o arco (o fechamento a lê no tique seguinte) vai ao Impedido, com alcance do arco.
     const parada = f.paradaDaSupervisao && f.encerramento?.motivo !== 'supervisao'
         ? [`• o arco: parado pela supervisão (${f.paradaDaSupervisao}); alcance: arco`] : [];
@@ -440,8 +474,8 @@ function linhasDoRelatorio(f, versao) {
     return l.map(x => (0, hitl_1.redigirSegredos)(x));
 }
 /** As páginas de até `TETO_DA_PAGINA` caracteres, cada uma com o arco, a versão e a página no cabeçalho. */
-function paginar(arco, versao, linhas) {
-    const cabecalho = (i, n) => `Arco ${arco}, relatório v${versao}, página ${i}/${n}`;
+function paginar(arco, versao, linhas, maquina) {
+    const cabecalho = (i, n) => `Arco ${arco}, relatório v${versao}, página ${i}/${n}${maquina ? `, máquina ${maquina}` : ''}`;
     const espaco = exports.TETO_DA_PAGINA - cabecalho(99, 99).length - 1;
     const blocos = [[]];
     let tamanho = 0;
@@ -583,7 +617,7 @@ function correcoesDoRelatorio(linhas, fatos) {
     return correcoes;
 }
 function compor(fatos, versao, motivo, canal, corrigidos) {
-    const paginas = paginar(fatos.arco, versao, linhasDoRelatorio(fatos, versao));
+    const paginas = paginar(fatos.arco, versao, linhasDoRelatorio(fatos, versao), fatos.maquina);
     return { tipo: 'composto', versao, motivo, vencimentoEm: fatos.vencimentoEm, canal, sha256: sha(paginas.join('\n')), paginas,
         informados: { entregues: fatos.entregues.map(e => ({ trabalho: e.trabalho, thread: e.thread, merge: e.merge })), corrigidos } };
 }
@@ -619,7 +653,7 @@ function entregarRelatorioSeDevido(carregado, arco, opcoes = {}) {
     const fatos = fatosDoRelatorio(carregado, arco, { ...opcoes, quando }, { semCusto: true });
     if (!fatos)
         return sem('sem-relatorio', `o arco ${arco} não tem envelope autorizado`);
-    const comCusto = (f) => ({ ...f, custo: linhasDeCusto(conteudo, medidorDoRelatorio(opcoes, conteudo)(raiz, estado, quando)) });
+    const comCusto = (f) => ({ ...f, custo: linhasDeCusto(conteudo, medidorDoRelatorio(opcoes, conteudo)(raiz, f.rede && !f.rede.lacuna ? { ...estado, consumo: { ...estado.consumo, arco: f.rede.consumo.arco } } : estado, quando)) });
     try {
         return (0, noctum_registro_1.comRegistro)(raiz, arco, 'relatorio', (linhas, anexar) => {
             const todas = [...linhas];
@@ -755,7 +789,7 @@ function relatorioNoTerminal(carregado, arco, opcoes = {}) {
         if (!fatos)
             return null;
         return { versao: null, previa: true, paginas: paginar(arco, 0, ['Prévia: nenhuma versão foi composta ainda; isto não é a entrega.',
-                ...linhasDoRelatorio(fatos, 0)]) };
+                ...linhasDoRelatorio(fatos, 0)], fatos.maquina) };
     }
     if (opcoes.interativo) {
         // Com a trava ocupada (o tique enviando), o dono vê as páginas assim mesmo; o recibo do terminal fica para a vez seguinte.