@orkastery/cli 0.5.3 → 0.6.0

package/dist/parado-no-condutor.js

@@ -33,9 +33,12 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CONTRATO_FORJA_SEM_LEITURA = 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.CONTRATO_FORJA_SEM_LEITURA = exports.ghPadrao = exports.FORJA_SEM_LEITURA = exports.LIMITES_DOS_PEDIDOS = 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.forjaDoRemotoDoPulse = forjaDoRemotoDoPulse;
 exports.lerPrsDaForja = lerPrsDaForja;
 exports.gravarRetratoDePrs = gravarRetratoDePrs;
 exports.avisarForjaSemLeitura = avisarForjaSemLeitura;
@@ -45,8 +48,10 @@ 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.
@@ -74,11 +79,18 @@ 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 api_1 = require("./forja/api");
+const cli_1 = require("./forja/cli");
+const endereco_1 = require("./forja/endereco");
+const executor_1 = require("./forja/executor");
+const resolver_1 = require("./forja/resolver");
+const registro_1 = require("./forja/registro");
+const estado_1 = require("./forja/estado");
 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");
+const locale_1 = require("./locale");
 const hitl_1 = require("./hitl");
 const hitl_contract_1 = require("./hitl-contract");
 const hitl_classificacao_1 = require("./hitl-classificacao");
@@ -99,41 +111,37 @@ exports.VALIDADE_DO_RETRATO_MIN = 60;
 exports.LIMITE_DE_PRS = 200;
 /** Quantos PRs recentes (de qualquer estado) a segunda leitura pede: so para achar o mesclado e o fechado. */
 exports.LIMITE_DE_RECENTES = 100;
+const PRAZO_DO_GH_MS = 30000;
+/** Os tetos e o prazo de cada chamada da leitura de pedidos, que o adaptador de cada forja respeita. */
+exports.LIMITES_DOS_PEDIDOS = { abertos: exports.LIMITE_DE_PRS, recentes: exports.LIMITE_DE_RECENTES, candidatas: 10,
+    minimoDaConferenciaMs: 5000, prazoMs: PRAZO_DO_GH_MS };
 /** Retrato com data mais a frente do relogio do que isto nao vale (relogio adiantado ou arquivo mexido). */
 const FOLGA_DO_RELOGIO_MIN = 5;
 const ARQUIVO_DOS_PRS = 'prs.json';
