@orkastery/cli 0.5.6 → 0.6.0

package/dist/ship-publicar.js

@@ -34,6 +34,9 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ETAPAS = exports.MODOS_QUE_PUBLICAM = exports.CONTRATO_DA_PISTA = exports.CONTRATO_DA_PUBLICACAO = void 0;
+exports.conferirCheck = conferirCheck;
+exports.conferirBundle = conferirBundle;
+exports.manifestoDaBranch = manifestoDaBranch;
 exports.tituloDoPr = tituloDoPr;
 exports.entreAspas = entreAspas;
 exports.comandoDoDono = comandoDoDono;
@@ -52,7 +55,7 @@ exports.pistaDeEntrega = pistaDeEntrega;
  *     thread ork-rm059pista);
  *  2. empurra sem forca o sha conferido, e nao a ref, com refspec explicito, e prova pelo `git ls-remote` (a prova do
  *     `ork ship`);
- *  3. reaproveita o PR aberto da branch ou abre um com o texto do `pr-body.md` da thread, e prova pela releitura da
+ *  3. reaproveita o PR (MR no GitLab) aberto da branch ou abre um com o texto do `pr-body.md` da thread, e prova pela releitura da
  *     lista;
  *  4. grava `ship_published` com a prova, so quando houve efeito; o push sem prova tambem vai. Repetido, ou com o PR
  *     ja mesclado no HEAD, devolve `ja-publicada`.
@@ -68,13 +71,20 @@ const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const branch_de_estado_1 = require("./branch-de-estado");
 const ci_1 = require("./ci");
-const hitl_1 = require("./hitl");
+const api_1 = require("./forja/api");
+const cli_1 = require("./forja/cli");
+const pedidos_1 = require("./forja/gitlab/pedidos");
+const registro_1 = require("./forja/registro");
+const resolver_1 = require("./forja/resolver");
+const cache_1 = require("./forja/cache");
+const texto_1 = require("./forja/texto");
 const claims_1 = require("./claims");
 const ledger_1 = require("./ledger");
 const manifest_1 = require("./manifest");
 const modos_1 = require("./modos");
 const parado_no_condutor_1 = require("./parado-no-condutor");
 const entrega_pr_1 = require("./entrega-pr");
+const noctum_guarda_1 = require("./noctum-guarda");
 const ship_1 = require("./ship");
 const session_watcher_claude_1 = require("./session-watcher-claude");
 const thread_1 = require("./thread");
@@ -96,21 +106,11 @@ const TETO_DO_CORPO = 64 * 1024;
 const PRAZO_DO_GH_MS = 45000;
 const PRAZO_DO_PUSH_MS = 180000;
 const PRAZO_DO_LS_REMOTE_MS = 60000;
-/** Os campos do `gh pr list` de uma branch: os do `prDaForja`, com o estado de merge do PR aberto. */
-const CAMPOS_DA_BRANCH = 'number,state,headRefName,headRefOid,baseRefName,isDraft,isCrossRepository,url,createdAt,mergedAt,mergeable';
 /** Git local sem rede escondida nem pergunta de credencial no terminal. */
 function git(raiz, args, prazoMs = 60000) {
     return (0, util_1.exec)('git', args, raiz, prazoMs, { ...process.env, GIT_NO_LAZY_FETCH: '1', GIT_TERMINAL_PROMPT: '0' });
 }
 const curto = (sha) => (sha ? sha.slice(0, 7) : '-');
-/** Texto curto: uma linha, sem controle, com teto. */
-function umaLinha(texto, teto = 200) {
-    return Array.from(texto.replace(/\p{Cc}/gu, ' ').replace(/\s+/g, ' ').trim()).slice(0, teto).join('') || '-';
-}
-/** Texto de fora (stderr do git ou do gh): sem segredo, numa linha e com teto, antes de ir ao `--json` e ao ledger. */
-function deFora(texto, teto = 200) {
-    return umaLinha((0, hitl_1.redigirSegredos)(texto), teto);
-}
 exports.ETAPAS = ['check', 'verify', 'bundle', 'branch', 'pr', 'ci', 'conflito', 'entrega'];
 const etapa = (id, estado, texto) => ({ id, estado, texto });
 /** Os caminhos mudados so cabem no bundle (`.ork-ci/`)? Lista vazia tambem nao e produto. */
@@ -138,7 +138,10 @@ function ultimoCommitDeProduto(raiz, baseRef, head) {
     }
     return null;
 }
