@orkastery/cli 0.5.1 → 0.5.3

package/dist/rede.js

@@ -0,0 +1,980 @@
+"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.RETRATO_PARADO_MS = exports.cachePronto = exports.MAXIMO_DE_ITENS = exports.refDaCasa = exports.PULSACAO_DA_REDE_MS = exports.PAINEL_DA_REDE = exports.DIR_DOS_RETRATOS = exports.BRANCH_DA_REDE = exports.CONTRATO_DO_RETRATO = void 0;
+exports.nomeSeguro = nomeSeguro;
+exports.arquivoDoRetrato = arquivoDoRetrato;
+exports.resolverCasa = resolverCasa;
+exports.hostnameSeguro = hostnameSeguro;
+exports.retratoDaMaquina = retratoDaMaquina;
+exports.retratoComDescartes = retratoComDescartes;
+exports.assinaturaDoRetrato = assinaturaDoRetrato;
+exports.achadoDeSegredo = achadoDeSegredo;
+exports.exigirRetratoSeguro = exigirRetratoSeguro;
+exports.segredoNoRetrato = segredoNoRetrato;
+exports.exigirSoOProprioRetrato = exigirSoOProprioRetrato;
+exports.normalizarRetrato = normalizarRetrato;
+exports.projetoNoContrato = projetoNoContrato;
+exports.retratosDaPonta = retratosDaPonta;
+exports.dirDoCache = dirDoCache;
+exports.prepararCache = prepararCache;
+exports.urlDaCasaAceita = urlDaCasaAceita;
+exports.identidadeDoGit = identidadeDoGit;
+exports.lerMarcaDaRede = lerMarcaDaRede;
+exports.gravarMarca = gravarMarca;
+exports.tirarTravaOrfa = tirarTravaOrfa;
+exports.idNoArquivo = idNoArquivo;
+exports.publicarRede = publicarRede;
+exports.publicarRedeNaBatida = publicarRedeNaBatida;
+exports.entrarNaRede = entrarNaRede;
+exports.sairDaRede = sairDaRede;
+exports.retratoParado = retratoParado;
+exports.painelDaRede = painelDaRede;
+/**
+ * RM-053: a Orkastery Network, as maquinas de uma pessoa em rede (lado da escrita).
+ *
+ * D1 (ADR-001): a rede mora num repositorio PRIVADO da pessoa na forja, `<usuario>/orkastery-network`,
+ * branch `main`, um `maquinas/<maquina>.json` por maquina (`ork.rede-maquina/v1`) e o `REDE.md`.
+ * A gravacao e a da RM-047 (`branch-de-estado`): indice temporario, commit sobre a ponta lida, push
+ * sem forca e releitura quando recusado, num cache em `~/.orkastery/rede/` (arvore de trabalho vazia),
+ * fora de qualquer clone de projeto.
+ *
+ * D3: publicar exige o repositorio privado, conferido na forja antes de cada publicacao.
+ * D5: o retrato e uma LISTA DE PERMISSAO (maquina, hostname, forjas, runtimes, hosts, projetos,
+ * versao do `ork`, batida) e passa por uma varredura de segredo antes do push: um achado recusa a
+ * publicacao inteira, e o erro diz o padrao e o campo, nunca o valor.
+ * D6: cada maquina so escreve o proprio retrato; o `REDE.md` e indice derivado que quem publica
+ * regenera. A forja nao distingue maquinas da mesma pessoa, entao a garantia e daqui e a auditoria
+ * e do git.
+ * D9: retrato igual so volta ao remoto de hora em hora (a batida); a leitura fica em `rede-status`.
+ */
+const node_crypto_1 = require("node:crypto");
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const branch_de_estado_1 = require("./branch-de-estado");
+const horario_1 = require("./horario");
+const hosts_1 = require("./hosts");
+const maquina_1 = require("./maquina");
+const monitor_lock_1 = require("./monitor-lock");
+const policies_1 = require("./policies");
+const rede_adesao_1 = require("./rede-adesao");
+const rede_forja_1 = require("./rede-forja");
+const rede_projetos_1 = require("./rede-projetos");
+const versao_1 = require("./versao");
+exports.CONTRATO_DO_RETRATO = 'ork.rede-maquina/v1';
+exports.BRANCH_DA_REDE = 'main';
+exports.DIR_DOS_RETRATOS = 'maquinas';
+exports.PAINEL_DA_REDE = 'REDE.md';
+/** D9: retrato igual so volta ao remoto depois disto; e o sinal de vida da maquina. */
+exports.PULSACAO_DA_REDE_MS = 60 * 60 * 1000;
+const PREFIXO = 'rede';
+const TENTATIVAS = 5;
+const DESCRICAO = 'Orkastery Network: o retrato de cada maquina desta pessoa (RM-053). Gerado pelo ork; nao edite a mao.';
+/** Os runtimes que o `ork` despacha, pelo binario que cada um usa. */
+const RUNTIMES_DA_REDE = [['claude-bg', 'claude'], ['codex', 'codex']];
+/** O binario de cada host de conducao. */
+const BINARIO_DO_HOST = { 'claude-code': 'claude', codex: 'codex', hermes: 'hermes', openclaw: 'openclaw' };
+const VERSAO_ESTRITA = /^\d+\.\d+(?:\.\d+)?(?:[-+][0-9A-Za-z.]{1,20})?$/;
+const refDaCasa = (c) => `${c.host}/${c.dono}/${c.repositorio}`;
+exports.refDaCasa = refDaCasa;
+/**
+ * O nome da maquina no que vai a forja: so o que o git e a forja aceitam sem surpresa. E o mesmo no
+ * arquivo, no campo `maquina` do retrato, na trava e nos commits (S2 da revisao 2: o leitor recusava o
+ * retrato de nome longo ou com espaco que o escritor publicava).
+ */
+function nomeSeguro(maquina) {
+    const nome = maquina.trim().replace(/[^A-Za-z0-9._-]+/g, '-').replace(/^[.-]+/, '').slice(0, 64);
+    // U3 da revisao 3: nome so com caracteres fora do ASCII (`日本`) ou so com pontos nao lanca mais; vira
+    // um nome estavel derivado dele, para o status e o sair continuarem funcionando.
+    return nome || `maquina-${(0, node_crypto_1.createHash)('sha256').update(maquina.trim()).digest('hex').slice(0, 8)}`;
+}
+/** O arquivo do retrato da maquina na casa. */
+function arquivoDoRetrato(maquina) {
+    return `${exports.DIR_DOS_RETRATOS}/${nomeSeguro(maquina)}.json`;
+}
+/**
+ * A casa: a opcao do comando, senao a adesao gravada, senao o login da primeira forja com login.
+ * Nunca lanca: sem forja ou sem login, devolve o motivo tipado.
+ */
+function resolverCasa(opcoes = {}) {
+    const amb = opcoes.amb ?? {};
+    const forjas = (0, rede_forja_1.forjasDaMaquina)(amb);
+    const identidades = opcoes.identidades ?? forjas.map((f) => f.identidade());
+    const config = (0, rede_adesao_1.lerConfigDaRede)();
+    const [donoPedido, nomePedido] = opcoes.repositorio?.includes('/') ? opcoes.repositorio.split('/', 2) : [null, opcoes.repositorio ?? null];
+    // B3: `--repositorio` sozinho troca so o repositorio; a forja gravada continua valendo.
+    const nomeDaForja = opcoes.forja ?? config?.forja ?? null;
+    if (!opcoes.forja && !opcoes.repositorio && config?.forja && config.dono && config.repositorio && config.host) {
+        // B9: a forja da casa e a do host gravado (GitLab proprio), nao a do ambiente de quem chamou.
+        const forja = (0, rede_forja_1.forjaPorNome)(config.forja, amb, config.host);
+        return { casa: { forja: config.forja, host: config.host, dono: config.dono, repositorio: config.repositorio, origem: 'rede.json' },
+            forja, identidades, motivo: forja ? null : { tipo: 'forja.ausente', detalhe: `a CLI da forja ${config.forja} nao esta nesta maquina` } };
+    }
+    // A forja gravada vale com o host gravado (GitLab proprio), mesmo quando so o repositorio muda.
+    const daCasaGravada = nomeDaForja && config?.forja === nomeDaForja && config.host ? (0, rede_forja_1.forjaPorNome)(nomeDaForja, amb, config.host) : null;
+    const candidatas = daCasaGravada ? [daCasaGravada] : nomeDaForja ? forjas.filter((f) => f.nome === nomeDaForja) : forjas;
+    if (candidatas.length === 0) {
+        return { casa: null, forja: null, identidades, motivo: { tipo: 'forja.ausente',
+                detalhe: nomeDaForja ? `a CLI da forja ${nomeDaForja} nao esta nesta maquina` : 'nenhuma CLI de forja (gh ou glab) nesta maquina' } };
+    }
+    const falhas = [];
+    for (const forja of candidatas) {
+        const lida = identidades.find((i) => i.forja === forja.nome && i.host === forja.host) ?? forja.identidade();
+        const usuario = lida.usuario;
+        if (!usuario) {
+            if (lida.falha)
+                falhas.push(lida.falha);
+            continue;
+        }
+        const origem = opcoes.forja || opcoes.repositorio ? 'opcao' : 'forja';
+        return { casa: { forja: forja.nome, host: forja.host, dono: donoPedido ?? usuario, repositorio: nomePedido ?? rede_adesao_1.REPOSITORIO_PADRAO, origem },
+            forja, identidades, motivo: null };
+    }
+    // Suspeitas da revisao de 03/10: prazo, erro da forja ou falta de rede no `gh api user` nao e falta de
+    // login; mandar a pessoa ao `gh auth login` esconderia o motivo de verdade.
+    if (falhas.length) {
+        return { casa: null, forja: null, identidades, motivo: { tipo: 'rede.sem-leitura',
+                detalhe: `${falhas.join('; ')}; o login nao foi lido, rode de novo com a forja respondendo` } };
+    }
+    return { casa: null, forja: null, identidades, motivo: { tipo: 'forja.sem-login',
+            detalhe: `${candidatas.map((f) => f.cli).join(' e ')} sem login nesta maquina (${candidatas.map((f) => `${f.cli} auth login`).join(' ou ')})` } };
+}
+function versaoDoAdaptador(host, home) {
+    const recibo = (0, hosts_1.lerRecibo)(path.join(home, hosts_1.HOSTS[host].destinoPadrao, hosts_1.HOSTS[host].subdir));
+    return typeof recibo?.versao === 'string' && VERSAO_ESTRITA.test(recibo.versao) ? recibo.versao : null;
+}
+function hostnameSeguro() {
+    const bruto = os.hostname().trim();
+    return /^[A-Za-z0-9][A-Za-z0-9._-]{0,252}$/.test(bruto) ? bruto : bruto.replace(/[^A-Za-z0-9._-]+/g, '-').slice(0, 253) || 'desconhecido';
+}
+/** O retrato desta maquina, montado so com os campos da lista de permissao (D5). */
+function retratoDaMaquina(opcoes = {}) {
+    return retratoComDescartes(opcoes).retrato;
+}
+/**
+ * O retrato e os projetos que ficaram fora dele. Projeto vem de fora do nucleo (o registro da
+ * RM-052, o cwd, o ultimo retrato): um valor dele com cara de segredo tira SO aquele projeto, com
+ * aviso, em vez de travar a publicacao da maquina para sempre (A1 do CHECK 1). O que o nucleo monta
+ * (maquina, hostname, forjas, runtimes, hosts) continua falhando fechado em `exigirRetratoSeguro`.
+ */
+function retratoComDescartes(opcoes = {}) {
+    const amb = opcoes.amb ?? {};
+    const home = amb.home ?? os.homedir();
+    const identidades = opcoes.identidades ?? (0, rede_forja_1.forjasDaMaquina)(amb).map((f) => f.identidade());
+    const versoes = new Map();
+    const binario = (nome) => {
+        if (!versoes.has(nome)) {
+            const achado = (0, rede_forja_1.acharBinario)(nome, amb);
+            versoes.set(nome, achado ? { binario: nome, versao: (0, rede_forja_1.versaoDoBinario)(achado, amb) } : null);
+        }
+        return versoes.get(nome) ?? null;
+    };
+    const runtimes = RUNTIMES_DA_REDE.flatMap(([runtime, nome]) => {
+        const b = binario(nome);
+        return b ? [{ runtime, binario: nome, versao: b.versao }] : [];
+    });
+    const hosts = hosts_1.ORDEM_DOS_HOSTS.flatMap((host) => {
+        const b = binario(BINARIO_DO_HOST[host]);
+        return b ? [{ host, versao: b.versao, adaptador: versaoDoAdaptador(host, home) }] : [];
+    });
+    const { projetos } = (0, rede_projetos_1.projetosConhecidos)({ arquivo: opcoes.arquivoDeProjetos, diretorio: opcoes.diretorio, anteriores: opcoes.anteriores });
+    const descartados = [];
+    // S2 da revisao 2: so vai o que o leitor aceita. Remoto longo demais vira `null` (e informativo);
+    // nome ou caminho fora do contrato tiram o projeto, com aviso; no maximo 200 projetos.
+    const presentes = projetos.filter((p) => p.presente)
+        .map((p) => ({ nome: p.nome, remoto: p.remoto !== null && p.remoto.length <= 500 ? p.remoto : null, caminho: p.caminho }));
+    const limpos = presentes.flatMap((p, i) => {
+        // V3 da revisao 4 e W1 da revisao 5: a regra unica de nome e o MESMO item de projeto do leitor
+        // (`projetoNoContrato`); vai ao retrato o que o leitor devolve, e o que ele recusa sai sozinho.
+        const lido = (0, rede_projetos_1.ehNomeDeProjeto)(p.nome) ? projetoNoContrato(p) : null;
+        if (!lido) {
+            descartados.push({ campo: `projetos[${i}]`, padrao: 'fora do contrato ork.rede-maquina/v1' });
+            return [];
+        }
+        for (const campo of ['nome', 'remoto', 'caminho']) {
+            const padrao = typeof lido[campo] === 'string' ? achadoDeSegredo(lido[campo]) : null;
+            if (padrao) {
+                descartados.push({ campo: `projetos[${i}].${campo}`, padrao });
+                return [];
+            }
+        }
+        return [lido];
+    });
+    if (limpos.length > exports.MAXIMO_DE_ITENS) {
+        descartados.push({ campo: `projetos[${exports.MAXIMO_DE_ITENS}..]`, padrao: `limite de ${exports.MAXIMO_DE_ITENS} projetos` });
+        limpos.length = exports.MAXIMO_DE_ITENS;
+    }
+    const retrato = {
+        contrato: exports.CONTRATO_DO_RETRATO,
+        maquina: nomeSeguro((0, maquina_1.nomeDaMaquina)(opcoes.maquina)),
+        ...(opcoes.id ? { id: opcoes.id } : {}),
+        hostname: hostnameSeguro(),
+        adesao: opcoes.adesao ?? (0, rede_adesao_1.adesaoDaRede)().adesao ?? 'rede',
+        forjas: identidades.map((i) => ({ forja: i.forja, host: i.host, cli: i.cli, versao: i.versao, usuario: i.usuario })),
+        runtimes,
+        hosts,
+        projetos: limpos,
+        versaoOrk: versao_1.VERSAO_DO_ORK,
+        publicadoEm: opcoes.agora ?? new Date().toISOString(),
+    };
+    return { retrato, descartados };
+}
+/** O que muda o retrato (sem o carimbo de hora): retrato igual nao precisa de push. */
+function assinaturaDoRetrato(r) {
+    const { publicadoEm: _publicadoEm, ...resto } = r;
+    return (0, node_crypto_1.createHash)('sha256').update(JSON.stringify(resto)).digest('hex');
+}
+// ---------------------------------------------------------------------------
+// As guardas (D5 e D6).
+// ---------------------------------------------------------------------------
+/** Alem do catalogo do nucleo (`procurarSegredos`): o que a rede nunca deixa sair. */
+const PADROES_DA_REDE = [
+    // V8 da revisao 4: token colado a letra ou `_` (`xghp_...`, `backup_sk-proj-...`) tambem vaza, entao
+    // nenhum prefixo pede limite a esquerda (X4 da revisao 6). W2 da revisao 5: o que separa o token de
+    // uma palavra comum (`task-proj-`, `flask-admin-`, `ASIAPACIFIC...`, `llama2_hf_...`) e a CAUDA de um
+    // token de verdade: alfabeto, tamanho, caixa mista e digito. Y2 da revisao 7: o AWS pede borda de
+    // maiuscula e digito dos dois lados (colado a minuscula ou `_` continua pego), e a OpenAI, 60 na cauda.
+    { nome: 'token do GitHub', regex: /(?:gh[pousr]_[A-Za-z0-9]{36,}|github_pat_[A-Za-z0-9_]{22,})/ },
+    { nome: 'token do GitLab', regex: /gl(?:pat|dt|oas|rt|cbt|ptt|ft|imt|agent|soat)-[A-Za-z0-9_-]{20,}/ },
+    { nome: 'token do Slack', regex: /xox[abprs]-[A-Za-z0-9-]{10,}/ },
+    { nome: 'chave de acesso AWS', regex: /(?<![A-Z0-9])(?:AKIA|ASIA)[A-Z2-7]{16}(?![A-Z0-9])/ },
+    { nome: 'token do Hugging Face', regex: /hf_(?=[A-Za-z0-9]*[A-Z])(?=[A-Za-z0-9]*[a-z])[A-Za-z0-9]{34,}/ },
+    // A chave de verdade traz `T3BlbkFJ` ("OpenAI" em base64) no corpo; sem ele, so cauda longa de token.
+    { nome: 'chave da OpenAI', regex: /sk-(?:proj|svcacct|admin|None)-(?:(?=[A-Za-z0-9_-]*T3BlbkFJ)[A-Za-z0-9_-]{20,}|(?=[A-Za-z0-9_-]*[0-9])(?=[A-Za-z0-9_-]*[A-Z])[A-Za-z0-9_-]{60,})/ },
+    { nome: 'token do npm', regex: /npm_[A-Za-z0-9]{36,}/ },
+    { nome: 'chave de API do Google', regex: /AIza[0-9A-Za-z_-]{35}/ },
+    { nome: 'token JWT', regex: /\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\./ },
+    { nome: 'credencial em URL', regex: /[a-z][a-z0-9+.-]*:\/\/[^\s"]*?[^/\s:@"\\]+:[^/\s@"]*@/i },
+    { nome: 'arquivo de credencial', regex: /(?:\.credentials\.json|auth\.json|hosts\.ya?ml|\.git-credentials|\.netrc|\.npmrc|\.pypirc|id_(?:rsa|ed25519|ecdsa)\b|[/\\]\.ssh[/\\]|\.config[/\\](?:gh|glab-cli)\b)/i },
+    { nome: 'e-mail de conta', regex: /[A-Za-z0-9._%+-]+@[A-Za-z0-9-]+(?:\.[A-Za-z0-9-]+)*\.[A-Za-z]{2,}\b(?!:)/ },
+];
+/** O nome do padrao de segredo que casa no texto, ou `null`: o catalogo do nucleo e o da rede. */
+function achadoDeSegredo(texto) {
+    return (0, policies_1.procurarSegredos)(texto)[0]?.nome ?? PADROES_DA_REDE.find((p) => p.regex.test(texto))?.nome ?? null;
+}
+const CAMPOS = {
+    retrato: ['contrato', 'maquina', 'id', 'hostname', 'adesao', 'forjas', 'runtimes', 'hosts', 'projetos', 'versaoOrk', 'publicadoEm'],
+    forjas: ['forja', 'host', 'cli', 'versao', 'usuario'],
+    runtimes: ['runtime', 'binario', 'versao'],
+    hosts: ['host', 'versao', 'adaptador'],
+    projetos: ['nome', 'remoto', 'caminho'],
+};
+function exigirSoCampos(onde, v, permitidos) {
+    if (!v || typeof v !== 'object' || Array.isArray(v))
+        throw new Error(`rede.segredo: ${onde} fora do contrato; nada foi publicado`);
+    for (const [k, x] of Object.entries(v)) {
+        if (!permitidos.includes(k))
+            throw new Error(`rede.segredo: campo "${onde}.${k}" fora da lista de permissao; nada foi publicado`);
+        if (x !== null && typeof x === 'string' && x.length > 1024)
+            throw new Error(`rede.segredo: campo "${onde}.${k}" longo demais; nada foi publicado`);
+    }
+}
+/**
+ * D5: o retrato so tem os campos da lista de permissao, e nenhum valor com cara de segredo. O erro
+ * diz o padrao e o campo, nunca o valor: relatorio que imprime o segredo vaza de novo.
+ */
+function exigirRetratoSeguro(r) {
+    exigirSoCampos('retrato', r, CAMPOS.retrato);
+    for (const lista of ['forjas', 'runtimes', 'hosts', 'projetos']) {
+        if (!Array.isArray(r[lista]))
+            throw new Error(`rede.segredo: ${lista} fora do contrato; nada foi publicado`);
+        r[lista].forEach((item, i) => exigirSoCampos(`${lista}[${i}]`, item, CAMPOS[lista]));
+    }
+    // S2 da revisao 2: o que o escritor publica, o leitor aceita; senao, ninguem ve esta maquina.
+    if (!normalizarRetrato(r))
+        throw new Error('rede.contrato: o retrato desta maquina nao passa no contrato ork.rede-maquina/v1; nada foi publicado');
+    const achado = segredoNoRetrato(r);
+    if (achado)
+        throw new Error(`rede.segredo: padrao "${achado.padrao}" em ${achado.onde}; nada foi publicado (valor omitido de proposito)`);
+}
+/** O primeiro valor do retrato com cara de segredo: o padrao e o campo, nunca o valor. */
+function segredoNoRetrato(r) {
+    const visitar = (v, onde) => {
+        if (typeof v === 'string') {
+            const padrao = achadoDeSegredo(v);
+            return padrao ? { padrao, onde } : null;
+        }
+        if (Array.isArray(v)) {
+            for (let i = 0; i < v.length; i++) {
+                const a = visitar(v[i], `${onde}[${i}]`);
+                if (a)
+                    return a;
+            }
+            return null;
+        }
+        if (v && typeof v === 'object') {
+            for (const [k, x] of Object.entries(v)) {
+                const a = visitar(x, onde ? `${onde}.${k}` : k);
+                if (a)
+                    return a;
+            }
+        }
+        return null;
+    };
+    return visitar(r, '');
+}
+/** D6: uma publicacao desta maquina so toca o proprio retrato e o indice. */
+function exigirSoOProprioRetrato(maquina, mudancas) {
+    const proprio = arquivoDoRetrato(maquina);
+    for (const m of mudancas) {
+        if (m.caminho !== proprio && m.caminho !== exports.PAINEL_DA_REDE) {
+            throw new Error(`rede.retrato-alheio: ${maquina} tentou gravar ${m.caminho}; cada maquina so escreve ${proprio}`);
+        }
+    }
+}
+const ehObjeto = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
+// V2 da revisao 4: texto com caractere que o terminal executa ou que ninguem ve fica fora do contrato.
+const ehTexto = (v, teto = 1024) => typeof v === 'string' && v.length <= teto && !rede_projetos_1.INVISIVEL.test(v);
+const ehTextoOuNulo = (v, teto = 1024) => v === null || ehTexto(v, teto);
+/** O teto de itens de cada lista do retrato, igual no escritor e no leitor. */
+exports.MAXIMO_DE_ITENS = 200;
+const PULAR = Symbol('pular');
+/**
+ * Cada item de uma lista do retrato, campo a campo; so os campos do contrato saem. Item com valor de
+ * enum que esta versao nao conhece (um host novo, outra forja) e PULADO: versao nova e compativel,
+ * e a maquina que atualizou primeiro nao some para quem nao atualizou (S2 da revisao 2).
+ */
+function itens(v, item) {
+    if (!Array.isArray(v) || v.length > exports.MAXIMO_DE_ITENS)
+        return null;
+    const saida = [];
+    for (const x of v) {
+        const ok = ehObjeto(x) ? item(x) : null;
+        if (ok === null)
+            return null;
+        if (ok !== PULAR)
+            saida.push(ok);
+    }
+    return saida;
+}
+/**
+ * O retrato lido da casa, conferido por inteiro (M1 do CHECK 1): cada campo do contrato com o tipo
+ * certo, cada item de cada lista idem. Campo desconhecido e ignorado (versao nova e compativel);
+ * campo do contrato ausente ou com outro tipo invalida o arquivo, que vira lacuna. Antes, um
+ * `projetos: [null]` derrubava o status, o publicar e o sair de todas as maquinas.
+ */
+function normalizarRetrato(bruto) {
+    if (!ehObjeto(bruto) || bruto.contrato !== exports.CONTRATO_DO_RETRATO)
+        return null;
+    const r = bruto;
+    if (!ehTexto(r.maquina, 64) || !r.maquina.trim() || !ehTexto(r.hostname, 253) || !ehTexto(r.versaoOrk, 40))
+        return null;
+    if (!ehTexto(r.publicadoEm, 40) || !Number.isFinite(Date.parse(r.publicadoEm)))
+        return null;
+    if (r.adesao !== 'rede' && r.adesao !== 'fabrica')
+        return null;
+    const forjas = itens(r.forjas, (x) => !(ehTexto(x.forja, 40) && ehTexto(x.host, 255) && ehTexto(x.cli, 16) &&
+        ehTextoOuNulo(x.versao, 40) && ehTextoOuNulo(x.usuario, 255)) ? null
+        : x.forja !== 'github' && x.forja !== 'gitlab' ? PULAR
+            : { forja: x.forja, host: x.host, cli: x.cli, versao: x.versao, usuario: x.usuario });
+    const runtimes = itens(r.runtimes, (x) => ehTexto(x.runtime, 40) && ehTexto(x.binario, 40) && ehTextoOuNulo(x.versao, 40)
+        ? { runtime: x.runtime, binario: x.binario, versao: x.versao } : null);
+    const hosts = itens(r.hosts, (x) => !(ehTexto(x.host, 40) && ehTextoOuNulo(x.versao, 40) && ehTextoOuNulo(x.adaptador, 40)) ? null
+        : !hosts_1.ORDEM_DOS_HOSTS.includes(x.host) ? PULAR
+            : { host: x.host, versao: x.versao, adaptador: x.adaptador });
+    const projetos = itens(r.projetos, projetoNoContrato);
+    if (!forjas || !runtimes || !hosts || !projetos)
+        return null;
+    if (r.id !== undefined && !(0, rede_adesao_1.ehIdDeMaquina)(r.id))
+        return null;
+    return { contrato: exports.CONTRATO_DO_RETRATO, maquina: r.maquina, ...(r.id !== undefined ? { id: r.id } : {}), hostname: r.hostname,
+        adesao: r.adesao, forjas, runtimes, hosts, projetos, versaoOrk: r.versaoOrk, publicadoEm: r.publicadoEm };
+}
+/**
+ * W1 da revisao 5: o item de projeto do contrato, o MESMO predicado no leitor e no filtro do escritor
+ * (antes, a regra de nome do escritor aceitava o que este recusava, e a publicacao inteira caia).
+ * V9 da revisao 4: o remoto e remontado; o que nao sai igual (de outra versao ou de outra mao) vira `null`.
+ */
+function projetoNoContrato(x) {
+    if (!ehTexto(x.nome, 80) || !ehTextoOuNulo(x.remoto, 500) || !ehTexto(x.caminho, 1024))
+        return null;
+    return { nome: x.nome, remoto: x.remoto !== null && (0, rede_projetos_1.limparRemoto)(x.remoto) === x.remoto ? x.remoto : null, caminho: x.caminho };
+}
+/**
+ * Os retratos de uma ponta, cada um conferido: contrato, forma e o NOME do arquivo igual ao da
+ * maquina que o retrato diz ser. Arquivo ruim vira `invalidos`, nunca derruba a leitura.
+ */
+function retratosDaPonta(cache, ponta) {
+    return (0, rede_forja_1.comGitIsolado)(() => lerRetratos(cache, ponta));
+}
+function lerRetratos(cache, ponta) {
+    if (!ponta)
+        return { retratos: [], invalidos: [] };
+    // B12: `-z`, porque sem ele o git poe aspas em nome nao ASCII e o arquivo sumia calado.
+    const arquivos = (0, branch_de_estado_1.exigirGit)(cache, ['ls-tree', '-r', '-z', '--name-only', ponta, '--', `${exports.DIR_DOS_RETRATOS}/`], PREFIXO)
+        .split('\0').filter(Boolean);
+    const retratos = [], invalidos = [];
+    for (const arquivo of arquivos) {
+        const visivel = JSON.stringify(arquivo).slice(1, -1).slice(0, 120);
+        if (!/^maquinas\/[A-Za-z0-9._-]{1,64}\.json$/.test(arquivo)) {
+            invalidos.push({ arquivo: visivel, motivo: 'nome de arquivo fora do padrao maquinas/<maquina>.json' });
+            continue;
+        }
+        let bruto;
+        try {
+            bruto = JSON.parse((0, branch_de_estado_1.exigirGit)(cache, ['show', `${ponta}:${arquivo}`], PREFIXO));
+        }
+        catch {
+            invalidos.push({ arquivo, motivo: 'JSON ilegivel' });
+            continue;
+        }
+        const retrato = normalizarRetrato(bruto);
+        if (!retrato) {
+            invalidos.push({ arquivo, motivo: `fora do contrato ${exports.CONTRATO_DO_RETRATO}` });
+            continue;
+        }
+        let esperado = null;
+        try {
+            esperado = arquivoDoRetrato(retrato.maquina);
+        }
+        catch { /* nome impossivel */ }
+        if (esperado !== arquivo) {
+            invalidos.push({ arquivo, motivo: `diz ser a maquina "${retrato.maquina}", que nao e a dona deste arquivo` });
+            continue;
+        }
+        // V9 da revisao 4: a mesma varredura do escritor; o que ela pega nao vai ao status nem ao REDE.md.
+        // W3 da revisao 5: o projeto com cara de segredo sai sozinho (o escritor faz o mesmo); so campo do
+        // nucleo com cara de segredo tira a maquina inteira.
+        const achados = retrato.projetos.map((x) => segredoNoRetrato(x));
+        const projetos = retrato.projetos.filter((_x, i) => !achados[i]);
+        const primeiro = achados.find((x) => x !== null);
+        if (primeiro) {
+            invalidos.push({ arquivo, motivo: `${retrato.projetos.length - projetos.length} projeto(s) fora da leitura: padrao "${primeiro.padrao}" (valor omitido de proposito)` });
+        }
+        const lido = { ...retrato, projetos };
+        const segredo = segredoNoRetrato(lido);
+        if (segredo) {
+            invalidos.push({ arquivo, motivo: `padrao "${segredo.padrao}" em ${segredo.onde} (valor omitido de proposito)` });
+            continue;
+        }
+        retratos.push(lido);
+    }
+    retratos.sort((a, b) => a.maquina.localeCompare(b.maquina));
+    return { retratos, invalidos };
+}
+// ---------------------------------------------------------------------------
+// O cache da casa e o git sem prompt.
+// ---------------------------------------------------------------------------
+function dirDoCache(casa) {
+    return path.join((0, rede_adesao_1.pastaDaRede)(), `${casa.forja}-${casa.host}-${casa.dono}-${casa.repositorio}`.replace(/[^A-Za-z0-9._-]+/g, '-'));
+}
+/** O cache ja foi criado? */
+const cachePronto = (dir) => fs.existsSync(path.join(dir, '.git', 'HEAD'));
+exports.cachePronto = cachePronto;
+/**
+ * O cache da casa: um repositorio com arvore de trabalho VAZIA (nunca ha checkout), porque a
+ * remocao de arquivo do `gravarNaBranch` (`update-index --force-remove`) exige arvore de trabalho,
+ * como nos clones em que a fabrica roda. Remoto `origin` na URL que a forja devolveu; autor = esta
+ * maquina; sem hook nem assinatura (roda em segundo plano); e, para HTTPS, o helper de credencial da
+ * propria forja so aqui dentro (D4): o primeiro valor vazio zera os helpers da configuracao global.
+ */
+function prepararCache(casa, url, helper, maquina) {
+    return (0, rede_forja_1.comGitIsolado)(() => configurarCache(casa, url, helper, maquina));
+}
+function configurarCache(casa, url, helper, maquina) {
+    const dir = dirDoCache(casa);
+    if (!(0, exports.cachePronto)(dir)) {
+        fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+        (0, branch_de_estado_1.exigirGit)(dir, ['init', '--quiet'], PREFIXO);
+    }
+    const semHooks = path.join(dir, '.git', 'sem-hooks');
+    fs.mkdirSync(semHooks, { recursive: true });
+    // B6: so grava o que mudou; leitura e publicacao simultaneas nao disputam a config a cada chamada.
+    // So a config LOCAL do cache conta: a global da pessoa (o `gh auth setup-git`, por exemplo) fica como esta.
+    const config = (chave, valor) => {
+        if ((0, branch_de_estado_1.git)(dir, ['config', '--local', '--get', chave]).stdout.replace(/\n$/, '') !== valor)
+            (0, branch_de_estado_1.exigirGit)(dir, ['config', '--local', chave, valor], PREFIXO);
+    };
+    config('remote.origin.url', url);
+    config('core.hooksPath', semHooks);
+    config('commit.gpgsign', 'false');
+    config('user.name', identidadeDoGit(maquina).nome);
+    config('user.email', identidadeDoGit(maquina).email);
+    if (helper && /^https:\/\//i.test(url)) {
+        const chave = `credential.${new URL(url).origin}.helper`;
+        if ((0, branch_de_estado_1.git)(dir, ['config', '--local', '--get-all', chave]).stdout !== `\n${helper}\n`) {
+            (0, branch_de_estado_1.git)(dir, ['config', '--local', '--unset-all', chave]);
+            (0, branch_de_estado_1.exigirGit)(dir, ['config', '--local', '--add', chave, ''], PREFIXO);
+            (0, branch_de_estado_1.exigirGit)(dir, ['config', '--local', '--add', chave, helper], PREFIXO);
+        }
+    }
+    return dir;
+}
+/**
+ * V9 da revisao 4: a URL da casa e https, com o helper da forja; `http://` mandaria o token sem TLS. O
+ * caminho local (sem esquema) e o remoto bare de um espelho ou dos testes: nao ha credencial nele.
+ */
+function urlDaCasaAceita(url) {
+    return /^https:\/\/[^\s@/]+\//i.test(url) || (path.isAbsolute(url) && !/^[A-Za-z][A-Za-z0-9+.-]*:/.test(url));
+}
+/** O autor dos commits da casa: a maquina, com e-mail que nao existe (B8). */
+function identidadeDoGit(maquina) {
+    return { nome: nomeSeguro(maquina), email: `${nomeSeguro(maquina)}@rede.orkastery.invalid` };
+}
+const arquivoDaMarca = () => path.join((0, rede_adesao_1.pastaDaRede)(), 'publicada.json');
+function lerMarcaDaRede() {
+    try {
+        return JSON.parse(fs.readFileSync(arquivoDaMarca(), 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Suspeitas da revisao de 03/10: a marca troca inteira, por `rename`. Escrita direta deixava o
+ * `ork network status`, o doctor e o `publicarRede` (que le fora da trava) ver o arquivo vazio ou
+ * cortado, e um processo morto entre o truncamento e a escrita deixava a marca ilegivel: a proxima
+ * publicacao perdia a reserva D7 dos projetos. Exportada so para o teste.
+ */
+function gravarMarca(marca) {
+    fs.mkdirSync((0, rede_adesao_1.pastaDaRede)(), { recursive: true });
+    const temporario = `${arquivoDaMarca()}.${process.pid}.tmp`;
+    try {
+        fs.writeFileSync(temporario, JSON.stringify(marca, null, 2) + '\n', { mode: 0o600 });
+        fs.renameSync(temporario, arquivoDaMarca());
+    }
+    catch (e) {
+        try {
+            fs.rmSync(temporario, { force: true });
+        }
+        catch { /* o temporario e so deste processo */ }
+        throw e;
+    }
+}
+/** A casa com o repositorio conferido: existe e e privado (D3). `criar` so no `ork network entrar`. */
+function casaConferida(opcoes) {
+    const r = resolverCasa(opcoes);
+    if (!r.casa || !r.forja)
+        throw new Error(`rede.sem-forja: ${r.motivo?.detalhe ?? 'nenhuma forja utilizavel'}`);
+    let repo = r.forja.repositorio(r.casa.dono, r.casa.repositorio);
+    let criado = false;
+    if (!repo.existe) {
+        if (!opcoes.criar)
+            throw new Error(`rede.sem-repositorio: ${(0, exports.refDaCasa)(r.casa)} ainda nao existe; ork network entrar o cria, privado`);
+        const login = (r.identidades.find((i) => i.forja === r.forja.nome && i.host === r.forja.host) ?? r.forja.identidade()).usuario;
+        if (r.casa.dono !== login) {
+            throw new Error(`rede.repositorio-alheio: ${(0, exports.refDaCasa)(r.casa)} nao existe e nao e do login ${login}; crie o repositorio privado na forja e rode de novo`);
+        }
+        repo = r.forja.criarPrivado(r.casa.repositorio, DESCRICAO);
+        criado = true;
+    }
+    if (repo.privado !== true)
+        throw new Error(`rede.repositorio-publico: ${(0, exports.refDaCasa)(r.casa)} nao e privado; nada foi publicado`);
+    if (!repo.url)
+        throw new Error(`rede.forja: ${r.forja.cli} nao devolveu a URL de ${(0, exports.refDaCasa)(r.casa)}`);
+    if (!urlDaCasaAceita(repo.url)) {
+        throw new Error(`rede.sem-https: ${r.forja.cli} devolveu para ${(0, exports.refDaCasa)(r.casa)} uma URL sem https; a rede so fala com a forja por https, e nada foi publicado`);
+    }
+    return { casa: r.casa, forja: r.forja, url: repo.url, criado, identidades: r.identidades };
+}
+/**
+ * S8 da revisao 2: no GitLab proprio, a forja do ambiente (sem `GITLAB_HOST` no cron) aponta para
+ * gitlab.com; o retrato leva a identidade do HOST DA CASA, lida pela forja da casa.
+ */
+function identidadesComACasa(identidades, forja) {
+    if (identidades.some((i) => i.forja === forja.nome && i.host === forja.host))
+        return identidades;
+    const ordem = (i) => (i.forja === 'github' ? 0 : 1);
+    return [...identidades.filter((i) => i.forja !== forja.nome), forja.identidade()].sort((a, b) => ordem(a) - ordem(b));
+}
+const TRAVA = () => path.join((0, rede_adesao_1.pastaDaRede)(), 'publicar.lock');
+/** Uma trava sem `pid` valido ha mais que isto e orfa: quem a criou caiu entre o `mkdir` e a gravacao do pid. */
+const TRAVA_ORFA_MS = 5 * 60 * 1000;
+/** U5 da revisao 3: sem `pid`, com `pid` vazio ou com lixo, e velha. A de `pid` valido fica com o monitor-lock (vivo ou morto). */
+function travaOrfa(dir = TRAVA()) {
+    try {
+        if (Date.now() - fs.statSync(dir).mtimeMs <= TRAVA_ORFA_MS)
+            return false;
+        const pid = fs.existsSync(path.join(dir, 'pid')) ? Number(fs.readFileSync(path.join(dir, 'pid'), 'utf8')) : NaN;
+        return !(Number.isInteger(pid) && pid > 0);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * W9 do CHECK 5 (RM-053 fatia 2): a faxina da trava orfa e SERIAL, sob a trava `<trava>.faxina`.
+ * Antes, com tres processos e uma orfa, quem tinha julgado "orfa" podia mover a trava VIVA de outro
+ * (que entrou depois da orfa sair) e, se um terceiro ja ocupava o lugar, a viva encalhava em
+ * `publicar.lock.orfa-*` e o `liberar()` do dono dava erro depois de um push que ja tinha dado certo.
+ *
+ * Sob a faxina, o julgamento e refeito no lugar antes de mover: so uma faxina tira orfa (a trava com
+ * `pid` valido o monitor-lock troca sozinho, e nunca e orfa aqui), entao o que esta no lugar quando a
+ * faxina julga e o que ela move. A trava viva nunca sai do lugar. O renomear antes de apagar fica
+ * como segunda guarda (V6 da revisao 4): so apaga o que, ja movido, continua orfao.
+ *
+ * `ocupada`: outra faxina esta em curso; quem chamou espera a trava como sempre. A faxina que caiu
+ * entre o `mkdir` e o `pid` (velha, sem `pid` valido) e tirada, e a proxima rodada faz a faxina.
+ */
+function tirarTravaOrfa(trava = TRAVA()) {
+    const faxina = `${trava}.faxina`;
+    const vez = (0, monitor_lock_1.adquirirLockMonitor)(faxina);
+    if (!vez.ok) {
+        if (!vez.ativo && travaOrfa(faxina))
+            fs.rmSync(faxina, { recursive: true, force: true });
+        return 'ocupada';
+    }
+    try {
+        if (!fs.existsSync(trava))
+            return 'sumiu';
+        if (!travaOrfa(trava))
+            return 'viva';
+        const lixo = `${trava}.orfa-${process.pid}-${Date.now()}`;
+        try {
+            fs.renameSync(trava, lixo);
+        }
+        catch {
+            return 'sumiu';
+        }
+        if (travaOrfa(lixo)) {
+            fs.rmSync(lixo, { recursive: true, force: true });
+            return 'removida';
+        }
+        try {
+            fs.renameSync(lixo, trava);
+        }
+        catch { /* uma terceira trava ja ocupa o lugar: esta fica para o dono */ }
+        return 'viva';
+    }
+    finally {
+        try {
+            vez.liberar();
+        }
+        catch { /* a faxina e desta chamada; sumir com ela nao desfaz o que foi feito */ }
+    }
+}
+/**
+ * A trava de escrita na casa desta maquina, esperando ate `esperaMs` quando outra escrita esta em
+ * curso. S11 da revisao 2: a trava orfa (sem `pid`, velha) sai uma vez, em vez de devolver "ocupado"
+ * para sempre; a com `pid` vivo nunca e tirada.
+ */
+function travarCasa(esperaMs) {
+    fs.mkdirSync((0, rede_adesao_1.pastaDaRede)(), { recursive: true });
+    const limite = Date.now() + esperaMs;
+    let tirouOrfa = false;
+    for (;;) {
+        const trava = (0, monitor_lock_1.adquirirLockMonitor)(TRAVA());
+        if (trava.ok)
+            return trava;
+        if (!trava.ativo && !tirouOrfa && travaOrfa()) {
+            tirouOrfa = true;
+            tirarTravaOrfa();
+            continue;
+        }
+        if (Date.now() >= limite)
+            return { ok: false };
+        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 100);
+    }
+}
+/**
+ * U2 da revisao 3: o `id` gravado no arquivo com o nome desta maquina, quando esta versao nao le o
+ * retrato (contrato mais novo, campo que ela recusa). W3 da revisao 5: vale o CABECALHO bem formado,
+ * em qualquer versao: `contrato` `ork.rede-maquina/vN`, `maquina` dona deste arquivo e `id` valido.
+ * Assim o retrato legitimo de outra instalacao continua prendendo o nome, e lixo com um `id` (V7 da
+ * revisao 4) ou a copia de outra maquina com o nome errado nao prendem. `null` sem cabecalho ou `id`.
+ */
+function idNoArquivo(cache, ponta, arquivo) {
+    if (!ponta)
+        return null;
+    const r = (0, rede_forja_1.comGitIsolado)(() => (0, branch_de_estado_1.git)(cache, ['show', `${ponta}:${arquivo}`]));
+    if (!r.ok)
+        return null;
+    try {
+        const { contrato, maquina, id } = JSON.parse(r.stdout);
+        if (typeof contrato !== 'string' || !/^ork\.rede-maquina\/v[1-9][0-9]{0,5}$/.test(contrato) || typeof maquina !== 'string')
+            return null;
+        return arquivoDoRetrato(maquina) === arquivo && (0, rede_adesao_1.ehIdDeMaquina)(id) ? id : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Grava o retrato na casa, sob a trava desta maquina. B6: a adesao e reconferida DENTRO da trava
+ * (um `sair` no meio nao ve o retrato reaparecer). B7: o arquivo com este nome que for de outra
+ * instalacao (outro `id`) nao e regravado, salvo `tomarNome`.
+ */
+function gravarNaCasa(conferida, retrato, descartados, opcoes) {
+    const { casa, forja, url } = conferida;
+    const maquina = retrato.maquina;
+    const trava = travarCasa(0);
+    if (!trava.ok)
+        return { acao: 'ocupado', maquina, casa: (0, exports.refDaCasa)(casa), commit: null, tentativas: 0, descartados };
+    try {
+        if (opcoes.exigirAdesao && !(0, rede_adesao_1.adesaoDaRede)().membro)
+            throw new Error('rede.fora: esta maquina saiu da rede; nada foi publicado');
+        const cache = prepararCache(casa, url, forja.helperDeCredencial(), maquina);
+        const assinatura = assinaturaDoRetrato(retrato);
+        for (let tentativa = 1; tentativa <= TENTATIVAS; tentativa++) {
+            const { ponta, atualizado } = (0, rede_forja_1.comGitIsolado)(() => (0, branch_de_estado_1.buscarBranch)(cache, 'origin', exports.BRANCH_DA_REDE, PREFIXO, 30000));
+            if (!atualizado)
+                throw new Error(`rede.sem-leitura: nao consegui ler ${(0, exports.refDaCasa)(casa)}; publicar exige rede`);
+            const { retratos } = retratosDaPonta(cache, ponta);
+            const atual = retratos.find((r) => r.maquina === maquina);
+            // U2: o arquivo que esta versao nao le ainda pode ser de outra instalacao (contrato mais novo).
+            const idDoOutro = atual ? atual.id ?? null : idNoArquivo(cache, ponta, arquivoDoRetrato(maquina));
+            const alheio = !!idDoOutro && idDoOutro !== retrato.id;
+            if (alheio && !opcoes.tomarNome) {
+                // U7 da revisao 3: o hostname igual sugere a propria maquina, mas duas VMs podem se chamar `ubuntu`.
+                const dica = atual?.hostname === hostnameSeguro()
+                    ? '; o retrato tem o hostname desta maquina: se for ela mesma, com ~/.orkastery apagada ou copiada, retome o nome com ' +
+                        'ork network entrar --forcar; se for outra maquina ou instalacao com o mesmo hostname, escolha outro nome com --maquina NOME'
+                    : '; escolha outro nome com ork network entrar --maquina NOME, ou tome este com --forcar';
+                const quem = atual ? ` (hostname ${atual.hostname}, batida ${(0, horario_1.formatarDataHora)(atual.publicadoEm)})` : ' (num retrato que esta versao nao le)';
+                throw new Error(`rede.nome-em-uso: outra instalacao ja publica como "${maquina}"${quem}${dica}`);
+            }
+            const mudancas = [
+                { caminho: arquivoDoRetrato(maquina), conteudo: JSON.stringify(retrato, null, 2) + '\n' },
+                { caminho: exports.PAINEL_DA_REDE, conteudo: painelDaRede([...retratos.filter((r) => r.maquina !== maquina), retrato], Date.parse(retrato.publicadoEm)) },
+            ];
+            exigirSoOProprioRetrato(maquina, mudancas);
+            const mensagem = alheio ? `rede: ${maquina} publicou o retrato, tomando o nome de outra instalacao` : `rede: ${maquina} publicou o retrato`;
+            const commit = (0, rede_forja_1.comGitIsolado)(() => (0, branch_de_estado_1.gravarNaBranch)(cache, 'origin', exports.BRANCH_DA_REDE, ponta, mudancas, mensagem, PREFIXO), identidadeDoGit(maquina));
+            if (commit) {
+                gravarMarca({ assinatura, em: retrato.publicadoEm, commit, casa: (0, exports.refDaCasa)(casa), forja: casa.forja, maquina,
+                    projetos: retrato.projetos, forjas: retrato.forjas });
+                return { acao: 'publicou', maquina, casa: (0, exports.refDaCasa)(casa), commit, tentativas: tentativa, descartados, ...(alheio ? { tomouNome: true } : {}) };
+            }
+        }
+        throw new Error(`rede.concorrencia: ${TENTATIVAS} pushes recusados seguidos; tente de novo em instantes`);
+    }
+    finally {
+        trava.liberar();
+    }
+}
+/**
+ * `ork network publicar`: grava o retrato desta maquina na casa. So membro publica. M4 do CHECK 1:
+ * retrato igual ao ultimo, dentro da batida, nao chama a forja nenhuma vez (as forjas vem da marca);
+ * `forcar` publica mesmo assim.
+ */
+function publicarRede(opcoes = {}) {
+    const adesao = (0, rede_adesao_1.adesaoDaRede)();
+    if (!adesao.membro)
+        throw new Error('rede.fora: esta maquina nao esta na rede; ork network entrar');
+    const amb = opcoes.amb ?? {};
+    const maquina = nomeSeguro((0, maquina_1.nomeDaMaquina)(opcoes.maquina));
+    const id = (0, rede_adesao_1.idDaMaquina)();
+    const agora = opcoes.agora ?? new Date().toISOString();
+    const marca = lerMarcaDaRede();
+    const base = { amb, maquina, id, diretorio: opcoes.diretorio, agora, arquivoDeProjetos: opcoes.arquivoDeProjetos, adesao: adesao.adesao ?? 'rede' };
+    // S15 da revisao 2: relogio que voltou (agora antes da marca) nao conta como dentro da batida.
+    const desde = marca ? Date.parse(agora) - Date.parse(marca.em) : NaN;
+    const dentroDaBatida = !!marca && marca.maquina === maquina && desde >= 0 && desde < exports.PULSACAO_DA_REDE_MS;
+    if (!opcoes.forcar && dentroDaBatida && marca.forjas && !opcoes.forja && !opcoes.repositorio) {
+        const barato = retratoComDescartes({ ...base, identidades: marca.forjas, anteriores: marca.projetos });
+        if (assinaturaDoRetrato(barato.retrato) === marca.assinatura) {
+            return { acao: 'sem-mudanca', maquina, casa: marca.casa, commit: marca.commit, tentativas: 0, descartados: barato.descartados };
+        }
+    }
+    const lidas = opcoes.identidades ?? (0, rede_forja_1.forjasDaMaquina)(amb).map((f) => f.identidade());
+    const conferida = casaConferida({ ...opcoes, identidades: lidas });
+    const identidades = identidadesComACasa(lidas, conferida.forja);
+    const mesmaCasa = marca?.casa === (0, exports.refDaCasa)(conferida.casa) && marca?.maquina === maquina;
+    const { retrato, descartados } = retratoComDescartes({ ...base, identidades, anteriores: mesmaCasa ? marca?.projetos : undefined });
+    exigirRetratoSeguro(retrato);
+    if (!opcoes.forcar && mesmaCasa && dentroDaBatida && marca?.assinatura === assinaturaDoRetrato(retrato)) {
+        return { acao: 'sem-mudanca', maquina, casa: marca.casa, commit: marca.commit, tentativas: 0, descartados };
+    }
+    return gravarNaCasa(conferida, retrato, descartados, { exigirAdesao: true, tomarNome: false });
+}
+/**
+ * D9: a batida do pulse (e o `ork network publicar --silencioso` dos eventos). So membro, so com a
+ * publicacao ligada, no maximo uma tentativa a cada 14 minutos. `null` quando nao era a vez.
+ */
+function publicarRedeNaBatida(opcoes = {}) {
+    if ((0, rede_adesao_1.publicacaoDesligada)(opcoes.amb?.env ?? process.env) || !(0, rede_adesao_1.adesaoDaRede)().membro)
+        return null;
+    if (!(0, rede_adesao_1.tomarVezDePublicar)(opcoes.agoraMs))
+        return null;
+    return publicarRede(opcoes);
+}
+const NOME_DE_MAQUINA = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
+/**
+ * `ork network entrar`. M2 do CHECK 1: atomico do ponto de vista da maquina. Confere (e cria,
+ * privada) a casa, publica o primeiro retrato e SO ENTAO grava o nome e a adesao; se a publicacao
+ * falha, nada muda aqui. M3: o nome que vale e gravado, como no `ork fabrica entrar`: `--maquina`,
+ * senao o ja gravado, senao `ORK_MAQUINA` ou o hostname; assim o cron publica com o mesmo nome.
+ */
+function entrarNaRede(opcoes = {}) {
+    // O nome explicito tem de ser valido; o que vem do arquivo, de ORK_MAQUINA ou do hostname e saneado.
+    const explicito = (opcoes.maquina ?? '').trim();
+    const maquina = explicito || nomeSeguro((0, maquina_1.lerConfigDaMaquina)()?.nome || (0, maquina_1.nomeDaMaquina)());
+    if (!NOME_DE_MAQUINA.test(maquina)) {
+        throw new Error(`rede.maquina: nome de maquina invalido ("${maquina}"); use ork network entrar --maquina NOME (letras, numeros, ponto, _ ou -)`);
+    }
+    const amb = opcoes.amb ?? {};
+    const lidas = opcoes.identidades ?? (0, rede_forja_1.forjasDaMaquina)(amb).map((f) => f.identidade());
+    const conferida = casaConferida({ ...opcoes, identidades: lidas, criar: true });
+    // S6 da revisao 2: entrar de novo, na mesma casa e com o mesmo nome, mantem a reserva D7 da marca.
+    const marca = lerMarcaDaRede();
+    const anteriores = marca?.casa === (0, exports.refDaCasa)(conferida.casa) && marca.maquina === maquina ? marca.projetos : undefined;
+    const { retrato, descartados } = retratoComDescartes({ amb, maquina, id: (0, rede_adesao_1.idDaMaquina)(), diretorio: opcoes.diretorio,
+        agora: opcoes.agora, identidades: identidadesComACasa(lidas, conferida.forja), anteriores, arquivoDeProjetos: opcoes.arquivoDeProjetos,
+        adesao: 'rede' });
+    exigirRetratoSeguro(retrato);
+    const publicacao = gravarNaCasa(conferida, retrato, descartados, { exigirAdesao: false, tomarNome: opcoes.tomarNome });
+    if (publicacao.acao === 'ocupado') {
+        throw new Error(`rede.ocupado: outra publicacao desta maquina esta em andamento (${TRAVA()}); rode ork network entrar de novo em instantes`);
+    }
+    (0, maquina_1.gravarConfigDaMaquina)({ nome: maquina });
+    const { casa } = conferida;
+    const config = (0, rede_adesao_1.gravarConfigDaRede)({ membro: true, forja: casa.forja, host: casa.host, dono: casa.dono, repositorio: casa.repositorio });
+    return { config, casa: { ...casa, origem: 'rede.json' }, criado: conferida.criado, publicacao };
+}
+/**
+ * `ork network sair`: a adesao vira `membro: false` e o retrato desta maquina sai da casa. B6: sob a
+ * trava desta maquina (espera a publicacao em curso). B7: nunca remove o retrato de outra instalacao.
+ */
+function sairDaRede(opcoes = {}) {
+    // U3 da revisao 3: a saida local vem primeiro; nada depois dela pode deixar a maquina membro.
+    (0, rede_adesao_1.gravarConfigDaRede)({ membro: false });
+    const maquina = nomeSeguro((0, maquina_1.nomeDaMaquina)(opcoes.maquina));
+    const r = resolverCasa(opcoes);
+    if (r.casa)
+        (0, rede_adesao_1.gravarConfigDaRede)({ forja: r.casa.forja, host: r.casa.host, dono: r.casa.dono, repositorio: r.casa.repositorio });
+    try {
+        fs.rmSync(arquivoDaMarca(), { force: true });
+    }
+    catch { /* marca local */ }
+    if (!r.casa || !r.forja)
+        return { maquina, casa: null, commit: null, alheio: false };
+    const repo = r.forja.repositorio(r.casa.dono, r.casa.repositorio);
+    if (!repo.existe || !repo.url)
+        return { maquina, casa: (0, exports.refDaCasa)(r.casa), commit: null, alheio: false };
+    if (!urlDaCasaAceita(repo.url)) {
+        throw new Error(`rede.sem-https: saiu da rede aqui, mas ${r.forja.cli} devolveu para ${(0, exports.refDaCasa)(r.casa)} uma URL sem https; o retrato fica na casa`);
+    }
+    const trava = travarCasa(30000);
+    if (!trava.ok)
+        throw new Error(`rede.ocupado: saiu da rede aqui, mas outra publicacao desta maquina segura a casa (${TRAVA()}); rode ork network sair de novo`);
+    try {
+        // Suspeitas da revisao de 03/10: a publicacao que ja segurava a trava quando o `sair` comecou grava
+        // a marca ao terminar o push. Sob a trava ela ja terminou, e a proxima reconfere a adesao e recusa
+        // (B6): a marca sai de novo aqui e nao volta.
+        try {
+            fs.rmSync(arquivoDaMarca(), { force: true });
+        }
+        catch { /* marca local */ }
+        const cache = prepararCache(r.casa, repo.url, r.forja.helperDeCredencial(), maquina);
+        const proprio = arquivoDoRetrato(maquina);
+        const id = (0, rede_adesao_1.idDaMaquina)();
+        for (let tentativa = 1; tentativa <= TENTATIVAS; tentativa++) {
+            const { ponta, atualizado } = (0, rede_forja_1.comGitIsolado)(() => (0, branch_de_estado_1.buscarBranch)(cache, 'origin', exports.BRANCH_DA_REDE, PREFIXO, 30000));
+            if (!atualizado)
+                throw new Error(`rede.sem-leitura: saiu da rede aqui, mas nao consegui ler ${(0, exports.refDaCasa)(r.casa)} para tirar o retrato; rode ork network sair de novo com rede`);
+            const { retratos, invalidos } = retratosDaPonta(cache, ponta);
+            const atual = retratos.find((x) => x.maquina === maquina);
+            // S9 da revisao 2: o arquivo com o nome desta maquina sai tambem quando esta invalido; so o de
+            // outra instalacao (retrato valido com outro `id`) fica.
+            const invalido = invalidos.some((x) => x.arquivo === proprio);
+            if (!atual && !invalido)
+                return { maquina, casa: (0, exports.refDaCasa)(r.casa), commit: null, alheio: false };
+            // U2: invalido para esta versao, mas com o `id` de outra instalacao (contrato mais novo): nao e nosso.
+            const idDoOutro = atual ? atual.id ?? null : idNoArquivo(cache, ponta, proprio);
+            if (!atual && idDoOutro && idDoOutro !== id)
+                return { maquina, casa: (0, exports.refDaCasa)(r.casa), commit: null, alheio: true };
+            if (atual?.id && atual.id !== id) {
+                return { maquina, casa: (0, exports.refDaCasa)(r.casa), commit: null, alheio: true, ...(atual.hostname === hostnameSeguro() ? { mesmoHostname: true } : {}) };
+            }
+            const mudancas = [
+                { caminho: proprio, conteudo: null },
+                { caminho: exports.PAINEL_DA_REDE, conteudo: painelDaRede(retratos.filter((x) => x.maquina !== maquina)) },
+            ];
+            exigirSoOProprioRetrato(maquina, mudancas);
+            const commit = (0, rede_forja_1.comGitIsolado)(() => (0, branch_de_estado_1.gravarNaBranch)(cache, 'origin', exports.BRANCH_DA_REDE, ponta, mudancas, `rede: ${maquina} saiu`, PREFIXO), identidadeDoGit(maquina));
+            if (commit)
+                return { maquina, casa: (0, exports.refDaCasa)(r.casa), commit, alheio: false };
+        }
+        throw new Error(`rede.concorrencia: ${TENTATIVAS} pushes recusados seguidos; tente de novo em instantes`);
+    }
+    finally {
+        trava.liberar();
+    }
+}
+// ---------------------------------------------------------------------------
+// O REDE.md da casa.
+// ---------------------------------------------------------------------------
+// V2 da revisao 4: a celula nao abre link, imagem, HTML nem codigo, e nao quebra a tabela. W5 da
+// revisao 5 e X1 da revisao 6: o `.` e o `:` escapados desfazem o autolink do GFM (`www.x.y`,
+// `http://x`, mesmo sem ponto no dominio, e-mail), e `&` e `~` nao viram entidade nem riscado; o
+// valor fica numa linha so.
+const celula = (s) => (0, rede_projetos_1.emUmaLinha)(s).replace(/[\\`*_[\]<>|!.:~&]/g, (c) => `\\${c}`);
+/**
+ * RM-053 (fatia 2): retrato sem batida ha mais de 14 dias sai do INDICE `REDE.md`. O arquivo dele
+ * em `maquinas/` fica (cada maquina so escreve o proprio retrato, D6) e o `ork network status`
+ * continua a mostra-lo, com a lacuna `maquina.sem-batida`. Quatorze dias cobrem ferias e uma maquina
+ * desligada por duas semanas sem tirar ninguem do indice; o rodape diz quem saiu, nunca em silencio.
+ * Batida ilegivel ou no futuro fica no indice: so sai o que se sabe parado.
+ */
+exports.RETRATO_PARADO_MS = 14 * 24 * 60 * 60 * 1000;
+/** O retrato publicado ha mais de `RETRATO_PARADO_MS` antes de `agoraMs`. */
+function retratoParado(r, agoraMs) {
+    const em = Date.parse(r.publicadoEm);
+    return Number.isFinite(em) && agoraMs - em > exports.RETRATO_PARADO_MS;
+}
+/**
+ * O `REDE.md`: a mesma rede, para quem abre a forja. Sem caminho local: esses ficam no JSON.
+ * `agoraMs` e a hora de quem publica (a batida do proprio retrato), a regua do retrato parado.
+ */
+function painelDaRede(retratos, agoraMs = Date.now()) {
+    const linhas = [
+        '# Orkastery Network',
+        '',
+        'As máquinas desta pessoa e o que cada uma tem. Gerado pelo `ork network publicar`; não edite à mão.',
+        'De qualquer máquina: `ork network status`.',
+        '',
+        '| Máquina | Hostname | Forjas | Runtimes | Hosts | Projetos | ork | Última batida |',
+        '| --- | --- | --- | --- | --- | --- | --- | --- |',
+    ];
+    const ordenados = [...retratos].sort((a, b) => a.maquina.localeCompare(b.maquina));
+    const lista = ordenados.filter((r) => !retratoParado(r, agoraMs));
+    const parados = ordenados.filter((r) => retratoParado(r, agoraMs));
+    if (lista.length === 0)
+        linhas.push(`| — | ${parados.length ? 'nenhuma máquina com batida recente' : 'nenhuma máquina publicou'} | — | — | — | — | — | — |`);
+    for (const r of lista) {
+        const forjas = r.forjas.map((f) => `${f.forja}: ${f.usuario ?? 'sem login'}`).join(', ') || '—';
+        const runtimes = r.runtimes.map((x) => `${x.runtime} ${x.versao ?? '?'}`).join(', ') || '—';
+        const hosts = r.hosts.map((h) => `${h.host} ${h.versao ?? '?'}${h.adaptador ? ` (adaptador ${h.adaptador})` : ''}`).join(', ') || '—';
+        const projetos = r.projetos.map((p) => p.nome).join(', ') || '—';
+        linhas.push(`| ${[r.maquina, r.hostname, forjas, runtimes, hosts, projetos, r.versaoOrk, (0, horario_1.formatarDataHora)(r.publicadoEm)].map(celula).join(' | ')} |`);
+    }
+    if (parados.length) {
+        const quem = parados.map((r) => `${celula(r.maquina)} (última batida ${celula((0, horario_1.formatarDataHora)(r.publicadoEm))})`).join(', ');
+        linhas.push('', `Fora do índice, sem batida há mais de ${exports.RETRATO_PARADO_MS / 86400000} dias: ${quem}. ` +
+            'O retrato continua em `maquinas/` e no `ork network status`.');
+    }
+    return [...linhas, '', (0, horario_1.legendaDoFuso)(), ''].join('\n');
+}