@orkastery/cli 0.5.3 → 0.6.0

package/dist/doctor-pulse-cron.js

@@ -7,6 +7,10 @@
  * 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;
@@ -42,16 +46,32 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.COMANDO_DO_TEMPLATE = exports.SCRIPT_DA_VARREDURA = exports.BATIDA_DO_TEMPLATE = void 0;
+exports.ARQUIVO_DO_TRANSPORTE = 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.linhasDaVarredura = linhasDaVarredura;
+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;
+exports.batidaNoDoctor = batidaNoDoctor;
+exports.ultimaEntrega = ultimaEntrega;
+exports.checarTransporteDoPulse = checarTransporteDoPulse;
 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");
+const horario_1 = require("./horario");
+const maquina_1 = require("./maquina");
 /** 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. */
@@ -64,9 +84,12 @@ function lerCrontabDoSistema() {
     if (r.ok)
         return { ok: true, texto: r.stdout };
     if (r.error === 'ENOENT')
-        return { ok: false, motivo: 'comando crontab ausente nesta maquina' };
-    const msg = (r.stderr || r.stdout).trim().split('\n')[0] ?? '';
-    return { ok: false, motivo: msg ? `crontab -l falhou: ${msg}` : `crontab -l saiu ${r.code}` };
+        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 };
@@ -124,13 +147,140 @@ function dividirLinha(linha) {
     const m = /^(\S+\s+\S+\s+\S+\s+\S+\s+\S+)\s+(.+)$/.exec(t);
     return m ? { quando: m[1], comando: m[2] } : null;
 }