-/** O CHECK: exatamente um veredito, PASSOU, gravado depois do ultimo commit de produto. */
+/**
+ * O CHECK: exatamente um veredito, PASSOU, gravado depois do ultimo commit de produto. RM-063 (F7): a batida da conducao
+ * tambem o le antes do merge do PR, para nada entrar na base sem ter passado pelo CHECK.
+ */
 function conferirCheck(raiz, t, baseRef, head) {
     if (!(t.fases ?? []).includes('CHECK')) {
         return { etapa: etapa('check', 'nao-se-aplica', (0, locale_1.textoDoCatalogo)((m) => m.ship.publicar.checkSemCiclo((0, modos_1.tagDoModo)(t.modo)))), passou: true };
@@ -249,7 +252,7 @@ function manifestoDaBranch(carregado, head) {
         if (!doHead)
             return carregado;
         return { ...carregado, manifesto: { ...carregado.manifesto,
-                verify: { ...carregado.manifesto.verify, typecheck: doHead.typecheck, build: doHead.build, test: doHead.test },
+                verify: { ...carregado.manifesto.verify, typecheck: doHead.typecheck, build: doHead.build, test: doHead.test, security_scan: doHead.securityScan },
                 ci: { ...carregado.manifesto.ci, command: doHead.ciCommand } } };
     }
     return carregado;
@@ -288,7 +291,7 @@ function refDaBase(refs, remoto, base) {
 function pontaNoRemoto(raiz, remoto, branch) {
     const r = git(raiz, ['ls-remote', '--', remoto, `refs/heads/${branch}`], PRAZO_DO_LS_REMOTE_MS);
     if (!r.ok)
-        return { sha: null, erro: deFora(r.stderr || r.stdout || `codigo ${r.code}`) };
+        return { sha: null, erro: (0, texto_1.deFora)(r.stderr || r.stdout || `codigo ${r.code}`) };
     const alvo = `refs/heads/${branch}`;
     const linha = r.stdout.split('\n').map((l) => l.trim().split(/\s+/)).find((partes) => partes[1] === alvo);
     const sha = linha?.[0] ?? '';
@@ -317,22 +320,59 @@ function pontasNoRemoto(raiz, remoto) {
     }
     return mapa;
 }
-/** Os PRs de uma branch, da base do projeto, do mais novo para o mais velho. */
-function prsDaBranch(executor, forja, base, branch) {
-    const r = executor(['pr', 'list', `--repo=${forja.host}/${forja.repositorio}`, `--head=${branch}`, '--state=all', '--limit=10',
-        `--json=${CAMPOS_DA_BRANCH}`], PRAZO_DO_GH_MS);
-    if (r.status !== 0)
-        return { prs: [], erro: deFora(r.stderr || r.stdout || `codigo ${r.status ?? '-'}`) };
-    try {
-        const lista = JSON.parse(r.stdout);
-        if (!Array.isArray(lista))
-            throw new Error('a resposta nao e uma lista');
-        const prs = lista.map((p) => (0, parado_no_condutor_1.prDaForja)(p, base)).filter((p) => !!p && p.branch === branch);
-        return { prs: prs.sort((a, b) => b.numero - a.numero), erro: null };
-    }
-    catch (e) {
-        return { prs: [], erro: deFora(e.message) };
-    }
+/**
+ * O tipo da forja sem rede nem CLI, para o comando que o dono roda: o fixado, o bloco `forja:`, o host conhecido ou a
+ * sondagem que ja esta no cache de 24 h. Remoto sem host (caminho local) segue o GitHub de sempre; host proprio que
+ * nada disso resolve da `null`, e o comando do dono mostra as duas forjas.
+ */
+function tipoSemRede(carregado, remoto, fixado) {
+    if (fixado)
+        return fixado;
+    if (carregado.manifesto.forja?.tipo)
+        return carregado.manifesto.forja.tipo;
+    const endereco = (0, entrega_pr_1.enderecoDoRemotoDaRaiz)(carregado.raiz, remoto);
+    if (!endereco)
+        return 'github';
+    const r = (0, resolver_1.resolverForja)({ endereco, manifesto: carregado.manifesto.forja, sondas: {}, cache: (0, cache_1.dirDoCacheDaForja)(carregado.raiz) });
+    return r.ok ? r.valor.tipo : null;
+}
+function pedidosDoGithub(forja, executor) {
+    const gh = (0, registro_1.adaptadorDaForja)('github');
+    return {
+        tipo: 'github',
+        listar: (base, branch) => (0, registro_1.exigirCapacidade)(gh, 'pedidosDaBranch')({ ...forja, base, branch, executor, prazoMs: PRAZO_DO_GH_MS }),
+        abrir: (base, branch, titulo, corpo) => (0, registro_1.exigirCapacidade)(gh, 'abrirPedido')({ ...forja, base, branch, titulo, corpo, executor,
+            prazoMs: PRAZO_DO_GH_MS }),
+        passoDaLista: (branch) => `gh pr list --head ${branch} --state all`,
+        passoDaCriacao: (base, branch) => `gh pr create --base ${base} --head ${branch}`,
+        ensaioDaCriacao: (base, branch, titulo, corpo) => `gh pr create --base ${base} --head ${branch} --title "${titulo}" --body-file <${corpo}>`,
+    };
+}
+/** O GitLab pela API com a CLI logada; o gh nunca roda aqui. */
+function pedidosDoGitlab(f, opcoes) {
+    const gl = (0, registro_1.adaptadorDaForja)('gitlab');
+    const semGh = () => ({ status: 1, stdout: '', stderr: 'o gh não fala com o GitLab' });
+    const comum = { host: (0, cli_1.hostDaApi)(f), repositorio: f.repo, executor: semGh, prazoMs: PRAZO_DO_GH_MS, api: (0, api_1.chamadorDaApi)(f, opcoes) };
+    const projeto = (0, pedidos_1.projetoNaApi)(f.repo);
+    return {
+        tipo: 'gitlab',
+        listar: (base, branch) => (0, registro_1.exigirCapacidade)(gl, 'pedidosDaBranch')({ ...comum, base, branch }),
+        abrir: (base, branch, titulo, corpo) => (0, registro_1.exigirCapacidade)(gl, 'abrirPedido')({ ...comum, base, branch, titulo, corpo }),
+        passoDaLista: (branch) => `glab api ${(0, pedidos_1.caminhoDosMrsDaBranch)(f.repo, branch)}`,
+        passoDaCriacao: (base, branch) => `glab api --method POST ${projeto}/merge_requests (source_branch=${branch}, target_branch=${base})`,
+        ensaioDaCriacao: (base, branch, titulo, corpo) => `glab api --method POST ${projeto}/merge_requests (source_branch=${branch}, target_branch=${base}, title="${titulo}", description <${corpo}>)`,
+    };
+}
+/** Os pedidos da entrega: o GitHub fixo dos testes, a forja fixada, ou a resolvida do remoto. */
+function pedidosDaEntrega(carregado, remoto, opcoes) {
+    const executor = opcoes.executorGh ?? parado_no_condutor_1.ghPadrao;
+    if (opcoes.forja)
+        return { ok: true, pedidos: pedidosDoGithub(opcoes.forja, executor) };
+    const r = opcoes.forjaResolvida ? { ok: true, valor: opcoes.forjaResolvida } : (0, entrega_pr_1.forjaDaEntrega)(carregado, remoto, opcoes.sondas);
+    if (!r.ok)
+        return r;
+    return { ok: true, pedidos: r.valor.tipo === 'gitlab' ? pedidosDoGitlab(r.valor, opcoes.api ?? {})
+            : pedidosDoGithub({ host: r.valor.host, repositorio: r.valor.repo }, executor) };
 }
 // ---------------------------------------------------------------------------
 // O corpo e o titulo do PR.
@@ -345,7 +385,7 @@ function corpoDaThread(raiz, threadId) {
         if (!st.isFile() || st.size === 0 || st.size > TETO_DO_CORPO)
             return null;
         const texto = fs.readFileSync(arquivo, 'utf8');
-        // O corpo vai ao gh como argumento (A5 da revisao): com NUL ele nao passa, e vale o corpo padrao.
+        // O corpo vai ao gh por um arquivo temporario 600, nunca pelo argv; com NUL ele nao e texto de PR, e vale o corpo padrao.
         return texto.includes('\0') ? null : { arquivo, texto };
     }
     catch {
@@ -360,13 +400,13 @@ function tituloDoPr(t, corpo) {
         if (!l)
             continue;
         const m = /^#{1,6}\s+(.+)$/.exec(l);
-        titulo = m ? umaLinha(m[1], 120) : null;
+        titulo = m ? (0, texto_1.umaLinha)(m[1], 120) : null;
         break;
     }
     const prefixo = `ship(${t.id})`;
     if (titulo?.startsWith(prefixo))
         return titulo;
-    return `${prefixo}: ${titulo ?? umaLinha(t.nome || t.id, 120)}`;
+    return `${prefixo}: ${titulo ?? (0, texto_1.umaLinha)(t.nome || t.id, 120)}`;
 }
 /** Uma palavra do shell entre aspas simples: nada dentro dela vira comando, nem `;`, `$`, crase ou barra. */
 function entreAspas(s) {
@@ -374,10 +414,21 @@ function entreAspas(s) {
 }
 /**
  * O que o dono roda no proprio terminal quando o modo da thread nao autoriza o push. A branch e a base vem do estado e do
- * manifesto, que podem ser do clone: cada parte vai entre aspas simples (A4 da revisao).
+ * manifesto, que podem ser do clone: cada parte vai entre aspas simples (A4 da revisao). No GitLab, a descricao vai pelo
+ * `--description-file` (ou o titulo, sem `pr-body.md`) e nunca pelo `--fill`, que empurra a branch e pode trocar o titulo;
+ * o `glab mr create` nao arma merge.
  */
-function comandoDoDono(remoto, base, branch, titulo, comCorpo) {
-    return `git push -u ${entreAspas(remoto)} ${entreAspas(branch)} && gh pr create --base ${entreAspas(base)} --head ${entreAspas(branch)} ` +
+function comandoDoDono(remoto, base, branch, titulo, comCorpo, tipo = 'github') {
+    if (tipo === null) {
+        const gh = comandoDoDono(remoto, base, branch, titulo, comCorpo, 'github'), glab = comandoDoDono(remoto, base, branch, titulo, comCorpo, 'gitlab');
+        return (0, locale_1.textoDoCatalogo)((m) => m.ship.publicar.comandoDasDuasForjas(gh, glab));
+    }
+    const push = `git push -u ${entreAspas(remoto)} ${entreAspas(branch)}`;
+    if (tipo === 'gitlab') {
+        return `${push} && glab mr create --source-branch ${entreAspas(branch)} --target-branch ${entreAspas(base)} --title ${entreAspas(titulo)} ` +
+            `${comCorpo ? `--description-file ${entreAspas(comCorpo)}` : `--description ${entreAspas(titulo)}`} --yes`;
+    }
+    return `${push} && gh pr create --base ${entreAspas(base)} --head ${entreAspas(branch)} ` +
         `--title ${entreAspas(titulo)} ${comCorpo ? `--body-file ${entreAspas(comCorpo)}` : '--fill'}`;
 }
 /**
@@ -390,7 +441,6 @@ function publicarEntrega(carregado, threadId, opcoes = {}) {
     const remoto = (0, branch_de_estado_1.exigirRemoto)(opcoes.remoto ?? 'origin', 'ship');
     const quando = opcoes.quando ?? new Date().toISOString();
     const dryRun = opcoes.dryRun === true;
-    const executor = opcoes.executorGh ?? parado_no_condutor_1.ghPadrao;
     const p = (m) => m.ship.publicar;
     const r = {
         contrato: exports.CONTRATO_DA_PUBLICACAO, thread: threadId, modo: null, tag: null, acao: 'recusada', motivo: null,
@@ -404,7 +454,7 @@ function publicarEntrega(carregado, threadId, opcoes = {}) {
         lida = (0, thread_1.lerThread)(raiz, threadId);
     }
     catch (e) {
-        return recusar('artifact.missing', (0, locale_1.textoDoCatalogo)((m) => p(m).threadInexistente(umaLinha(threadId, 80), deFora(e.message))), (0, locale_1.textoDoCatalogo)((m) => p(m).threadInexistenteCorrecao));
+        return recusar('artifact.missing', (0, locale_1.textoDoCatalogo)((m) => p(m).threadInexistente((0, texto_1.umaLinha)(threadId, 80), (0, texto_1.deFora)(e.message))), (0, locale_1.textoDoCatalogo)((m) => p(m).threadInexistenteCorrecao));
     }
     const t = lida;
     r.thread = t.id;
@@ -413,6 +463,11 @@ function publicarEntrega(carregado, threadId, opcoes = {}) {
     if (t.status === 'fechada') {
         return recusar('artifact.missing', (0, locale_1.textoDoCatalogo)((m) => p(m).threadFechada(t.id)), (0, locale_1.textoDoCatalogo)((m) => p(m).threadFechadaCorrecao));
     }
+    // RM-058, integração (T1.1, D3 da ork-rm058integra): a thread de um arco #Noctum que a guarda só é publicada pelo próprio
+    // arco (`doArco`). Antes de qualquer git, e sem ledger, como as outras recusas daqui.
+    const guarda = (0, noctum_guarda_1.guardaDaThread)(raiz, t.id, quando, { doArco: opcoes.doArco });
+    if (guarda)
+        return { ...recusar('policy.violation', guarda.detalhe, guarda.correcao), codigo: guarda.motivo };
     const refs = (0, parado_no_condutor_1.refsLocais)(raiz, remoto);
     const baseRef = refDaBase(refs, remoto, base);
     const f = fatosDaThread(carregado, t, refs, baseRef, quando);
@@ -421,7 +476,7 @@ function publicarEntrega(carregado, threadId, opcoes = {}) {
     const corpo = corpoDaThread(raiz, t.id);
     // 2. O modo que ja autoriza push (D1): fora dele, o push e do dono, e a correcao diz o comando dele.
     if (!exports.MODOS_QUE_PUBLICAM.includes(t.modo)) {
-        const comando = comandoDoDono(remoto, base, f.branch, tituloDoPr(t, corpo?.texto ?? null), corpo ? path.relative(raiz, corpo.arquivo) : null);
+        const comando = comandoDoDono(remoto, base, f.branch, tituloDoPr(t, corpo?.texto ?? null), corpo ? path.relative(raiz, corpo.arquivo) : null, tipoSemRede(carregado, remoto, opcoes.forja ? 'github' : opcoes.forjaResolvida?.tipo));
         return recusar('human.pending', (0, locale_1.textoDoCatalogo)((m) => p(m).modoSemPush((0, modos_1.tagDoModo)(t.modo))), (0, locale_1.textoDoCatalogo)((m) => p(m).modoSemPushCorrecao(comando)));
     }
     // 3. Ninguem conduz a thread agora: a branch pode mudar no meio da publicacao.
@@ -451,22 +506,28 @@ function publicarEntrega(carregado, threadId, opcoes = {}) {
     if (!git(raiz, ['remote', 'get-url', '--', remoto]).ok) {
         return recusar('runtime.unavailable', (0, locale_1.textoDoCatalogo)((m) => p(m).semRemoto(remoto)), (0, locale_1.textoDoCatalogo)((m) => p(m).semRemotoCorrecao));
     }
-    const forja = opcoes.forja ?? (0, parado_no_condutor_1.githubDoRemoto)(raiz, remoto);
-    if (!forja)
-        return recusar('runtime.unavailable', (0, locale_1.textoDoCatalogo)((m) => p(m).semForja(remoto)), (0, locale_1.textoDoCatalogo)((m) => p(m).semForjaCorrecao));
+    const daForja = pedidosDaEntrega(carregado, remoto, opcoes);
+    if (!daForja.ok) {
+        const erro = daForja.erro;
+        return recusar('runtime.unavailable', (0, locale_1.textoDoCatalogo)((m) => p(m).semForja(remoto, erro ? m.forja.motivo(erro, null) : null)), (0, locale_1.textoDoCatalogo)((m) => p(m).semForjaCorrecao));
+    }
+    const pedidos = daForja.pedidos;
+    const noGitlab = pedidos.tipo === 'gitlab';
+    const rede = (m) => (noGitlab ? p(m).redeCorrecaoGitlab : p(m).redeCorrecao);
     // 9. A ponta no remoto e os PRs da branch, antes de qualquer efeito.
     const provaDoPush = `git ls-remote ${remoto} refs/heads/${f.branch}`;
     const antes = pontaNoRemoto(raiz, remoto, f.branch);
     r.passos.push(provaDoPush);
     if (antes.erro !== null) {
-        return recusar('runtime.unavailable', (0, locale_1.textoDoCatalogo)((m) => p(m).lsRemoteFalhou(remoto, antes.erro ?? '-')), (0, locale_1.textoDoCatalogo)((m) => p(m).redeCorrecao));
+        return recusar('runtime.unavailable', (0, locale_1.textoDoCatalogo)((m) => p(m).lsRemoteFalhou(remoto, antes.erro ?? '-')), (0, locale_1.textoDoCatalogo)(rede));
     }
     r.remotaAntes = antes.sha;
     r.remota = antes.sha;
-    const lidos = prsDaBranch(executor, forja, base, f.branch);
-    r.passos.push(`gh pr list --head ${f.branch} --state all`);
+    const lidos = pedidos.listar(base, f.branch);
+    r.passos.push(pedidos.passoDaLista(f.branch));
     if (lidos.erro !== null) {
-        return recusar('runtime.unavailable', (0, locale_1.textoDoCatalogo)((m) => p(m).prsFalharam(lidos.erro ?? '-')), (0, locale_1.textoDoCatalogo)((m) => p(m).redeCorrecao));
+        const erro = lidos.erro;
+        return recusar('runtime.unavailable', (0, locale_1.textoDoCatalogo)((m) => noGitlab ? p(m).prsFalharamGitlab(erro) : p(m).prsFalharam(erro)), (0, locale_1.textoDoCatalogo)(rede));
     }
     const aberto = lidos.prs.find((x) => x.estado === 'aberto') ?? null;
     const mesclado = lidos.prs.find((x) => x.estado === 'mesclado' && x.head === head) ?? null;
@@ -475,11 +536,11 @@ function publicarEntrega(carregado, threadId, opcoes = {}) {
     // A2 da revisao: o PR mesclado no HEAD ja e a entrega, com ou sem a branch no remoto (o GitHub pode te-la apagado).
     if (mesclado && !aberto) {
         return { ...r, acao: 'ja-publicada', pr: { numero: mesclado.numero, url: mesclado.url, criado: false, head: mesclado.head },
-            detalhe: (0, locale_1.textoDoCatalogo)((m) => p(m).jaMesclado(mesclado.numero)), correcao: (0, locale_1.textoDoCatalogo)((m) => p(m).registreAEntrega(t.id)) };
+            detalhe: (0, locale_1.textoDoCatalogo)((m) => p(m).jaMesclado(mesclado.numero, noGitlab)), correcao: (0, locale_1.textoDoCatalogo)((m) => p(m).registreAEntrega(t.id)) };
     }
     if (noRemoto && aberto) {
         return { ...r, acao: 'ja-publicada', pr: { numero: aberto.numero, url: aberto.url, criado: false, head: aberto.head },
-            detalhe: (0, locale_1.textoDoCatalogo)((m) => p(m).jaPublicada(aberto.numero)) };
+            detalhe: (0, locale_1.textoDoCatalogo)((m) => p(m).jaPublicada(aberto.numero, noGitlab)) };
     }
     // O remoto com commit que a branch local nao tem, ou que esta copia nem conhece (A3 da revisao): o push sem forca
     // seria recusado. Nunca forcar.
@@ -488,8 +549,9 @@ function publicarEntrega(carregado, threadId, opcoes = {}) {
     }
     r.corpo = corpo ? 'pr-body.md' : 'padrao';
     const titulo = tituloDoPr(t, corpo?.texto ?? null);
-    // A5 da revisao: o corpo vai ao gh como texto, o mesmo que foi lido agora; o gh nunca reabre o arquivo.
-    const textoDoCorpo = corpo?.texto ?? (0, locale_1.textoDoCatalogo)((m) => p(m).corpoPadrao((0, modos_1.tagDoModo)(t.modo), f.branch, curto(head), carregado.manifesto.ci.context || 'ork-verify'));
+    // A5 da revisao: o corpo e o texto lido agora, gravado num arquivo temporario 600 so para o `gh pr create`
+    // (`--body-file`); o gh nunca reabre o `pr-body.md`.
+    const textoDoCorpo = corpo?.texto ?? (0, locale_1.textoDoCatalogo)((m) => p(m).corpoPadrao((0, modos_1.tagDoModo)(t.modo), f.branch, curto(head), carregado.manifesto.ci.context || 'ork-verify', noGitlab));
     // B1 da revisao: o push leva o sha conferido, e nao a ref: o commit que chegue a branch depois das conferencias fica
     // fora desta publicacao.
     const refspec = `${head}:refs/heads/${f.branch}`;
@@ -497,10 +559,10 @@ function publicarEntrega(carregado, threadId, opcoes = {}) {
         const passos = [...r.passos];
         if (!noRemoto)
             passos.push(`git push -- ${remoto} ${refspec}`, provaDoPush);
-        passos.push(aberto ? (0, locale_1.textoDoCatalogo)((m) => p(m).passoReaproveita(aberto.numero))
-            : `gh pr create --base ${base} --head ${f.branch} --title "${titulo}" --body <${corpo ? 'pr-body.md' : 'padrao'}>`);
+        passos.push(aberto ? (0, locale_1.textoDoCatalogo)((m) => p(m).passoReaproveita(aberto.numero, noGitlab))
+            : pedidos.ensaioDaCriacao(base, f.branch, titulo, corpo ? 'pr-body.md' : 'padrao'));
         return { ...r, acao: 'publicaria', passos, pr: aberto ? { numero: aberto.numero, url: aberto.url, criado: false, head: aberto.head } : null,
-            detalhe: (0, locale_1.textoDoCatalogo)((m) => p(m).publicaria(curto(head), aberto?.numero ?? null)) };
+            detalhe: (0, locale_1.textoDoCatalogo)((m) => p(m).publicaria(curto(head), aberto?.numero ?? null, noGitlab)) };
     }
     // A evidencia de cada efeito, com a prova ou a falta dela.
     let pushFeito = false;
@@ -511,6 +573,9 @@ function publicarEntrega(carregado, threadId, opcoes = {}) {
     });
     // Efeito 1: o push sem forca do sha conferido, provado pelo ls-remote.
     if (!noRemoto) {
+        const conferido = opcoes.antesDoEfeito?.('push') ?? null;
+        if (conferido)
+            return recusar('policy.violation', conferido.recusa, conferido.correcao);
         const argv = ['push', '--', remoto, refspec];
         const push = (opcoes.executorGit ?? ((args, prazoMs) => git(raiz, args, prazoMs)))(argv, PRAZO_DO_PUSH_MS);
         r.passos.push(`git ${argv.join(' ')}`);
@@ -521,9 +586,9 @@ function publicarEntrega(carregado, threadId, opcoes = {}) {
         // O push que saiu com erro mas chegou (o prazo venceu depois da escrita no remoto) conta: quem decide e o ls-remote.
         pushFeito = push.ok || r.pushVerificado;
         if (!pushFeito) {
-            const erro = deFora(push.stderr || push.stdout || `codigo ${push.code}`, 300);
+            const erro = (0, texto_1.deFora)(push.stderr || push.stdout || `codigo ${push.code}`, 300);
             const recusado = /rejected|non-fast-forward|fetch first|stale info|failed to update ref/i.test(erro);
-            return recusar(recusado ? 'tree.blocked' : 'runtime.unavailable', (0, locale_1.textoDoCatalogo)((m) => p(m).pushFalhou(remoto, f.branch, erro)), (0, locale_1.textoDoCatalogo)((m) => recusado ? p(m).remotoDivergiuCorrecao(remoto, f.branch) : p(m).redeCorrecao));
+            return recusar(recusado ? 'tree.blocked' : 'runtime.unavailable', (0, locale_1.textoDoCatalogo)((m) => p(m).pushFalhou(remoto, f.branch, erro)), (0, locale_1.textoDoCatalogo)((m) => recusado ? p(m).remotoDivergiuCorrecao(remoto, f.branch) : rede(m)));
         }
         if (!r.pushVerificado) {
             // B1 da revisao: o push aconteceu e o remoto nao mostra o HEAD; a tentativa vai ao ledger com o que ele respondeu.
@@ -535,35 +600,41 @@ function publicarEntrega(carregado, threadId, opcoes = {}) {
     let pr = aberto ? { numero: aberto.numero, url: aberto.url, criado: false, head: aberto.head } : null;
     let erroDoPr = null;
     if (!pr) {
-        const argv = ['pr', 'create', `--repo=${forja.host}/${forja.repositorio}`, `--base=${base}`, `--head=${f.branch}`, `--title=${titulo}`,
-            `--body=${textoDoCorpo}`];
-        const criado = executor(argv, PRAZO_DO_GH_MS);
-        r.passos.push(`gh pr create --base ${base} --head ${f.branch}`);
-        const relidos = prsDaBranch(executor, forja, base, f.branch);
-        r.passos.push(`gh pr list --head ${f.branch} --state all   (prova do PR)`);
+        const conferido = opcoes.antesDoEfeito?.('pr', { titulo, corpo: textoDoCorpo }) ?? null;
+        if (conferido) {
+            // O push desta chamada aconteceu: ele vai ao ledger com a prova, e o PR fica para depois (B1 da revisao).
+            if (pushFeito)
+                gravar({ pr: null, prRecusado: conferido.recusa.slice(0, 300) });
+            return recusar('policy.violation', conferido.recusa, conferido.correcao);
+        }
+        const criado = pedidos.abrir(base, f.branch, titulo, textoDoCorpo);
+        r.passos.push(pedidos.passoDaCriacao(base, f.branch));
+        const relidos = pedidos.listar(base, f.branch);
+        r.passos.push(`${pedidos.passoDaLista(f.branch)}   (prova do PR)`);
         const achado = relidos.prs.find((x) => x.estado === 'aberto') ?? null;
         if (achado)
             pr = { numero: achado.numero, url: achado.url, criado: criado.status === 0, head: achado.head };
         else {
-            erroDoPr = criado.status !== 0 ? deFora(criado.stderr || criado.stdout || `codigo ${criado.status ?? '-'}`)
-                : relidos.erro ?? (0, locale_1.textoDoCatalogo)((m) => p(m).prSemReleitura);
+            erroDoPr = criado.status !== 0 ? (0, texto_1.deFora)(criado.stderr || criado.stdout || `codigo ${criado.status ?? '-'}`)
+                : relidos.erro ?? (0, locale_1.textoDoCatalogo)((m) => noGitlab ? p(m).prSemReleituraGitlab : p(m).prSemReleitura);
         }
     }
     r.pr = pr;
     // A evidencia: so com efeito (push ou PR novo), com a prova.
     if (pushFeito || pr?.criado || erroDoPr) {
         gravar({ pr: pr ? { numero: pr.numero, url: pr.url, criado: pr.criado, head: pr.head } : null,
-            ...(pr ? { provaDoPr: `gh pr list --head ${f.branch} --state all` } : {}), ...(erroDoPr ? { erroDoPr } : {}) });
+            ...(pr ? { provaDoPr: pedidos.passoDaLista(f.branch) } : {}), ...(erroDoPr ? { erroDoPr } : {}) });
     }
     if (erroDoPr) {
-        return recusar('runtime.unavailable', (0, locale_1.textoDoCatalogo)((m) => p(m).prFalhou(curto(head), erroDoPr ?? '-')), (0, locale_1.textoDoCatalogo)((m) => p(m).prFalhouCorrecao(t.id)));
+        const erro = erroDoPr;
+        return recusar('runtime.unavailable', (0, locale_1.textoDoCatalogo)((m) => noGitlab ? p(m).prFalhouGitlab(curto(head), erro) : p(m).prFalhou(curto(head), erro)), (0, locale_1.textoDoCatalogo)((m) => noGitlab ? p(m).prFalhouCorrecaoGitlab(t.id) : p(m).prFalhouCorrecao(t.id)));
     }
     // S7 da revisao: sem push e sem PR aberto por este processo, quem publicou foi outro; a entrega ja estava publicada.
     if (!pushFeito && !pr?.criado) {
-        return { ...r, acao: 'ja-publicada', motivo: null, correcao: '', detalhe: (0, locale_1.textoDoCatalogo)((m) => p(m).jaPublicada(pr?.numero ?? 0)) };
+        return { ...r, acao: 'ja-publicada', motivo: null, correcao: '', detalhe: (0, locale_1.textoDoCatalogo)((m) => p(m).jaPublicada(pr?.numero ?? 0, noGitlab)) };
     }
     return { ...r, acao: 'publicou', motivo: null, correcao: '',
-        detalhe: (0, locale_1.textoDoCatalogo)((m) => p(m).publicou(curto(head), pr?.numero ?? 0, pr?.criado === true)) };
+        detalhe: (0, locale_1.textoDoCatalogo)((m) => p(m).publicou(curto(head), pr?.numero ?? 0, pr?.criado === true, noGitlab)) };
 }
 /** As linhas da saida de texto do `ork ship publicar`, no locale ativo. */
 function linhasDaPublicacao(r) {
@@ -580,8 +651,9 @@ function linhasDaPublicacao(r) {
             linhas.push(r.pushVerificado ? p.linhaPushProvado : p.linhaPushSemProva);
         }
     }
+    // O MR do GitLab se reconhece pelos passos, que dizem a CLI de cada forja.
     if (r.pr)
-        linhas.push(p.linhaPr(r.pr.numero, r.pr.criado, r.pr.url ?? ''));
+        linhas.push(p.linhaPr(r.pr.numero, r.pr.criado, r.pr.url ?? '', r.passos.some((x) => x.startsWith('glab '))));
     if (r.corpo)
         linhas.push(p.linhaCorpo(r.corpo));
     if (r.acao === 'recusada')
@@ -626,9 +698,62 @@ function entregaLocal(raiz, f, remotas, remoto, base) {
     const naEntrega = (passouDoCheck && f.comProduto) || (!!remota && f.comProduto) || mergeSemRegistro || entregue;
     return { remota, entregue, merge, mergeSemRegistro, naEntrega };
 }
+/** Quantas branches a pista confere uma a uma no GitLab por chamada; as outras ficam "sem conferir". */
+const MRS_CONFERIDOS_POR_LEITURA = 20;
+/** Os MRs das branches candidatas, uma leitura por branch; a primeira que falha deixa a lista sem leitura. */
+function lerMrsDasCandidatas(pedidos, base, candidatas) {
+    const prs = [], semConferir = [];
+    for (const [i, branch] of [...new Set(candidatas)].entries()) {
+        if (i >= MRS_CONFERIDOS_POR_LEITURA) {
+            semConferir.push(branch);
+            continue;
+        }
+        const lidos = pedidos.listar(base, branch);
+        if (lidos.erro !== null)
+            return { erro: lidos.erro };
+        prs.push(...lidos.prs);
+    }
+    return { prs, semConferir };
+}
+/**
+ * A etapa `ci` do MR aberto pela CI do head. O mesmo mapa do rollup do GitHub: `success` e `bloqueado` (`manual`,
+ * `skipped`) sao verdes, vermelho e falhou, pendente e ausente esperam, e a leitura que falhou nao e lida.
+ */
+function etapaDaCiNoHead(ci, contexto, pr) {
+    const c = (m) => m.ship.publicar;
+    if (ci.state === 'success' || (ci.state === 'failure' && ci.bloqueado)) {
+        return etapa('ci', 'feita', (0, locale_1.textoDoCatalogo)((m) => c(m).ciVerde(contexto, curto(pr.head))));
+    }
+    if (ci.state === 'failure')
+        return etapa('ci', 'falhou', (0, locale_1.textoDoCatalogo)((m) => c(m).ciVermelho(contexto, pr.numero, true)));
+    if (ci.state === 'pending')
+        return etapa('ci', 'pendente', (0, locale_1.textoDoCatalogo)((m) => c(m).ciEsperando(contexto, pr.numero, true)));
+    if (ci.state === 'missing')
+        return etapa('ci', 'pendente', (0, locale_1.textoDoCatalogo)((m) => c(m).ciSemCheck(contexto, pr.numero, true)));
+    return etapa('ci', 'nao-lida', ci.detail);
+}
+/**
+ * O GitLab do remoto, quando e ele; `null` deixa a pista no caminho do GitHub de sempre. `erro` quando o remoto e do
+ * GitLab (pelo bloco `forja:` ou pelo host conhecido) e a forja nao resolveu: a pista diz "sem leitura", nunca "sem MR".
+ */
+function gitlabDaPista(carregado, remoto, opcoes) {
+    if (opcoes.forja)
+        return null;
+    if (opcoes.forjaResolvida)
+        return opcoes.forjaResolvida.tipo === 'gitlab' ? opcoes.forjaResolvida : null;
+    // So o remoto que ja se sabe do GitLab, sem rede, passa pela resolucao aqui; o host proprio sem tipo e resolvido
+    // uma vez pela pista, como o pulse o resolveria, e o resto segue pelo caminho do GitHub.
+    if (tipoSemRede(carregado, remoto) !== 'gitlab')
+        return null;
+    const r = (0, entrega_pr_1.forjaDaEntrega)(carregado, remoto, opcoes.sondas);
+    if (r.ok)
+        return r.valor.tipo === 'gitlab' ? r.valor : null;
+    return r.erro ? { erro: r.erro } : null;
+}
 /** O que a pista de uma thread diz, das leituras ja feitas. */
 function pistaDaThread(carregado, f, local, leitura) {
     const { t } = f;
+    const gl = leitura.tipo === 'gitlab';
     const raiz = carregado.raiz;
     const { remota, entregue, merge, mergeSemRegistro } = local;
     const pr = leitura.prs ? prDaBranchNaLista(leitura.prs, f.branch, f.head) : null;
@@ -666,24 +791,25 @@ function pistaDaThread(carregado, f, local, leitura) {
         conflitoEtapa = etapa('conflito', 'nao-lida', texto);
     }
     else if (!pr || pr.estado === 'fechado') {
-        prEtapa = etapa('pr', 'pendente', pr ? (0, locale_1.textoDoCatalogo)((m) => c(m).prFechado(pr.numero)) : (0, locale_1.textoDoCatalogo)((m) => c(m).semPr));
+        prEtapa = etapa('pr', 'pendente', pr ? (0, locale_1.textoDoCatalogo)((m) => c(m).prFechado(pr.numero, gl)) : (0, locale_1.textoDoCatalogo)((m) => c(m).semPr));
         ciEtapa = etapa('ci', leitura.ciExigido ? 'pendente' : 'nao-se-aplica', (0, locale_1.textoDoCatalogo)((m) => leitura.ciExigido ? c(m).ciSemPr : c(m).ciNaoExigido));
         conflitoEtapa = etapa('conflito', 'nao-se-aplica', (0, locale_1.textoDoCatalogo)((m) => c(m).conflitoSemPr));
     }
     else if (pr.estado === 'mesclado') {
-        prEtapa = etapa('pr', 'feita', (0, locale_1.textoDoCatalogo)((m) => c(m).prMesclado(pr.numero)));
+        prEtapa = etapa('pr', 'feita', (0, locale_1.textoDoCatalogo)((m) => c(m).prMesclado(pr.numero, gl)));
         ciEtapa = etapa('ci', 'nao-se-aplica', (0, locale_1.textoDoCatalogo)((m) => c(m).ciDoMesclado));
-        conflitoEtapa = etapa('conflito', 'feita', (0, locale_1.textoDoCatalogo)((m) => c(m).prMesclado(pr.numero)));
+        conflitoEtapa = etapa('conflito', 'feita', (0, locale_1.textoDoCatalogo)((m) => c(m).prMesclado(pr.numero, gl)));
     }
     else {
-        prEtapa = etapa('pr', 'feita', (0, locale_1.textoDoCatalogo)((m) => pr.rascunho ? c(m).prRascunho(pr.numero) : c(m).prAberto(pr.numero)));
+        prEtapa = etapa('pr', 'feita', (0, locale_1.textoDoCatalogo)((m) => pr.rascunho ? c(m).prRascunho(pr.numero, gl) : c(m).prAberto(pr.numero, gl)));
         const check = pr.checks.find((k) => k.nome === leitura.contexto);
         ciEtapa = !leitura.ciExigido ? etapa('ci', 'nao-se-aplica', (0, locale_1.textoDoCatalogo)((m) => c(m).ciNaoExigido))
-            : !check ? etapa('ci', 'pendente', (0, locale_1.textoDoCatalogo)((m) => c(m).ciSemCheck(leitura.contexto, pr.numero)))
-                : check.situacao === 'verde' ? etapa('ci', 'feita', (0, locale_1.textoDoCatalogo)((m) => c(m).ciVerde(leitura.contexto, curto(pr.head))))
-                    : check.situacao === 'vermelho' ? etapa('ci', 'falhou', (0, locale_1.textoDoCatalogo)((m) => c(m).ciVermelho(leitura.contexto, pr.numero)))
-                        : etapa('ci', 'pendente', (0, locale_1.textoDoCatalogo)((m) => c(m).ciEsperando(leitura.contexto, pr.numero)));
-        conflitoEtapa = pr.conflito === true ? etapa('conflito', 'falhou', (0, locale_1.textoDoCatalogo)((m) => c(m).conflito(pr.numero)))
+            : leitura.ciDoPedido ? leitura.ciDoPedido(pr)
+                : !check ? etapa('ci', 'pendente', (0, locale_1.textoDoCatalogo)((m) => c(m).ciSemCheck(leitura.contexto, pr.numero, gl)))
+                    : check.situacao === 'verde' ? etapa('ci', 'feita', (0, locale_1.textoDoCatalogo)((m) => c(m).ciVerde(leitura.contexto, curto(pr.head))))
+                        : check.situacao === 'vermelho' ? etapa('ci', 'falhou', (0, locale_1.textoDoCatalogo)((m) => c(m).ciVermelho(leitura.contexto, pr.numero, gl)))
+                            : etapa('ci', 'pendente', (0, locale_1.textoDoCatalogo)((m) => c(m).ciEsperando(leitura.contexto, pr.numero, gl)));
+        conflitoEtapa = pr.conflito === true ? etapa('conflito', 'falhou', (0, locale_1.textoDoCatalogo)((m) => c(m).conflito(pr.numero, gl)))
             : pr.conflito === false ? etapa('conflito', 'feita', (0, locale_1.textoDoCatalogo)((m) => c(m).semConflito))
                 : etapa('conflito', 'nao-lida', (0, locale_1.textoDoCatalogo)((m) => c(m).conflitoNaoCalculado));
     }
@@ -715,21 +841,21 @@ function pistaDaThread(carregado, f, local, leitura) {
     else if (branchEtapa.estado === 'pendente' || (prEtapa.estado === 'pendente')) {
         proximo = publicavel
             ? { acao: 'publicar', disponivel: true, comando: `ork ship publicar ${t.id}`,
-                texto: (0, locale_1.textoDoCatalogo)((m) => pr?.estado === 'aberto' ? c(m).proximoPublicarNoPr(pr.numero) : c(m).proximoPublicar) }
+                texto: (0, locale_1.textoDoCatalogo)((m) => pr?.estado === 'aberto' ? c(m).proximoPublicarNoPr(pr.numero, gl) : c(m).proximoPublicar) }
             : { acao: 'publicar', disponivel: false, texto: (0, locale_1.textoDoCatalogo)((m) => c(m).proximoDoDono(t.id, (0, modos_1.tagDoModo)(t.modo))),
-                comando: comandoDoDono(leitura.remoto, leitura.base, f.branch, tituloDoPr(t, corpo?.texto ?? null), corpo ? path.relative(raiz, corpo.arquivo) : null) };
+                comando: comandoDoDono(leitura.remoto, leitura.base, f.branch, tituloDoPr(t, corpo?.texto ?? null), corpo ? path.relative(raiz, corpo.arquivo) : null, leitura.tipo) };
     }
     else if (prEtapa.estado === 'nao-lida')
         proximo = nada(prEtapa.texto, `ork ship pista ${t.id}`);
     else if (conflitoEtapa.estado === 'falhou')
-        proximo = nada((0, locale_1.textoDoCatalogo)((m) => c(m).proximoConflito(pr?.numero ?? 0)));
+        proximo = nada((0, locale_1.textoDoCatalogo)((m) => c(m).proximoConflito(pr?.numero ?? 0, gl)));
     else if (ciEtapa.estado === 'falhou')
-        proximo = nada((0, locale_1.textoDoCatalogo)((m) => c(m).proximoCiVermelho(leitura.contexto, pr?.numero ?? 0)));
+        proximo = nada((0, locale_1.textoDoCatalogo)((m) => c(m).proximoCiVermelho(leitura.contexto, pr?.numero ?? 0, gl)));
     else if (ciEtapa.estado === 'pendente' || ciEtapa.estado === 'nao-lida') {
-        proximo = nada((0, locale_1.textoDoCatalogo)((m) => c(m).proximoEsperandoCi(leitura.contexto, pr?.numero ?? 0)), pr ? `ork ci status --sha ${pr.head}` : null);
+        proximo = nada((0, locale_1.textoDoCatalogo)((m) => c(m).proximoEsperandoCi(leitura.contexto, pr?.numero ?? 0, gl)), pr ? `ork ci status --sha ${pr.head}` : null);
     }
     else
-        proximo = nada((0, locale_1.textoDoCatalogo)((m) => pr?.rascunho ? c(m).proximoRascunho(pr.numero) : c(m).proximoMerge(pr?.numero ?? 0)));
+        proximo = nada((0, locale_1.textoDoCatalogo)((m) => pr?.rascunho ? c(m).proximoRascunho(pr.numero, gl) : c(m).proximoMerge(pr?.numero ?? 0, gl)));
     return {
         thread: t.id, nome: t.nome, modo: t.modo, tag: (0, modos_1.tagDoModo)(t.modo), publicavel, conduzida: !!f.conducao, branch: f.branch, head: f.head,
         remota, pr: pr ? { numero: pr.numero, url: pr.url, estado: pr.estado, rascunho: pr.rascunho, head: pr.head } : null,
@@ -771,18 +897,63 @@ function pistaDeEntrega(carregado, opcoes = {}) {
     let prsNaoLidos = null;
     let parcial = false;
     let semConferir = new Set();
+    let ciDoPedido;
+    let prsNaoLidosDoGitlab = false;
+    let doHostProprio;
     if (candidatas.length) {
-        const leitura = (0, parado_no_condutor_1.lerPrsDaForja)(carregado, { quando: lidoEm, executor: opcoes.executorGh, remoto, candidatas, forja: opcoes.forja });
-        if (leitura.ok) {
-            prs = leitura.retrato.prs;
-            parcial = leitura.retrato.parcial;
-            semConferir = new Set(leitura.retrato.semConferir ?? []);
+        let gitlab = gitlabDaPista(carregado, remoto, opcoes);
+        // Host proprio sem o bloco `forja:` (um GitLab como o de um piloto, ou um GitHub Enterprise): a forja e resolvida uma
+        // vez, como o pulse a resolve, e a leitura segue pela forja certa, com o mesmo criterio do gate no GitLab.
+        let naoResolvida = null;
+        if (!gitlab && !opcoes.forja && !opcoes.forjaResolvida && tipoSemRede(carregado, remoto) === null) {
+            const lido = (0, parado_no_condutor_1.forjaDoRemotoDoPulse)(carregado, remoto, { executor: opcoes.executorGh, sondas: opcoes.sondas });
+            if (!lido.ok)
+                naoResolvida = lido.erro;
+            else if (lido.forja.tipo === 'gitlab')
+                gitlab = lido.forja;
+            else
+                doHostProprio = lido.forja;
         }
-        else {
+        if (naoResolvida !== null) {
             prs = null;
-            prsNaoLidos = deFora(leitura.erro);
+            prsNaoLidos = (0, texto_1.deFora)(naoResolvida);
+        }
+        else if (gitlab && 'erro' in gitlab) {
+            prs = null;
+            prsNaoLidos = (0, locale_1.textoDoCatalogo)((m) => m.forja.motivo(gitlab.erro, 'gitlab'));
+            prsNaoLidosDoGitlab = true;
+        }
+        else if (gitlab) {
+            const lidos = lerMrsDasCandidatas(pedidosDoGitlab(gitlab, opcoes.api ?? {}), base, candidatas);
+            if ('erro' in lidos) {
+                prs = null;
+                prsNaoLidos = (0, texto_1.deFora)(lidos.erro);
+            }
+            else {
+                prs = lidos.prs;
+                semConferir = new Set(lidos.semConferir);
+            }
+            const ciDoHead = opcoes.ciDoHead ?? ((sha) => (0, ci_1.consultarCi)(carregado, sha, remoto, undefined, undefined, opcoes.sondas, opcoes.api));
+            ciDoPedido = (pr) => etapaDaCiNoHead(ciDoHead(pr.head), contexto, pr);
+        }
+        else {
+            const fixada = opcoes.forja ?? (opcoes.forjaResolvida?.tipo === 'github'
+                ? { host: (0, cli_1.hostDaApi)(opcoes.forjaResolvida), repositorio: opcoes.forjaResolvida.repo } : undefined);
+            const leitura = (0, parado_no_condutor_1.lerPrsDaForja)(carregado, { quando: lidoEm, executor: opcoes.executorGh, remoto, candidatas, forja: fixada,
+                resolvida: doHostProprio, sondas: opcoes.sondas });
+            if (leitura.ok) {
+                prs = leitura.retrato.prs;
+                parcial = leitura.retrato.parcial;
+                semConferir = new Set(leitura.retrato.semConferir ?? []);
+            }
+            else {
+                prs = null;
+                prsNaoLidos = (0, texto_1.deFora)(leitura.erro);
+            }
         }
     }
+    const tipo = ciDoPedido || prsNaoLidosDoGitlab ? 'gitlab' : doHostProprio ? 'github'
+        : tipoSemRede(carregado, remoto, opcoes.forja ? 'github' : opcoes.forjaResolvida?.tipo);
     // S8 da revisao (rodada 2): a candidata sem nenhum PR na leitura foi conferida uma a uma pelo `--head`, que a lista
     // cortada nao limita; so a que nao foi conferida, ou que so tem PR achado na lista cortada, fica em duvida.
     const comPrNaLeitura = new Set((prs ?? []).map((x) => x.branch));
@@ -791,7 +962,7 @@ function pistaDeEntrega(carregado, opcoes = {}) {
         : parcial && !conferida(branch) ? 'parcial' : null);
     const pistas = fatos.flatMap((f) => {
         const local = locais.get(f.t.id);
-        const x = local ? pistaDaThread(carregado, f, local, { remoto, base, remotasLidas: remotas !== null, prs, prsNaoLidos, corte, ciExigido, contexto })
+        const x = local ? pistaDaThread(carregado, f, local, { remoto, base, remotasLidas: remotas !== null, prs, prsNaoLidos, corte, ciExigido, contexto, tipo, ciDoPedido })
             : null;
         return x ? [x] : [];
     });