@orkastery/cli 0.5.6 → 0.6.1

package/dist/parado-no-condutor.js

@@ -33,11 +33,12 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-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.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;
@@ -78,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");
@@ -94,6 +102,7 @@ const session_watcher_claude_1 = require("./session-watcher-claude");
 const thread_1 = require("./thread");
 const util_1 = require("./util");
 const worktree_1 = require("./worktree");
+const merge_da_entrega_1 = require("./merge-da-entrega");
 exports.CONTRATO_PRS = 'ork.prs-abertos/v1';
 /** D4: duas batidas do pulse. Abaixo disto o condutor pode estar agindo. */
 exports.LIMIAR_PARADO_NO_CONDUTOR_MIN = 30;
@@ -103,36 +112,26 @@ 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';
-/** 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. */
-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. */
@@ -140,6 +139,10 @@ const git = (raiz, args) => (0, util_1.exec)('git', args, raiz, 60000, { ...proc
 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. */
@@ -185,11 +188,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) ?? '' };
@@ -252,52 +257,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();
@@ -305,79 +355,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 ?? 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 = 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. */
@@ -460,7 +483,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)))))
@@ -761,20 +784,19 @@ function refsLocais(raiz, remoto) {
     }
     return mapa;
 }
-/** Os merges `ship(<thread>)` da base numa leitura so, do mais novo para o mais velho (fica o mais novo). */
-function mergesNaBase(raiz, baseRef) {
+/** Os merges das entregas da base numa leitura so, do mais novo para o mais velho (fica o mais novo). */
+function mergesNaBase(raiz, baseRef, base, threads) {
     const mapa = new Map();
     if (!baseRef)
         return mapa;
-    // Regex basica do git: o `(` e literal. A ref vem qualificada do `for-each-ref`.
-    const r = git(raiz, ['log', baseRef, '--first-parent', '--format=%H%x09%cI%x09%s', '--grep=^ship(']);
-    if (!r.ok)
-        return mapa;
-    for (const linha of r.stdout.split('\n')) {
-        const [sha, em, assunto] = linha.split('\t');
-        const m = /^ship\(([A-Za-z0-9._-]+)\)/.exec(assunto ?? '');
-        if (m && sha && SHA.test(sha) && !mapa.has(m[1]))
-            mapa.set(m[1], { sha, em: instante(em) });
+    const reconhecidos = (0, merge_da_entrega_1.mergesDasEntregasNaBase)(raiz, baseRef, base, threads.map((t) => ({
+        thread: t.id,
+        branch: (0, merge_da_entrega_1.branchRegistradaDaEntrega)(raiz, t.id) ?? (0, worktree_1.branchDaWorktree)(t),
+    })));
+    for (const t of threads) {
+        const merge = reconhecidos.get(t.id)?.[0];
+        if (merge)
+            mapa.set(t.id, { sha: merge.mergeSha, em: merge.em });
     }
     return mapa;
 }
@@ -835,7 +857,6 @@ function entregasDoProjeto(carregado, opcoes) {
     const refs = refsLocais(raiz, remoto);
     // A copia do remoto vem primeiro: a base local desta maquina pode estar parada (o merge e pelo GitHub).
     const baseRef = [`refs/remotes/${remoto}/${baseBranch}`, `refs/heads/${baseBranch}`].find((r) => refs.has(r)) ?? null;
-    const merges = mergesNaBase(raiz, baseRef);
     const sessoes = opcoes.sessoes ?? [];
     const threads = [];
     for (const id of (0, thread_1.listarIds)(raiz)) {
@@ -844,6 +865,7 @@ function entregasDoProjeto(carregado, opcoes) {
         }
         catch { /* thread ilegivel fica de fora */ }
     }
+    const merges = mergesNaBase(raiz, baseRef, baseBranch, threads);
     const fatos = threads.filter((t) => t.status !== 'fechada').map((t) => {
         let eventos = [];
         try {
@@ -880,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';
@@ -985,11 +1007,10 @@ function entregasDoProjeto(carregado, opcoes) {
                 desde = f.merge.em ?? fimEm;
                 peloGit = true;
                 passo = `registrar a entrega do merge ${f.merge.sha.slice(0, 7)} (ork ship registrar-pr ${t.id})`;
-                evidencia.push(`git log: merge ship(${t.id}) ${f.merge.sha.slice(0, 7)} na base, sem ship_done no ledger`);
+                evidencia.push(`git log: merge da entrega de ${t.id} ${f.merge.sha.slice(0, 7)} na base, sem ship_done no ledger`);
             }
             else if (!aberto && daBranch.mesclado && !f.entregueNaPonta && (daBranch.mesclado.mescladoEm ?? fimEm)) {
-                // N4 do CHECK (rodada 2): PR mesclado sem o assunto ship(<thread>); o `registrar-pr` nao o acha sozinho. Com o
-                // merge ship(<thread>) ainda sem registro na base (squash), o `registrar-pr` acha.
+                // N4 do CHECK (rodada 2): PR mesclado sem assunto ou branch reconhecivel; o `registrar-pr` nao o acha sozinho.
                 caso = 'sem-registro';
                 desde = daBranch.mesclado.mescladoEm ?? fimEm;
                 passo = f.merge && !f.mergeRegistrado ? `registrar a entrega do merge ${f.merge.sha.slice(0, 7)} (ork ship registrar-pr ${t.id})`