@orkastery/cli 0.5.1 → 0.5.3

package/dist/doctor-pulse-cron.js

@@ -0,0 +1,194 @@
+"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.
+ */
+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_DO_TEMPLATE = exports.SCRIPT_DA_VARREDURA = exports.BATIDA_DO_TEMPLATE = void 0;
+exports.lerCrontabDoSistema = lerCrontabDoSistema;
+exports.intervaloEmMinutos = intervaloEmMinutos;
+exports.linhasDaVarredura = linhasDaVarredura;
+exports.scriptDaVarreduraDoOrk = scriptDaVarreduraDoOrk;
+exports.comandoDaVarredura = comandoDaVarredura;
+exports.checarCronDoPulse = checarCronDoPulse;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const util_1 = require("./util");
+/** 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: '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}` };
+}
+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;
+}
+/** 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));
+}
+/** Aspas de shell so quando o caminho precisa (a linha vai colada no crontab, que roda por `sh`). */
+function citar(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 citar(doProjeto);
+    return `ORK_PULSE_PROJECT=${citar(raizDoProjeto)} ${citar(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.
+ */
+function checarCronDoPulse(dirMonitor, raizDoCheckout, ler = lerCrontabDoSistema, scriptDoOrk = scriptDaVarreduraDoOrk()) {
+    if (!fs.existsSync(path.join(dirMonitor, 'pulse-host.json')))
+        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 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);
+    if (linhas.length === 0)
+        return ausente(`pulse-host.json presente, e nenhuma linha do crontab roda ${exports.SCRIPT_DA_VARREDURA}: o resumo nao sai`);
+    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: `varredura no cron a cada 15 minutos ou menos (${linhas.length} linha(s))` };
+    }
+    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)}` };
+}

package/dist/doctor-rede.js

