@orkastery/cli 0.5.0 → 0.5.3

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

@@ -39,9 +39,15 @@ 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;
 exports.checarOnboarding = checarOnboarding;
+exports.blocosDoRuntime = blocosDoRuntime;
+exports.checarRuntimeClaude = checarRuntimeClaude;
+exports.checarDespachoPeloCodex = checarDespachoPeloCodex;
 exports.checar = checar;
 exports.relatorio = relatorio;
 exports.doctor = doctor;
@@ -63,6 +69,42 @@ const project_state_1 = require("./project-state");
 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
@@ -148,6 +190,81 @@ function checarChaveDeEmbedding(carregado, env = process.env) {
     return { nome, nivel: 'warn', detalhe: `${variavel} ausente do ambiente: a busca por significado usa o fallback local ou cai para FTS; o regime nao muda`,
         correcao: `exporte ${variavel} com a chave dedicada ao Orkastery (com limite de credito no painel do provider)` };
 }
+/** Acima disso a conferencia do dono do `.git` fica parcial (aviso), para o doctor nao pesar. */
+exports.TETO_DO_DONO_DO_GIT = 200_000;
+/**
+ * RM-037 (fatia 3, defeito 7): git rodado como root no repositorio do dono deixa objeto, pasta e
+ * `FETCH_HEAD` com outro dono, e o git do dono deixa de gravar neles: o fetch travou em 29/09 e em
+ * 01/10. O dono do repositorio e o dono do diretorio comum do git. O check acusa com a contagem, ate
+ * tres exemplos e o `chown` exato; o doctor nunca roda nada. Fora de repositorio git, `null`.
+ */
+function checarDonoDoGit(dirInicial, opcoes = {}) {
+    const nome = 'dono do .git';
+    const comum = (0, util_1.exec)('git', ['rev-parse', '--git-common-dir'], dirInicial);
+    if (!comum.ok || !comum.stdout.trim())
+        return null;
+    const dirComum = path.resolve(dirInicial, comum.stdout.trim());
+    const lstat = opcoes.lstat ?? ((p) => fs.lstatSync(p));
+    let raiz;
+    try {
+        raiz = lstat(dirComum);
+    }
+    catch {
+        return null;
+    }
+    const teto = opcoes.teto ?? exports.TETO_DO_DONO_DO_GIT;
+    const relativo = (f) => path.relative(path.dirname(dirComum), f);
+    // A correcao sai pronta para copiar: caminho com caractere fora do conjunto seguro vai entre aspas simples.
+    const noShell = (s) => /^[A-Za-z0-9._/-]+$/.test(s) ? s : `'${s.replace(/'/g, "'\\''")}'`;
+    const estranhos = [], uids = new Set();
+    let total = 0, vistos = 0, parcial = false;
+    const pilha = [dirComum];
+    while (pilha.length > 0 && !parcial) {
+        const atual = pilha.pop();
+        let nomes;
+        // Pasta que o dono nao consegue listar ja aparece pelo dono dela, na entrada de cima.
+        try {
+            nomes = fs.readdirSync(atual);
+        }
+        catch {
+            continue;
+        }
+        for (const n of nomes) {
+            if (++vistos > teto) {
+                parcial = true;
+                break;
+            }
+            const f = path.join(atual, n);
+            let st;
+            try {
+                st = lstat(f);
+            }
+            catch {
+                continue;
+            }
+            if (st.uid !== raiz.uid) {
+                total++;
+                uids.add(st.uid);
+                if (estranhos.length < 3)
+                    estranhos.push(relativo(f));
+            }
+            if (st.isDirectory())
+                pilha.push(f);
+        }
+    }
+    if (total > 0) {
+        return { nome, nivel: 'fail',
+            detalhe: `${total} entrada(s) de ${relativo(dirComum)} com outro dono (uid ${[...uids].sort((a, b) => a - b).join(', ')}; o do ` +
+                `repositorio e ${raiz.uid}): ${estranhos.join(', ')}${total > estranhos.length ? ', ...' : ''}; o git do dono nao grava nelas, ` +
+                `e o fetch e o commit falham${parcial ? ` (conferencia parcial: mais de ${teto} entradas)` : ''}`,
+            correcao: `sudo chown -R ${raiz.uid}:${raiz.gid} ${noShell(dirComum)} (o ork nao roda isso sozinho)` };
+    }
+    if (parcial) {
+        return { nome, nivel: 'warn', detalhe: `mais de ${teto} entradas em ${relativo(dirComum)}: conferencia parcial, sem outro dono ate aqui`,
+            correcao: `confira o resto com: find ${noShell(dirComum)} -not -uid ${raiz.uid}` };
+    }
+    return { nome, nivel: 'ok', detalhe: `${vistos} entradas de ${relativo(dirComum)} com o dono do repositorio (uid ${raiz.uid})` };
+}
 /** Checks locais; ler a entrevista não abre driver, banco, runtime ou rede. */
 function checarOnboarding(carregado) {
     const estado = (0, onboarding_1.lerOnboarding)(carregado.raiz);
@@ -163,9 +280,15 @@ function checarOnboarding(carregado) {
         checks.push({ nome: 'onboarding memoria', nivel: 'warn', detalhe: `entrevista escolheu ${modo}; manifesto declara ${carregado.manifesto.memory.mode}`,
             correcao: `revise memory.mode: ${modo} em orkastery.yaml; a entrevista não altera o manifesto` });
     }
-    // I-35: o fuso respondido na etapa maestro orienta owner.timezone, sem editar o manifesto.
+    // I-35: o fuso respondido na etapa maestro orienta owner.timezone, sem editar o manifesto. Com
+    // `owner.timezone` na mesma resposta (gravado no manifesto pelo `onboarding set`), vale ele: no
+    // ensaio da 0.5.0, o `fuso` legado da resposta anterior mandava desfazer a escolha explicita.
     const maestro = estado.etapas.maestro?.conteudo;
-    const fusoDaEntrevista = maestro && typeof maestro === 'object' && !Array.isArray(maestro) ? (0, horario_1.normalizarFuso)(maestro.fuso) : undefined;
+    const owner = maestro && typeof maestro === 'object' && !Array.isArray(maestro) ? maestro.owner : undefined;
+    const fusoDoOwner = owner && typeof owner === 'object' && !Array.isArray(owner) ? owner.timezone : undefined;
+    // Owner invalido (so por edicao a mao: o `onboarding set` recusa) nao cala o fuso legado.
+    const fusoDaEntrevista = maestro && typeof maestro === 'object' && !Array.isArray(maestro)
+        ? (0, horario_1.normalizarFuso)(fusoDoOwner) ?? (0, horario_1.normalizarFuso)(maestro.fuso) : undefined;
     if (fusoDaEntrevista && fusoDaEntrevista !== carregado.manifesto.owner?.timezone) {
         checks.push({ nome: 'onboarding fuso', nivel: 'warn',
             detalhe: `entrevista informou ${fusoDaEntrevista}; manifesto declara ${carregado.manifesto.owner?.timezone ?? `${horario_1.CHAVE_DO_FUSO} ausente`}`,
@@ -173,8 +296,128 @@ function checarOnboarding(carregado) {
     }
     return checks;
 }
-/** Roda todos os checks a partir do diretorio informado. */
-function checar(dirInicial = process.cwd(), nomesHerdados = (0, runtime_ambiente_1.nomesDeProviderAtivos)()) {
+/**
+ * Fatia 2 do ensaio da 0.5.0 (P1): por qual runtime cada bloco dos modos de
+ * `conduction.allowed_modes` despacha, pelo mesmo criterio do despacho sem opcao de CLI
+ * (`resolverDespacho`: o bloco do setup vence `runtime.adapter`). Quem passou os blocos para o
+ * Codex nao precisa do `claude`. Setup ilegivel devolve `null`: quem chama fica no lado seguro.
+ */
+function blocosDoRuntime(carregado, runtime) {
+    const { manifesto } = carregado;
+    const r = { principal: [], fallback: [] };
+    try {
+        const setup = (0, setup_1.lerSetup)(carregado.raiz);
+        for (const modo of manifesto.conduction.allowed_modes) {
+            modos_1.MODOS[modo].blocos.forEach((b, i) => {
+                const doBloco = (0, setup_1.configDoBloco)(setup, modo, b.fases[0]);
+                const bloco = { tag: modos_1.MODOS[modo].tag, bloco: i + 1 };
+                if ((doBloco?.runtime ?? manifesto.runtime.adapter) === runtime)
+                    r.principal.push(bloco);
+                else if (doBloco?.fallback?.some((f) => f.split(':')[0] === runtime))
+                    r.fallback.push(bloco);
+            });
+        }
+    }
+    catch {
+        return null;
+    }
+    return r;
+}
+/** `#Classic 1, 2; #Auto 1`: os blocos agrupados por modo, na ordem dos modos permitidos. */
+function textoDosBlocos(blocos) {
+    const porModo = new Map();
+    for (const b of 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, auth = null) {
+    const nome = 'runtime claude-bg';
+    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.
+        return { nome, nivel: 'warn',
+            detalhe: 'binario `claude` fora do PATH (opcional para as fases: nenhum bloco dos modos permitidos despacha pelo claude-bg' +
+                (blocos.fallback.length
+                    ? `; o fallback de ${blocos.fallback.length} bloco(s) cai nele e falharia: ${textoDosBlocos(blocos.fallback)}` : '') +
+                '; o ork audit run ainda despacha por ele)',
+            correcao: 'para despachar pelo claude-bg (e rodar ork audit run), instale o Claude Code e garanta `claude` no PATH' };
+    }
+    return { nome, nivel: 'fail',
+        detalhe: 'binario `claude` fora do PATH' + (blocos
+            ? `; ${blocos.principal.length} bloco(s) dos modos permitidos despacham por ele (${textoDosBlocos(blocos.principal)})` : ''),
+        correcao: 'instale o Claude Code e garanta `claude` no PATH; so com o Codex, passe cada bloco para ele ' +
+            '(ork setup <modo> --bloco N --runtime codex --model <modelo>) ou tire o modo de conduction.allowed_modes ' +
+            '(mantenha o conduction.default_mode entre os permitidos)' };
+}
+/**
+ * O despacho pelo Codex quando o projeto o elege: por `runtime.adapter: codex`, como antes, ou, desde
+ * a fatia 2 do ensaio da 0.5.0 (P1), por bloco de modo permitido. A falta do `codex`, ou um sandbox
+ * que nao executa, deixa de ser aviso: e exatamente o que bloquearia a fase. Sem nenhum dos dois, o
+ * check nao sai.
+ */
+function checarDespachoPeloCodex(carregado, codex, sonda) {
+    const pelaAdapter = carregado.manifesto.runtime.adapter === 'codex';
+    const blocos = blocosDoRuntime(carregado, 'codex')?.principal ?? [];
+    if (!pelaAdapter && blocos.length === 0)
+        return null;
+    const origem = [pelaAdapter ? 'runtime.adapter: codex' : '',
+        blocos.length ? `${blocos.length} bloco(s) dos modos permitidos no codex (${textoDosBlocos(blocos)})` : '']
+        .filter(Boolean).join(' e ');
+    const sandboxConfigurado = carregado.manifesto.runtime.sandbox;
+    const sandboxQuebrado = sonda !== null && !sonda.ok && sandboxConfigurado !== 'danger-full-access';
+    return {
+        nome: 'despacho pelo codex',
+        nivel: !codex ? 'fail' : sandboxQuebrado ? 'fail' : 'ok',
+        detalhe: !codex
+            ? `${origem}, mas o binario \`codex\` esta fora do PATH`
+            : sandboxQuebrado
+                ? `${origem} com sandbox "${sandboxConfigurado}", mas o sandbox nao executa nesta maquina (o agente narraria sucesso sem rodar nada)`
+                : `${origem} com sandbox "${sandboxConfigurado}"`,
+        correcao: !codex
+            ? 'instale o Codex CLI e autentique com `codex login` (assinatura, nunca API key)'
+            : sandboxQuebrado
+                ? 'instale o bubblewrap do sistema, ou declare runtime.sandbox: danger-full-access ciente do risco'
+                : undefined,
+    };
+}
+/**
+ * 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({
@@ -183,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',
@@ -192,31 +437,43 @@ function checar(dirInicial = process.cwd(), nomesHerdados = (0, runtime_ambiente
     });
     const repo = (0, util_1.exec)('git', ['rev-parse', '--is-inside-work-tree'], dirInicial);
     const dentroDeRepo = repo.ok && repo.stdout.trim() === 'true';
-    const branch = (0, util_1.exec)('git', ['rev-parse', '--abbrev-ref', 'HEAD'], dirInicial);
+    // Ensaio da 0.5.0: sem commit, o `rev-parse --abbrev-ref` respondia "HEAD"; a branch vem do
+    // `symbolic-ref`, e a falta de commit fica dita.
+    const semCommit = dentroDeRepo && !(0, util_1.exec)('git', ['rev-parse', '--verify', '--quiet', 'HEAD'], dirInicial).ok;
+    const branch = dentroDeRepo ? (0, util_1.branchDoHead)(dirInicial) ?? (0, util_1.exec)('git', ['rev-parse', '--abbrev-ref', 'HEAD'], dirInicial).stdout.trim() : '';
     checks.push({
         nome: 'repositorio',
         nivel: dentroDeRepo ? 'ok' : 'fail',
-        detalhe: dentroDeRepo ? `branch ${branch.stdout.trim()}` : 'fora de um repositorio git',
+        detalhe: dentroDeRepo ? `branch ${branch}${semCommit ? ' (sem commit)' : ''}` : 'fora de um repositorio git',
         correcao: dentroDeRepo ? undefined : 'rode o ork dentro de um repositorio git',
     });
+    if (dentroDeRepo) {
+        const dono = checarDonoDoGit(dirInicial);
+        if (dono)
+            checks.push(dono);
+    }
+    // Fatia 2 do ensaio da 0.5.0 (P1): o manifesto e lido antes dos runtimes, porque e o setup dos
+    // modos permitidos que diz se o `claude` e obrigatorio; a ordem das linhas do relatorio nao muda.
+    const carregado = (0, manifest_1.carregarManifesto)(dirInicial);
     const claude = adapter.disponivel();
     const v = claude ? adapter.versao() : null;
-    checks.push({
-        nome: 'runtime claude-bg',
-        nivel: claude ? 'ok' : 'fail',
-        detalhe: claude ? `${claude} (${v ?? 'versao desconhecida'})` : 'binario `claude` fora do PATH',
-        correcao: claude ? undefined : 'instale o Claude Code e garanta `claude` no PATH',
-    });
+    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();
     const codexVersao = codex ? codexAdapter.versao() : null;
+    // CHECK, rodada 1 (S6): com o projeto despachando pelo codex, a falta dele nao e "opcional"; quem
+    // reprova e o check `despacho pelo codex`, mais abaixo.
+    const usaCodex = !!carregado && carregado.erros.length === 0 && (carregado.manifesto.runtime.adapter === 'codex' ||
+        (blocosDoRuntime(carregado, 'codex')?.principal.length ?? 0) > 0);
     checks.push({
         nome: 'runtime codex',
         nivel: codex ? 'ok' : 'warn',
         detalhe: codex
             ? `${codex} (${codexVersao ?? 'versao desconhecida'})`
-            : 'binario `codex` fora do PATH (opcional: claude-bg e o runtime padrao)',
+            : usaCodex
+                ? 'binario `codex` fora do PATH (o projeto despacha por ele: veja despacho pelo codex)'
+                : 'binario `codex` fora do PATH (opcional: claude-bg e o runtime padrao)',
         correcao: codex
             ? undefined
             : 'para despachar pelo codex, instale o Codex CLI e autentique com `codex login`',
@@ -238,13 +495,13 @@ function checar(dirInicial = process.cwd(), nomesHerdados = (0, runtime_ambiente
                     'nesta maquina) ou declare runtime.sandbox: danger-full-access ciente do risco',
         });
     }
-    const carregado = (0, manifest_1.carregarManifesto)(dirInicial);
     if (!carregado) {
         checks.push({
             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 {
@@ -257,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);
@@ -285,26 +547,11 @@ function checar(dirInicial = process.cwd(), nomesHerdados = (0, runtime_ambiente
                 : `${fuso.fuso} (fuso do sistema; ${horario_1.CHAVE_DO_FUSO} nao configurado)`),
             correcao: fuso.aviso ? `corrija ${horario_1.CHAVE_DO_FUSO} com um nome IANA` : undefined,
         });
-        // Quando o manifesto ELEGE o codex como runtime de despacho, a ausencia dele (ou um
+        // Quando o manifesto ou um bloco de modo permitido ELEGE o codex, a ausencia dele (ou um
         // sandbox que nao executa) deixa de ser aviso: e exatamente o que bloquearia a fase.
-        if (carregado.manifesto.runtime.adapter === 'codex') {
-            const sandboxConfigurado = carregado.manifesto.runtime.sandbox;
-            const sandboxQuebrado = sondaDoCodex !== null && !sondaDoCodex.ok && sandboxConfigurado !== 'danger-full-access';
-            checks.push({
-                nome: 'despacho pelo codex',
-                nivel: !codex ? 'fail' : sandboxQuebrado ? 'fail' : 'ok',
-                detalhe: !codex
-                    ? 'runtime.adapter: codex, mas o binario `codex` esta fora do PATH'
-                    : sandboxQuebrado
-                        ? `runtime.adapter: codex com sandbox "${sandboxConfigurado}", mas o sandbox nao executa nesta maquina (o agente narraria sucesso sem rodar nada)`
-                        : `runtime.adapter: codex com sandbox "${sandboxConfigurado}"`,
-                correcao: !codex
-                    ? 'instale o Codex CLI e autentique com `codex login` (assinatura, nunca API key)'
-                    : sandboxQuebrado
-                        ? 'instale o bubblewrap do sistema, ou declare runtime.sandbox: danger-full-access ciente do risco'
-                        : undefined,
-            });
-        }
+        const despachoPeloCodex = checarDespachoPeloCodex(carregado, codex, sondaDoCodex);
+        if (despachoPeloCodex)
+            checks.push(despachoPeloCodex);
         const politica = carregado.manifesto.runtime.provider_policy;
         const soAssinatura = politica === 'subscription-only';
         const redirecionam = ENVS_QUE_REDIRECIONAM.filter(e => nomesHerdados.includes(e));
@@ -380,22 +627,32 @@ 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));
         {
             const inventario = (0, sessoes_inventario_1.inventariarSessoes)(carregado.raiz, { global: true, todas: true });
+            // Fatia 2 do ensaio da 0.5.0 (P1): binario ausente e fonte ausente, dita no detalhe.
+            const ausentes = inventario.fontes.filter((f) => f.ausente).map((f) => f.origem);
             checks.push({
                 nome: 'governanca de sessoes',
                 nivel: inventario.ok && inventario.semThread === 0 ? 'ok' : 'warn',
                 detalhe: `${inventario.escopo.usuario}, Claude e Codex, global com histórico: ${inventario.total} sessões; ` +
                     `${inventario.semThread} sem thread; ${inventario.ambiguas} ambíguas; ` +
-                    `inventário ${inventario.ok ? 'válido' : 'INCOMPLETO (zero não comprovado)'}`,
+                    `inventário ${inventario.ok ? 'válido' : 'INCOMPLETO (zero não comprovado)'}` +
+                    (ausentes.length ? `; fonte ausente: ${ausentes.join(', ')}` : ''),
                 correcao: inventario.ok && inventario.semThread === 0 ? undefined :
                     'ork sessions --global --all --json; adote identidades sem vínculo com ork sessions adopt <id>',
             });
         }
     }
+    // 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". */
@@ -431,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 };
 }