-/** Linhas ativas (nao comentario, nao variavel) que agendam a varredura do pulse. */
-function linhasDaVarredura(crontab) {
-    return crontab.split('\n').map(l => l.trim())
-        .filter(l => l && !l.startsWith('#') && !/^[A-Za-z_][A-Za-z0-9_]*\s*=/.test(l) && l.includes(exports.SCRIPT_DA_VARREDURA));
+/**
+ * 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 citar(caminho) {
+function citarNoShell(caminho) {
     return /^[A-Za-z0-9_./:@+-]+$/.test(caminho) ? caminho : `'${caminho.replace(/'/g, `'\\''`)}'`;
 }
 /**
@@ -154,27 +304,40 @@ function scriptDaVarreduraDoOrk(dirDoDist = __dirname) {
 function comandoDaVarredura(raizDoProjeto, scriptDoOrk = scriptDaVarreduraDoOrk()) {
     const doProjeto = path.join(raizDoProjeto, 'monitor', exports.SCRIPT_DA_VARREDURA);
     if (fs.existsSync(doProjeto) || !scriptDoOrk)
-        return citar(doProjeto);
-    return `ORK_PULSE_PROJECT=${citar(raizDoProjeto)} ${citar(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: sem
- * `pulse-host.json` nao ha resumo para entregar, e o doctor nao fala de cron.
+ * 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()) {
-    if (!fs.existsSync(path.join(dirMonitor, 'pulse-host.json')))
+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) => ({ nome, nivel: 'warn', detalhe,
-        correcao: `adicione ao crontab (crontab -e), como no template monitor/pulse.cron: ${linhaNova(comandoSugerido)}` });
+    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 ausente(`pulse-host.json presente, mas sem crontab para ler (${leitura.motivo}): a varredura nao bate`);
-    const linhas = linhasDaVarredura(leitura.texto);
+        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 ausente(`pulse-host.json presente, e nenhuma linha do crontab roda ${exports.SCRIPT_DA_VARREDURA}: o resumo nao sai`);
+        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);
@@ -183,12 +346,116 @@ function checarCronDoPulse(dirMonitor, raizDoCheckout, ler = lerCrontabDoSistema
             lentas.push({ linha, comando: partes?.comando ?? comandoSugerido, intervalo });
     }
     if (lentas.length < linhas.length) {
-        return { nome, nivel: 'ok', detalhe: `varredura no cron a cada 15 minutos ou menos (${linhas.length} linha(s))` };
+        // RM-063 (fatia 3, H1): a linha no crontab nao prova que a batida roda (cron parado, script que cai antes do log).
+        // Com thread aberta, a ultima rodada mais velha que o atraso reprova; sem rodada nenhuma ainda, ou com a batida
+        // instalada ha menos de 30 min depois da ultima rodada, a linha recem-instalada vale.
+        if (abertas > 0 && haMin !== null && haMin > exports.ATRASO_DA_BATIDA_MIN && !recemInstalada(raizDoCheckout, rodada?.em ?? null)) {
+            return { nome, nivel: 'fail', detalhe: (0, locale_1.msg)().doctor.batidaAtrasada(haMin, linhas.length), correcao: (0, locale_1.msg)().doctor.batidaAtrasadaCorrecao };
+        }
+        return { nome, nivel: 'ok', detalhe: (0, locale_1.msg)().doctor.cronOk(linhas.length) };
     }
     const l = lentas[0];
-    const ritmo = l.intervalo === null ? 'com horario que o doctor nao le' : l.intervalo === 60 ? 'de hora em hora'
-        : `a cada ${l.intervalo} minutos`;
-    return { nome, nivel: 'warn',
-        detalhe: `a varredura do pulse bate ${ritmo} (\`${l.linha}\`): a cadencia por tag (RM-039) pede 15 minutos`,
-        correcao: `troque a linha no crontab (crontab -e) por: ${linhaNova(l.comando)}` };
+    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)) };
+}
+/**
+ * A batida deste projeto foi instalada (`batida_instalada` no ledger da maquina) depois da ultima rodada e ha menos de
+ * 30 min: o `hitl.log` velho de antes da instalacao nao e atraso, a primeira rodada ainda vem.
+ */
+function recemInstalada(raizDoCheckout, ultimaRodadaEm, agora = Date.now()) {
+    let eventos = [];
+    try {
+        eventos = fs.readFileSync(path.join((0, maquina_1.pastaDoUsuario)(), 'ledger.jsonl'), 'utf8').split('\n').filter(Boolean)
+            .map((l) => { try {
+            return JSON.parse(l);
+        }
+        catch {
+            return {};
+        } });
+    }
+    catch {
+        return false;
+    }
+    const instalada = eventos.filter((e) => e.tipo === 'batida_instalada' && typeof e.projeto === 'string' &&
+        mesmoCaminho(e.projeto, raizDoCheckout) && typeof e.ts === 'string').map((e) => Date.parse(e.ts)).filter(Number.isFinite).at(-1);
+    if (instalada === undefined)
+        return false;
+    const rodada = ultimaRodadaEm ? Date.parse(ultimaRodadaEm) : Number.NEGATIVE_INFINITY;
+    return instalada > rodada && agora - instalada <= exports.ATRASO_DA_BATIDA_MIN * 60000;
+}
+function batidaNoDoctor(dirMonitor, raizDoCheckout, opcoes) {
+    const abertas = opcoes.abertas ?? threadsAbertasNoEstado(path.dirname(dirMonitor));
+    const rodada = ultimaRodadaDaVarredura(dirMonitor);
+    const agora = opcoes.agora ?? Date.now();
+    const haMin = rodada ? Math.max(0, Math.floor((agora - Date.parse(rodada.em)) / 60000)) : null;
+    const leitura = (opcoes.ler ?? lerCrontabDoSistema)();
+    const instalada = leitura.ok ? entradasDaVarredura(leitura.texto).some((e) => entradaDoProjeto(e, raizDoCheckout)) : null;
+    const atrasada = abertas > 0 && (haMin !== null ? haMin > exports.ATRASO_DA_BATIDA_MIN && !recemInstalada(raizDoCheckout, rodada?.em ?? null, agora)
+        : instalada !== true);
+    const quando = rodada ? (0, horario_1.formatarDataHoraRotulada)(rodada.em, { agora: new Date(agora).toISOString() }) : null;
+    const aviso = !atrasada ? null : haMin !== null
+        ? `Orkastery: a fabrica ${opcoes.projeto} na maquina ${opcoes.maquina} esta sem batida ha ${haMin} min (ultima rodada em ${quando}` +
+            `${rodada?.code ? `, codigo ${rodada.code}` : ''}), com ${abertas} thread(s) aberta(s). Confira com: ork fabrica batida status`
+        : `Orkastery: a fabrica ${opcoes.projeto} na maquina ${opcoes.maquina} nao tem batida (nenhuma rodada da varredura e a linha nao ` +
+            `esta no crontab), com ${abertas} thread(s) aberta(s). Instale com: ork fabrica batida instalar`;
+    return { threadsAbertas: abertas, instalada, ultimaRodadaEm: rodada?.em ?? null, codigo: rodada?.code ?? null, haMin,
+        limiteMin: exports.ATRASO_DA_BATIDA_MIN, atrasada, aviso };
+}
+// ---------------------------------------------------------------------------
+// RM-063 (fatia 3, H4): a falha do transporte do pulse, que a entrega grava em `transporte.log`.
+// ---------------------------------------------------------------------------
+exports.ARQUIVO_DO_TRANSPORTE = 'transporte.log';
+/** A entrega mais velha que isto nao e mais noticia: o doctor nao acusa a falha de ontem. */
+const VALIDADE_DA_FALHA_MS = 24 * 60 * 60 * 1000;
+/** A ultima entrega registrada no `transporte.log` (lida do fim, com teto). */
+function ultimaEntrega(dirMonitor) {
+    let texto;
+    try {
+        const fd = fs.openSync(path.join(dirMonitor, exports.ARQUIVO_DO_TRANSPORTE), '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 !== 'transporte_entrega' || typeof e.ts !== 'string' || !Array.isArray(e.tentativas))
+                continue;
+            return { ts: e.ts, oQue: String(e.oQue ?? ''), ok: e.ok === true, host: typeof e.host === 'string' ? e.host : null, tentativas: e.tentativas };
+        }
+        catch { /* linha cortada */ }
+    }
+    return null;
+}
+/**
+ * Check "transporte do pulse": a ultima entrega do resumo. Saiu pelo primeiro transporte, ok; saiu pelo outro host
+ * configurado, aviso; nao saiu por nenhum, falha. `null` sem `pulse-host.json`, ou sem entrega nas ultimas 24 h.
+ */
+function checarTransporteDoPulse(dirMonitor, agora = Date.now()) {
+    if (!fs.existsSync(path.join(dirMonitor, 'pulse-host.json')))
+        return null;
+    const e = ultimaEntrega(dirMonitor);
+    if (!e || !(agora - Date.parse(e.ts) <= VALIDADE_DA_FALHA_MS))
+        return null;
+    const nome = 'transporte do pulse';
+    const quando = (0, horario_1.formatarDataHoraRotulada)(e.ts, { agora: new Date(agora).toISOString() });
+    if (!e.ok) {
+        const tentativas = e.tentativas.map((t) => `${t.host}: ${t.codigo ?? 'sem código'}`).join('; ');
+        return { nome, nivel: 'fail', detalhe: (0, locale_1.msg)().doctor.transporteFalhou(quando, tentativas), correcao: (0, locale_1.msg)().doctor.transporteCorrecao };
+    }
+    const falhas = e.tentativas.filter((t) => !t.ok);
+    if (falhas.length) {
+        return { nome, nivel: 'warn', detalhe: (0, locale_1.msg)().doctor.transporteDesvio(falhas.map((t) => t.host).join(', '), e.host ?? '?', quando),
+            correcao: (0, locale_1.msg)().doctor.transporteCorrecao };
+    }
+    return { nome, nivel: 'ok', detalhe: (0, locale_1.msg)().doctor.transporteOk(e.host ?? '?', quando) };
 }

package/dist/doctor-rede.js

@@ -41,7 +41,7 @@ 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 srvjcp86 ficou de 02/10 em diante como membro herdado da fabrica,
+ * `~/.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
@@ -56,6 +56,7 @@ 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. */
@@ -102,16 +103,16 @@ const curto = (s, teto = 200) => {
 /** 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] ?? '';
-    if (codigo === 'rede.sem-repositorio' || codigo === 'rede.repositorio-alheio') {
-        return 'a casa da rede ainda nao existe: o dono roda ork network entrar, que cria o repositorio privado; ou ork network sair, para tirar esta maquina da rede';
-    }
+    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 'faca login na forja (gh auth login ou glab auth login) e rode ork network publicar';
+        return m.redeSemForjaCorrecao;
     if (codigo === 'rede.repositorio-publico')
-        return 'torne a casa da rede privada na forja; nada e publicado num repositorio publico';
+        return m.redePublicaCorrecao;
     if (codigo === 'rede.nome-em-uso')
-        return 'escolha outro nome com ork network entrar --maquina NOME, ou tome este com --forcar';
-    return 'ork network status mostra as lacunas; ork network publicar tenta de novo';
+        return m.redeNomeCorrecao;
+    return m.redeOutraCorrecao;
 }
 /** O check "rede". `agoraMs` e o log ficam injetaveis para o teste. */
 function checarRede(opcoes = {}) {
@@ -120,8 +121,8 @@ function checarRede(opcoes = {}) {
     const adesao = (0, rede_adesao_1.adesaoDaRede)();
     if (!adesao.membro) {
         return { nome, nivel: 'ok', detalhe: adesao.config && !adesao.config.membro
-                ? 'fora da rede (saiu com ork network sair)'
-                : 'fora da rede; ork network entrar poe esta maquina na rede da pessoa' };
+                ? (0, locale_1.msg)().doctor.redeSaiu
+                : (0, locale_1.msg)().doctor.foraDaRede };
     }
     const marca = (0, rede_1.lerMarcaDaRede)();
     const config = adesao.config;
@@ -131,19 +132,19 @@ function checarRede(opcoes = {}) {
     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' ? 'membro herdado da fabrica' : 'membro',
-        casa ? `casa ${curto(casa, 120)}` : 'casa ainda nao gravada',
-        emBatida ? `ultima batida ${(0, horario_1.formatarDataHora)(emBatida)} (ha ${(0, rede_status_1.duracao)(idade)})` : 'nenhuma batida publicada',
-        falha ? `ultima falha ${(0, horario_1.formatarDataHora)(falha.ts)}${falha.origem ? ` (${curto(falha.origem, 20)})` : ''}: ${curto(falha.erro ?? 'sem detalhe')}`
-            : 'nenhuma falha no rede.log',
+        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 ?? '')
-        : 'a batida sai do pulse: confira o cron do pulse e rode ork network publicar';
+    const correcao = falhaAtual ? correcaoDaFalha(falha.erro ?? '') : m.redeParadaCorrecao;
     return { nome, nivel: 'warn', detalhe: partes.join('; '), correcao };
 }