-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`;
-/** 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. */
-const MINIMO_DA_CONFERENCIA_MS = 5000;
 /** As fases que o ciclo despacha antes da entrega: depois de um bloco que para nelas, o passo e despachar, nao publicar. */
 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' };
-    delete env.GH_HOST;
-    delete env.GH_REPO;
-    delete env.GH_FORCE_TTY;
-    return env;
-}
 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 ?? '') };
+    const r = (0, executor_1.rodarCli)({ cmd: 'gh', args, prazoMs: timeoutMs, maxBuffer: 16 * 1024 * 1024, procurarBinario: false,
+        acrescentar: { GH_PROMPT_DISABLED: '1', NO_COLOR: '1', CLICOLOR: '0', CLICOLOR_FORCE: '0' },
+        apagar: ['GH_HOST', 'GH_REPO', 'GH_FORCE_TTY'] });
+    return { status: r.status, stdout: r.stdout, stderr: r.mensagemDoErro ?? 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 caminho do projeto no retrato: `dono/nome` no GitHub, o caminho completo com subgrupos no GitLab. */
+const CAMINHO_DO_PROJETO = /^[A-Za-z0-9_.-]{1,100}(?:\/[A-Za-z0-9_.-]{1,100}){1,19}$/;
+/** O caminho do projeto na forma, sem segmento `.` ou `..`. */
+const caminhoDoProjeto = (v) => CAMINHO_DO_PROJETO.test(v) && v.split('/').every((p) => p !== '.' && p !== '..');
 /** 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. */
@@ -179,11 +187,13 @@ function checkDaForja(c) {
     let situacao;
     if (o.__typename === 'StatusContext' || (o.status === undefined && typeof o.state === 'string')) {
         const s = String(o.state ?? '').toUpperCase();
-        situacao = s === 'SUCCESS' ? 'verde' : s === 'FAILURE' || s === 'ERROR' ? 'vermelho' : 'pendente';
+        situacao = (0, estado_1.estadoDoCheck)('commit-status', s, null);
     }
     else {
         const status = String(o.status ?? '').toUpperCase(), conclusao = String(o.conclusion ?? '').toUpperCase();
-        situacao = status !== 'COMPLETED' ? 'pendente' : ['SUCCESS', 'NEUTRAL', 'SKIPPED'].includes(conclusao) ? 'verde' : 'vermelho';
+        // O pulse mostra o job pulado de proposito como verde, como sempre: so o gate trata `bloqueado` como nao verde.
+        const estado = (0, estado_1.estadoDoCheck)('check-run', status, conclusao);
+        situacao = estado === 'bloqueado' ? 'verde' : estado;
     }
     const concluidoEm = situacao === 'pendente' ? null : instante(o.completedAt) ?? instante(o.startedAt);
     return { check: { nome, situacao, concluidoEm }, chave, inicio: instante(o.startedAt) ?? instante(o.completedAt) ?? '' };
@@ -220,8 +230,12 @@ 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
@@ -242,52 +256,97 @@ function repositorioDoRemoto(raiz, remoto) {
     const github = githubDoRemoto(raiz, remoto);
     return github && github.host === 'github.com' ? github.repositorio : null;
 }
+const githubResolvido = (f) => ({ tipo: 'github', host: f.host, porta: null,
+    caminhoBase: '', sshHost: null, sshPorta: null, ca: null, repo: f.repositorio,
+    origem: { tipo: 'remoto', host: 'remoto', porta: 'padrao', caminhoBase: 'padrao' } });
 /**
- * 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.
+ * As sondas do pulse: o GitHub pelo `gh auth status --hostname` de sempre (o host proprio em que o `gh` tem login e
+ * um GitHub Enterprise) e o GitLab pela sonda padrao (o `glab` com login no host responde o `metadata`). O `auth
+ * status` que falha por outro motivo que nao a falta de login (prazo, rede, `gh` ausente) fica em `falha`.
  */
-function forjaDosPrs(raiz, remoto, executor, prazoMs) {
+function sondasDoPulse(executor, prazoMs, rodar, logins, falha) {
+    return {
+        github: (alvo) => {
+            if (alvo.caminhoBase)
+                return 'nao-responde';
+            // Com porta propria, o login se confere no `host:porta` exato, pela sonda padrao: o `--hostname` nao leva porta.
+            if (alvo.porta !== null && alvo.porta !== 443)
+                return (0, resolver_1.sondasPadrao)(rodar, logins).github(alvo);
+            const auth = executor(['auth', 'status', '--hostname', alvo.host], prazoMs);
+            if (auth.status === 0)
+                return 'responde';
+            // 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.
+            if (auth.status === 1 && /\bnot logged in/i.test(`${auth.stdout}\n${auth.stderr}`)) {
+                falha.ghSemLogin = true;
+                return 'sem-login';
+            }
+            falha.gh = `gh auth status --hostname ${alvo.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');
+            return 'nao-responde';
+        },
+        gitlab: (alvo) => {
+            const r = (0, resolver_1.sondasPadrao)(rodar, logins).gitlab(alvo);
+            if (r === 'sem-login')
+                falha.glabSemLogin = true;
+            return r;
+        },
+    };
+}
+/**
+ * De onde o pulse le os pedidos do remoto: a forja resolvida pelo bloco `forja:` do manifesto, pelo host conhecido ou
+ * pela sondagem so por CLI com login no host (nunca pelo nome do host). Ficar sem leitura (remoto sem forja, forja
+ * que nao se resolve, tipo sem a capacidade) nao e falha desta batida: e o estado da forja, que o pulse diz uma vez.
+ */
+function forjaDosPrs(carregado, remoto, executor, prazoMs, rodar, logins, sondas) {
     // 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]);
+    const url = git(carregado.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());
+    const endereco = (0, forja_1.enderecoDoRemoto)(url.stdout.trim()), lido = (0, endereco_1.lerEnderecoDoRemoto)(url.stdout.trim());
     // Caminho local, ou apelido de SSH sem dominio (`git@github-trabalho:dono/repo.git`): nao ha host para ler.
-    if (!endereco) {
+    if (!endereco || !lido) {
         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 falha = {};
+    // Sem o cache de 24 h: o pulse percebe na batida seguinte a CLI que perdeu o login no host.
+    const r = (0, resolver_1.resolverForja)({ endereco: lido, manifesto: carregado.manifesto.forja, sondas: sondas ?? sondasDoPulse(executor, prazoMs, rodar, logins, falha) });
+    if (!r.ok) {
+        if (falha.gh)
+            return { leitura: false, host: endereco.host, semLeitura: false, motivo: falha.gh };
+        const erro = r.erro;
+        const motivo = erro.codigo === 'forja.desconhecida' && falha.ghSemLogin
+            ? (0, locale_1.textoDoCatalogo)((m) => falha.glabSemLogin ? m.pulse.forjaSemLoginNasDuas(endereco.host, remoto) : m.pulse.forjaSemLogin('gh', endereco.host, remoto))
+            : (0, locale_1.textoDoCatalogo)((m) => m.pulse.forjaNaoResolvida(remoto, m.forja.motivo(erro, null)));
+        return { leitura: false, host: endereco.host, semLeitura: true, motivo };
     }
-    const github = githubDoRemoto(raiz, remoto);
-    if (!github) {
+    const forja = r.valor;
+    if (forja.tipo === 'github' && !REPOSITORIO.test(forja.repo)) {
         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') };
+    if (!(0, registro_1.adaptadorDaForja)(forja.tipo).pedidosAbertos) {
+        return { leitura: false, host: endereco.host, semLeitura: true,
+            motivo: (0, locale_1.textoDoCatalogo)((m) => m.pulse.forjaSemPedidos(forja.tipo, forja.host, remoto)) };
+    }
+    return { leitura: true, forja, hostDoRemoto: endereco.host };
+}
+/**
+ * A forja do remoto como o pulse a resolve (o bloco `forja:`, o host conhecido, o cache ou a sondagem pela CLI com
+ * login), sem ler pedido nenhum: a pista a usa num host proprio, para seguir o caminho da forja certa. `erro` e a frase
+ * que a leitura dos pedidos diria.
+ */
+function forjaDoRemotoDoPulse(carregado, remoto, opcoes = {}) {
+    const lido = forjaDosPrs(carregado, remoto, opcoes.executor ?? exports.ghPadrao, PRAZO_DO_GH_MS, opcoes.rodar ?? executor_1.rodarCli, new Map(), opcoes.sondas);
+    return lido.leitura ? { ok: true, forja: lido.forja } : { ok: false, erro: lido.motivo };
 }
 /**
- * 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. RM-037 (fatia 5, A5): no GitHub Enterprise, o host
- * vai no `--repo`; forja sem leitura de PR nao chama o `gh pr list`.
+ * Le os pedidos da base do projeto pela capacidade `pedidosAbertos` da forja resolvida: os abertos (so a lista deles
+ * pode dizer "sem PR"), os recentes de qualquer estado e as candidatas que nao apareceram. A CLI usa a autenticacao
+ * dela; nenhum token passa por aqui. Forja sem leitura de pedidos nao chama CLI nenhuma alem da sondagem.
  */
 function lerPrsDaForja(carregado, opcoes = {}) {
     const lidoEm = opcoes.quando ?? new Date().toISOString();
@@ -295,78 +354,52 @@ function lerPrsDaForja(carregado, opcoes = {}) {
     const base = carregado.manifesto.worktree.base_branch;
     const orcamento = opcoes.orcamentoMs ?? ORCAMENTO_DA_LEITURA_MS, fimDaLeitura = Date.now() + orcamento;
     const resta = () => fimDaLeitura - Date.now();
-    const executor = opcoes.executor ?? ghPadrao;
-    const 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 = 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}`;
-        }
-        try {
-            const lista = JSON.parse(r.stdout);
-            if (!Array.isArray(lista))
-                throw new Error('a resposta não é uma lista');
-            return lista;
-        }
-        catch (e) {
-            return `resposta do gh pr list fora do formato: ${curto((0, hitl_1.redigirSegredos)(e.message), 120) ?? 'sem detalhe'}`;
-        }
-    };
-    try {
-        const porNumero = new Map();
-        const juntar = (lista, comChecks) => {
-            for (const bruto of lista) {
-                const pr = prDaForja(bruto, base);
-                if (!pr || porNumero.has(pr.numero))
-                    continue;
-                // S-b do CHECK (rodada 3): a leitura sem rollup nunca diz que o aberto nao tem checks.
-                if (!comChecks && pr.estado === 'aberto')
-                    pr.checks = [{ nome: 'checks não lidos', situacao: 'pendente', concluidoEm: null }];
-                porNumero.set(pr.numero, pr);
-            }
-        };
-        const abertos = pedir(['--state=open', `--limit=${exports.LIMITE_DE_PRS}`, `--json=${CAMPOS_DO_GH}`]);
-        if (typeof abertos === 'string')
-            return { ok: false, lidoEm, erro: abertos };
-        juntar(abertos, true);
-        const recentes = pedir(['--state=all', `--limit=${exports.LIMITE_DE_RECENTES}`, `--json=${CAMPOS_DOS_RECENTES}`]);
-        if (typeof recentes === 'string')
-            return { ok: false, lidoEm, erro: recentes };
-        juntar(recentes, false);
-        // R1 do CHECK (rodada 3): antes de dizer "sem PR", a branch candidata e conferida sozinha (o mesclado velho
-        // fica fora dos recentes). Acima do teto da batida, a branch fica sem conferir, e isso e "PR nao lido".
-        const achadas = new Set([...porNumero.values()].map((p) => p.branch));
-        const faltam = [...new Set(opcoes.candidatas ?? [])].filter((b) => BRANCH.test(b) && !achadas.has(b));
-        const semConferir = [];
-        for (const [i, branch] of faltam.entries()) {
-            // Acima do teto da batida, sem tempo para a conferencia inteira ou com ela falhando, a candidata fica sem conferir
-            // ("PR nao lido") e o que ja foi lido vale (sugestao da seguranca na rodada 4 do CHECK).
-            if (i >= LIMITE_DE_CANDIDATAS || resta() < MINIMO_DA_CONFERENCIA_MS) {
-                semConferir.push(branch);
-                continue;
-            }
-            const daBranch = pedir(['--state=all', `--head=${branch}`, '--limit=5', `--json=${CAMPOS_DOS_RECENTES}`]);
-            try {
-                if (typeof daBranch === 'string')
-                    throw new Error(daBranch);
-                juntar(daBranch, false);
-            }
-            catch {
-                semConferir.push(branch);
-            }
+    const executor = opcoes.executor ?? exports.ghPadrao, rodar = opcoes.rodar ?? executor_1.rodarCli, logins = new Map();
+    const lido = opcoes.resolvida ? { leitura: true, forja: opcoes.resolvida, hostDoRemoto: null }
+        : opcoes.forja ? { leitura: true, forja: githubResolvido(opcoes.forja), hostDoRemoto: null }
+            : forjaDosPrs(carregado, remoto, executor, Math.min(PRAZO_DO_GH_MS, Math.max(1, resta())), rodar, logins, opcoes.sondas);
+    if (!lido.leitura)
+        return { ok: false, lidoEm, erro: lido.motivo, ...(lido.semLeitura ? { semLeitura: { remoto, host: lido.host } } : {}) };
+    const forja = lido.forja;
+    const lidos = (0, registro_1.exigirCapacidade)((0, registro_1.adaptadorDaForja)(forja.tipo), 'pedidosAbertos')({ forja, base, candidatas: opcoes.candidatas ?? [],
+        contexto: carregado.manifesto.ci.context || 'ork-verify',
+        api: (0, api_1.chamadorDaApi)(forja, { rodar, logins }), executor, resta, orcamentoMs: orcamento, limites: exports.LIMITES_DOS_PEDIDOS });
+    if (!lidos.ok) {
+        const erro = lidos.erro, cli = cli_1.CLI_DA_FORJA[forja.tipo].cmd;
+        // O GitHub guarda a frase de sempre do `gh pr list` (o pulse e os snapshots a fixam); as outras dizem o motivo tipado.
+        if (forja.tipo === 'github')
+            return { ok: false, lidoEm, erro: erro.detalhe };
+        // A CLI sem login no host e o estado da forja, dito uma vez, como o `gh` sem login no host proprio.
+        if (erro.codigo === 'forja.sem-login') {
+            return { ok: false, lidoEm, erro: (0, locale_1.textoDoCatalogo)((m) => m.pulse.forjaSemLogin(cli, forja.host, remoto)),
+                semLeitura: { remoto, host: lido.hostDoRemoto ?? forja.host } };
         }
-        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'}` };
+        return { ok: false, lidoEm, erro: (0, locale_1.textoDoCatalogo)((m) => m.forja.motivo(erro, forja.tipo)) };
     }
+    return { ok: true, retrato: { contrato: exports.CONTRATO_PRS, lidoEm, repositorio: forja.repo, ...(forja.host !== 'github.com' ? { host: forja.host } : {}),
+            base, parcial: lidos.valor.parcial, ...(lidos.valor.semConferir.length ? { semConferir: lidos.valor.semConferir } : {}), prs: lidos.valor.prs } };
+}
+/**
+ * O host e o caminho do projeto no remoto, sem rede nem CLI: o que o retrato tem de bater. A resolucao roda sem
+ * sondas; sem tipo declarado e fora dos hosts conhecidos, valem o host (o declarado, senao o do remoto) e o caminho do
+ * remoto sem o caminho base.
+ */
+function forjaDoRemotoSemRede(carregado, remoto) {
+    if (!(0, branch_de_estado_1.remotoValido)(remoto))
+        return null;
+    const url = git(carregado.raiz, ['remote', 'get-url', '--', remoto]);
+    const endereco = url.ok ? (0, endereco_1.lerEnderecoDoRemoto)(url.stdout.trim()) : null;
+    if (!endereco)
+        return null;
+    const m = carregado.manifesto.forja;
+    const r = (0, resolver_1.resolverForja)({ endereco, manifesto: m, sondas: {} });
+    if (r.ok)
+        return { host: r.valor.host, repositorio: r.valor.repo };
+    if (r.erro.codigo !== 'forja.desconhecida')
+        return null;
+    const prefixo = m?.caminho_base ? `${m.caminho_base.slice(1)}/` : '';
+    return { host: m?.host ?? endereco.host,
+        repositorio: prefixo && endereco.caminho.startsWith(prefixo) ? endereco.caminho.slice(prefixo.length) : endereco.caminho };
 }
 const dirDoMonitor = (raiz) => path.join((0, estado_thread_1.raizDoEstado)(raiz), '.orkastery', 'monitor');
 /** Grava o retrato de uma leitura que deu certo: arquivo novo exclusivo, so do dono, renomeado por cima. */
@@ -449,7 +482,7 @@ function lerRetratoDePrs(raiz) {
     try {
         const r = JSON.parse(fs.readFileSync(path.join(dirDoMonitor(raiz), ARQUIVO_DOS_PRS), 'utf8'));
         const lidoEm = instante(r.lidoEm);
-        if (r.contrato !== exports.CONTRATO_PRS || !lidoEm || typeof r.repositorio !== 'string' || !REPOSITORIO.test(r.repositorio) ||
+        if (r.contrato !== exports.CONTRATO_PRS || !lidoEm || typeof r.repositorio !== 'string' || !caminhoDoProjeto(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)))))
@@ -702,6 +735,19 @@ 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;
@@ -856,7 +902,7 @@ function entregasDoProjeto(carregado, opcoes) {
     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, atual = githubDoRemoto(raiz, remoto);
+        const r = prs.retrato, atual = forjaDoRemotoSemRede(carregado, 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';
@@ -886,9 +932,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;
@@ -1040,7 +1086,8 @@ function entregasDoProjeto(carregado, opcoes) {
                             : 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