@orkastery/cli 0.5.1 → 0.5.6

package/dist/parado-no-condutor.js

@@ -33,17 +33,24 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LIMITE_DE_RECENTES = exports.LIMITE_DE_PRS = exports.VALIDADE_DO_RETRATO_MIN = exports.LIMIAR_PARADO_NO_CONDUTOR_MIN = exports.CONTRATO_PRS = void 0;
+exports.CONTRATO_FORJA_SEM_LEITURA = exports.ghPadrao = exports.FORJA_SEM_LEITURA = exports.LIMITE_DE_RECENTES = exports.LIMITE_DE_PRS = exports.VALIDADE_DO_RETRATO_MIN = exports.LIMIAR_PARADO_NO_CONDUTOR_MIN = exports.CONTRATO_PRS = void 0;
 exports.nomeDeCheck = nomeDeCheck;
+exports.prDaForja = prDaForja;
+exports.githubDoRemoto = githubDoRemoto;
 exports.repositorioDoRemoto = repositorioDoRemoto;
 exports.lerPrsDaForja = lerPrsDaForja;
 exports.gravarRetratoDePrs = gravarRetratoDePrs;
+exports.avisarForjaSemLeitura = avisarForjaSemLeitura;
+exports.esquecerForjaSemLeitura = esquecerForjaSemLeitura;
+exports.forjaSemLeituraDoRemoto = forjaSemLeituraDoRemoto;
 exports.lerRetratoDePrs = lerRetratoDePrs;
 exports.perguntaAberta = perguntaAberta;
 exports.fimDoTurno = fimDoTurno;
 exports.pendenciaDoDono = pendenciaDoDono;
+exports.conducaoAgora = conducaoAgora;
 exports.esperaDoCondutor = esperaDoCondutor;
 exports.sessaoSemPergunta = sessaoSemPergunta;
+exports.refsLocais = refsLocais;
 exports.entregasDoProjeto = entregasDoProjeto;
 /**
  * RM-037 (fatia 4): o trabalho parado no condutor.
@@ -72,6 +79,7 @@ exports.entregasDoProjeto = entregasDoProjeto;
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const node_child_process_1 = require("node:child_process");
+const branch_de_estado_1 = require("./branch-de-estado");
 const conducao_1 = require("./conducao");
 const estado_thread_1 = require("./estado-thread");
 const forja_1 = require("./forja");
@@ -102,7 +110,8 @@ const PRAZO_DO_GH_MS = 30000;
 /** A leitura inteira da forja numa batida: cabe com folga nos 240 s que a varredura da ao subprocesso do pulse. */
 const ORCAMENTO_DA_LEITURA_MS = 60000;
 const CAMPOS_DOS_RECENTES = 'number,state,headRefName,headRefOid,baseRefName,isDraft,isCrossRepository,url,createdAt,mergedAt';
-const CAMPOS_DO_GH = `${CAMPOS_DOS_RECENTES},statusCheckRollup`;
+/** RM-059 (F7, D11 da ork-rm059pista): o estado de merge do PR aberto, que a pista de entrega mostra como conflito. */
+const CAMPOS_DO_GH = `${CAMPOS_DOS_RECENTES},statusCheckRollup,mergeable`;
 /** Quantas branches candidatas a "sem PR" sao conferidas uma a uma por batida; o resto fica "PR nao lido". */
 const LIMITE_DE_CANDIDATAS = 10;
 /** A conferencia de uma candidata so comeca com este tempo de sobra no orcamento; com menos, a branch fica sem conferir. */
@@ -111,6 +120,8 @@ const MINIMO_DA_CONFERENCIA_MS = 5000;
 const FASES_ANTES_DA_ENTREGA = ['GOAL', 'PLAN', 'GO', 'CHECK'];
 /** Os modos em que a #TAG ja autoriza o push (`autorizacaoDePush`, `core/src/ship.ts`). */
 const MODOS_COM_PUSH_AUTORIZADO = ['auto', 'maestro'];
