@orkastery/cli 0.5.6 → 0.6.0

package/dist/doctor-forja.js

@@ -0,0 +1,345 @@
+"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.REMOTO_DA_FORJA = void 0;
+exports.sondasPadraoDoDoctor = sondasPadraoDoDoctor;
+exports.checarForja = checarForja;
+/**
+ * A secao "forja" do `ork doctor`: a forja resolvida do remoto `origin` e de onde veio cada valor, o alcance das
+ * portas HTTPS e SSH, a cadeia TLS, o subcaminho, a CLI e o login, os escopos do token, a versao do servidor, as
+ * opcoes de merge do projeto e as capacidades do adaptador.
+ *
+ * Sem remoto com host de forja e sem o bloco `forja:`, a secao nao se aplica e nao tem linha. Cada linha encerra as
+ * que dependem dela (sem HTTPS nao ha TLS; sem login nao ha API). So reprova o que a forja impede de verdade, e so
+ * quando o projeto depende dela (`ci.required_for_ship` ou o bloco `forja:`); fora disso, o mesmo achado e aviso: o
+ * doctor e gate de despacho. So consulta: nada e escrito na forja. A rede e a CLI sao injetaveis.
+ */
+const node_child_process_1 = require("node:child_process");
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const zod_1 = require("zod");
+const adaptador_1 = require("./forja/adaptador");
+const api_1 = require("./forja/api");
+const cli_1 = require("./forja/cli");
+const registro_1 = require("./forja/registro");
+const versao_1 = require("./forja/versao");
+const endereco_1 = require("./forja/endereco");
+const executor_1 = require("./forja/executor");
+const cache_1 = require("./forja/cache");
+const resolver_1 = require("./forja/resolver");
+const locale_1 = require("./locale");
+const pedidos_1 = require("./forja/gitlab/pedidos");
+const mcp_ship_transporte_1 = require("./mcp-ship-transporte");
+const util_1 = require("./util");
+/** O remoto conferido: o mesmo que a CI do `ork ship` consulta por padrao. */
+exports.REMOTO_DA_FORJA = 'origin';
+const PRAZO_DA_REDE_MS = 5_000;
+/** Um processo filho do Node mede a porta ou a cadeia TLS e devolve JSON: o doctor e sincrono. */
+const SCRIPT_DA_REDE = [
+    "const net = require('node:net'), tls = require('node:tls'), fs = require('node:fs');",
+    'const [modo, host, porta, prazo, ca] = process.argv.slice(1);',
+    'const fim = (r) => { process.stdout.write(JSON.stringify(r)); process.exit(0); };',
+    "setTimeout(() => fim(modo === 'tcp' ? { estado: 'sem-resposta' } : { ok: false, motivo: 'sem-resposta' }), Number(prazo));",
+    "if (modo === 'tcp') {",
+    '  const s = net.connect({ host, port: Number(porta) });',
+    "  s.on('connect', () => { s.destroy(); fim({ estado: 'aberta' }); });",
+    "  s.on('error', (e) => fim({ estado: e.code === 'ECONNREFUSED' ? 'recusada' : 'sem-resposta' }));",
+    '} else {',
+    '  const o = { host, port: Number(porta), rejectUnauthorized: true };',
+    '  if (!net.isIP(host)) o.servername = host;',
+    '  if (ca) o.ca = fs.readFileSync(ca);',
+    '  const s = tls.connect(o);',
+    "  s.on('secureConnect', () => { s.destroy(); fim({ ok: true }); });",
+    "  s.on('error', (e) => fim({ ok: false, motivo: e.code || 'erro' }));",
+    '}',
+].join('\n');
+function sondarRede(argv, prazoMs) {
+    const r = (0, node_child_process_1.spawnSync)(process.execPath, ['-e', SCRIPT_DA_REDE, ...argv], { encoding: 'utf8', timeout: prazoMs + 2_000, maxBuffer: 64 * 1024 });
+    try {
+        const j = JSON.parse(r.stdout);
+        return j && typeof j === 'object' ? j : {};
+    }
+    catch {
+        return {};
+    }
+}
+function sondasPadraoDoDoctor(raiz) {
+    return {
+        urlDoRemoto: (dir, remoto) => {
+            const r = (0, util_1.exec)('git', ['remote', 'get-url', '--', remoto], dir, 10_000);
+            return r.ok ? r.stdout.trim() : null;
+        },
+        sondas: resolver_1.SONDAS_PADRAO,
+        porta: (host, porta, prazoMs) => {
+            const e = sondarRede(['tcp', host, String(porta), String(prazoMs), ''], prazoMs).estado;
+            return e === 'aberta' || e === 'recusada' ? e : 'sem-resposta';
+        },
+        tls: (host, porta, ca, prazoMs) => {
+            const r = sondarRede(['tls', host, String(porta), String(prazoMs), ca ?? ''], prazoMs);
+            return r.ok === true ? { ok: true } : { ok: false, motivo: typeof r.motivo === 'string' ? r.motivo : 'sem-resposta' };
+        },
+        rodar: executor_1.rodarCli,
+        agoraMs: () => Date.now(),
+        cache: (0, cache_1.dirDoCacheDaForja)(raiz),
+        plataforma: process.platform,
+        transporteDoShip: (dir) => { try {
+            return (0, mcp_ship_transporte_1.fixacaoInstalada)(dir)?.transporte ?? null;
+        }
+        catch {
+            return null;
+        } },
+    };
+}
+const legivel = (arquivo) => {
+    try {
+        fs.accessSync(arquivo, fs.constants.R_OK);
+        return fs.statSync(arquivo).isFile();
+    }
+    catch {
+        return false;
+    }
+};
+function identidade(f, porta) {
+    const m = (0, locale_1.msg)().forja.doctor;
+    const o = (x) => m.origens[x] ?? x;
+    return m.identidade(f.tipo, f.host, porta, f.caminhoBase || '/', f.repo, m.origensDosCampos(o(f.origem.tipo), o(f.origem.host), o(f.origem.porta), o(f.origem.caminhoBase)));
+}
+/** Alcance e TLS; `false` quando o que vem depois nao tem como rodar. */
+function alcanceETls(f, portaWeb, http, s, linha, checks) {
+    const m = (0, locale_1.msg)().forja.doctor;
+    const sshHost = f.sshHost ?? f.host, sshPorta = f.sshPorta ?? 22;
+    const web = s.porta(f.host, portaWeb, PRAZO_DA_REDE_MS), ssh = s.porta(sshHost, sshPorta, PRAZO_DA_REDE_MS);
+    const detalhe = m.alcance(m.alcanceDe(f.host, portaWeb, m.portas[web]), m.alcanceDe(sshHost, sshPorta, m.portas[ssh]));
+    if (web !== 'aberta') {
+        checks.push(linha('forja alcance', 'fail', detalhe, m.webForaCorrecao(f.host, portaWeb)));
+        return false;
+    }
+    checks.push(linha('forja alcance', ssh === 'aberta' ? 'ok' : 'warn', detalhe, m.sshForaCorrecao));
+    if (http) {
+        checks.push(linha('forja tls', 'warn', m.tlsHttp(f.host), m.tlsHttpCorrecao));
+        return true;
+    }
+    if (f.ca && !legivel(f.ca)) {
+        checks.push(linha('forja tls', 'fail', m.caAusente(f.ca), m.caAusenteCorrecao));
+        return false;
+    }
+    const tls = s.tls(f.host, portaWeb, f.ca, PRAZO_DA_REDE_MS);
+    if (!tls.ok) {
+        checks.push(linha('forja tls', 'fail', m.tlsFalhou(f.host, tls.motivo), m.tlsCorrecao));
+        return false;
+    }
+    // O gh le a CA do manifesto por SSL_CERT_FILE, e o Go so o le no Linux.
+    if (f.tipo === 'github' && f.ca && s.plataforma !== 'linux') {
+        checks.push(linha('forja tls', 'warn', m.tlsCaForaDoLinux(f.host, f.ca), m.tlsCaForaDoLinuxCorrecao));
+        return true;
+    }
+    checks.push(linha('forja tls', 'ok', m.tlsOk(f.host, f.ca)));
+    return true;
+}
+const PRAZO_DA_CLI_MS = 10_000;
+function cliELogin(f, http, s, linha, checks) {
+    const m = (0, locale_1.msg)().forja.doctor, cli = cli_1.CLI_DA_FORJA[f.tipo];
+    const correcao = m.cliCorrecao(cli.cmd, cli.minima);
+    const v = s.rodar({ cmd: cli.cmd, args: ['--version'], prazoMs: PRAZO_DA_CLI_MS, maxBuffer: 1024 * 1024, cwd: os.tmpdir(), reduzido: true });
+    if (v.erro === 'ENOENT') {
+        checks.push(linha('forja cli', 'fail', m.cliAusente(cli.cmd, cli.minima), correcao));
+        return false;
+    }
+    const versao = cli.lerVersao(`${v.stdout}\n${v.stderr}`);
+    if (!versao) {
+        checks.push(linha('forja cli', 'fail', m.cliIlegivel(cli.cmd), correcao));
+        return false;
+    }
+    if ((0, cli_1.versaoAbaixo)(versao, cli.minima)) {
+        checks.push(linha('forja cli', 'fail', m.cliAbaixo(cli.cmd, versao, cli.minima), correcao));
+        return false;
+    }
+    checks.push(linha('forja cli', 'ok', m.cli(cli.cmd, versao, cli.minima)));
+    const alvo = `${(0, cli_1.hostDaApi)(f)}${f.caminhoBase}`;
+    if (!(0, api_1.temLogin)(f, s.rodar)) {
+        // O comando que a pessoa roda: com o caminho base no glab (guardado como host, com subfolder) e o token pelo stdin.
+        checks.push(linha('forja login', 'fail', m.semLogin(cli.cmd, alvo), m.loginCorrecao(cli.entrar(f, http).join(' '))));
+        return false;
+    }
+    checks.push(linha('forja login', 'ok', m.login(cli.cmd, alvo)));
+    return true;
+}
+/** O subcaminho (com caminho base) e o servidor, pela mesma leitura do metadata. */
+function servidor(f, s, api, linha, checks) {
+    const m = (0, locale_1.msg)().forja.doctor;
+    const meta = (0, versao_1.lerMetadados)(f, { cache: s.cache, agoraMs: s.agoraMs(), api });
+    if (f.caminhoBase) {
+        checks.push(meta.ok ? linha('forja subcaminho', 'ok', m.subcaminho(f.caminhoBase))
+            : linha('forja subcaminho', 'fail', m.subcaminhoFalhou(f.caminhoBase, (0, locale_1.msg)().forja.motivo(meta.erro, f.tipo)), m.subcaminhoCorrecao));
+    }
+    if (!meta.ok) {
+        if (!f.caminhoBase)
+            checks.push(linha('forja servidor', 'fail', m.servidorFalhou((0, locale_1.msg)().forja.motivo(meta.erro, f.tipo)), m.servidorFalhouCorrecao));
+        return false;
+    }
+    const v = meta.valor;
+    const cache = v.doCache ? `; ${m.doCache}` : '';
+    const piso = versao_1.FAIXAS[f.tipo]?.piso;
+    // A versao ilegivel na forja com faixas (`sem-faixa`) nao prova o piso: reprova como abaixo dele.
+    if ((v.faixa === 'abaixo-do-piso' || v.faixa === 'sem-faixa') && piso) {
+        checks.push(linha('forja servidor', 'fail', m.servidorAbaixo(v.versao ?? '?', piso) + cache, m.servidorCorrecao(piso)));
+        return false;
+    }
+    checks.push(linha('forja servidor', 'ok', (versao_1.FAIXAS[f.tipo]
+        ? m.servidor(v.versao ?? '?', (v.edicao ?? '?').toUpperCase(), m.faixas[v.faixa] ?? v.faixa)
+        : m.servidorSemFaixa(f.host, v.versao)) + cache));
+    return true;
+}
+const TOKEN_DO_GITLAB = zod_1.z.object({ scopes: zod_1.z.array(zod_1.z.string()) });
+/** `empurra`: o SHIP do MCP empurra pelo `forja-https`, com o token da CLI; no GitLab, ele precisa de escrita no repositorio. */
+function escopo(f, api, linha, empurra = false) {
+    const m = (0, locale_1.msg)().forja.doctor;
+    const naoMedivel = (motivo) => linha('forja escopo', 'warn', m.escopoNaoMedivel(motivo), m.escopoNaoMedivelCorrecao);
+    if (f.tipo === 'gitlab') {
+        const r = api({ metodo: 'GET', caminho: 'personal_access_tokens/self' });
+        if (!r.ok)
+            return naoMedivel((0, locale_1.msg)().forja.motivo(r.erro, f.tipo));
+        const lido = TOKEN_DO_GITLAB.safeParse(r.valor.corpo);
+        if (!lido.success)
+            return naoMedivel('personal_access_tokens/self');
+        const lista = lido.data.scopes.join(', ') || m.nenhum;
+        if (!lido.data.scopes.some((x) => x === 'api' || x === 'read_api'))
+            return linha('forja escopo', 'fail', m.escopoSemLeitura(lista), m.escopoCorrecao);
+        if (empurra && !lido.data.scopes.some((x) => x === 'api' || x === 'write_repository')) {
+            return linha('forja escopo', 'fail', m.escopoSemEscrita(lista), m.escopoSemEscritaCorrecao);
+        }
+        return linha('forja escopo', 'ok', m.escopo(lista));
+    }
+    if (f.tipo === 'github') {
+        // `rate_limit` nao gasta a cota e traz o `x-oauth-scopes` do token classico.
+        const r = api({ metodo: 'GET', caminho: 'rate_limit' });
+        if (!r.ok)
+            return naoMedivel((0, locale_1.msg)().forja.motivo(r.erro, f.tipo));
+        const cabecalho = r.valor.cabecalhos['x-oauth-scopes'];
+        if (cabecalho === undefined)
+            return linha('forja escopo', 'ok', m.escopoFineGrained);
+        const escopos = cabecalho.split(',').map((x) => x.trim()).filter(Boolean);
+        const lista = escopos.join(', ') || m.nenhum;
+        return escopos.includes('repo') ? linha('forja escopo', 'ok', m.escopo(lista)) : linha('forja escopo', 'warn', m.escopoSemRepo(lista), m.escopoSemRepoCorrecao);
+    }
+    return linha('forja escopo', 'ok', m.escopoNaoMedivel(f.tipo));
+}
+const PROJETO_DO_GITLAB = zod_1.z.object({
+    merge_method: zod_1.z.string(), squash_option: zod_1.z.string().optional(), merge_commit_template: zod_1.z.string().nullable().optional(),
+    merge_pipelines_enabled: zod_1.z.boolean().optional(), merge_trains_enabled: zod_1.z.boolean().optional(),
+});
+const REPOSITORIO_DO_GITHUB = zod_1.z.object({
+    allow_merge_commit: zod_1.z.boolean().optional(), allow_squash_merge: zod_1.z.boolean().optional(), allow_rebase_merge: zod_1.z.boolean().optional(),
+});
+/** O metodo de merge e o resto do que decide se o merge `ship(<thread>)` chega a base. So avisa; o projeto nao lido reprova. */
+function projetoDaForja(f, api, linha) {
+    const m = (0, locale_1.msg)().forja.doctor;
+    const caminho = f.tipo === 'gitlab' ? (0, pedidos_1.projetoNaApi)(f.repo) : `repos/${f.repo}`;
+    if (f.tipo !== 'gitlab' && f.tipo !== 'github')
+        return linha('forja projeto', 'ok', m.naoMedivel);
+    const r = api({ metodo: 'GET', caminho });
+    if (!r.ok)
+        return linha('forja projeto', 'fail', m.projetoFalhou(f.repo, (0, locale_1.msg)().forja.motivo(r.erro, f.tipo)), m.projetoFalhouCorrecao);
+    const invalido = () => linha('forja projeto', 'warn', m.projetoFalhou(f.repo, (0, locale_1.msg)().forja.motivo({ codigo: 'forja.resposta-invalida', detalhe: caminho }, f.tipo)), m.projetoFalhouCorrecao);
+    if (f.tipo === 'gitlab') {
+        const lido = PROJETO_DO_GITLAB.safeParse(r.valor.corpo);
+        if (!lido.success)
+            return invalido();
+        const p = lido.data;
+        const estado = (v) => (v === undefined ? m.naoDisponivel : v ? m.ligado : m.desligado);
+        const avisos = [];
+        if (p.merge_method === 'ff')
+            avisos.push(m.avisoFf);
+        else if (!(p.merge_commit_template ?? '').trimStart().startsWith('%{title}'))
+            avisos.push(m.avisoMensagemPadrao);
+        if (p.squash_option === 'always' || p.squash_option === 'default_on')
+            avisos.push(m.avisoSquash(p.squash_option));
+        const detalhe = [m.projetoGitlab(p.merge_method, p.squash_option ?? '?', estado(p.merge_pipelines_enabled), estado(p.merge_trains_enabled)),
+            ...avisos].join('; ');
+        return linha('forja projeto', avisos.length ? 'warn' : 'ok', detalhe, m.projetoGitlabCorrecao);
+    }
+    const lido = REPOSITORIO_DO_GITHUB.safeParse(r.valor.corpo);
+    if (!lido.success)
+        return invalido();
+    const p = lido.data;
+    const permite = (v) => (v === undefined ? m.naoMedivel : v ? m.permitido : m.desligado);
+    const avisos = p.allow_merge_commit === false ? [m.avisoSemMergeCommit] : [];
+    const detalhe = [m.projetoGithub(permite(p.allow_merge_commit), permite(p.allow_squash_merge), permite(p.allow_rebase_merge)), ...avisos].join('; ');
+    return linha('forja projeto', avisos.length ? 'warn' : 'ok', detalhe, m.projetoGithubCorrecao);
+}
+function capacidades(f) {
+    const m = (0, locale_1.msg)().forja.doctor, a = (0, registro_1.adaptadorDaForja)(f.tipo);
+    // O `checksNoCommit` e o caminho antigo do executor do `gh`: a forja que le a CI pelo `estadoDeCi` nao precisa dele.
+    const mostradas = adaptador_1.CAPACIDADES.filter((c) => c !== 'checksNoCommit' || typeof a.checksNoCommit === 'function' || typeof a.estadoDeCi !== 'function');
+    const ligadas = mostradas.filter((c) => typeof a[c] === 'function');
+    const desligadas = mostradas.filter((c) => typeof a[c] !== 'function');
+    return desligadas.length
+        ? { nome: 'forja capacidades', nivel: 'warn', detalhe: m.capacidadesDesligadas(ligadas.join(', ') || m.nenhum, desligadas.join(', ')),
+            correcao: m.capacidadesCorrecao }
+        : { nome: 'forja capacidades', nivel: 'ok', detalhe: m.capacidades(ligadas.join(', ')) };
+}
+function checarForja(carregado, s = sondasPadraoDoDoctor(carregado.raiz)) {
+    const m = (0, locale_1.msg)().forja.doctor;
+    const declarada = carregado.manifesto.forja;
+    const dependeDaForja = carregado.manifesto.ci.required_for_ship || declarada !== undefined;
+    const linha = (nome, nivel, detalhe, correcao) => {
+        const n = nivel === 'fail' && !dependeDaForja ? 'warn' : nivel;
+        return { nome, nivel: n, detalhe, ...(n !== 'ok' && correcao ? { correcao } : {}) };
+    };
+    const url = s.urlDoRemoto(carregado.raiz, exports.REMOTO_DA_FORJA);
+    const endereco = url ? (0, endereco_1.lerEnderecoDoRemoto)(url) : null;
+    if (!endereco) {
+        return declarada ? [linha('forja identidade', 'warn', m.semHostComBloco(exports.REMOTO_DA_FORJA), m.semHostCorrecao(exports.REMOTO_DA_FORJA))] : [];
+    }
+    const resolvida = (0, resolver_1.resolverForja)({ endereco, manifesto: declarada, sondas: s.sondas, cache: s.cache, agoraMs: s.agoraMs() });
+    if (!resolvida.ok) {
+        return [linha('forja identidade', 'fail', (0, locale_1.msg)().forja.motivo(resolvida.erro, null), resolvida.erro.codigo === 'forja.remoto-divergente' ? m.divergenteCorrecao : m.identidadeCorrecao)];
+    }
+    const f = resolvida.valor;
+    // Remoto http sem porta declarada no manifesto: a web e a do remoto, sem TLS.
+    const http = endereco.protocolo === 'http' && declarada?.porta === undefined;
+    const portaWeb = f.porta ?? (http ? 80 : 443);
+    const checks = [linha('forja identidade', 'ok', identidade(f, portaWeb))];
+    if (!alcanceETls(f, portaWeb, http, s, linha, checks))
+        return checks;
+    if (!cliELogin(f, http, s, linha, checks))
+        return checks;
+    // O login ja foi conferido: as chamadas da API nao repetem o `auth status`.
+    const api = (0, api_1.chamadorDaApi)(f, { rodar: s.rodar, agoraMs: s.agoraMs, logins: new Map([[(0, api_1.chaveDoLogin)(f), true]]) });
+    if (!servidor(f, s, api, linha, checks))
+        return checks;
+    checks.push(escopo(f, api, linha, s.transporteDoShip?.(carregado.raiz) === 'forja-https'), projetoDaForja(f, api, linha), capacidades(f));
+    return checks;
+}

package/dist/doctor-pulse-cron.js

@@ -46,7 +46,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 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.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.valorNoShell = valorNoShell;
@@ -62,11 +62,16 @@ 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. */
@@ -341,9 +346,116 @@ function checarCronDoPulse(dirMonitor, raizDoCheckout, ler = lerCrontabDoSistema
             lentas.push({ linha, comando: partes?.comando ?? comandoSugerido, intervalo });
     }
     if (lentas.length < linhas.length) {
+        // 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];
     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) };
+}