@orkastery/cli 0.5.1 → 0.5.6

package/dist/doctor-pulse-cron.js

@@ -0,0 +1,349 @@
+"use strict";
+/**
+ * RM-039 (B6): o `ork doctor` acusa o pulse que bate devagar demais.
+ *
+ * A cadencia por tag (#OrkPulseOn-15m e as outras) so vale inteira com a varredura do cron de 15
+ * em 15 minutos. A instalacao antiga fica em `0 * * * *`, e nada avisava. Com o transporte do
+ * pulse configurado (`.orkastery/monitor/pulse-host.json`), o doctor le o `crontab -l` e avisa,
+ * sem bloquear, quando a linha da varredura falta ou bate mais devagar que o template
+ * `monitor/pulse.cron`. O doctor nunca edita o crontab: a correcao traz a linha pronta.
+ *
+ * RM-063 (F1): com thread aberta no projeto, a falta da batida REPROVA, com ou sem `pulse-host.json`.
+ * Sem transporte o doctor calava, e o maquina-b ficou de 03/10 a 12/10/2026 sem varredura nenhuma. A
+ * correcao e o `ork fabrica batida instalar`, que instala a linha do template de forma idempotente.
+ */
+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.COMANDO_DE_INSTALAR_A_BATIDA = exports.ATRASO_DA_BATIDA_MIN = exports.COMANDO_DO_TEMPLATE = exports.SCRIPT_DA_VARREDURA = exports.BATIDA_DO_TEMPLATE = void 0;
+exports.lerCrontabDoSistema = lerCrontabDoSistema;
+exports.intervaloEmMinutos = intervaloEmMinutos;
+exports.valorNoShell = valorNoShell;
+exports.projetoDaLinha = projetoDaLinha;
+exports.scriptsDaLinha = scriptsDaLinha;
+exports.entradasDaVarredura = entradasDaVarredura;
+exports.entradaDoProjeto = entradaDoProjeto;
+exports.mesmoCaminho = mesmoCaminho;
+exports.entradaNaoEDeOutro = entradaNaoEDeOutro;
+exports.ultimaRodadaDaVarredura = ultimaRodadaDaVarredura;
+exports.threadsAbertasNoEstado = threadsAbertasNoEstado;
+exports.citarNoShell = citarNoShell;
+exports.scriptDaVarreduraDoOrk = scriptDaVarreduraDoOrk;
+exports.comandoDaVarredura = comandoDaVarredura;
+exports.checarCronDoPulse = checarCronDoPulse;
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const util_1 = require("./util");
+const locale_1 = require("./locale");
+/** A batida do template `monitor/pulse.cron` (I-50): a menor cadencia das tags. */
+exports.BATIDA_DO_TEMPLATE = '*/15 * * * *';
+/** O script que o template agenda; a linha do crontab e achada por ele. */
+exports.SCRIPT_DA_VARREDURA = 'varredura-pulse.sh';
+/** Comando do template antes da troca do caminho pelo checkout de quem instala. */
+exports.COMANDO_DO_TEMPLATE = '/CAMINHO/orkastery/monitor/varredura-pulse.sh';
+/** Le o crontab do usuario do processo, sem shell e com prazo. */
+function lerCrontabDoSistema() {
+    const r = (0, util_1.exec)('crontab', ['-l'], undefined, 5000);
+    if (r.ok)
+        return { ok: true, texto: r.stdout };
+    if (r.error === 'ENOENT')
+        return { ok: false, motivo: (0, locale_1.msg)().doctor.cronSemComando };
+    // RM-063 (F1): o usuario sem crontab tem um crontab vazio, nao uma leitura que falhou; e o caso da maquina nova.
+    if (/no crontab for /i.test(`${r.stderr}${r.stdout}`))
+        return { ok: true, texto: '' };
+    const primeira = (r.stderr || r.stdout).trim().split('\n')[0] ?? '';
+    return { ok: false, motivo: primeira ? (0, locale_1.msg)().doctor.cronFalhou(primeira) : (0, locale_1.msg)().doctor.cronSaiu(r.code) };
+}
+const MACROS = { '@hourly': 60, '@daily': 1440, '@midnight': 1440, '@weekly': 10080,
+    '@monthly': 43200, '@yearly': 525600, '@annually': 525600 };
+/**
+ * Maior intervalo, em minutos, entre duas batidas da linha (so os campos de minuto e hora; dia,
+ * mes e dia da semana restritos contam como mais devagar que uma hora). `null` quando a expressao
+ * nao e reconhecida: o doctor entao avisa pela linha, sem adivinhar.
+ */
+function intervaloEmMinutos(expressao) {
+    const campos = expressao.trim().split(/\s+/);
+    if (campos.length === 1 && campos[0].startsWith('@'))
+        return MACROS[campos[0]] ?? null;
+    if (campos.length !== 5)
+        return null;
+    const [minuto, hora, dia, mes, semana] = campos;
+    const minutos = valoresDoCampo(minuto, 0, 59);
+    if (!minutos)
+        return null;
+    if (hora !== '*' || dia !== '*' || mes !== '*' || semana !== '*')
+        return Math.max(60, maiorLacuna(minutos, 60));
+    return maiorLacuna(minutos, 60);
+}
+function valoresDoCampo(campo, min, max) {
+    const valores = new Set();
+    for (const parte of campo.split(',')) {
+        const m = /^(\*|(\d+)(?:-(\d+))?)(?:\/(\d+))?$/.exec(parte);
+        if (!m)
+            return null;
+        const inicio = m[1] === '*' ? min : Number(m[2]);
+        const fim = m[1] === '*' ? max : m[3] !== undefined ? Number(m[3]) : m[4] !== undefined ? max : inicio;
+        const passo = m[4] !== undefined ? Number(m[4]) : 1;
+        if (passo < 1 || inicio < min || fim > max || inicio > fim)
+            return null;
+        for (let v = inicio; v <= fim; v += passo)
+            valores.add(v);
+    }
+    return [...valores].sort((a, b) => a - b);
+}
+/** Maior distancia entre dois valores consecutivos, contando a volta do ciclo. */
+function maiorLacuna(valores, ciclo) {
+    let maior = 0;
+    for (let i = 0; i < valores.length; i++) {
+        const proximo = i + 1 < valores.length ? valores[i + 1] : valores[0] + ciclo;
+        maior = Math.max(maior, proximo - valores[i]);
+    }
+    return maior;
+}
+/** Separa a expressao de horario do comando numa linha do crontab. */
+function dividirLinha(linha) {
+    const t = linha.trim();
+    if (t.startsWith('@')) {
+        const m = /^(@\S+)\s+(.+)$/.exec(t);
+        return m ? { quando: m[1], comando: m[2] } : null;
+    }
+    const m = /^(\S+\s+\S+\s+\S+\s+\S+\s+\S+)\s+(.+)$/.exec(t);
+    return m ? { quando: m[1], comando: m[2] } : null;
+}
+/**
+ * RM-063 (F1, GO-FIX): um valor como o `sh` do cron o le: aspas simples literais; aspas duplas com `$HOME`; sem aspas,
+ * com o `~` do comeco e `$HOME`. So o que a linha da varredura usa; o resto fica como esta.
+ */
+function valorNoShell(bruto, home = os.homedir()) {
+    const comHome = (v) => v.replace(/\$\{HOME\}|\$HOME(?![A-Za-z0-9_])/g, home);
+    if (bruto.length >= 2 && bruto.startsWith(`'`) && bruto.endsWith(`'`))
+        return bruto.slice(1, -1).replace(/'\\''/g, `'`);
+    if (bruto.length >= 2 && bruto.startsWith('"') && bruto.endsWith('"'))
+        return comHome(bruto.slice(1, -1).replace(/\\(["\\$`])/g, '$1'));
+    return comHome(bruto === '~' ? home : bruto.startsWith('~/') ? home + bruto.slice(1) : bruto);
+}
+/** Um valor de atribuicao ou um caminho: entre aspas simples, entre aspas duplas, ou ate o espaco. */
+const VALOR = String.raw `(?:'(?:[^']|'\\'')*'|"(?:[^"\\]|\\.)*"|[^\s;&|<>()]+)`;
+/** O valor de `ORK_PULSE_PROJECT=` na linha, como o `sh` o le; `null` quando a linha nao o diz. */
+function projetoDaLinha(linha, home = os.homedir()) {
+    const m = new RegExp(`(?:^|\\s)ORK_PULSE_PROJECT=(${VALOR})`).exec(linha);
+    return m ? valorNoShell(m[1], home) : null;
+}
+/** Os scripts da varredura citados na linha, como o `sh` os le; `varredura-pulse.sh.bak` nao e o script. */
+function scriptsDaLinha(linha, home = os.homedir()) {
+    const nome = exports.SCRIPT_DA_VARREDURA.replace(/\./g, '\\.');
+    const re = new RegExp(`(?:^|[\\s=])('[^']*${nome}'|"[^"]*${nome}"|[^\\s'";&|<>()]*${nome})(?=$|[\\s;&|<>)])`, 'g');
+    return [...linha.matchAll(re)].map((m) => valorNoShell(m[1], home));
+}
+/**
+ * RM-063 (F1, GO-FIX): as entradas da varredura, na ordem. A linha de ambiente do crontab (`NOME=valor`) vale para as
+ * entradas que vem depois dela: o template sem `ORK_PULSE_PROJECT` abaixo de `ORK_PULSE_PROJECT=/outro` varre o outro.
+ */
+function entradasDaVarredura(crontab, home = os.homedir()) {
+    const ambiente = {};
+    const entradas = [];
+    for (const linha of crontab.split('\n')) {
+        const t = linha.trim();
+        if (!t || t.startsWith('#'))
+            continue;
+        const env = /^([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)$/.exec(t);
+        if (env) {
+            ambiente[env[1]] = valorNoShell(env[2].trim(), ambiente.HOME ?? home);
+            continue;
+        }
+        const casa = ambiente.HOME ?? home;
+        const scripts = scriptsDaLinha(t, casa);
+        if (!scripts.length)
+            continue;
+        entradas.push({ linha, projeto: projetoDaLinha(t, casa) ?? ambiente.ORK_PULSE_PROJECT ?? null, scripts });
+    }
+    return entradas;
+}
+/**
+ * RM-063 (F1): a entrada roda, com certeza, a varredura DESTE projeto: o `ORK_PULSE_PROJECT` efetivo e ele, ou nao ha
+ * projeto nenhum e o script e o do proprio checkout (que entao e o alvo, como no template).
+ */
+function entradaDoProjeto(e, raiz) {
+    if (e.projeto !== null)
+        return mesmoCaminho(e.projeto, raiz);
+    const doCheckout = path.join(raiz, 'monitor', exports.SCRIPT_DA_VARREDURA);
+    return e.scripts.some((s) => mesmoCaminho(s, doCheckout));
+}
+/** O mesmo caminho, escrito igual ou pelo mesmo destino real. */
+function mesmoCaminho(a, b) {
+    if (path.resolve(a) === path.resolve(b))
+        return true;
+    try {
+        return fs.realpathSync(a) === fs.realpathSync(b);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * A entrada vale para o aviso de cadencia (sem thread aberta) quando nao aponta OUTRO projeto: a linha antiga do
+ * template, sem projeto, continua valendo como na RM-039.
+ */
+function entradaNaoEDeOutro(e, raiz) {
+    return e.projeto === null || mesmoCaminho(e.projeto, raiz);
+}
+/** Acima disto sem rodada nova no `hitl.log`, a batida esta atrasada: duas batidas do template perdidas. */
+exports.ATRASO_DA_BATIDA_MIN = 30;
+function ultimaRodadaDaVarredura(dirMonitor) {
+    const arquivo = path.join(dirMonitor, 'hitl.log');
+    let texto;
+    try {
+        const fd = fs.openSync(arquivo, 'r');
+        try {
+            const tamanho = fs.fstatSync(fd).size, lido = Math.min(tamanho, 64 * 1024);
+            const buffer = Buffer.alloc(lido);
+            fs.readSync(fd, buffer, 0, lido, tamanho - lido);
+            texto = buffer.toString('utf8');
+        }
+        finally {
+            fs.closeSync(fd);
+        }
+    }
+    catch {
+        return null;
+    }
+    for (const linha of texto.split('\n').reverse()) {
+        try {
+            const e = JSON.parse(linha);
+            if (e.tipo !== 'pulse_scan' || typeof e.ts !== 'string' || !Number.isFinite(Date.parse(e.ts)))
+                continue;
+            return { em: e.ts, code: typeof e.code === 'number' ? e.code : null, detalhe: typeof e.detalhe === 'string' ? e.detalhe : '' };
+        }
+        catch { /* linha cortada no inicio do trecho, ou ilegivel */ }
+    }
+    return null;
+}
+/** RM-063 (F1): threads nao fechadas no estado do projeto (`.orkastery/threads/<id>/thread.json`). */
+function threadsAbertasNoEstado(dirEstado) {
+    const dir = path.join(dirEstado, 'threads');
+    let nomes;
+    try {
+        nomes = fs.readdirSync(dir);
+    }
+    catch {
+        return 0;
+    }
+    let abertas = 0;
+    for (const nome of nomes) {
+        try {
+            const t = JSON.parse(fs.readFileSync(path.join(dir, nome, 'thread.json'), 'utf8'));
+            // O registro de adocao nao tem trabalho a conduzir; a thread pausada espera o dono, e a batida e quem o lembra.
+            if (t.status !== 'fechada' && t.origem !== 'adocao')
+                abertas++;
+        }
+        catch { /* pasta sem thread.json, ou ilegivel: nao e thread a vigiar */ }
+    }
+    return abertas;
+}
+/** O comando que instala a batida; e a correcao do doctor quando ela falta (RM-063, F1). */
+exports.COMANDO_DE_INSTALAR_A_BATIDA = 'ork fabrica batida instalar';
+/** Aspas de shell so quando o caminho precisa (a linha vai colada no crontab, que roda por `sh`). */
+function citarNoShell(caminho) {
+    return /^[A-Za-z0-9_./:@+-]+$/.test(caminho) ? caminho : `'${caminho.replace(/'/g, `'\\''`)}'`;
+}
+/**
+ * O script da varredura que este `ork` traz: no pacote do npm, `monitor/` fica ao lado de `dist/`; no
+ * checkout, na raiz do repositorio, dois niveis acima de `core/dist/`. `null` quando nenhum existe.
+ */
+function scriptDaVarreduraDoOrk(dirDoDist = __dirname) {
+    for (const dir of [path.join(dirDoDist, '..', 'monitor'), path.join(dirDoDist, '..', '..', 'monitor')]) {
+        const script = path.join(dir, exports.SCRIPT_DA_VARREDURA);
+        if (fs.existsSync(script))
+            return path.resolve(script);
+    }
+    return null;
+}
+/**
+ * O comando que a linha nova do crontab roda. Ensaio de 03/10/2026 (RM-049): a correcao apontava
+ * `<projeto>/monitor/varredura-pulse.sh`, que so existe no checkout do proprio Orkastery; quem instalou
+ * pelo npm recebia um caminho que nao existe. Quando o projeto nao traz o script, a linha usa o do `ork`
+ * instalado e diz o projeto por `ORK_PULSE_PROJECT` (o cron nao roda no diretorio do projeto).
+ */
+function comandoDaVarredura(raizDoProjeto, scriptDoOrk = scriptDaVarreduraDoOrk()) {
+    const doProjeto = path.join(raizDoProjeto, 'monitor', exports.SCRIPT_DA_VARREDURA);
+    if (fs.existsSync(doProjeto) || !scriptDoOrk)
+        return citarNoShell(doProjeto);
+    return `ORK_PULSE_PROJECT=${citarNoShell(raizDoProjeto)} ${citarNoShell(scriptDoOrk)}`;
+}
+/**
+ * Check "cadencia do pulse no cron". `null` quando o projeto nao tem transporte do pulse nem thread
+ * aberta: sem `pulse-host.json` e sem thread a vigiar, o doctor nao fala de cron.
+ *
+ * RM-063 (F1): com thread aberta (`abertas`, contadas no estado ao lado de `dirMonitor`), a falta da
+ * batida reprova, com ou sem transporte, e a correcao e o `ork fabrica batida instalar`.
+ */
+function checarCronDoPulse(dirMonitor, raizDoCheckout, ler = lerCrontabDoSistema, scriptDoOrk = scriptDaVarreduraDoOrk(), abertas = threadsAbertasNoEstado(path.dirname(dirMonitor))) {
+    const comHost = fs.existsSync(path.join(dirMonitor, 'pulse-host.json'));
+    if (!comHost && abertas === 0)
+        return null;
+    const nome = 'cadencia do pulse no cron';
+    const comandoSugerido = comandoDaVarredura(raizDoCheckout, scriptDoOrk);
+    const linhaNova = (comando) => `${exports.BATIDA_DO_TEMPLATE} ${comando}`;
+    const ausente = (detalhe) => abertas > 0
+        ? { nome, nivel: 'fail', detalhe: (0, locale_1.msg)().doctor.batidaAusente(abertas, detalhe),
+            correcao: (0, locale_1.msg)().doctor.batidaInstale(exports.COMANDO_DE_INSTALAR_A_BATIDA) }
+        : { nome, nivel: 'warn', detalhe, correcao: (0, locale_1.msg)().doctor.cronAdicione(linhaNova(comandoSugerido)) };
+    // RM-063 (F1, GO-FIX): a varredura que bate por outro agendador (timer do systemd, batida do host) se prova pelo hitl.log.
+    const rodada = ultimaRodadaDaVarredura(dirMonitor);
+    const haMin = rodada ? Math.floor((Date.now() - Date.parse(rodada.em)) / 60000) : null;
+    const semCron = (detalhe) => haMin !== null && haMin >= 0 && haMin <= exports.ATRASO_DA_BATIDA_MIN
+        ? { nome, nivel: 'ok', detalhe: (0, locale_1.msg)().doctor.batidaPeloLog(haMin) } : ausente(detalhe);
+    const leitura = ler();
+    if (!leitura.ok)
+        return semCron(comHost ? (0, locale_1.msg)().doctor.cronSemLeitura(leitura.motivo) : (0, locale_1.msg)().doctor.batidaSemLeitura(leitura.motivo));
+    // Com thread aberta, so a batida DESTE projeto; sem thread, o aviso de cadencia aceita a linha antiga sem projeto.
+    const linhas = entradasDaVarredura(leitura.texto)
+        .filter(e => abertas > 0 ? entradaDoProjeto(e, raizDoCheckout) : entradaNaoEDeOutro(e, raizDoCheckout)).map(e => e.linha.trim());
+    if (linhas.length === 0)
+        return semCron(comHost ? (0, locale_1.msg)().doctor.cronSemLinha(exports.SCRIPT_DA_VARREDURA) : (0, locale_1.msg)().doctor.batidaSemLinha(exports.SCRIPT_DA_VARREDURA));
+    const lentas = [];
+    for (const linha of linhas) {
+        const partes = dividirLinha(linha);
+        const intervalo = partes ? intervaloEmMinutos(partes.quando) : null;
+        if (intervalo === null || intervalo > 15)
+            lentas.push({ linha, comando: partes?.comando ?? comandoSugerido, intervalo });
+    }
+    if (lentas.length < linhas.length) {
+        return { nome, nivel: 'ok', detalhe: (0, locale_1.msg)().doctor.cronOk(linhas.length) };
+    }
+    const l = lentas[0];
+    return { nome, nivel: 'warn', detalhe: (0, locale_1.msg)().doctor.cronLento((0, locale_1.msg)().doctor.cronRitmo(l.intervalo), l.linha),
+        correcao: (0, locale_1.msg)().doctor.cronTroque(linhaNova(l.comando)) };
+}

package/dist/doctor-rede.js

@@ -0,0 +1,150 @@
+"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.CAUDA_DO_LOG_BYTES = void 0;
+exports.caudaDoLogDaRede = caudaDoLogDaRede;
+exports.correcaoDaFalha = correcaoDaFalha;
+exports.checarRede = checarRede;
+/**
+ * RM-053 (fatia 2): o check "rede" do `ork doctor`.
+ *
+ * A rede pessoal publica sozinha (batida do pulse e eventos de thread) e so deixava rastro em
+ * `~/.orkastery/rede/rede.log`: a maquina-b ficou de 02/10 em diante como membro herdado da fabrica,
+ * com toda publicacao caindo em `rede.sem-repositorio`, e o doctor dizia PRONTO sem uma palavra.
+ *
+ * O check diz a adesao, a casa, a ultima batida publicada e a ultima falha do log. Ele so le
+ * arquivos locais (`rede.json`, `maquina.json`, `rede/publicada.json`, `rede/rede.log`): nao chama
+ * a forja, nao cria estado e roda de qualquer diretorio. Nunca reprova: a rede e opcional e o
+ * doctor e gate de despacho; o pior nivel e `warn`, com a correcao.
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const horario_1 = require("./horario");
+const rede_1 = require("./rede");
+const rede_adesao_1 = require("./rede-adesao");
+const rede_status_1 = require("./rede-status");
+const saida_segura_1 = require("./saida-segura");
+const locale_1 = require("./locale");
+/** O fim do `rede.log` que o doctor le: o log so cresce, e o que importa e o mais recente. */
+exports.CAUDA_DO_LOG_BYTES = 64 * 1024;
+/** As linhas legiveis do fim do `rede.log`, da mais antiga para a mais nova. Sem log, lista vazia. */
+function caudaDoLogDaRede(arquivo = path.join((0, rede_adesao_1.pastaDaRede)(), 'rede.log')) {
+    let texto;
+    try {
+        const fd = fs.openSync(arquivo, 'r');
+        try {
+            const tamanho = fs.fstatSync(fd).size;
+            const inicio = Math.max(0, tamanho - exports.CAUDA_DO_LOG_BYTES);
+            const buf = Buffer.alloc(tamanho - inicio);
+            fs.readSync(fd, buf, 0, buf.length, inicio);
+            texto = buf.toString('utf8');
+            // A primeira linha de uma cauda cortada vem pela metade.
+            if (inicio > 0)
+                texto = texto.slice(texto.indexOf('\n') + 1);
+        }
+        finally {
+            fs.closeSync(fd);
+        }
+    }
+    catch {
+        return [];
+    }
+    const registros = [];
+    for (const linha of texto.split('\n')) {
+        if (!linha.trim())
+            continue;
+        try {
+            const r = JSON.parse(linha);
+            if (typeof r.ts !== 'string' || !Number.isFinite(Date.parse(r.ts)) || typeof r.acao !== 'string')
+                continue;
+            registros.push({ ts: r.ts, acao: r.acao, origem: typeof r.origem === 'string' ? r.origem : null,
+                erro: typeof r.erro === 'string' ? r.erro : null });
+        }
+        catch { /* linha ilegivel: o log e informativo */ }
+    }
+    return registros;
+}
+const curto = (s, teto = 200) => {
+    const limpo = (0, saida_segura_1.emUmaLinha)(s).trim();
+    return limpo.length > teto ? `${limpo.slice(0, teto - 3)}...` : limpo;
+};
+/** A correcao pela familia do erro da ultima falha (o prefixo tipado, como `rede.sem-repositorio`). */
+function correcaoDaFalha(erro) {
+    const codigo = /^([a-z]+\.[a-z-]+):/.exec(erro)?.[1] ?? '';
+    const m = (0, locale_1.msg)().doctor;
+    if (codigo === 'rede.sem-repositorio' || codigo === 'rede.repositorio-alheio')
+        return m.redeSemCasaCorrecao;
+    if (codigo === 'rede.sem-forja')
+        return m.redeSemForjaCorrecao;
+    if (codigo === 'rede.repositorio-publico')
+        return m.redePublicaCorrecao;
+    if (codigo === 'rede.nome-em-uso')
+        return m.redeNomeCorrecao;
+    return m.redeOutraCorrecao;
+}
+/** O check "rede". `agoraMs` e o log ficam injetaveis para o teste. */
+function checarRede(opcoes = {}) {
+    const nome = 'rede';
+    const agora = opcoes.agoraMs ?? Date.now();
+    const adesao = (0, rede_adesao_1.adesaoDaRede)();
+    if (!adesao.membro) {
+        return { nome, nivel: 'ok', detalhe: adesao.config && !adesao.config.membro
+                ? (0, locale_1.msg)().doctor.redeSaiu
+                : (0, locale_1.msg)().doctor.foraDaRede };
+    }
+    const marca = (0, rede_1.lerMarcaDaRede)();
+    const config = adesao.config;
+    const casa = config?.host && config.dono && config.repositorio ? `${config.host}/${config.dono}/${config.repositorio}`
+        : typeof marca?.casa === 'string' ? marca.casa : null;
+    const registros = caudaDoLogDaRede(opcoes.log);
+    const falha = [...registros].reverse().find((r) => r.acao === 'falhou') ?? null;
+    const emBatida = marca && typeof marca.em === 'string' && Number.isFinite(Date.parse(marca.em)) ? marca.em : null;
+    const idade = emBatida ? agora - Date.parse(emBatida) : NaN;
+    const m = (0, locale_1.msg)().doctor;
+    const partes = [
+        adesao.adesao === 'fabrica' ? m.redeMembroHerdado : m.redeMembro,
+        casa ? m.redeCasa(curto(casa, 120)) : m.redeSemCasa,
+        emBatida ? m.redeBatida((0, horario_1.formatarDataHora)(emBatida), (0, rede_status_1.duracao)(idade)) : m.redeSemBatida,
+        falha ? m.redeFalha((0, horario_1.formatarDataHora)(falha.ts), falha.origem ? curto(falha.origem, 20) : null, curto(falha.erro ?? m.redeSemDetalhe))
+            : m.redeSemFalha,
+    ];
+    // A falha mais nova que a ultima batida e o estado de agora; a de antes ja passou.
+    const falhaAtual = !!falha && (!emBatida || Date.parse(falha.ts) > Date.parse(emBatida));
+    const parada = !emBatida || !(idade <= rede_status_1.SEM_BATIDA_MS);
+    if (!falhaAtual && !parada)
+        return { nome, nivel: 'ok', detalhe: partes.join('; ') };
+    const correcao = falhaAtual ? correcaoDaFalha(falha.erro ?? '') : m.redeParadaCorrecao;
+    return { nome, nivel: 'warn', detalhe: partes.join('; '), correcao };
+}