+/** RM-037 (fatia 5, A5): o que as linhas e o resumo dizem quando a forja nao tem leitura de PR. */
+exports.FORJA_SEM_LEITURA = 'forja sem leitura de PR';
 /** O ambiente do `gh`: sem cor, sem prompt e sem host ou repositorio herdados (o host vai no `--repo`). */
 function ambienteDoGh() {
     const env = { ...process.env, GH_PROMPT_DISABLED: '1', NO_COLOR: '1', CLICOLOR: '0', CLICOLOR_FORCE: '0' };
@@ -123,11 +134,14 @@ const ghPadrao = (args, timeoutMs) => {
     const r = (0, node_child_process_1.spawnSync)('gh', [...args], { encoding: 'utf8', timeout: timeoutMs, maxBuffer: 16 * 1024 * 1024, env: ambienteDoGh() });
     return { status: r.status, stdout: r.stdout ?? '', stderr: r.error ? r.error.message : (r.stderr ?? '') };
 };
+exports.ghPadrao = ghPadrao;
 /** Git local sem rede escondida: clone parcial nunca busca objeto durante uma leitura daqui. */
 const git = (raiz, args) => (0, util_1.exec)('git', args, raiz, 60000, { ...process.env, GIT_NO_LAZY_FETCH: '1' });
 const SHA = /^[0-9a-f]{40}$/;
 const BRANCH = /^[A-Za-z0-9._/-]{1,200}$/;
 const REPOSITORIO = /^[A-Za-z0-9_.-]{1,100}\/[A-Za-z0-9_.-]{1,100}$/;
+/** O host do GitHub Enterprise guardado no retrato: rotulos alfanumericos separados por ponto, como na forja. */
+const HOST = /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]*[a-z0-9])?)+$/;
 /** Texto curto vindo de fora: sem controle, num teto. */
 function curto(v, teto = 120) {
     if (typeof v !== 'string')
@@ -212,33 +226,95 @@ function prDaForja(bruto, base) {
         }
     }
     const url = typeof p.url === 'string' && /^https:\/\/[^\s]+$/.test(p.url) ? curto(p.url, 300) : null;
