@orkastery/cli 0.5.0 → 0.5.3

package/dist/pulse.js

@@ -13,6 +13,7 @@ const liveness_1 = require("./liveness");
 const master_1 = require("./master");
 const master_batch_1 = require("./master-batch");
 const orquestracao_1 = require("./orquestracao");
+const impedimento_1 = require("./impedimento");
 const thread_1 = require("./thread");
 const sessoes_adopt_1 = require("./sessoes-adopt");
 const ledger_1 = require("./ledger");
@@ -26,6 +27,9 @@ const decisao_autonoma_1 = require("./decisao-autonoma");
 const docs_1 = require("./docs");
 const conducao_1 = require("./conducao");
 const conducao_texto_1 = require("./conducao-texto");
+const hitl_resumo_1 = require("./hitl-resumo");
+const hitl_tempo_parado_1 = require("./hitl-tempo-parado");
+const parado_no_condutor_1 = require("./parado-no-condutor");
 exports.CONTRATO_PULSE = 'ork.pulse/v1';
 /** Uma semana: o resumo cita a decisao uma vez, e ela continua lida ate sair da janela. */
 exports.JANELA_DAS_DECISOES_MS = 7 * 24 * 60 * 60 * 1000;
@@ -47,6 +51,17 @@ function apresentacaoCurtaDoItem(pedido, desde, quando) {
 function comporPulse(carregado, entrada) {
     const { radar, monitor, batch, orfas } = entrada, quando = radar.consultadoEm;
     const humanos = [], automaticas = [];
+    // RM-037 (fatia 4): o fim de turno sem pergunta e do condutor. Ele sai da fila do dono aqui e volta
+    // como linha propria (`paradoNoCondutor`); leitura que falha nao esconde nada do dono.
+    let entregas = entrada.entregas;
+    if (!entregas) {
+        try {
+            entregas = (0, parado_no_condutor_1.entregasDoProjeto)(carregado, { quando, sessoes: radar.sessoes });
+        }
+        catch {
+            entregas = undefined;
+        }
+    }
     const registros = new Map();
     const ehRegistro = (id) => {
         if (!id)
@@ -79,6 +94,11 @@ function comporPulse(carregado, entrada) {
     };
     const TERMINAIS = ['failed', 'done', 'stopped', 'completed'];
     for (const s of radar.sessoes.filter(s => s.precisaDeHumano)) {
+        // RM-037 (fatia 4): sessao `blocked` de quem o turno acabou sem pergunta e do condutor: a que o ledger provou
+        // (Stop sem atividade depois; a lista numerada da mensagem final nao e menu) e a sobra sem menu na tela.
+        if (entregas?.doCondutor.sessoes.has(s.sessionId) &&
+            ((0, parado_no_condutor_1.sessaoSemPergunta)(s) || entregas.doCondutor.turnosEncerrados.has(s.sessionId)))
+            continue;
         // Job morto ou estado terminal é história. Bloqueio vivo ou desconhecido continua visível.
         if (ehRegistro(s.thread?.id ?? null) && s.jobVivo !== true &&
             (s.jobVivo === false || TERMINAIS.includes(s.estadoBruto)))
@@ -123,6 +143,9 @@ function comporPulse(carregado, entrada) {
         for (const p of l.paradas) {
             if (VERIFICACAO.includes(p.motivo) && jaMesclada(l.thread))
                 continue;
+            // RM-037 (fatia 4): o `human.pending` que o observador grava no fim de turno sem pergunta nao e do dono.
+            if (p.motivo === 'human.pending' && p.fonte === 'ledger' && entregas?.doCondutor.gates.has(`${l.thread}|${p.fase}`))
+                continue;
             if (ehRegistro(l.thread)) {
                 if (p.fonte === 'escalonador' || ['lease.busy', 'conducao.em-andamento', 'concurrency.limite', 'vaga.stale', 'runtime.silencio'].includes(p.motivo))
                     continue;
@@ -148,6 +171,19 @@ function comporPulse(carregado, entrada) {
                 thread: l.thread, fase: p.fase, sessionId: null, desdeEm: p.desdeEm, paradaHaMin: p.paradaHaMin, impacto: impacto(p.fase),
                 pergunta: p.detalhe, opcoes: [], recomendacao: p.correcao, comandoResposta: p.correcao, evidencia: [p.evidencia],
                 fontes: ['monitor'], contextoLogs: [] };
+            // RM-055: o impedimento do despacho sai no contrato curto, com o comando exato e o re-despacho depois.
+            if (p.impedimento) {
+                try {
+                    const curto = (0, impedimento_1.pedidoCurtoDoImpedimento)({ thread: l.thread, fase: p.fase, motivo: p.motivo, detalhe: p.detalhe,
+                        desdeEm: p.desdeEm, impedimento: p.impedimento }, quando);
+                    item.apresentacaoCurta = { telegram: (0, hitl_curto_1.textoDoPedidoCurto)(curto, 'telegram'), terminal: (0, hitl_curto_1.textoDoPedidoCurto)(curto, 'terminal') };
+                    item.opcoes = curto.alternativas.map(a => `${a.chave}. ${a.texto}`);
+                    item.comandoResposta = `ork retry run ${l.thread}`;
+                }
+                catch {
+                    item.evidencia.push('Pedido curto do impedimento indisponível; a correção acima vale.');
+                }
+            }
             // I-45: vaga parada e sinal do escalonador (`ork board reap` devolve a vaga), nao pergunta ao dono.
             const esperaAutomatica = ['lease.busy', 'conducao.em-andamento', 'concurrency.limite', 'runtime.rate-limited', 'vaga.stale'].includes(p.motivo);
             (esperaAutomatica ? automaticas : humanos).push(item);
@@ -216,7 +252,8 @@ function comporPulse(carregado, entrada) {
         }
     }
     return { contrato: exports.CONTRATO_PULSE, consultadoEm: quando, runtime: { ok: radar.runtimeConsultado, detalhe: radar.runtimeDetalhe },
-        precisaDeHumanoAgora: h, acoesAutomaticas: a, resumo: { humanos: h.length, automaticas: a.length, scores: batch.length, fasesOrfas: orfas.length } };
+        precisaDeHumanoAgora: h, acoesAutomaticas: a, resumo: { humanos: h.length, automaticas: a.length, scores: batch.length, fasesOrfas: orfas.length },
+        ...(entregas?.parados.length ? { paradoNoCondutor: entregas.parados } : {}) };
 }
 function montarPulse(carregado, opcoes = {}) {
     if (opcoes.registrar)
@@ -243,7 +280,42 @@ function montarPulse(carregado, opcoes = {}) {
             }
         }
     const monitor = (0, orquestracao_1.montarMonitor)(carregado, { agora: quando, estados });
-    const pulse = comporPulse(carregado, { radar, monitor, orfas, batch: (0, master_1.pendentesDeScore)(carregado.raiz) });
+    // RM-037 (fatia 4, D2): a forja so e lida quando alguma thread tem branch publicada; a leitura boa vira o
+    // retrato que o status do roadmap le sem rede. Falha de leitura e diagnostico, nunca "sem PR".
+    let entregas;
+    try {
+        entregas = (0, parado_no_condutor_1.entregasDoProjeto)(carregado, { quando, sessoes: radar.sessoes, lerPrs: (candidatas) => {
+                const leitura = (0, parado_no_condutor_1.lerPrsDaForja)(carregado, { quando, executor: opcoes.executorDoGh, candidatas });
+                if (leitura.ok) {
+                    try {
+                        (0, parado_no_condutor_1.gravarRetratoDePrs)(carregado.raiz, leitura.retrato);
+                    }
+                    catch { /* o retrato e economia do status */ }
+                    try {
+                        (0, parado_no_condutor_1.esquecerForjaSemLeitura)(carregado.raiz);
+                    }
+                    catch { /* sem a marca, a proxima perda de leitura e dita de novo */ }
+                }
+                return leitura;
+            } });
+        const leitura = entregas.prs;
+        if (leitura && !leitura.ok && leitura.semLeitura) {
+            // RM-037 (fatia 5, A5): a forja sem leitura de PR e dita uma vez por remoto e host; as batidas seguintes nao repetem.
+            let novidade = true;
+            try {
+                novidade = (0, parado_no_condutor_1.avisarForjaSemLeitura)(carregado.raiz, leitura.semLeitura, leitura.erro, quando);
+            }
+            catch { /* sem marca, diz de novo */ }
+            if (novidade)
+                diagnosticos.push(`prs.sem-leitura: ${leitura.erro.slice(0, 160)}`);
+        }
+        else if (leitura && !leitura.ok)
+            diagnosticos.push(`prs.nao-lidos: ${leitura.erro.slice(0, 160)}`);
+    }
+    catch (e) {
+        diagnosticos.push(`entregas.indisponiveis: ${e.message.slice(0, 120)}`);
+    }
+    const pulse = comporPulse(carregado, { radar, monitor, orfas, batch: (0, master_1.pendentesDeScore)(carregado.raiz), ...(entregas ? { entregas } : {}) });
     const conducoes = monitor.linhas.filter((l) => l.conducao).map((l) => ({ thread: l.thread, linha: (0, conducao_texto_1.linhaDeConducao)(l.conducao, { agora: quando }) }));
     if (conducoes.length > 0)
         pulse.conducoes = conducoes;
@@ -256,6 +328,15 @@ function montarPulse(carregado, opcoes = {}) {
     catch (e) {
         diagnosticos.push(`decisoes.indisponiveis: ${e.message.slice(0, 120)}`);
     }
+    // RM-057 (fatia 3): leitura pura do ledger; falhar aqui nunca derruba a fila de atencao.
+    try {
+        const hitl = (0, hitl_tempo_parado_1.lerHitlDeConducaoAgora)(carregado.raiz, quando);
+        if (hitl.abertas.length || hitl.seteDias.pedidos || hitl.seteDias.respondidos)
+            pulse.hitlDeConducao = hitl;
+    }
+    catch (e) {
+        diagnosticos.push(`hitl-conducao.indisponivel: ${e.message.slice(0, 120)}`);
+    }
     if (diagnosticos.length)
         pulse.runtime.detalhe = [pulse.runtime.detalhe, ...diagnosticos].filter(Boolean).join('; ');
     return pulse;
@@ -264,8 +345,10 @@ function textoDoPulse(p) {
     // I-35: o pulse guarda ISO; o texto ao dono sai no fuso dele, rotulado no cabeçalho.
     const local = (texto) => (0, horario_1.localizarTexto)(texto, { agora: p.consultadoEm });
     const linhas = [`Pulse (${p.contrato}) ${(0, horario_1.formatarDataHoraRotulada)(p.consultadoEm, { agora: p.consultadoEm })}`, `Precisa de humano agora: ${p.resumo.humanos}`, `${p.resumo.scores} entrega(s) sem nota, aceitas por padrão com registro`];
-    if (p.runtime.ok && p.runtime.detalhe.includes('liveness.snapshot.invalid'))
+    // RM-037 (fatia 4): PR nao lido tambem e dito, para a falta de linha do condutor nao parecer "nada parado".
+    if (p.runtime.ok && ['liveness.snapshot.invalid', 'prs.nao-lidos', 'prs.sem-leitura', 'entregas.indisponiveis'].some(d => p.runtime.detalhe.includes(d))) {
         linhas.push(`[diagnostico] ${local(p.runtime.detalhe)}`);
+    }
     if (!p.runtime.ok)
         linhas.push(`[consulta incompleta] ${local(p.runtime.detalhe)}`);
     for (const i of p.precisaDeHumanoAgora) {
@@ -276,6 +359,19 @@ function textoDoPulse(p) {
         for (const c of p.conducoes)
             linhas.push(`${c.thread}: ${c.linha}`);
     }
+    // RM-037 (fatia 4): o que espera o condutor, uma linha por thread; nao e pergunta ao dono.
+    if (p.paradoNoCondutor?.length) {
+        linhas.push('', `Parado no condutor: ${p.paradoNoCondutor.length}`);
+        for (const x of p.paradoNoCondutor)
+            linhas.push((0, hitl_resumo_1.linhaDoParadoNoCondutor)(x, { agora: p.consultadoEm }));
+    }
+    // RM-057 (fatia 3): quanto tempo cada pergunta de conducao aberta ja parou a thread, e a mediana da semana.
+    if (p.hitlDeConducao) {
+        const h = p.hitlDeConducao;
+        linhas.push('', `HITL de condução: ${h.abertas.length} aberta(s); ${(0, hitl_tempo_parado_1.textoDaMediana)(h)}`);
+        for (const a of h.abertas)
+            linhas.push((0, hitl_tempo_parado_1.linhaDaPerguntaParada)(a, { agora: p.consultadoEm }));
+    }
     linhas.push('', `Ações automáticas pendentes: ${p.resumo.automaticas}`);
     for (const i of p.acoesAutomaticas)
         linhas.push(`${i.thread}: ${i.motivo}; ${i.comandoResposta}`);

package/dist/ratelimit.js

@@ -61,6 +61,7 @@ exports.lerFilaDeRetomada = lerFilaDeRetomada;
 exports.janelaPadraoMs = janelaPadraoMs;
 exports.enfileirar = enfileirar;
 exports.prazoDaConta = prazoDaConta;
+exports.prazoDaCotaVista = prazoDaCotaVista;
 exports.marcarContaDaFalha = marcarContaDaFalha;
 exports.gravarPedido = gravarPedido;
 exports.exigirPedido = exigirPedido;
@@ -151,15 +152,30 @@ function prazoDaConta(manifesto, falha, agoraMs = Date.now()) {
         return falha.resetEm;
     return new Date(agoraMs + janelaPadraoMs(manifesto)).toISOString();
 }
-/** Marca no store o perfil que falhou pela conta. Sem perfil (ambiente do processo), nada a marcar. */
-function marcarContaDaFalha(carregado, perfil, falha, agoraMs = Date.now()) {
+/**
+ * RM-037 (fatia 5): ate quando a conta sai do rodizio pela cota que o observador viu na transcricao, com a
+ * sessao viva. Vale a hora dita (ja ancorada no instante da mensagem) ou a janela padrao contada da mensagem,
+ * nunca do relogio de quem leu. Prazo que ja venceu volta `null`: a conta ja voltou, e marcar agora tiraria do
+ * rodizio uma conta boa (a regra A10 do despacho recusado nao vale aqui, porque ninguem acabou de recusar nada).
+ */
+function prazoDaCotaVista(manifesto, falha, mensagemMs, agoraMs = Date.now()) {
+    if (falha.motivo !== 'runtime.quota-exhausted' || !Number.isFinite(mensagemMs))
+        return null;
+    const prazo = falha.resetEm ?? new Date(mensagemMs + janelaPadraoMs(manifesto)).toISOString();
+    return Date.parse(prazo) > agoraMs ? prazo : null;
+}
+/**
+ * Marca no store o perfil que falhou pela conta. Sem perfil (ambiente do processo), nada a marcar. `prazo`,
+ * quando vem, e o ja calculado por quem viu a falha (`prazoDaCotaVista`); sem ele, vale `prazoDaConta`.
+ */
+function marcarContaDaFalha(carregado, perfil, falha, agoraMs = Date.now(), prazo) {
     // RM-037 (defeitosdeco D-6): modelo inacessivel nao e falha da conta inteira; o perfil fica no rodizio.
     if (!perfil || falha.motivo === 'runtime.model-unavailable')
         return null;
     const esgotado = falha.motivo === 'runtime.quota-exhausted';
     return (0, runtime_profiles_1.marcarFalhaDePerfil)(carregado.raiz, perfil.id, { estado: esgotado ? 'esgotado' : 'sem-auth',
-        esgotadoAte: prazoDaConta(carregado.manifesto, falha, agoraMs), motivo: falha.motivo, detalhe: falha.trecho,
-        em: new Date(agoraMs).toISOString() });
+        esgotadoAte: esgotado && prazo ? prazo : prazoDaConta(carregado.manifesto, falha, agoraMs), motivo: falha.motivo,
+        detalhe: falha.trecho, em: new Date(agoraMs).toISOString() });
 }
 /** Regrava um pedido (append-only: a versao nova vence, o historico fica). */
 function gravarPedido(raiz, pedido) {

package/dist/recall.js

@@ -257,7 +257,9 @@ function recallDaThread(carregado, memoria, threadId, opcoes = {}) {
             falhas.push({ id: 'memoria-busca', titulo: 'Descoberta de handoffs da fase', location: '',
                 orkmind: null, retrieve_when: fase, resolvido: false, motivo: 'orkmind-indisponivel', via: null,
                 conteudo: '', metodo: '', sha256: '', intervalo: null,
-                detalhe: `${memoria.leituraRestrita ? falhaDeConsulta(erro) : 'memory.transport.export'}: busca semantica falhou; resultado nao comprova colecao vazia` });
+                // RM-038: a janela cheia do export tem codigo proprio; o resto segue como falha de transporte.
+                detalhe: `${memoria.leituraRestrita ? falhaDeConsulta(erro) : erro instanceof Error && erro.message === 'memory.query.window-saturated'
+                    ? erro.message : 'memory.transport.export'}: busca semantica falhou; resultado nao comprova colecao vazia` });
         }
     }
     if (opcoes.id !== undefined && resolvidos.length === 0 && falhas.length === 0 && adiados.length === 0) {

package/dist/rede-adesao.js

@@ -0,0 +1,399 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ehIdDeMaquina = exports.pastaDaRede = exports.TETO_DE_TENTATIVA_MS = exports.REPOSITORIO_PADRAO = exports.CONTRATO_DA_ADESAO = void 0;
+exports.lerConfigDaRede = lerConfigDaRede;
+exports.gravarConfigDaRede = gravarConfigDaRede;
+exports.adesaoDaRede = adesaoDaRede;
+exports.lerIdDaMaquina = lerIdDaMaquina;
+exports.idDaMaquina = idDaMaquina;
+exports.idDerivado = idDerivado;
+exports.publicacaoDesligada = publicacaoDesligada;
+exports.tomarVezDePublicar = tomarVezDePublicar;
+exports.publicarRedeEmSegundoPlano = publicarRedeEmSegundoPlano;
+exports.registrarNaRede = registrarNaRede;
+/**
+ * RM-053 (D2, D9): a adesao desta maquina a rede da pessoa, e o disparo em segundo plano.
+ *
+ * Modulo leve de proposito, como a `fabrica-publicar`: quem publica em segundo plano (thread nova,
+ * despacho de fase, entrega) chega aqui por ela e nao pode arrastar o retrato nem a forja.
+ *
+ * A adesao e da MAQUINA, em `~/.orkastery/rede.json` (contrato `ork.rede/v1`), gravado por
+ * `ork network entrar` e `ork network sair`. Sem esse arquivo, a maquina que ja fez
+ * `ork fabrica entrar` (`fabricaCompartilhada: true` em `maquina.json`) e membro HERDADO: entra na
+ * rede sem refazer nada. `ork network sair` grava `membro: false`, que vence a heranca. O manifesto
+ * do projeto nao conta: um time nao inscreve a maquina de ninguem na rede pessoal.
+ */
+const node_crypto_1 = require("node:crypto");
+const node_child_process_1 = require("node:child_process");
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const maquina_1 = require("./maquina");
+const monitor_lock_1 = require("./monitor-lock");
+const util_1 = require("./util");
+exports.CONTRATO_DA_ADESAO = 'ork.rede/v1';
+exports.REPOSITORIO_PADRAO = 'orkastery-network';
+/**
+ * D9: no maximo uma tentativa de publicacao em segundo plano (evento ou batida) a cada 14 minutos.
+ * Um minuto de folga sob o cron de 15: com o teto igual ao periodo, a oscilacao do horario de cada
+ * batida pulava metade delas (B4 do CHECK 1).
+ */
+exports.TETO_DE_TENTATIVA_MS = 14 * 60 * 1000;
+/** `~/.orkastery/rede`: o cache bare da casa, as marcas e o log da rede. */
+const pastaDaRede = () => path.join((0, maquina_1.pastaDoUsuario)(), 'rede');
+exports.pastaDaRede = pastaDaRede;
+const arquivoDaConfig = () => path.join((0, maquina_1.pastaDoUsuario)(), 'rede.json');
+const arquivoDaTentativa = () => path.join((0, exports.pastaDaRede)(), 'tentativa.json');
+const IDENTIFICADOR = /^[A-Za-z0-9][A-Za-z0-9._-]{0,99}$/;
+const HOST = /^[A-Za-z0-9.-]+(?::\d+)?$/;
+const texto = (v, padrao) => typeof v === 'string' && padrao.test(v) ? v : null;
+function lerConfigDaRede() {
+    try {
+        const bruto = JSON.parse(fs.readFileSync(arquivoDaConfig(), 'utf8'));
+        if (!bruto || bruto.contrato !== exports.CONTRATO_DA_ADESAO || typeof bruto.membro !== 'boolean')
+            return null;
+        return {
+            contrato: exports.CONTRATO_DA_ADESAO, membro: bruto.membro,
+            forja: bruto.forja === 'github' || bruto.forja === 'gitlab' ? bruto.forja : null,
+            host: texto(bruto.host, HOST), dono: texto(bruto.dono, IDENTIFICADOR), repositorio: texto(bruto.repositorio, IDENTIFICADOR),
+            atualizadoEm: typeof bruto.atualizadoEm === 'string' ? bruto.atualizadoEm : '',
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/** Grava a adesao (troca atomica). Campo ausente na mudanca fica como estava. */
+function gravarConfigDaRede(mudanca) {
+    const atual = lerConfigDaRede();
+    const config = {
+        contrato: exports.CONTRATO_DA_ADESAO,
+        membro: mudanca.membro ?? atual?.membro ?? false,
+        forja: mudanca.forja !== undefined ? mudanca.forja : atual?.forja ?? null,
+        host: mudanca.host !== undefined ? mudanca.host : atual?.host ?? null,
+        dono: mudanca.dono !== undefined ? mudanca.dono : atual?.dono ?? null,
+        repositorio: mudanca.repositorio !== undefined ? mudanca.repositorio : atual?.repositorio ?? null,
+        atualizadoEm: new Date().toISOString(),
+    };
+    if (config.host !== null && !HOST.test(config.host))
+        throw new Error(`rede.config: host invalido ("${config.host}")`);
+    for (const [campo, valor] of [['dono', config.dono], ['repositorio', config.repositorio]]) {
+        if (valor !== null && !IDENTIFICADOR.test(valor))
+            throw new Error(`rede.config: ${campo} invalido ("${valor}")`);
+    }
+    const dir = (0, maquina_1.pastaDoUsuario)();
+    fs.mkdirSync(dir, { recursive: true });
+    const temp = path.join(dir, `.rede.json.${process.pid}.tmp`);
+    fs.writeFileSync(temp, JSON.stringify(config, null, 2) + '\n', { mode: 0o600 });
+    fs.renameSync(temp, arquivoDaConfig());
+    return config;
+}
+/** Esta maquina esta na rede? Explicita pelo `rede.json`, senao herdada da fabrica. */
+function adesaoDaRede() {
+    const config = lerConfigDaRede();
+    if (config)
+        return { membro: config.membro, adesao: config.membro ? 'rede' : null, config };
+    const herdada = (0, maquina_1.lerConfigDaMaquina)()?.fabricaCompartilhada === true;
+    return { membro: herdada, adesao: herdada ? 'fabrica' : null, config: null };
+}
+const ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+const arquivoDoId = () => path.join((0, maquina_1.pastaDoUsuario)(), 'maquina-id');
+function lerId(arquivo) {
+    try {
+        const id = fs.readFileSync(arquivo, 'utf8').trim();
+        return ID.test(id) ? id : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** O id desta instalacao, sem criar: `null` quando ela nunca publicou (a leitura nao cria estado). */
+function lerIdDaMaquina() {
+    return lerId(arquivoDoId());
+}
+/**
+ * B7 do CHECK 1: um identificador aleatorio desta instalacao, criado na primeira publicacao. Vai no
+ * retrato para duas maquinas com o mesmo nome (hostname `ubuntu`, o corte em 64 caracteres) nao
+ * regravarem o arquivo uma da outra. Nao identifica pessoa.
+ *
+ * S3 da revisao 2: mora em `~/.orkastery/maquina-id`, ao lado do `maquina.json`, e NAO na pasta de
+ * cache `~/.orkastery/rede/`: apagar o cache nao pode fazer a maquina virar outra de si mesma.
+ * U6 da revisao 3: sem arquivo, `link` de um temporario cria so se nao existe (atomico).
+ * V5 da revisao 4: arquivo ruim e trocado por um id DERIVADO dele, o mesmo para todo processo que o
+ * viu. W7 e W8 da revisao 5: nenhum caminho expoe arquivo vazio, e link pendurado tambem e trocado.
+ * X6 do CHECK 6: sem hard link, e na troca do arquivo ruim, o id vem de uma reserva (`idReservado`),
+ * igual para todo host que divide a pasta; o derivado so fica para quando a reserva falha.
+ * Todo caminho devolve o que ficou gravado, nunca o que tentou gravar.
+ */
+function idDaMaquina() {
+    const arquivo = arquivoDoId();
+    for (let tentativa = 0; tentativa < 3; tentativa++) {
+        const lido = lerId(arquivo);
+        if (lido)
+            return lido;
+        fs.mkdirSync((0, maquina_1.pastaDoUsuario)(), { recursive: true });
+        let st = null;
+        try {
+            st = fs.lstatSync(arquivo, { bigint: true });
+        }
+        catch (e) {
+            if (e.code !== 'ENOENT')
+                throw e;
+        }
+        if (st)
+            trocarIdInvalido(arquivo, st);
+        else
+            criarId(arquivo);
+    }
+    const persistido = lerId(arquivo);
+    if (!persistido)
+        throw new Error(`rede.id: nao consegui gravar nem ler ${arquivo}`);
+    return persistido;
+}
+function gravarTemporario(conteudo) {
+    const temporario = path.join((0, maquina_1.pastaDoUsuario)(), `.maquina-id.${process.pid}.${(0, node_crypto_1.randomUUID)()}.tmp`);
+    fs.writeFileSync(temporario, conteudo, { mode: 0o600 });
+    return temporario;
+}
+/** Troca o que estiver no caminho (arquivo ou link) por um arquivo inteiro com o id: `rename` e atomico. */
+function trocarPor(arquivo, id) {
+    const temporario = gravarTemporario(id);
+    try {
+        fs.renameSync(temporario, arquivo);
+    }
+    finally {
+        fs.rmSync(temporario, { force: true });
+    }
+}
+const SEM_HARD_LINK = new Set(['EPERM', 'ENOTSUP', 'EOPNOTSUPP', 'ENOSYS']);
+/** Cria o id so se o arquivo nao existe; perdeu a corrida, fica o do outro. */
+function criarId(arquivo) {
+    const temporario = gravarTemporario((0, node_crypto_1.randomUUID)());
+    try {
+        fs.linkSync(temporario, arquivo);
+        return;
+    }
+    catch (e) {
+        const codigo = e.code ?? '';
+        if (codigo === 'EEXIST')
+            return;
+        if (!SEM_HARD_LINK.has(codigo))
+            throw e;
+    }
+    finally {
+        fs.rmSync(temporario, { force: true });
+    }
+    // W7 da revisao 5: sistema de arquivos sem hard link (vboxsf, alguns FUSE e SMB). Nada de arquivo
+    // vazio nem de espera por relogio. X6 do CHECK 6: o id sai da reserva, o mesmo para todo processo
+    // de todo host que divide a pasta; so se a reserva falhar, o id DERIVADO da pasta e do boot.
+    const reservado = idReservado('maquina-id.reserva');
+    if (reservado)
+        return trocarPor(arquivo, reservado);
+    const pasta = fs.statSync((0, maquina_1.pastaDoUsuario)(), { bigint: true });
+    trocarPor(arquivo, idDerivado(['novo', pasta.dev, pasta.ino]));
+}
+/**
+ * X6 do CHECK 6: cria-se-ausente sem hard link, sem relogio e sem arquivo vazio. A pasta temporaria
+ * ganha o id inteiro antes do `rename`; `rename` de pasta sobre pasta NAO vazia falha (ENOTEMPTY ou
+ * EEXIST no POSIX, EPERM no Windows), entao so a primeira entra, e todo processo, de qualquer host ou
+ * conteiner que divida `~/.orkastery`, le dela o mesmo id. A reserva fica: e ela que responde ao lento.
+ * Clones de uma imagem (W6) tem disco proprio e criam cada um a sua. Qualquer falha devolve `null`, e
+ * quem chamou usa o id derivado de antes.
+ */
+function idReservado(nome) {
+    const reserva = path.join((0, maquina_1.pastaDoUsuario)(), nome);
+    const jaReservado = lerId(path.join(reserva, 'id'));
+    if (jaReservado)
+        return jaReservado;
+    const temporaria = path.join((0, maquina_1.pastaDoUsuario)(), `.${nome}.${process.pid}.${(0, node_crypto_1.randomUUID)()}.tmp`);
+    try {
+        fs.mkdirSync(temporaria, { mode: 0o700 });
+        fs.writeFileSync(path.join(temporaria, 'id'), (0, node_crypto_1.randomUUID)(), { mode: 0o600 });
+        fs.renameSync(temporaria, reserva);
+    }
+    catch { /* outro entrou antes (ou a pasta recusa): vale o que estiver na reserva */ }
+    finally {
+        fs.rmSync(temporaria, { recursive: true, force: true });
+    }
+    return lerId(path.join(reserva, 'id'));
+}
+/** O arquivo ruim (vazio, corrompido, link pendurado) vira o id derivado dele; o que mudou no meio, quem chamou rele. */
+function trocarIdInvalido(arquivo, st) {
+    let conteudo;
+    if (st.isSymbolicLink()) {
+        // W8 da revisao 5: o link pendurado (ou para arquivo ruim) sai; o alvo fica como esta. X2 da revisao
+        // 6: se outro processo ja o trocou (ou tirou) depois do `lstat`, quem chamou rele.
+        let alvo;
+        try {
+            alvo = fs.readlinkSync(arquivo);
+        }
+        catch (e) {
+            if (['ENOENT', 'EINVAL'].includes(e.code ?? ''))
+                return;
+            throw e;
+        }
+        conteudo = Buffer.from(`link:${alvo}`);
+    }
+    else if (st.isFile()) {
+        let fd;
+        try {
+            fd = fs.openSync(arquivo, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
+        }
+        catch (e) {
+            if (['ENOENT', 'ELOOP'].includes(e.code ?? ''))
+                return;
+            throw e;
+        }
+        try {
+            // Conteudo e metadados do MESMO inode: o `fstat` do descritor aberto, nao do caminho.
+            st = fs.fstatSync(fd, { bigint: true });
+            const buffer = Buffer.alloc(4096);
+            conteudo = buffer.subarray(0, fs.readSync(fd, buffer, 0, buffer.length, 0));
+        }
+        finally {
+            fs.closeSync(fd);
+        }
+        if (ID.test(conteudo.toString('utf8').trim()))
+            return;
+    }
+    else {
+        throw new Error(`rede.id: ${arquivo} nao e um arquivo; apague-o e rode de novo`);
+    }
+    // X6 do CHECK 6: a reserva da troca e chaveada pelo que todo host ve igual do arquivo ruim (conteudo,
+    // tamanho e hora); `dev` e local a cada host e fica so no id derivado, o caminho de quando a reserva falha.
+    const sha = (0, node_crypto_1.createHash)('sha256').update(conteudo).digest('hex');
+    const chave = (0, node_crypto_1.createHash)('sha256').update([sha, st.size, st.mtimeNs].join('\0')).digest('hex').slice(0, 32);
+    trocarPor(arquivo, idReservado(`maquina-id.troca-${chave}`) ?? idDerivado([sha, st.dev, st.ino, st.mtimeNs, st.size]));
+}
+/**
+ * O id que todo processo desta maquina deriva do mesmo estado, agora. W6 da revisao 5: alem das
+ * partes (o arquivo ruim, ou a pasta), o hostname e o boot (`boot_id` e `machine-id`): VMs clonadas
+ * da mesma imagem, com o mesmo arquivo, inode e hostname, tem boot proprio e ganham ids diferentes.
+ * Formato de UUID v4.
+ */
+function idDerivado(partes, fontes = fontesDaMaquina()) {
+    const h = (0, node_crypto_1.createHash)('sha256').update([...partes.map(String), ...fontes].join('\0')).digest('hex');
+    return `${h.slice(0, 8)}-${h.slice(8, 12)}-4${h.slice(13, 16)}-${'89ab'[parseInt(h[16], 16) & 3]}${h.slice(17, 20)}-${h.slice(20, 32)}`;
+}
+function fontesDaMaquina() {
+    const ler = (arquivo) => { try {
+        return fs.readFileSync(arquivo, 'utf8').trim();
+    }
+    catch {
+        return '';
+    } };
+    return [os.hostname(), ler('/proc/sys/kernel/random/boot_id'), ler('/etc/machine-id')];
+}
+const ehIdDeMaquina = (v) => typeof v === 'string' && ID.test(v);
+exports.ehIdDeMaquina = ehIdDeMaquina;
+/** Publicacao automatica desligada pelo ambiente (testes, `ork eval`, demo). */
+function publicacaoDesligada(env = process.env) {
+    return env.ORK_REDE_PUBLICAR === '0' || env.ORK_FABRICA_PUBLICAR === '0';
+}
+/**
+ * D9: toma a vez de tentar publicar, no maximo uma a cada 14 minutos por maquina. Devolve `false`
+ * quando a ultima tentativa (evento ou batida) foi ha menos que isso; a marca e gravada antes da
+ * tentativa, para duas batidas simultaneas nao dispararem juntas. Revisao de 03/10: a leitura e a
+ * gravacao da marca correm sob uma trava (quem nao a pega perde a vez) e a marca troca por rename;
+ * sem isso, varios processos na mesma batida liam a marca velha e todos tomavam a vez.
+ */
+function tomarVezDePublicar(agoraPedido) {
+    try {
+        fs.mkdirSync((0, exports.pastaDaRede)(), { recursive: true });
+    }
+    catch {
+        return false;
+    }
+    const trava = (0, monitor_lock_1.adquirirLockMonitor)(path.join((0, exports.pastaDaRede)(), 'tentativa.lock'));
+    if (!trava.ok)
+        return false;
+    // A hora e lida DENTRO da trava: lida antes, o processo que perdia a CPU entre a leitura e a trava
+    // via a marca do vencedor "no futuro", a tomava por relogio que voltou e tomava a vez tambem.
+    const agora = agoraPedido ?? Date.now();
+    try {
+        try {
+            const ultima = Date.parse(JSON.parse(fs.readFileSync(arquivoDaTentativa(), 'utf8')).em ?? '');
+            if (Number.isFinite(ultima) && agora - ultima < exports.TETO_DE_TENTATIVA_MS && agora >= ultima)
+                return false;
+        }
+        catch { /* primeira vez, ou marca ilegivel: tenta */ }
+        try {
+            // Dado de maquina: o JSON vai inteiro, sem concatenar o ISO em texto (lint de horario, RM-035).
+            const temporario = `${arquivoDaTentativa()}.${process.pid}.tmp`;
+            fs.writeFileSync(temporario, JSON.stringify({ em: new Date(agora).toISOString() }), { mode: 0o600 });
+            fs.renameSync(temporario, arquivoDaTentativa());
+        }
+        catch {
+            return false;
+        }
+        return true;
+    }
+    finally {
+        try {
+            trava.liberar();
+        }
+        catch { /* a trava de outro dono nao e desfeita aqui */ }
+    }
+}
+/**
+ * Evento de thread (criada, fase despachada, entregue, fechada): dispara `ork network publicar
+ * --silencioso` sem segurar quem chamou. So para membro, so fora do teto, nunca com a publicacao
+ * desligada pelo ambiente.
+ */
+function publicarRedeEmSegundoPlano(opcoes = {}) {
+    const env = opcoes.env ?? process.env;
+    if (publicacaoDesligada(env) || !adesaoDaRede().membro)
+        return false;
+    const cli = opcoes.cli ?? path.join(__dirname, 'index.js');
+    if (!fs.existsSync(cli) || !tomarVezDePublicar(opcoes.agora))
+        return false;
+    try {
+        const filho = (0, node_child_process_1.spawn)(process.execPath, [cli, 'network', 'publicar', '--silencioso'], { cwd: opcoes.diretorio ?? process.cwd(), detached: true, stdio: 'ignore', env });
+        filho.unref();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Uma linha JSON por publicacao em segundo plano, em `~/.orkastery/rede/rede.log`: quem publica sozinho deixa rastro. */
+function registrarNaRede(registro) {
+    try {
+        fs.mkdirSync((0, exports.pastaDaRede)(), { recursive: true });
+        fs.appendFileSync(path.join((0, exports.pastaDaRede)(), 'rede.log'), JSON.stringify({ ts: (0, util_1.agora)(), ...registro }) + '\n', { mode: 0o600 });
+    }
+    catch { /* o log e informativo */ }
+}