@@ -0,0 +1,149 @@
+"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 srvjcp86 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");
+/** 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] ?? '';
+    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';
+    }
+    if (codigo === 'rede.sem-forja')
+        return 'faca login na forja (gh auth login ou glab auth login) e rode ork network publicar';
+    if (codigo === 'rede.repositorio-publico')
+        return 'torne a casa da rede privada na forja; nada e publicado num repositorio publico';
+    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';
+}
+/** 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
+                ? 'fora da rede (saiu com ork network sair)'
+                : 'fora da rede; ork network entrar poe esta maquina na rede da pessoa' };
+    }
+    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 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',
+    ];
+    // 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';
+    return { nome, nivel: 'warn', detalhe: partes.join('; '), correcao };
+}

package/dist/doctor.js

@@ -40,6 +40,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TETO_DO_DONO_DO_GIT = void 0;
+exports.manifestoForaDoRepositorio = manifestoForaDoRepositorio;
 exports.checarContas = checarContas;
 exports.checarChaveDeEmbedding = checarChaveDeEmbedding;
 exports.checarDonoDoGit = checarDonoDoGit;
@@ -69,6 +70,41 @@ const runtime_ambiente_1 = require("./runtime-ambiente");
 const runtime_profiles_1 = require("./runtime-profiles");
 const preflight_1 = require("./preflight");
 const setup_1 = require("./setup");
+const doctor_pulse_cron_1 = require("./doctor-pulse-cron");
+const doctor_rede_1 = require("./doctor-rede");
+/**
+ * Ensaio de 03/10/2026 (RM-049): o manifesto e achado subindo a partir do diretorio atual. Um
+ * `orkastery.yaml` de uma pasta acima do repositorio (um `ork init` rodado por engano no HOME) era
+ * lido como o deste projeto, com outro nome e outra abbrev, e o doctor dizia PRONTO. Vale o manifesto
+ * dentro do repositorio ou na arvore principal dele (a worktree de thread le o da arvore principal).
+ */
+function manifestoForaDoRepositorio(dirInicial, caminhoDoManifesto) {
+    const topo = (0, util_1.exec)('git', ['rev-parse', '--show-toplevel'], dirInicial);
+    if (!topo.ok)
+        return null;
+    const real = (p) => { try {
+        return fs.realpathSync(p);
+    }
+    catch {
+        return path.resolve(p);
+    } };
+    const dirDoManifesto = real(path.dirname(caminhoDoManifesto));
+    const dentro = (raiz) => {
+        const r = path.relative(real(raiz), dirDoManifesto);
+        return r === '' || (!r.startsWith('..') && !path.isAbsolute(r));
+    };
+    if (dentro(topo.stdout.trim()))
+        return null;
+    const comum = (0, util_1.exec)('git', ['rev-parse', '--path-format=absolute', '--git-common-dir'], dirInicial);
+    if (comum.ok && path.basename(comum.stdout.trim()) === '.git' && dentro(path.dirname(comum.stdout.trim())))
+        return null;
+    return {
+        nome: 'manifesto do repositorio',
+        nivel: 'warn',
+        detalhe: `o ${manifest_1.NOME_MANIFESTO} lido fica fora deste repositorio (${caminhoDoManifesto}): o ork conduz o projeto daquela pasta, nao o de ${topo.stdout.trim()}`,
+        correcao: `rode ork init na raiz deste repositorio (${topo.stdout.trim()}); se o manifesto de fora nasceu por engano, apague-o junto com o AGENTS.md e o .orkastery/ ao lado dele`,
+    };
+}
 /**
  * I-33 (D7): check "contas por runtime". Cada perfil ativo tem o login conferido pelo proprio
  * CLI com o env dele (`claude auth status`, `codex login status`); o doctor so le e relata, sem
@@ -294,15 +330,40 @@ function textoDosBlocos(blocos) {
         porModo.set(b.tag, [...(porModo.get(b.tag) ?? []), b.bloco]);
     return [...porModo].map(([tag, numeros]) => `${tag} ${numeros.join(', ')}`).join('; ');
 }
+/**
+ * Ensaio de 03/10 (R1): com perfil ativo do runtime, quem confere o login e o check "contas por runtime";
+ * sem perfil (ou com o store ilegivel, que aquele check reprova), o despacho usa o login do `claude` do processo.
+ */
+function temPerfilAtivo(carregado, runtime) {
+    if (!carregado || carregado.erros.length)
+        return false;
+    try {
+        return (0, runtime_profiles_1.lerPerfisComContas)(carregado.raiz).perfis.some(p => p.runtime === runtime && p.estado !== 'desativado');
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * Fatia 2 do ensaio da 0.5.0 (P1): o `claude` so e obrigatorio quando algum bloco de modo permitido
  * despacha por ele. Sem manifesto, com manifesto invalido ou com setup ilegivel vale o padrao (todo
  * bloco no claude-bg), e a falta reprova como antes.
  */
-function checarRuntimeClaude(carregado, claude, versao) {
+function checarRuntimeClaude(carregado, claude, versao, auth = null) {
     const nome = 'runtime claude-bg';
-    if (claude)
-        return { nome, nivel: 'ok', detalhe: `${claude} (${versao ?? 'versao desconhecida'})` };
+    if (claude) {
+        const detalhe = `${claude} (${versao ?? 'versao desconhecida'})`;
+        // Ensaio de 03/10 (R1): sem perfil de conta, o despacho usa o login do proprio `claude`; sem ele, o
+        // primeiro despacho falha. Conferencia inconclusiva (timeout, JSON ilegivel) nao prova falta de login.
+        if (auth && !auth.ok && !auth.transitorio) {
+            return { nome, nivel: 'warn', detalhe: `${detalhe}; ${auth.detalhe}: o despacho pelo claude-bg falharia`,
+                correcao: auth.pago
+                    ? 'faca o login de assinatura (claude.ai) no `claude`, sem API key nem provider de nuvem'
+                    : 'rode `claude` uma vez, faca o login de assinatura (/login) e aceite a confianca no diretorio do projeto; ' +
+                        'ou crie um perfil com ork accounts add <id> --runtime claude-bg --dir <pasta>' };
+        }
+        return { nome, nivel: 'ok', detalhe };
+    }
     const blocos = carregado && carregado.erros.length === 0 ? blocosDoRuntime(carregado, 'claude-bg') : null;
     if (blocos && blocos.principal.length === 0) {
         // CHECK, rodada 1 (S6): as fases nao precisam dele, mas o `ork audit run` despacha sempre pelo claude-bg.
@@ -351,8 +412,12 @@ function checarDespachoPeloCodex(carregado, codex, sonda) {
                 : undefined,
     };
 }
-/** Roda todos os checks a partir do diretorio informado. */
-function checar(dirInicial = process.cwd(), nomesHerdados = (0, runtime_ambiente_1.nomesDeProviderAtivos)()) {
+/**
+ * Roda todos os checks a partir do diretorio informado. RM-031: `analisadores` e o check do grafo
+ * (`checarAnalisadoresDoGrafo` do CLI do grafo), que o `index.ts` passa: fora da familia do grafo so
+ * ele e o worker do MCP a abrem (fronteira do KG1), e o doctor nao a importa.
+ */
+function checar(dirInicial = process.cwd(), nomesHerdados = (0, runtime_ambiente_1.nomesDeProviderAtivos)(), lerCrontab = doctor_pulse_cron_1.lerCrontabDoSistema, conferirAuthDoClaude = () => adapter.conferirAuth(null), analisadores) {
     const checks = [];
     const major = versaoNode();
     checks.push({
@@ -361,6 +426,8 @@ function checar(dirInicial = process.cwd(), nomesHerdados = (0, runtime_ambiente
         detalhe: `v${process.versions.node}`,
         correcao: major >= 20 ? undefined : 'instale Node 20 ou superior',
     });
+    if (analisadores)
+        checks.push(analisadores());
     const git = (0, util_1.noPath)('git');
     checks.push({
         nome: 'git',
@@ -390,7 +457,7 @@ function checar(dirInicial = process.cwd(), nomesHerdados = (0, runtime_ambiente
     const carregado = (0, manifest_1.carregarManifesto)(dirInicial);
     const claude = adapter.disponivel();
     const v = claude ? adapter.versao() : null;
-    checks.push(checarRuntimeClaude(carregado, claude, v));
+    checks.push(checarRuntimeClaude(carregado, claude, v, claude && !temPerfilAtivo(carregado, 'claude-bg') ? conferirAuthDoClaude() : null));
     // Segundo runtime homologado. Ausente e `warn`, nao `fail`: o claude-bg segue sendo o
     // padrao, e um projeto que nunca pediu codex nao pode ficar bloqueado por ele.
     const codex = codexAdapter.disponivel();
@@ -433,7 +500,8 @@ function checar(dirInicial = process.cwd(), nomesHerdados = (0, runtime_ambiente
             nome: 'manifesto',
             nivel: 'fail',
             detalhe: `${manifest_1.NOME_MANIFESTO} nao encontrado a partir de ${dirInicial}`,
-            correcao: 'ork init',
+            // Ensaio de 03/10/2026 (RM-049): fora de repositorio, o `ork init` recusa; a correcao diz onde roda-lo.
+            correcao: dentroDeRepo ? 'ork init' : 'entre no repositorio do projeto (ou crie um com git init e o primeiro commit) e rode ork init',
         });
     }
     else {
@@ -446,6 +514,11 @@ function checar(dirInicial = process.cwd(), nomesHerdados = (0, runtime_ambiente
                     (carregado.avisos.length > 0 ? `; ${carregado.avisos.join('; ')}` : ''),
             correcao: carregado.erros.length > 0 ? 'corrija o manifesto e rode ork doctor de novo' : undefined,
         });
+        if (dentroDeRepo) {
+            const fora = manifestoForaDoRepositorio(dirInicial, carregado.caminho);
+            if (fora)
+                checks.push(fora);
+        }
         checks.push(...checarOnboarding(carregado));
         const abbrev = carregado.manifesto.project.abbrev;
         const checkAbbrev = (0, slug_1.validarAbbrev)(abbrev);
@@ -554,6 +627,11 @@ function checar(dirInicial = process.cwd(), nomesHerdados = (0, runtime_ambiente
                 : `${dirEstadoProjeto} ausente`,
             correcao: fs.existsSync(dirEstadoProjeto) ? undefined : 'ork init cria o diretorio de estado',
         });
+        // RM-039 (B6): com o transporte do pulse configurado, a varredura tem de bater de 15 em 15
+        // minutos; a instalacao antiga em `0 * * * *` vira aviso com a linha nova. Nunca edita o crontab.
+        const cronDoPulse = (0, doctor_pulse_cron_1.checarCronDoPulse)(path.join(dirEstadoProjeto, 'monitor'), (0, estado_thread_1.raizDoEstado)(carregado.raiz), lerCrontab);
+        if (cronDoPulse)
+            checks.push(cronDoPulse);
         checks.push(checarContas(carregado.raiz));
         // I-33 (D7): umask e permissoes do estado, na mesma regra do sensor (sem bits 0o022).
         checks.push(...(0, preflight_1.sondasDeAmbiente)(carregado.raiz));
@@ -573,6 +651,8 @@ function checar(dirInicial = process.cwd(), nomesHerdados = (0, runtime_ambiente
             });
         }
     }
+    // RM-053 (fatia 2): a rede da pessoa e da maquina, nao do projeto; vale de qualquer diretorio.
+    checks.push((0, doctor_rede_1.checarRede)());
     return checks;
 }
 /** Texto do relatorio, com o resumo "o que vale nesta maquina agora". */
@@ -608,8 +688,8 @@ function relatorio(checks) {
     return linhas.join('\n');
 }
 /** Executa o doctor e devolve o codigo de saida (0 = pronto). */
-function doctor(dirInicial = process.cwd(), nomesHerdados = (0, runtime_ambiente_1.nomesDeProviderAtivos)()) {
-    const checks = checar(dirInicial, nomesHerdados);
+function doctor(dirInicial = process.cwd(), nomesHerdados = (0, runtime_ambiente_1.nomesDeProviderAtivos)(), analisadores) {
+    const checks = checar(dirInicial, nomesHerdados, undefined, undefined, analisadores);
     const falhas = checks.filter((c) => c.nivel === 'fail').length;
     return { texto: relatorio(checks), codigo: falhas > 0 ? 1 : 0 };
 }

package/dist/entrega-pr.js

@@ -16,7 +16,9 @@ exports.registrarEntregasPorPr = registrarEntregasPorPr;
  * remota (ancestralidade conferida contra a ponta que o `ls-remote` devolve) e o check do CI no
  * head do PR. Sem CI verde, nao registra: merge sem prova independente nao e entrega.
  */
+const branch_de_estado_1 = require("./branch-de-estado");
 const ci_1 = require("./ci");
+const docs_1 = require("./docs");
 const fabrica_publicar_1 = require("./fabrica-publicar");
 const ledger_1 = require("./ledger");
 const modos_1 = require("./modos");
@@ -49,7 +51,7 @@ function avancarParaShip(raiz, threadId) {
     (0, thread_1.gravarThread)(raiz, atualizada);
 }
 function resultado(thread, acao, motivo, extra = {}) {
-    return { thread, acao, motivo, mergeSha: null, headSha: null, ci: null, ...extra };
+    return { thread, acao, motivo, mergeSha: null, headSha: null, ci: null, docsPendentes: [], ...extra };
 }
 /**
  * `ork ship registrar-pr <thread>`: grava o `ship_done` da entrega feita por PR. Idempotente:
@@ -57,22 +59,26 @@ function resultado(thread, acao, motivo, extra = {}) {
  */
 function registrarEntregaPorPr(carregado, threadId, opcoes = {}) {
     const raiz = carregado.raiz;
-    const remoto = opcoes.remoto ?? 'origin';
+    // RM-047: o `--remoto` vem da linha de comando; so nome de remoto chega ao git, e depois do `--`.
+    const remoto = (0, branch_de_estado_1.exigirRemoto)(opcoes.remoto ?? 'origin', 'ship');
     const base = carregado.manifesto.worktree.base_branch;
     const thread = (0, thread_1.lerThread)(raiz, threadId);
     if (thread.status === 'fechada')
         return resultado(threadId, 'ja-registrada', 'thread ja fechada');
     if (opcoes.buscar !== false)
-        (0, util_1.exec)('git', ['fetch', '-q', remoto, `+refs/heads/${base}:refs/remotes/${remoto}/${base}`], raiz);
-    const merge = mergeDaEntrega(raiz, threadId, remoto, base);
-    if (!merge)
+        (0, util_1.exec)('git', ['fetch', '-q', '--', remoto, `+refs/heads/${base}:refs/remotes/${remoto}/${base}`], raiz);
+    const encontrado = mergeDaEntrega(raiz, threadId, remoto, base);
+    if (!encontrado)
         return resultado(threadId, 'sem-merge', `nenhum merge ship(${threadId}) em ${remoto}/${base}`);
+    // RM-044 (A3): o condutor roda o registrar-pr logo depois do merge; e aqui que ele fica sabendo da pagina que
+    // vai deixar o push da base vermelho, lida da base remota que o fetch acabou de trazer.
+    const merge = { ...encontrado, docsPendentes: (0, docs_1.docsPendentesDoMerge)(raiz, threadId, `refs/remotes/${remoto}/${base}`) };
     const dir = (0, thread_1.dirThread)(raiz, threadId);
     const jaTem = (0, ledger_1.lerLedger)(dir).some((e) => e.tipo === ledger_1.TIPOS_DE_EVENTO.shipConcluido && e.mergeSha === merge.mergeSha);
     if (jaTem)
         return resultado(threadId, 'ja-registrada', 'esta entrega ja tem ship_done', merge);
     // A ponta do remoto AGORA, e o merge dentro dela: e o que torna o push provado, nao presumido.
-    const remotoAgora = (0, util_1.exec)('git', ['ls-remote', remoto, `refs/heads/${base}`], raiz);
+    const remotoAgora = (0, util_1.exec)('git', ['ls-remote', '--', remoto, `refs/heads/${base}`], raiz);
     const ponta = remotoAgora.ok ? remotoAgora.stdout.split('\t')[0].trim() : '';
     if (!ponta || !(0, util_1.exec)('git', ['merge-base', '--is-ancestor', merge.mergeSha, ponta], raiz).ok) {
         return resultado(threadId, 'recusada', `o merge ${merge.mergeSha.slice(0, 7)} nao esta na ponta de ${remoto}/${base}`, merge);
@@ -90,6 +96,9 @@ function registrarEntregaPorPr(carregado, threadId, opcoes = {}) {
         para: base,
         shaDe: merge.headSha,
         mergeSha: merge.mergeSha,
+        // RM-037 (fatia 5, A1): a ponta que o ls-remote provou vai em campo proprio; o recibo do Maestro confere o push
+        // contra ela quando a base andou depois do merge.
+        pontaDaBase: ponta,
         jaIncorporado: true,
         remoto,
         shaRemoto: ponta,
@@ -189,6 +198,9 @@ function registrarEntregaExternaPorPr(carregado, threadId, opcoes) {
         url: pr.html_url ?? `https://github.com/${repo}/pull/${n}`,
         shaDe: headSha,
         mergeSha,
+        // RM-037 (fatia 5, A1; aviso da rodada 1 do CHECK): a ponta conferida vai em campo proprio, como no PR local; a
+        // comparacao aceita `ahead`, e o recibo do Maestro confere o push contra ela.
+        pontaDaBase: ponta,
         jaIncorporado: true,
         remoto: `github:${repo}`,
         shaRemoto: ponta,
@@ -207,9 +219,9 @@ function registrarEntregaExternaPorPr(carregado, threadId, opcoes) {
 }
 /** `ork ship registrar-pr --todas`: toda thread aberta que ja tem merge `ship(<thread>)` na base. */
 function registrarEntregasPorPr(carregado, opcoes = {}) {
-    const remoto = opcoes.remoto ?? 'origin';
+    const remoto = (0, branch_de_estado_1.exigirRemoto)(opcoes.remoto ?? 'origin', 'ship');
     const base = carregado.manifesto.worktree.base_branch;
-    (0, util_1.exec)('git', ['fetch', '-q', remoto, `+refs/heads/${base}:refs/remotes/${remoto}/${base}`], carregado.raiz);
+    (0, util_1.exec)('git', ['fetch', '-q', '--', remoto, `+refs/heads/${base}:refs/remotes/${remoto}/${base}`], carregado.raiz);
     const r = (0, thread_1.listarIds)(carregado.raiz)
         .filter((id) => (0, thread_1.lerThread)(carregado.raiz, id).status !== 'fechada')
         .filter((id) => mergeDaEntrega(carregado.raiz, id, remoto, base) !== null)