+    // RM-059 (F7): o estado de merge so vale do PR aberto, e so quando a leitura pediu o campo.
+    const conflito = estado !== 'aberto' || p.mergeable === undefined ? undefined
+        : p.mergeable === 'CONFLICTING' ? true : p.mergeable === 'MERGEABLE' ? false : null;
     return { numero: numero, branch: p.headRefName, head, estado, rascunho: p.isDraft, url,
-        criadoEm: instante(p.createdAt), mescladoEm: instante(p.mergedAt), checks: [...porChave.values()].map((x) => x.check) };
+        criadoEm: instante(p.createdAt), mescladoEm: instante(p.mergedAt), checks: [...porChave.values()].map((x) => x.check),
+        ...(conflito !== undefined ? { conflito } : {}) };
+}
+/**
+ * RM-037 (fatia 5, A5): o host e o `dono/nome` do remoto quando ele pode ser um GitHub (o github.com ou um host
+ * proprio), so pelo git local, sem rede nem `gh`. O GitLab fica de fora.
+ */
+function githubDoRemoto(raiz, remoto) {
+    // RM-047: o remoto vem do manifesto versionado; so nome de remoto chega ao git, e depois do `--`.
+    if (!(0, branch_de_estado_1.remotoValido)(remoto))
+        return null;
+    const url = git(raiz, ['remote', 'get-url', '--', remoto]);
+    const forja = url.ok ? (0, forja_1.repositorioGithubNoHost)(url.stdout.trim()) : null;
+    // `ssh.github.com` e o SSH do github.com pela porta 443, e nao um GitHub Enterprise (sugestao da rodada 1 do CHECK).
+    return forja && REPOSITORIO.test(forja.repo) ? { host: forja.host === 'ssh.github.com' ? 'github.com' : forja.host, repositorio: forja.repo }
+        : null;
 }
 /** O repositorio `dono/nome` do remoto, so quando ele e do github.com (o host ancorado, nao so citado no caminho). */
 function repositorioDoRemoto(raiz, remoto) {
-    const url = git(raiz, ['remote', 'get-url', remoto]);
-    const forja = url.ok ? (0, forja_1.identidadeDaForja)(url.stdout.trim()) : null;
-    return forja && forja.tipo === 'github' && forja.host === 'github.com' && REPOSITORIO.test(forja.repo) ? forja.repo : null;
+    const github = githubDoRemoto(raiz, remoto);
+    return github && github.host === 'github.com' ? github.repositorio : null;
+}
+/**
+ * RM-037 (fatia 5, A5): de onde o pulse le os PRs do remoto. O github.com, como sempre; o host proprio em que o `gh`
+ * esta autenticado, que e um GitHub Enterprise (`gh auth status --hostname <host>`); ou nenhum: GitLab, caminho local,
+ * ou host em que o `gh` nao tem login. Ficar sem leitura nao e falha desta batida (o "PR nao lido"): e o estado da
+ * forja, que o pulse diz uma vez.
+ */
+function forjaDosPrs(raiz, remoto, executor, prazoMs) {
+    // RM-047: remoto que nao e nome de remoto nao chega ao git; para o pulse, e forja sem leitura.
+    if (!(0, branch_de_estado_1.remotoValido)(remoto)) {
+        return { leitura: false, host: null, motivo: `o remoto ${(0, branch_de_estado_1.remotoRedigido)(remoto)} não é nome de remoto do git`, semLeitura: true };
+    }
+    const url = git(raiz, ['remote', 'get-url', '--', remoto]);
+    if (!url.ok)
+        return { leitura: false, host: null, motivo: `o remoto ${remoto} não está configurado neste checkout`, semLeitura: true };
+    const endereco = (0, forja_1.enderecoDoRemoto)(url.stdout.trim());
+    // Caminho local, ou apelido de SSH sem dominio (`git@github-trabalho:dono/repo.git`): nao ha host para ler.
+    if (!endereco) {
+        return { leitura: false, host: null, motivo: `o remoto ${remoto} não tem host de forja (caminho local ou apelido de SSH)`, semLeitura: true };
+    }
+    if ((0, forja_1.identidadeDaForja)(url.stdout.trim())?.tipo === 'gitlab') {
+        return { leitura: false, host: endereco.host, motivo: `a forja de ${remoto} (${endereco.host}) é um GitLab, e o ork só lê PR do GitHub`,
+            semLeitura: true };
+    }
+    const github = githubDoRemoto(raiz, remoto);
+    if (!github) {
+        return { leitura: false, host: endereco.host, motivo: `o remoto ${remoto} (${endereco.host}) não aponta um repositório dono/nome`,
+            semLeitura: true };
+    }
+    if (github.host === 'github.com')
+        return { leitura: true, ...github };
+    const auth = executor(['auth', 'status', '--hostname', github.host], prazoMs);
+    if (auth.status === 0)
+        return { leitura: true, ...github };
+    // So a resposta de login ausente (o `gh` 2.46 diz "You are not logged into any accounts on <host>") e o estado da
+    // forja; prazo estourado, `gh` ausente ou host fora do ar sao falha desta batida.
+    const semLogin = auth.status === 1 && /\bnot logged in/i.test(`${auth.stdout}\n${auth.stderr}`);
+    return { leitura: false, host: github.host, semLeitura: semLogin, motivo: semLogin
+            ? `o gh não está autenticado em ${github.host}, a forja de ${remoto}`
+            : `gh auth status --hostname ${github.host} falhou (${auth.status === null ? 'sem código de saída' : `código ${auth.status}`}): ` +
+                (curto((0, hitl_1.redigirSegredos)(auth.stderr || auth.stdout || ''), 120) ?? 'sem detalhe') };
 }
 /**
  * Le os PRs da base do repositorio do remoto em duas chamadas: os abertos (ate `LIMITE_DE_PRS`; e so a
  * lista deles que pode dizer "sem PR") e os recentes de qualquer estado (para achar o mesclado e o fechado).
- * O `gh` usa a autenticacao dele; nenhum token passa por aqui. Remoto que nao e do github.com nao chama nada.
+ * O `gh` usa a autenticacao dele; nenhum token passa por aqui. RM-037 (fatia 5, A5): no GitHub Enterprise, o host
+ * vai no `--repo`; forja sem leitura de PR nao chama o `gh pr list`.
  */
 function lerPrsDaForja(carregado, opcoes = {}) {
     const lidoEm = opcoes.quando ?? new Date().toISOString();
     const remoto = opcoes.remoto ?? carregado.manifesto.fabrica.remoto;
     const base = carregado.manifesto.worktree.base_branch;
-    const repositorio = repositorioDoRemoto(carregado.raiz, remoto);
-    if (!repositorio)
-        return { ok: false, lidoEm, erro: `o remoto ${remoto} não é um repositório do github.com` };
     const orcamento = opcoes.orcamentoMs ?? ORCAMENTO_DA_LEITURA_MS, fimDaLeitura = Date.now() + orcamento;
     const resta = () => fimDaLeitura - Date.now();
+    const executor = opcoes.executor ?? exports.ghPadrao;
+    const forja = opcoes.forja ? { leitura: true, ...opcoes.forja }
+        : forjaDosPrs(carregado.raiz, remoto, executor, Math.min(PRAZO_DO_GH_MS, Math.max(1, resta())));
+    if (!forja.leitura)
+        return { ok: false, lidoEm, erro: forja.motivo, ...(forja.semLeitura ? { semLeitura: { remoto, host: forja.host } } : {}) };
+    const { host, repositorio } = forja;
     const pedir = (args) => {
         if (resta() <= 0)
             return `gh pr list: orçamento de ${Math.round(orcamento / 1000)} s da leitura esgotado`;
-        const r = (opcoes.executor ?? ghPadrao)(['pr', 'list', `--repo=github.com/${repositorio}`, `--base=${base}`, ...args], Math.min(PRAZO_DO_GH_MS, resta()));
+        const r = executor(['pr', 'list', `--repo=${host}/${repositorio}`, `--base=${base}`, ...args], Math.min(PRAZO_DO_GH_MS, resta()));
         if (r.status !== 0) {
             const detalhe = curto((0, hitl_1.redigirSegredos)(r.stderr || r.stdout || ''), 160) ?? 'sem detalhe';
             return `gh pr list falhou (${r.status === null ? 'sem código de saída' : `código ${r.status}`}): ${detalhe}`;
@@ -296,8 +372,8 @@ function lerPrsDaForja(carregado, opcoes = {}) {
                 semConferir.push(branch);
             }
         }
-        return { ok: true, retrato: { contrato: exports.CONTRATO_PRS, lidoEm, repositorio, base, parcial: abertos.length >= exports.LIMITE_DE_PRS,
-                ...(semConferir.length ? { semConferir } : {}), prs: [...porNumero.values()] } };
+        return { ok: true, retrato: { contrato: exports.CONTRATO_PRS, lidoEm, repositorio, ...(host !== 'github.com' ? { host } : {}), base,
+                parcial: abertos.length >= exports.LIMITE_DE_PRS, ...(semConferir.length ? { semConferir } : {}), prs: [...porNumero.values()] } };
     }
     catch (e) {
         return { ok: false, lidoEm, erro: `resposta do gh pr list fora do formato: ${curto((0, hitl_1.redigirSegredos)(e.message), 120) ?? 'sem detalhe'}` };
@@ -321,6 +397,64 @@ function gravarRetratoDePrs(raiz, retrato) {
         throw e;
     }
 }
+const ARQUIVO_DA_FORJA_SEM_LEITURA = 'forja-sem-leitura.json';
+exports.CONTRATO_FORJA_SEM_LEITURA = 'ork.forja-sem-leitura/v1';
+function lerAvisoDeForjaSemLeitura(raiz) {
+    try {
+        const a = JSON.parse(fs.readFileSync(path.join(dirDoMonitor(raiz), ARQUIVO_DA_FORJA_SEM_LEITURA), 'utf8'));
+        const ditoEm = instante(a.ditoEm), motivo = curto(a.motivo, 200);
+        if (a.contrato !== exports.CONTRATO_FORJA_SEM_LEITURA || typeof a.remoto !== 'string' || !/^[A-Za-z0-9._-]{1,100}$/.test(a.remoto) ||
+            !(a.host === null || (typeof a.host === 'string' && HOST.test(a.host))) || !ditoEm || !motivo)
+            return null;
+        return { contrato: exports.CONTRATO_FORJA_SEM_LEITURA, remoto: a.remoto, host: a.host, motivo, ditoEm };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * RM-037 (fatia 5, A5): a forja sem leitura de PR e dita uma vez por remoto e host. Com o remoto fora do github.com,
+ * o pulse dizia "PR nao lido" a cada batida, para um estado que nao muda de uma batida para a outra. A marca em
+ * `.orkastery/monitor/` guarda o que ja foi dito; devolve true quando e novidade (e grava a marca).
+ */
+function avisarForjaSemLeitura(raiz, semLeitura, motivo, quando) {
+    const atual = lerAvisoDeForjaSemLeitura(raiz);
+    if (atual && atual.remoto === semLeitura.remoto && atual.host === semLeitura.host)
+        return false;
+    const dir = dirDoMonitor(raiz);
+    fs.mkdirSync(dir, { recursive: true });
+    const arquivo = path.join(dir, ARQUIVO_DA_FORJA_SEM_LEITURA), tmp = `${arquivo}.${process.pid}.${Date.now()}.tmp`;
+    const aviso = { contrato: exports.CONTRATO_FORJA_SEM_LEITURA, ...semLeitura, motivo: curto(motivo, 200) ?? exports.FORJA_SEM_LEITURA,
+        ditoEm: quando };
+    try {
+        fs.writeFileSync(tmp, JSON.stringify(aviso, null, 2) + '\n', { mode: 0o600, flag: 'wx' });
+        fs.renameSync(tmp, arquivo);
+    }
+    catch (e) {
+        try {
+            fs.unlinkSync(tmp);
+        }
+        catch { /* ja saiu */ }
+        throw e;
+    }
+    return true;
+}
+/** A leitura voltou: a marca sai, e a forja que perder a leitura de novo volta a ser dita. */
+function esquecerForjaSemLeitura(raiz) {
+    fs.rmSync(path.join(dirDoMonitor(raiz), ARQUIVO_DA_FORJA_SEM_LEITURA), { force: true });
+}
+/**
+ * A forja sem leitura que o pulse ja disse, so quando ela e a do remoto de agora (mesmo nome e mesmo host): o status
+ * do roadmap a le sem rede e sem `gh`.
+ */
+function forjaSemLeituraDoRemoto(raiz, remoto) {
+    const aviso = lerAvisoDeForjaSemLeitura(raiz);
+    if (!aviso || aviso.remoto !== remoto || !(0, branch_de_estado_1.remotoValido)(remoto))
+        return null;
+    const url = git(raiz, ['remote', 'get-url', '--', remoto]);
+    const host = url.ok ? (0, forja_1.enderecoDoRemoto)(url.stdout.trim())?.host ?? null : null;
+    return host === aviso.host ? aviso : null;
+}
 /** O ultimo retrato gravado pelo pulse, conferido campo a campo e com os nomes de check limpos de novo. */
 function lerRetratoDePrs(raiz) {
     try {
@@ -328,6 +462,7 @@ function lerRetratoDePrs(raiz) {
         const lidoEm = instante(r.lidoEm);
         if (r.contrato !== exports.CONTRATO_PRS || !lidoEm || typeof r.repositorio !== 'string' || !REPOSITORIO.test(r.repositorio) ||
             typeof r.base !== 'string' || typeof r.parcial !== 'boolean' || !Array.isArray(r.prs) ||
+            (r.host !== undefined && !(typeof r.host === 'string' && HOST.test(r.host))) ||
             (r.semConferir !== undefined && !(Array.isArray(r.semConferir) && r.semConferir.every((b) => typeof b === 'string' && BRANCH.test(b)))))
             return null;
         const opcional = (v) => (v === null || v === undefined ? null : instante(v) ?? undefined);
@@ -351,8 +486,8 @@ function lerRetratoDePrs(raiz) {
             prs.push({ numero: p.numero, branch: p.branch, head: p.head, estado, rascunho: p.rascunho,
                 url: typeof p.url === 'string' && /^https:\/\/[^\s]+$/.test(p.url) ? curto(p.url, 300) : null, criadoEm, mescladoEm, checks });
         }
-        return { contrato: exports.CONTRATO_PRS, lidoEm, repositorio: r.repositorio, base: r.base, parcial: r.parcial,
-            ...(Array.isArray(r.semConferir) && r.semConferir.length ? { semConferir: r.semConferir } : {}), prs };
+        return { contrato: exports.CONTRATO_PRS, lidoEm, repositorio: r.repositorio, ...(typeof r.host === 'string' ? { host: r.host } : {}),
+            base: r.base, parcial: r.parcial, ...(Array.isArray(r.semConferir) && r.semConferir.length ? { semConferir: r.semConferir } : {}), prs };
     }
     catch {
         return null;
@@ -411,13 +546,25 @@ const doRadar = (e) => e.tipo === 'sessao_bloqueada' && e.fonte === 'ork session
  * intervalo do despacho. A prova do ork no SHIP e so o `ship_done` (`provaDoOrk`): o que falta e mergear o PR
  * ou registrar a entrega, e isso e do condutor, como o fim de turno em `blocked`. Dos 4 `human.pending` do SHIP
  * nos ledgers de 30/09, 2 tem este formato (ork-rm037noite e ork-pacotedeexpe). O CHECK em `done` sem o veredito
- * e outra coisa, e continua com o dono (A3 da rodada 5, pendente).
+ * e outra coisa: `checkSemVeredito`.
  */
 function shipSemRegistro(e) {
     const { ok: provou } = (e.provaOrk ?? {});
     return e.motivo === 'human.pending' && e.origem === 'sessions.watch' && e.fase === 'SHIP' && e.estadoNativo === 'done' &&
         !!e.stop && provou === false;
 }
+/**
+ * RM-037 (fatia 5, A3): o CHECK que o observador viu terminar em `done`, com o Stop, sem exatamente um veredito
+ * legivel no `docs/check.md` (`provaDoOrk`). No #Auto, com o bloco sem pausa ao fim, ninguem perguntou nada ao dono:
+ * o passo e do condutor, que redespacha o CHECK. Nos dois casos reais (ork-i35horariodo em 20/09 e ork-pacotedeexpe
+ * em 30/09, as duas #Auto) o condutor seguiu sozinho minutos depois, sem pergunta ao dono. Fora do #Auto, segue com
+ * o dono, como antes.
+ */
+function checkSemVeredito(e) {
+    const { ok: provou } = (e.provaOrk ?? {});
+    return e.motivo === 'human.pending' && e.origem === 'sessions.watch' && e.fase === 'CHECK' && e.estadoNativo === 'done' &&
+        !!e.stop && provou === false;
+}
 /**
  * O bloqueio que pede o dono: o prompt de permissao do hook e o que o radar leu com pergunta na tela. O
  * carimbo do radar no fim de turno (`blocked` lido sem menu nem pergunta) nao e prompt nenhum.
@@ -473,7 +620,8 @@ function atividadeDaSessao(e) {
         return !(e.sensor === 'notification' && e.notificationType === 'idle_prompt');
     return e.tipo === 'commit' || e.tipo === 'runtime_stop' || (e.tipo === 'sessao_bloqueada' && !doRadar(e));
 }
-function fimDoTurno(eventos, despacho) {
+/** `modo`: o da thread. Sem ele, o CHECK sem o veredito fica com o dono, como fora do #Auto. */
+function fimDoTurno(eventos, despacho, modo) {
     const i = eventos.lastIndexOf(despacho);
     const depois = eventos.slice(i + 1);
     const sid = texto(despacho.sessionId);
@@ -497,12 +645,13 @@ function fimDoTurno(eventos, despacho) {
             // S-a do CHECK (rodada 3): no bloco com pausa ao fim, todo `human.pending` do resultado e a fase entregue ao dono.
             return { em: resultado.ts, tipo: 'pausa-do-bloco', sessionId: sid, fase, comProva: true };
         }
-        else if (resultado.motivo === 'human.pending' && resultado.stop && (resultado.estadoNativo === 'blocked' || shipSemRegistro(resultado))) {
+        else if (resultado.motivo === 'human.pending' && resultado.stop && (resultado.estadoNativo === 'blocked' || shipSemRegistro(resultado) ||
+            (modo === 'auto' && checkSemVeredito(resultado)))) {
             if (!retomou) {
                 const { ts: doStop } = resultado.stop;
                 const { ok: provou } = (resultado.provaOrk ?? {});
-                return { em: instante(doStop) ?? resultado.ts, tipo: 'espera-do-observador', sessionId: sid, fase,
-                    comProva: typeof provou === 'boolean' ? provou : null };
+                return { em: instante(doStop) ?? resultado.ts, tipo: checkSemVeredito(resultado) ? 'check-sem-veredito' : 'espera-do-observador',
+                    sessionId: sid, fase, comProva: typeof provou === 'boolean' ? provou : null };
             }
         }
         else
@@ -544,17 +693,17 @@ function pendenciaDoDono(t, eventos, quando) {
         return 'prompt de permissão pendente';
     // Aviso da rodada 6 do CHECK: o gate do observador so muda de dono com o fim de turno provado. A sessao que voltou a
     // trabalhar depois do resultado, sem Stop novo, segue do dono, e a thread nao sai tambem como linha do condutor.
-    const fim = fimDoTurno(eventos, despacho);
+    const fim = fimDoTurno(eventos, despacho, t.modo);
     const turnoEncerrado = !!fim && fim.tipo !== 'outro';
     for (let k = 0; k < depois.length; k++) {
         const e = depois[k];
         if (e.tipo !== 'gate_blocked')
             continue;
         const motivo = String(e.motivo ?? '');
-        // O fim de turno que o observador viu em `blocked`, e o SHIP em `done` sem o `ship_done` (B1 da rodada 5), nao sao
-        // escalacao: sao justamente o que muda de dono.
+        // O fim de turno que o observador viu em `blocked`, o SHIP em `done` sem o `ship_done` (B1 da rodada 5) e, no #Auto,
+        // o CHECK em `done` sem o veredito (A3, fatia 5) nao sao escalacao: sao justamente o que muda de dono.
         if (turnoEncerrado && motivo === 'human.pending' && e.origem === 'sessions.watch' &&
-            (e.estadoNativo === 'blocked' || shipSemRegistro(e)))
+            (e.estadoNativo === 'blocked' || shipSemRegistro(e) || (t.modo === 'auto' && checkSemVeredito(e))))
             continue;
         const doDono = motivo === 'human.pending' ||
             (hitl_gates_1.MOTIVOS_DE_ESCALACAO_HUMANA.includes(motivo) && (0, hitl_classificacao_1.quemDecide)(motivo) === 'dono');
@@ -564,13 +713,26 @@ function pendenciaDoDono(t, eventos, quando) {
     }
     return null;
 }
+/**
+ * Quem conduz a thread agora, ou `null`. P7: a sessao que ja encerrou o turno nao conduz mais nada, mesmo com o lease
+ * de pe. RM-059 (F7): a mesma regra do pulse decide se o `ork ship publicar` pode publicar a branch.
+ */
+function conducaoAgora(raiz, t, eventos, quando) {
+    const conducao = (0, conducao_1.conducaoDaThread)(raiz, t.id, { agora: new Date(quando) });
+    if (!conducao)
+        return null;
+    const despacho = ultimoDespacho(eventos);
+    const fim = despacho ? fimDoTurno(eventos, despacho, t.modo) : null;
+    const terminou = !!fim && fim.tipo !== 'outro';
+    return conducao.dono.tipo === 'sessao' && terminou && conducao.dono.sessionId === fim.sessionId ? null : conducao;
+}
 function esperaDoCondutor(t, eventos, quando) {
     if (t.status === 'fechada')
         return null;
     const despacho = ultimoDespacho(eventos);
     if (!despacho || despacho.pausaAoFim !== false)
         return null;
-    const fim = fimDoTurno(eventos, despacho);
+    const fim = fimDoTurno(eventos, despacho, t.modo);
     if (!fim || fim.tipo === 'outro' || fim.tipo === 'pausa-do-bloco' || pendenciaDoDono(t, eventos, quando))
         return null;
     return { thread: t.id, fase: fim.fase, sessionId: fim.sessionId, fimDoTurnoEm: fim.em, tipo: fim.tipo, comProva: fim.comProva };
@@ -699,9 +861,13 @@ function entregasDoProjeto(carregado, opcoes) {
         // R4-4 do CHECK (rodada 4): o `ship_done` cobre a entrega do mesmo head (`shaDe`) ou do mesmo merge; a entrega
         // nova depois dele ainda nao foi registrada. O legado sem o sha cobre tudo, como antes.
         const cobre = (campo, sha) => ships.some((e) => typeof e[campo] !== 'string' || !SHA.test(e[campo]) || e[campo] === sha);
+        // RM-037 (fatia 5, A1): ate esta fatia, o `ork ship` com a branch ja incorporada gravava a ponta da base no
+        // `mergeSha`. Esse `ship_done` registra o merge `ship(<thread>)` que a ponta gravada contem.
+        const contemOMerge = (sha) => ships.some((e) => typeof e.mergeSha === 'string' && SHA.test(e.mergeSha) &&
+            e.mergeSha !== sha && git(raiz, ['merge-base', '--is-ancestor', sha, e.mergeSha]).code === 0);
         return { t, eventos, branch: cabeca ? branch : null, cabeca, comProduto, publicada, temRemota: !!remota,
             shipNoLedger: ships.length > 0, entregueNaPonta: cabeca ? cobre('shaDe', cabeca) : ships.length > 0,
-            mergeRegistrado: !!merge && cobre('mergeSha', merge.sha), merge };
+            mergeRegistrado: !!merge && (cobre('mergeSha', merge.sha) || contemOMerge(merge.sha)), merge };
     });
     // D2: a forja so e lida quando alguma thread tem o que mostrar la: produto numa branch que ja foi ao remoto
     // (inteira, ou com commit novo ainda sem push, que pode ter PR aberto).
@@ -710,11 +876,15 @@ function entregasDoProjeto(carregado, opcoes) {
     if (opcoes.lerPrs && candidatas.length)
         prs = opcoes.lerPrs(candidatas);
     // O retrato so vale do repositorio e da base de agora, e lido ha menos de `VALIDADE_DO_RETRATO_MIN`.
-    let retrato = null, semRetrato = prs && !prs.ok ? prs.erro : 'sem leitura dos PRs';
+    // RM-037 (fatia 5, A5): a forja sem leitura de PR e o estado dela, dito uma vez pelo pulse; a linha nunca diz "PR nao lido".
+    const semLeituraDaForja = !!prs && !prs.ok && !!prs.semLeitura;
+    let retrato = null, semRetrato = prs && !prs.ok ? (semLeituraDaForja ? exports.FORJA_SEM_LEITURA : prs.erro) : 'sem leitura dos PRs';
     if (prs?.ok) {
-        const r = prs.retrato;
-        if (r.base !== baseBranch || r.repositorio !== repositorioDoRemoto(raiz, remoto))
+        const r = prs.retrato, atual = githubDoRemoto(raiz, remoto);
+        // O retrato vale do mesmo host: o do GitHub Enterprise (`host`) ou, sem ele, o github.com.
+        if (r.base !== baseBranch || !atual || r.repositorio !== atual.repositorio || (r.host ?? 'github.com') !== atual.host) {
             semRetrato = 'retrato de PRs de outro repositório ou base';
+        }
         else if (minutosDesde(r.lidoEm, quando) > exports.VALIDADE_DO_RETRATO_MIN)
             semRetrato = 'retrato de PRs velho';
         else if (Date.parse(r.lidoEm) - Date.parse(quando) > FOLGA_DO_RELOGIO_MIN * 60000)
@@ -727,7 +897,7 @@ function entregasDoProjeto(carregado, opcoes) {
     for (const f of fatos) {
         const { t, eventos } = f;
         const despacho = ultimoDespacho(eventos);
-        const fim = despacho ? fimDoTurno(eventos, despacho) : null;
+        const fim = despacho ? fimDoTurno(eventos, despacho, t.modo) : null;
         const terminou = !!fim && fim.tipo !== 'outro';
         const fimEm = terminou ? fim.em : null;
         // A1 do CHECK (rodada 3): o fim de turno vem do ledger (Stop sem atividade depois); a tela da sessao depois
@@ -740,9 +910,9 @@ function entregasDoProjeto(carregado, opcoes) {
                 doCondutor.turnosEncerrados.add(espera.sessionId);
             }
         }
-        const conducao = (0, conducao_1.conducaoDaThread)(raiz, t.id, { agora: new Date(quando) });
-        // P7: a sessao que ja encerrou o turno nao conduz mais nada, mesmo com o lease de pe.
-        const conduzidaAgora = !!conducao && !(conducao.dono.tipo === 'sessao' && terminou && conducao.dono.sessionId === fim.sessionId);
+        // A mesma regra do `ork ship publicar` (RM-059): quem conduz agora, ou ninguem.
+        const conducao = conducaoAgora(raiz, t, eventos, quando);
+        const conduzidaAgora = conducao !== null;
         const doDono = pendenciaDoDono(t, eventos, quando);
         // A2 do CHECK (rodada 3): depois do veredito do dono, o tempo do condutor conta a partir dele.
         const aprovacao = despacho ? eventos.slice(eventos.lastIndexOf(despacho) + 1).filter(ocupacao_1.ehAprovacaoHumana).at(-1) : undefined;
@@ -771,7 +941,15 @@ function entregasDoProjeto(carregado, opcoes) {
         let caso = null, desde = null, passo = '', peloGit = false;
         const evidencia = [];
         if (!conduzidaAgora && !doDono) {
-            if (f.comProduto && publicada === false && terminou) {
+            if (espera?.tipo === 'check-sem-veredito') {
+                // RM-037 (fatia 5, A3): antes de qualquer caso de entrega. Publicar ou mergear sem o veredito do CHECK pularia
+                // a revisao; e o `ork retry run` nao redespacha `human.pending` (`escalar-humano`), entao o passo e o despacho.
+                caso = 'check-sem-veredito';
+                desde = espera.fimDoTurnoEm;
+                passo = `redespachar o CHECK (ork phase run ${t.id} CHECK --prompt "<pedido da fase>")`;
+                evidencia.push('ledger: CHECK em done com o Stop, sem exatamente um veredito no docs/check.md');
+            }
+            else if (f.comProduto && publicada === false && terminou) {
                 desde = fimOuVeredito;
                 if (antesDaEntrega && !aberto) {
                     caso = 'fase-seguinte';
@@ -782,7 +960,8 @@ function entregasDoProjeto(carregado, opcoes) {
                     // N2 da seguranca (rodada 2): branch que ja foi ao remoto pode ter PR; sem a leitura, nunca "abrir o PR". A4 da
                     // rodada 5: publicar e abrir o PR pedem a mesma autorizacao de push que o merge.
                     passo = (aberto ? `publicar os commits novos da branch ${f.branch} no PR #${aberto.numero}`
-                        : f.temRemota && !prSabido ? `publicar os commits novos da branch ${f.branch} (PR não lido)`
+                        // RM-037 (fatia 5, A5): a forja sem leitura de PR ja foi dita uma vez; a linha so diz o passo.
+                        : f.temRemota && !prSabido ? `publicar os commits novos da branch ${f.branch}${semLeituraDaForja ? '' : ' (PR não lido)'}`
                             : `publicar a branch ${f.branch} e abrir o PR`) + autorizacao;
                 }
                 evidencia.push(`refs/heads/${f.branch} tem commit fora de refs/remotes/${remoto}/${f.branch}`);
@@ -850,7 +1029,8 @@ function entregasDoProjeto(carregado, opcoes) {
                     caso = 'sessao-sem-pergunta';
                     passo = f.shipNoLedger && !f.comProduto ? `fechar o MASTER da thread (ork master ${t.id})`
                         : aberto ? `acompanhar os checks do PR #${aberto.numero}, que seguem em andamento`
-                            : precisaDePr && !usouPr ? `conferir o PR da branch ${f.branch} (PR não lido) e seguir`
+                            : precisaDePr && !usouPr ? (semLeituraDaForja ? `conferir na forja o PR da branch ${f.branch} e seguir`
+                                : `conferir o PR da branch ${f.branch} (PR não lido) e seguir`)
                                 : `ler o fim da sessão ${id} (ork sessions logs ${id}) e seguir a thread`;
                 }
             }
@@ -880,11 +1060,12 @@ function entregasDoProjeto(carregado, opcoes) {
                 : daBranch.mesclado && !f.entregueNaPonta ? (f.merge && !f.mergeRegistrado ? `PR #${daBranch.mesclado.numero} mesclado, falta registrar a entrega (${registrar})`
                     : `PR #${daBranch.mesclado.numero} mesclado sem o assunto ship(${t.id}), falta registrar a entrega`)
                     : !f.comProduto && f.merge && !f.mergeRegistrado ? `merge ${f.merge.sha.slice(0, 7)} na base, falta registrar a entrega (${registrar})`
-                        : precisaDePr ? (!usouPr ? 'branch publicada, PR não lido'
+                        : precisaDePr ? (!usouPr ? (semLeituraDaForja ? `branch publicada, ${exports.FORJA_SEM_LEITURA}` : 'branch publicada, PR não lido')
                             : daBranch.fechado ? `branch publicada, PR #${daBranch.fechado.numero} fechado sem merge` : 'branch publicada sem PR')
                             : null;
         estados.push({ thread: t.id, branch: f.branch, comProduto: f.comProduto, publicada, pr: prDaEntrega,
-            prLidoEm: prLido && (usouPr || aberto) ? prLido.lidoEm : null, prNaoLido, conduzidaAgora, espera, parado, resumo });
+            prLidoEm: prLido && (usouPr || aberto) ? prLido.lidoEm : null, prNaoLido, conduzidaAgora,
+            donoDaConducao: conduzidaAgora && conducao ? conducao.dono.tipo : null, espera, parado, resumo });
     }
     // As sessoes `blocked` sem pergunta que sobraram: de thread fechada, ou de despacho antigo de thread aberta.
     // A do despacho corrente fica com o predicado do ledger (`esperaDoCondutor`). Sem o carimbo do radar nao