@orkastery/cli 0.5.6 → 0.6.1

package/dist/locale-ship.js

@@ -10,6 +10,8 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SHIP_EN = exports.SHIP_PT_BR = void 0;
+/** O pedido de merge pelo numero, como cada forja o escreve: `PR #n` no GitHub, `MR !n` no GitLab. */
+const rotuloDoPedido = (n, gitlab) => (gitlab ? `MR !${n}` : `PR #${n}`);
 exports.SHIP_PT_BR = {
     uso: 'uso: ork ship <thread-id> --para <branch> [--de <branch>] [--dry-run]',
     // textoDoShip
@@ -58,6 +60,10 @@ exports.SHIP_PT_BR = {
     contratoPublicoCorrecao: 'refaca a mudanca numa thread #Classic, #Maestro ou #Auto',
     ciReprovou: (detalhe, sha, contexto) => `${detalhe} (commit ${sha}, contexto ${contexto})`,
     ciReprovouCorrecao: (contexto) => `publique a branch, aguarde o check ${contexto} verde no GitHub e repita o SHIP`,
+    scanNaoVarrido: (categorias, sha) => `o security scan nao varreu estas categorias do laco no commit ${sha}: ${categorias} (ferramenta indisponivel, com falha ou sem relatorio)`,
+    passoAutorizariaSemScan: (quem, categorias, sha) => `ensaio: o ship real gravaria ship_unscanned_authorized por ${quem} para ${categorias} no commit ${sha}`,
+    allowUnscannedSemValor: 'erro: --allow-unscanned pede quem autoriza: ork ship <thread> --para <branch> --allow-unscanned "<quem>"',
+    scanNaoVarridoCorrecao: (thread) => `rode ork security-scan com Docker ou os binarios nativos e repita o SHIP; para entregar sem varredura, autorize: ork ship ${thread} --para <branch> --allow-unscanned "<quem>"`,
     arvoreDona: (dona, para, suja) => `${dona} (arvore que tem ${para} em check-out; ${suja ? 'SUJA, o ship reprovaria com tree.blocked' : 'limpa'})`,
     arvoreTemporaria: (dir, para) => `worktree temporaria em ${dir} (ninguem tem ${para} em check-out)`,
     arvoreDeMerge: (arvore) => `arvore de merge: ${arvore}`,
@@ -85,17 +91,31 @@ exports.SHIP_PT_BR = {
     semPrimeiroPaiCorrecao: 'confira o repositorio: o ship_done precisa do merge que entregou a thread',
     passoJaIncorporado: (de, para, sha) => `(nada a mergear: ${de} ja e ancestral de ${para}, incorporado em ${sha})`,
     pushFalhou: (remoto, para, erro) => `push para ${remoto}/${para} falhou: ${erro}`,
+    configDoRemotoInvalida: (chave) => `ship.config-do-remoto.invalida: a config do remoto aceita só pares -c chave=valor das chaves do transporte fixado (recusada: ${chave || 'forma inválida'}); nada foi passado ao git`,
     pushFalhouCorrecao: 'resolva o acesso ao remoto e rode o ship de novo (o merge local ja aconteceu)',
+    pushBaseProtegida: (remoto, para, erro) => `a proteção de ${remoto}/${para} recusou o push direto na base (entrega.base-protegida): ${erro}`,
+    pushBaseProtegidaCorrecao: (thread) => `entregue por PR/MR: ork ship publicar ${thread} (em #Auto e #Maestro) ou o pedido aberto na forja; depois do merge, ` +
+        `ork ship registrar-pr ${thread}. O merge local na base não chegou ao remoto`,
     pushSemProva: (sha, ponta) => `ls-remote devolveu ${sha ?? '(nada)'} e o destino local esta em ${ponta}: o push nao ficou provado`,
     pushSemProvaCorrecao: 'rode o ship de novo e confira o remoto',
     // ci.ts: o detalhe da consulta ao CI (vai ao ledger dentro da evidencia do ship)
     ciNaoExigidoDetalhe: 'gate de CI não exigido pelo manifesto',
-    ciRemotoNaoGithub: (remoto) => `remoto ${remoto} não é um repositório GitHub reconhecível`,
+    ciRemotoNaoGithub: (remoto) => `remoto ${remoto} não é um repositório GitHub reconhecível, nem GitLab`,
+    ciHostSemLogin: (host) => `o gh não está autenticado em ${host}: a CI desse host não foi consultada`,
+    ciForjaNaoResolvida: (remoto, motivo) => `a forja do remoto ${remoto} não foi resolvida: ${motivo}`,
     ciConsultaFalhou: 'consulta ao GitHub falhou',
     ciRespostaInvalida: 'GitHub devolveu uma resposta de checks inválida',
+    ciIncompleto: (contexto) => `check ${contexto}: a lista de check-runs ou de commit statuses do commit veio incompleta e o gate não decide sem ela inteira`,
+    ciStatusSemProdutorConfiavel: (contexto) => `${contexto}: só commit status de conta fora de ci.produtor; status verde só aprova de produtor aceito`,
+    ciSemProdutorAceito: (contexto, produtores, aceitos) => `${contexto}: verde só de produtor fora de ci.produtor (${produtores}); aceitos: ${aceitos}`,
+    ciProdutores: (contexto, produtores) => `check ${contexto} com mais de um produtor: ${produtores}`,
     ciSemCheck: (contexto) => `check ${contexto} não encontrado no commit`,
     ciVerde: 'CHECK independente verde no GitHub',
+    ciBloqueado: (contexto, conclusao) => `check ${contexto}: bloqueado (${conclusao})`,
     ciEstado: (contexto, status, conclusao) => `check ${contexto}: ${status}/${conclusao || 'sem conclusão'}`,
+    ciVerdeNoGitlab: 'CHECK independente verde no GitLab',
+    ciLeituraFalhou: (contexto, motivo) => `check ${contexto}: a CI não foi lida: ${motivo}`,
+    ciMescladoSemVinculo: (contexto, sha) => `ci.merged-results-sem-vinculo: o ${contexto} rodou só em pipeline de resultado mesclado sem vínculo provado com o head ${sha}; o gate não aprova`,
     // ork ship registrar-pr
     usoRegistrarPr: 'uso: ork ship registrar-pr <thread-id> [--repo <dono/nome> --pr <n>] | --todas [--remoto R] [--json] [--dry-run]',
     ensaio: 'Ensaio (--dry-run): nada foi gravado.',
@@ -103,7 +123,7 @@ exports.SHIP_PT_BR = {
     linhaDoRegistro: (thread, acao, motivo) => `  ${thread.padEnd(20)} ${acao.padEnd(13)} ${motivo}`,
     /** A acao e dado do `--json`; o texto so a traduz na impressao. */
     acoes: { 'registrou': 'registrou', 'registraria': 'registraria', 'ja-registrada': 'ja-registrada', 'sem-merge': 'sem-merge',
-        'recusada': 'recusada' },
+        'recusada': 'recusada', 'pulada': 'pulada' },
     avisoDeDocs: (n) => `Aviso: ${n} pagina(s) do roadmap com estado.codigo fora de "Mesclado" depois do merge; ` +
         'o push da base reprova em docs.paridade.merge:',
     docPendente: (id, arquivo, merge, thread, codigo) => `  ${id} (${arquivo}): merge ${merge} de ship(${thread}), estado.codigo "${codigo || 'vazio'}"`,
@@ -113,6 +133,9 @@ exports.SHIP_PT_BR = {
     // entrega-pr.ts: o motivo de cada registro (sai no --json)
     prThreadFechada: 'thread ja fechada',
     prSemMerge: (thread, remoto, base) => `nenhum merge ship(${thread}) em ${remoto}/${base}`,
+    prSemLeitura: (remoto, base) => `o git fetch de ${remoto}/${base} falhou: sem leitura do remoto nao ha como achar o merge`,
+    prSemVinculo: (thread, sha) => `o merge ${sha} de ship(${thread}) tem um pai so (squash ou rebase) e nao liga a base ao head verificado; entregue por merge commit`,
+    prSemHead: (n, repo, forja = 'GitHub') => `o ${rotuloDoPedido(n, forja === 'GitLab')} de ${repo} esta mesclado, mas o ${forja} nao informou o head`,
     prJaTemShipDone: 'esta entrega ja tem ship_done',
     prForaDaPonta: (merge, remoto, base) => `o merge ${merge} nao esta na ponta de ${remoto}/${base}`,
     prSemCiVerde: (detalhe) => `sem CI verde no head do PR: ${detalhe}`,
@@ -120,15 +143,44 @@ exports.SHIP_PT_BR = {
     prRegistrou: (merge) => `ship_done pelo merge ${merge} do PR`,
     prRepoNaoDeclarado: (repo) => `o repositorio ${repo} nao esta declarado em ci.external_repositories do orkastery.yaml`,
     prNumeroInvalido: (recebido) => `--pr precisa ser o numero do PR, recebido ${recebido}`,
-    prExternoJaTem: (n, repo) => `o PR #${n} de ${repo} ja tem ship_done`,
-    prConsultaFalhou: (n, repo) => `a consulta do PR #${n} de ${repo} ao GitHub falhou`,
-    prNaoMesclado: (n, repo) => `o PR #${n} de ${repo} nao esta mesclado`,
-    prNaoCitaThread: (n, repo, thread) => `o PR #${n} de ${repo} nao cita a thread ${thread} no titulo, no corpo nem na branch`,
-    prRepoFalhou: (repo) => `a consulta de ${repo} ao GitHub falhou`,
-    prOutraBase: (n, base, repo, padrao) => `o PR #${n} entrou em ${base}, e a branch padrao de ${repo} e ${padrao ?? 'desconhecida'}`,
+    prExternoJaTem: (n, repo, gitlab = false) => `o ${rotuloDoPedido(n, gitlab)} de ${repo} ja tem ship_done`,
+    prConsultaFalhou: (n, repo, forja = 'GitHub') => `a consulta do ${rotuloDoPedido(n, forja === 'GitLab')} de ${repo} ao ${forja} falhou`,
+    prNaoMesclado: (n, repo, gitlab = false) => `o ${rotuloDoPedido(n, gitlab)} de ${repo} nao esta mesclado`,
+    prNaoCitaThread: (n, repo, thread, gitlab = false) => `o ${rotuloDoPedido(n, gitlab)} de ${repo} nao cita a thread ${thread} no titulo, no corpo nem na branch`,
+    prRepoFalhou: (repo, forja = 'GitHub') => `a consulta de ${repo} ao ${forja} falhou`,
+    prOutraBase: (n, base, repo, padrao, gitlab = false) => `o ${rotuloDoPedido(n, gitlab)} entrou em ${base}, e a branch padrao de ${repo} e ${padrao ?? 'desconhecida'}`,
     prExternoForaDaPonta: (merge, repo, base) => `o merge ${merge} nao esta na ponta de ${repo}:${base}`,
-    prExternoRegistraria: (merge, n, repo) => `ensaio: registraria ship_done pelo merge ${merge} do PR #${n} de ${repo} (nada gravado)`,
-    prExternoRegistrou: (merge, n, repo) => `ship_done pelo merge ${merge} do PR #${n} de ${repo}`,
+    prForjaDoExterno: (repo, motivo) => `a forja de ${repo} não foi resolvida: ${motivo}`,
+    prForjaDoProjetoNaoResolvida: (repo, remoto, motivo) => `a forja do remoto ${remoto} não foi resolvida (${motivo}), e ${repo} não é consultado em outro host; declare forja.tipo no orkastery.yaml ou faça login na CLI da forja nesse host`,
+    prRepoComSubgrupoNoGithub: (repo) => `${repo} tem subgrupos, e um repositorio do GitHub e so dono/nome; num projeto do GitLab, o remoto ou forja.tipo: gitlab no orkastery.yaml diz a forja`,
+    prExternoRegistraria: (merge, n, repo, gitlab = false) => `ensaio: registraria ship_done pelo merge ${merge} do ${rotuloDoPedido(n, gitlab)} de ${repo} (nada gravado)`,
+    prExternoRegistrou: (merge, n, repo, gitlab = false) => `ship_done pelo merge ${merge} do ${rotuloDoPedido(n, gitlab)} de ${repo}`,
+    // RM-058, integração (T1.1 e D3 da ork-rm058integra): a guarda das threads do arco #Noctum nos caminhos de entrega de fora
+    // do arco (`noctum-guarda.ts`). O motivo tipado abre o texto, igual nas duas línguas.
+    guarda: {
+        situacoes: { 'proposto': 'proposto', 'agendado': 'agendado', 'vigente': 'vigente', 'expirado': 'expirado', 'revogado': 'revogado',
+            'encerrado': 'encerrado' },
+        origens: { 'envelope': 'pela lista do envelope', 'proposta': 'pela proposta que espera o dono', 'despacho': 'pelo log de despachos do arco',
+            'correlacao': 'pelo último despacho da thread', 'rede': 'pela rede do arco' },
+        doArco: (thread, arco, situacao, origem) => `noctum.guarda.thread-do-arco: a thread ${thread} é trabalho do arco ${arco} (${situacao}, ${origem})`,
+        doArcoCorrecao: (arco) => `a entrega desta thread é do passo da entrega do arco ${arco}: o SHIP e o MASTER dela são do arco (ork noctum status ${arco})`,
+        arcoIlegivel: (thread, arco, motivo) => `noctum.guarda.arco-ilegivel: o último despacho da thread ${thread} foi do arco ${arco}, e o arco não se lê (${motivo})`,
+        arcoIlegivelCorrecao: (arco) => `inspecione o arco antes de entregar a thread por fora dele (ork noctum status ${arco})`,
+        redeIlegivel: (thread, arco, motivo) => `noctum.guarda.rede-ilegivel: a thread ${thread} é trabalho do arco ${arco}, encerrado nesta máquina, e a rede não se lê (${motivo})`,
+        redeIlegivelCorrecao: (arco) => `restaure a leitura da rede antes de entregar a thread por fora do arco (ork noctum status ${arco})`,
+        redeDoArco: (thread, arco, estado, trabalho) => `noctum.guarda.thread-do-arco: a thread ${thread} é o trabalho ${trabalho} do arco ${arco}, ainda ${estado} na rede`,
+        redeDoArcoCorrecao: (arco) => `espere o trabalho terminar na rede ou entregue-o pelo passo da entrega do arco ${arco} (ork noctum status ${arco})`,
+        retencao: (thread, arco, situacao) => `noctum.guarda.thread-do-arco: o arco ${arco} (${situacao}) despachou a thread ${thread} por último; a batida e a Sentinela ` +
+            'não a despacham, não a retomam nem a mesclam até um despacho fora do arco ou um arco novo que a liste',
+        // A2 do CHECK: o arco terminou, e a sessão que ele despachou ainda conduz a thread.
+        sessaoDoArco: (thread, arco, situacao, sessao) => `noctum.guarda.thread-do-arco: o arco ${arco} está ${situacao}, e a sessão ${sessao} que ele despachou ainda conduz a thread ${thread}: ` +
+            'ela não entrega fora do arco',
+        sessaoDoArcoCorrecao: (arco) => `espere a parada que o fechamento do arco pede, ou pare a sessão; sem sessão do arco em voo, a thread se entrega à mão (ork noctum status ${arco})`,
+        // M3 do CHECK 3: a reserva pendente sem o id da sessão; não há sessão a parar, e quem a resolve é o vigia.
+        reservaDoArco: (thread, arco, situacao, seq) => `noctum.guarda.thread-do-arco: o arco ${arco} está ${situacao}, e a reserva ${seq} que ele fez para a thread ${thread} pode ter aberto ` +
+            'uma sessão sem id: ela não entrega fora do arco',
+        reservaDoArcoCorrecao: (arco) => `espere o vigia reconciliar a reserva (ele a conclui com a sessão ou a devolve); sem sessão do arco em voo, a thread se entrega à mão (ork noctum status ${arco})`,
+    },
     // RM-059 (F7, T7.1): `ork ship publicar` e `ork ship pista`. O detalhe, a correcao e o texto das etapas vao ao
     // `--json` e ao ledger em pt-BR; a impressao os remonta no locale do comando.
     publicar: {
@@ -141,7 +193,7 @@ exports.SHIP_PT_BR = {
         linhaRemoto: (remoto, antes, depois) => `  remoto        ${remoto}: ${depois} (antes: ${antes})`,
         linhaPushProvado: '  push          PROVADO pelo ls-remote (mesmo sha do HEAD)',
         linhaPushSemProva: '  push          sem prova',
-        linhaPr: (n, criado, url) => `  PR            #${n} ${criado ? 'aberto agora' : 'reaproveitado'}${url ? ` (${url})` : ''}`,
+        linhaPr: (n, criado, url, gitlab = false) => `  ${gitlab ? 'MR            !' : 'PR            #'}${n} ${criado ? 'aberto agora' : 'reaproveitado'}${url ? ` (${url})` : ''}`,
         linhaCorpo: (corpo) => `  corpo do PR   ${corpo}`,
         resultado: (acao) => `${acao}.`,
         acoes: { 'publicou': 'PUBLICADA', 'publicaria': 'PUBLICARIA', 'ja-publicada': 'JÁ PUBLICADA', 'recusada': 'RECUSADA' },
@@ -152,6 +204,8 @@ exports.SHIP_PT_BR = {
         threadFechadaCorrecao: 'a entrega nova vai numa thread nova',
         modoSemPush: (tag) => `o modo ${tag} pede a autorização do dono para o push; o ork ship publicar só publica em #Auto e #Maestro`,
         modoSemPushCorrecao: (comando) => `o dono publica do próprio terminal: ${comando}`,
+        /** O comando do dono quando o tipo da forja nao se sabe sem rede (host proprio sem o bloco `forja:`). */
+        comandoDasDuasForjas: (gh, glab) => `no GitHub, ${gh}; no GitLab, ${glab}`,
         conduzida: (sessao, fase) => `a sessão ${sessao} conduz a thread agora (fase ${fase}); a branch pode mudar no meio da publicação`,
         conduzidaCorrecao: (thread) => `publique depois do fim do turno (ork conducao status ${thread})`,
         semBranch: (branch) => `a branch ${branch} da thread não existe neste repositório`,
@@ -186,27 +240,32 @@ exports.SHIP_PT_BR = {
         bundleCorrecao: (thread) => `rode ork ci prepare ${thread} na worktree e commite o bundle como ci(${thread}): bundle`,
         semRemoto: (remoto) => `o remoto ${remoto} não está configurado neste repositório`,
         semRemotoCorrecao: 'configure o remoto (git remote add) ou informe outro em --remoto',
-        semForja: (remoto) => `o remoto ${remoto} não é um repositório do GitHub; o ork ship publicar abre PR só no GitHub`,
+        semForja: (remoto, motivo) => `o remoto ${remoto} não é um repositório do GitHub nem do GitLab${motivo ? ` (${motivo})` : ''}; o ork ship publicar abre PR/MR só nessas forjas`,
         semForjaCorrecao: 'publique a branch e abra o pedido de merge pela forja do remoto',
         lsRemoteFalhou: (remoto, erro) => `git ls-remote ${remoto} falhou: ${erro}`,
         prsFalharam: (erro) => `a lista de PRs da branch falhou: ${erro}`,
         redeCorrecao: 'confira a rede e o login do gh (gh auth status) e rode de novo',
-        jaPublicada: (n) => `a branch já está no remoto no HEAD e o PR #${n} está aberto; nada a fazer`,
-        jaMesclado: (n) => `o PR #${n} já foi mesclado no HEAD; nada a publicar`,
+        jaPublicada: (n, gitlab = false) => `a branch já está no remoto no HEAD e o ${rotuloDoPedido(n, gitlab)} está aberto; nada a fazer`,
+        jaMesclado: (n, gitlab = false) => `o ${rotuloDoPedido(n, gitlab)} já foi mesclado no HEAD; nada a publicar`,
         registreAEntrega: (thread) => `registre a entrega: ork ship registrar-pr ${thread}`,
         remotoDivergiu: (remoto, branch, sha) => `o remoto ${remoto} tem a branch ${branch} em ${sha}, com commit que a branch local não tem`,
         remotoDivergiuCorrecao: (remoto, branch) => `traga o remoto para a branch pela sessão de GO (git pull --no-rebase ${remoto} ${branch}) e publique de novo; nunca force`,
-        passoReaproveita: (n) => `reaproveita o PR #${n}, já aberto`,
-        publicaria: (sha, n) => `ensaio: publicaria o HEAD ${sha} e ${n ? `atualizaria o PR #${n}` : 'abriria o PR'} (nada foi feito)`,
+        passoReaproveita: (n, gitlab = false) => `reaproveita o ${rotuloDoPedido(n, gitlab)}, já aberto`,
+        publicaria: (sha, n, gitlab = false) => `ensaio: publicaria o HEAD ${sha} e ${n ? `atualizaria o ${rotuloDoPedido(n, gitlab)}` : `abriria o ${gitlab ? 'MR' : 'PR'}`} (nada foi feito)`,
         pushFalhou: (remoto, branch, erro) => `o push de ${branch} para ${remoto} falhou: ${erro}`,
         pushSemProva: (remota, head) => `o ls-remote devolveu ${remota ?? '(nada)'} e o HEAD está em ${head}: o push não ficou provado`,
         pushSemProvaCorrecao: (thread) => `confira o remoto e rode ork ship publicar ${thread} de novo`,
-        corpoPadrao: (tag, branch, sha, contexto) => `Publicado pelo ork ship publicar (modo ${tag}): a branch ${branch} no HEAD ${sha}, provada pelo ls-remote. ` +
-            `O CHECK independente roda no CI (${contexto}) a partir deste PR.`,
+        corpoPadrao: (tag, branch, sha, contexto, gitlab = false) => `Publicado pelo ork ship publicar (modo ${tag}): a branch ${branch} no HEAD ${sha}, provada pelo ls-remote. ` +
+            `O CHECK independente roda no CI (${contexto}) a partir deste ${gitlab ? 'MR' : 'PR'}.`,
         prSemReleitura: 'o PR não apareceu na releitura da lista',
         prFalhou: (sha, erro) => `a branch foi publicada e provada no HEAD ${sha}, mas o PR não abriu: ${erro}`,
         prFalhouCorrecao: (thread) => `confira o login do gh e rode ork ship publicar ${thread} de novo (o push já está provado)`,
-        publicou: (sha, n, criado) => `HEAD ${sha} publicado e provado; PR #${n} ${criado ? 'aberto agora' : 'reaproveitado'}`,
+        prsFalharamGitlab: (erro) => `a lista de MRs da branch falhou: ${erro}`,
+        redeCorrecaoGitlab: 'confira a rede e o login do glab no host (glab auth status) e rode de novo',
+        prSemReleituraGitlab: 'o MR não apareceu na releitura da lista',
+        prFalhouGitlab: (sha, erro) => `a branch foi publicada e provada no HEAD ${sha}, mas o MR não abriu: ${erro}`,
+        prFalhouCorrecaoGitlab: (thread) => `confira o login do glab e rode ork ship publicar ${thread} de novo (o push já está provado)`,
+        publicou: (sha, n, criado, gitlab = false) => `HEAD ${sha} publicado e provado; ${rotuloDoPedido(n, gitlab)} ${criado ? 'aberto agora' : 'reaproveitado'}`,
         // As etapas da pista
         remotoNaoLido: (remoto) => `o git ls-remote ${remoto} não respondeu`,
         branchPublicada: (sha) => `branch publicada no HEAD ${sha}`,
@@ -215,20 +274,20 @@ exports.SHIP_PT_BR = {
         prsNaoLidos: (erro) => `PRs não lidos: ${erro}`,
         prsCortados: (limite) => `a lista dos PRs abertos veio cortada nos ${limite} mais novos: o PR da branch não foi lido`,
         branchSemConferir: 'a branch ficou sem conferir nesta leitura da forja: o PR dela não foi lido',
-        prFechado: (n) => `o PR #${n} foi fechado sem merge`,
+        prFechado: (n, gitlab = false) => `o ${rotuloDoPedido(n, gitlab)} foi fechado sem merge`,
         semPr: 'sem PR da branch',
         ciSemPr: 'sem PR, o CI não roda',
         ciNaoExigido: 'CI não exigido pelo manifesto',
         conflitoSemPr: 'sem PR, sem conflito a medir',
-        prMesclado: (n) => `PR #${n} mesclado`,
+        prMesclado: (n, gitlab = false) => `${rotuloDoPedido(n, gitlab)} mesclado`,
         ciDoMesclado: 'PR mesclado; o ork ship registrar-pr confere o CI no head',
-        prRascunho: (n) => `PR #${n} aberto em rascunho`,
-        prAberto: (n) => `PR #${n} aberto`,
-        ciSemCheck: (contexto, n) => `o check ${contexto} ainda não apareceu no PR #${n}`,
+        prRascunho: (n, gitlab = false) => `${rotuloDoPedido(n, gitlab)} aberto em rascunho`,
+        prAberto: (n, gitlab = false) => `${rotuloDoPedido(n, gitlab)} aberto`,
+        ciSemCheck: (contexto, n, gitlab = false) => `o check ${contexto} ainda não apareceu no ${rotuloDoPedido(n, gitlab)}`,
         ciVerde: (contexto, sha) => `check ${contexto} verde no head ${sha}`,
-        ciVermelho: (contexto, n) => `check ${contexto} vermelho no PR #${n}`,
-        ciEsperando: (contexto, n) => `check ${contexto} em andamento no PR #${n}`,
-        conflito: (n) => `o PR #${n} conflita com a base`,
+        ciVermelho: (contexto, n, gitlab = false) => `check ${contexto} vermelho no ${rotuloDoPedido(n, gitlab)}`,
+        ciEsperando: (contexto, n, gitlab = false) => `check ${contexto} em andamento no ${rotuloDoPedido(n, gitlab)}`,
+        conflito: (n, gitlab = false) => `o ${rotuloDoPedido(n, gitlab)} conflita com a base`,
         semConflito: 'sem conflito com a base',
         conflitoNaoCalculado: 'o GitHub ainda não calculou o merge com a base',
         entregue: 'entregue: ship_done no ledger',
@@ -238,14 +297,14 @@ exports.SHIP_PT_BR = {
         proximoEntregue: 'entregue; o MASTER fecha a thread',
         proximoRegistrar: 'mesclado na base: registre a entrega',
         proximoConduzida: (sessao) => `a sessão ${sessao} conduz a thread agora; a entrega espera o fim do turno`,
-        proximoPublicarNoPr: (n) => `publique os commits novos no PR #${n}`,
+        proximoPublicarNoPr: (n, gitlab = false) => `publique os commits novos no ${rotuloDoPedido(n, gitlab)}`,
         proximoPublicar: 'publique a branch e abra o PR',
         proximoDoDono: (thread, tag) => `o modo ${tag} da ${thread} pede a sua autorização de push: publique do seu terminal`,
-        proximoConflito: (n) => `o PR #${n} conflita com a base: mescle a origin/main na worktree pela sessão de GO, rode o verify e regrave o bundle`,
-        proximoCiVermelho: (contexto, n) => `o check ${contexto} está vermelho no PR #${n}: corrija pela sessão de GO e publique de novo`,
-        proximoEsperandoCi: (contexto, n) => `esperando o check ${contexto} no PR #${n}`,
-        proximoRascunho: (n) => `o PR #${n} está em rascunho, com o CI verde: tire do rascunho; o merge é do dono ou do condutor`,
-        proximoMerge: (n) => `o PR #${n} está pronto para o merge, que é do dono ou do condutor`,
+        proximoConflito: (n, gitlab = false) => `o ${rotuloDoPedido(n, gitlab)} conflita com a base: mescle a origin/main na worktree pela sessão de GO, rode o verify e regrave o bundle`,
+        proximoCiVermelho: (contexto, n, gitlab = false) => `o check ${contexto} está vermelho no ${rotuloDoPedido(n, gitlab)}: corrija pela sessão de GO e publique de novo`,
+        proximoEsperandoCi: (contexto, n, gitlab = false) => `esperando o check ${contexto} no ${rotuloDoPedido(n, gitlab)}`,
+        proximoRascunho: (n, gitlab = false) => `o ${rotuloDoPedido(n, gitlab)} está em rascunho, com o CI verde: tire do rascunho; o merge é do dono ou do condutor`,
+        proximoMerge: (n, gitlab = false) => `o ${rotuloDoPedido(n, gitlab)} está pronto para o merge, que é do dono ou do condutor`,
         // A impressao da pista
         cabecalhoPista: (quando, remoto, base) => `Pista de entrega (lida em ${quando}, base ${remoto}/${base})`,
         semPistas: 'Nenhuma thread aberta na entrega.',
@@ -303,6 +362,10 @@ exports.SHIP_EN = {
     contratoPublicoCorrecao: 'redo the change in a #Classic, #Maestro or #Auto thread',
     ciReprovou: (detalhe, sha, contexto) => `${detalhe} (commit ${sha}, context ${contexto})`,
     ciReprovouCorrecao: (contexto) => `publish the branch, wait for the ${contexto} check to go green on GitHub and run SHIP again`,
+    scanNaoVarrido: (categorias, sha) => `the security scan did not scan these loop categories at commit ${sha}: ${categorias} (tool unavailable, failed or no report)`,
+    passoAutorizariaSemScan: (quem, categorias, sha) => `dry run: the real ship would record ship_unscanned_authorized by ${quem} for ${categorias} at commit ${sha}`,
+    allowUnscannedSemValor: 'error: --allow-unscanned needs who authorizes: ork ship <thread> --para <branch> --allow-unscanned "<who>"',
+    scanNaoVarridoCorrecao: (thread) => `run ork security-scan with Docker or the native binaries and run SHIP again; to ship unscanned, authorize it: ork ship ${thread} --para <branch> --allow-unscanned "<who>"`,
     arvoreDona: (dona, para, suja) => `${dona} (the tree with ${para} checked out; ${suja ? 'DIRTY, ship would fail with tree.blocked' : 'clean'})`,
     arvoreTemporaria: (dir, para) => `temporary worktree at ${dir} (nobody has ${para} checked out)`,
     arvoreDeMerge: (arvore) => `merge tree: ${arvore}`,
@@ -329,22 +392,36 @@ exports.SHIP_EN = {
     semPrimeiroPaiCorrecao: 'check the repository: ship_done needs the merge that delivered the thread',
     passoJaIncorporado: (de, para, sha) => `(nothing to merge: ${de} is already an ancestor of ${para}, brought in by ${sha})`,
     pushFalhou: (remoto, para, erro) => `push to ${remoto}/${para} failed: ${erro}`,
+    configDoRemotoInvalida: (chave) => `ship.config-do-remoto.invalida: the remote config accepts only -c key=value pairs for the pinned transport keys (refused: ${chave || 'invalid shape'}); nothing was passed to git`,
     pushFalhouCorrecao: 'fix the access to the remote and run ship again (the local merge already happened)',
+    pushBaseProtegida: (remoto, para, erro) => `the protection of ${remoto}/${para} refused the direct push to the base (entrega.base-protegida): ${erro}`,
+    pushBaseProtegidaCorrecao: (thread) => `deliver by PR/MR: ork ship publicar ${thread} (in #Auto and #Maestro) or a request opened on the forge; after the merge, ` +
+        `ork ship registrar-pr ${thread}. The local merge on the base did not reach the remote`,
     pushSemProva: (sha, ponta) => `ls-remote returned ${sha ?? '(nothing)'} and the local target is at ${ponta}: the push was not proven`,
     pushSemProvaCorrecao: 'run ship again and check the remote',
     ciNaoExigidoDetalhe: 'CI gate not required by the manifest',
-    ciRemotoNaoGithub: (remoto) => `remote ${remoto} is not a recognizable GitHub repository`,
+    ciRemotoNaoGithub: (remoto) => `remote ${remoto} is not a recognizable GitHub repository, nor a GitLab one`,
+    ciHostSemLogin: (host) => `gh is not logged in to ${host}: CI on that host was not queried`,
+    ciForjaNaoResolvida: (remoto, motivo) => `the forge of remote ${remoto} was not resolved: ${motivo}`,
     ciConsultaFalhou: 'GitHub query failed',
     ciRespostaInvalida: 'GitHub returned an invalid checks response',
+    ciIncompleto: (contexto) => `check ${contexto}: the commit's list of check runs or commit statuses came back incomplete, and the gate does not decide without all of it`,
+    ciStatusSemProdutorConfiavel: (contexto) => `${contexto}: commit status only, from accounts outside ci.produtor; a green status approves only from an accepted producer`,
+    ciSemProdutorAceito: (contexto, produtores, aceitos) => `${contexto}: green only from producers outside ci.produtor (${produtores}); accepted: ${aceitos}`,
+    ciProdutores: (contexto, produtores) => `check ${contexto} from more than one producer: ${produtores}`,
     ciSemCheck: (contexto) => `check ${contexto} not found on the commit`,
     ciVerde: 'independent CHECK green on GitHub',
+    ciBloqueado: (contexto, conclusao) => `check ${contexto}: blocked (${conclusao})`,
     ciEstado: (contexto, status, conclusao) => `check ${contexto}: ${status}/${conclusao || 'no conclusion'}`,
+    ciVerdeNoGitlab: 'independent CHECK green on GitLab',
+    ciLeituraFalhou: (contexto, motivo) => `check ${contexto}: CI was not read: ${motivo}`,
+    ciMescladoSemVinculo: (contexto, sha) => `ci.merged-results-sem-vinculo: ${contexto} ran only in a merged results pipeline with no proven link to head ${sha}; the gate does not approve`,
     usoRegistrarPr: 'usage: ork ship registrar-pr <thread-id> [--repo <owner/name> --pr <n>] | --todas [--remoto R] [--json] [--dry-run]',
     ensaio: 'Dry run (--dry-run): nothing was written.',
     nenhumaComMerge: 'No open thread with a ship(<thread>) merge on the base.',
     linhaDoRegistro: (thread, acao, motivo) => `  ${thread.padEnd(20)} ${acao.padEnd(13)} ${motivo}`,
     acoes: { 'registrou': 'recorded', 'registraria': 'would record', 'ja-registrada': 'already recorded', 'sem-merge': 'no merge',
-        'recusada': 'refused' },
+        'recusada': 'refused', 'pulada': 'skipped' },
     avisoDeDocs: (n) => `Warning: ${n} roadmap page(s) with \`estado.codigo\` other than "Mesclado" after the merge; ` +
         'the push to the base fails on docs.paridade.merge:',
     docPendente: (id, arquivo, merge, thread, codigo) => `  ${id} (${arquivo}): merge ${merge} from ship(${thread}), estado.codigo "${codigo || 'empty'}"`,
@@ -353,6 +430,9 @@ exports.SHIP_EN = {
     registrariam: (n) => `${n} delivery(ies) would be recorded. To write them, run the same command without \`--dry-run\`.`,
     prThreadFechada: 'thread already closed',
     prSemMerge: (thread, remoto, base) => `no ship(${thread}) merge on ${remoto}/${base}`,
+    prSemLeitura: (remoto, base) => `git fetch of ${remoto}/${base} failed: without reading the remote the merge cannot be found`,
+    prSemVinculo: (thread, sha) => `merge ${sha} of ship(${thread}) has a single parent (squash or rebase) and does not tie the base to the verified head; deliver with a merge commit`,
+    prSemHead: (n, repo, forja = 'GitHub') => `${rotuloDoPedido(n, forja === 'GitLab')} of ${repo} is merged, but ${forja} did not report its head`,
     prJaTemShipDone: 'this delivery already has ship_done',
     prForaDaPonta: (merge, remoto, base) => `merge ${merge} is not at the tip of ${remoto}/${base}`,
     prSemCiVerde: (detalhe) => `no green CI on the PR head: ${detalhe}`,
@@ -360,15 +440,40 @@ exports.SHIP_EN = {
     prRegistrou: (merge) => `ship_done from merge ${merge} of the PR`,
     prRepoNaoDeclarado: (repo) => `repository ${repo} is not declared in \`ci.external_repositories\` of \`orkastery.yaml\``,
     prNumeroInvalido: (recebido) => `\`--pr\` must be the PR number, got ${recebido}`,
-    prExternoJaTem: (n, repo) => `PR #${n} of ${repo} already has ship_done`,
-    prConsultaFalhou: (n, repo) => `the GitHub query for PR #${n} of ${repo} failed`,
-    prNaoMesclado: (n, repo) => `PR #${n} of ${repo} is not merged`,
-    prNaoCitaThread: (n, repo, thread) => `PR #${n} of ${repo} does not mention thread ${thread} in its title, body or branch`,
-    prRepoFalhou: (repo) => `the GitHub query for ${repo} failed`,
-    prOutraBase: (n, base, repo, padrao) => `PR #${n} landed on ${base}, and the default branch of ${repo} is ${padrao ?? 'unknown'}`,
+    prExternoJaTem: (n, repo, gitlab = false) => `${rotuloDoPedido(n, gitlab)} of ${repo} already has ship_done`,
+    prConsultaFalhou: (n, repo, forja = 'GitHub') => `the ${forja} query for ${rotuloDoPedido(n, forja === 'GitLab')} of ${repo} failed`,
+    prNaoMesclado: (n, repo, gitlab = false) => `${rotuloDoPedido(n, gitlab)} of ${repo} is not merged`,
+    prNaoCitaThread: (n, repo, thread, gitlab = false) => `${rotuloDoPedido(n, gitlab)} of ${repo} does not mention thread ${thread} in its title, body or branch`,
+    prRepoFalhou: (repo, forja = 'GitHub') => `the ${forja} query for ${repo} failed`,
+    prOutraBase: (n, base, repo, padrao, gitlab = false) => `${rotuloDoPedido(n, gitlab)} landed on ${base}, and the default branch of ${repo} is ${padrao ?? 'unknown'}`,
     prExternoForaDaPonta: (merge, repo, base) => `merge ${merge} is not at the tip of ${repo}:${base}`,
-    prExternoRegistraria: (merge, n, repo) => `dry run: would record ship_done from merge ${merge} of PR #${n} of ${repo} (nothing written)`,
-    prExternoRegistrou: (merge, n, repo) => `ship_done from merge ${merge} of PR #${n} of ${repo}`,
+    prForjaDoExterno: (repo, motivo) => `the forge of ${repo} was not resolved: ${motivo}`,
+    prForjaDoProjetoNaoResolvida: (repo, remoto, motivo) => `the forge of remote ${remoto} was not resolved (${motivo}), and ${repo} is not queried on another host; declare forja.tipo in orkastery.yaml or log in to the forge CLI on that host`,
+    prRepoComSubgrupoNoGithub: (repo) => `${repo} has subgroups, and a GitHub repository is only owner/name; in a GitLab project, the remote or forja.tipo: gitlab in orkastery.yaml names the forge`,
+    prExternoRegistraria: (merge, n, repo, gitlab = false) => `dry run: would record ship_done from merge ${merge} of ${rotuloDoPedido(n, gitlab)} of ${repo} (nothing written)`,
+    prExternoRegistrou: (merge, n, repo, gitlab = false) => `ship_done from merge ${merge} of ${rotuloDoPedido(n, gitlab)} of ${repo}`,
+    guarda: {
+        situacoes: { 'proposto': 'proposed', 'agendado': 'scheduled', 'vigente': 'in force', 'expirado': 'expired', 'revogado': 'revoked',
+            'encerrado': 'closed' },
+        origens: { 'envelope': 'by the envelope list', 'proposta': 'by the proposal waiting for the owner', 'despacho': 'by the arc dispatch log',
+            'correlacao': 'by the last dispatch of the thread', 'rede': 'by the arc network' },
+        doArco: (thread, arco, situacao, origem) => `noctum.guarda.thread-do-arco: thread ${thread} is work of arc ${arco} (${situacao}, ${origem})`,
+        doArcoCorrecao: (arco) => `this thread is delivered by the delivery step of arc ${arco}: its SHIP and MASTER belong to the arc (ork noctum status ${arco})`,
+        arcoIlegivel: (thread, arco, motivo) => `noctum.guarda.arco-ilegivel: the last dispatch of thread ${thread} came from arc ${arco}, and the arc cannot be read (${motivo})`,
+        arcoIlegivelCorrecao: (arco) => `inspect the arc before delivering the thread outside it (ork noctum status ${arco})`,
+        redeIlegivel: (thread, arco, motivo) => `noctum.guarda.rede-ilegivel: thread ${thread} is work of arc ${arco}, closed on this machine, and its network cannot be read (${motivo})`,
+        redeIlegivelCorrecao: (arco) => `restore network reading before delivering the thread outside the arc (ork noctum status ${arco})`,
+        redeDoArco: (thread, arco, estado, trabalho) => `noctum.guarda.thread-do-arco: thread ${thread} is work ${trabalho} of arc ${arco}, still ${estado} on the network`,
+        redeDoArcoCorrecao: (arco) => `wait for the work to finish on the network or deliver it through the delivery step of arc ${arco} (ork noctum status ${arco})`,
+        retencao: (thread, arco, situacao) => `noctum.guarda.thread-do-arco: arc ${arco} (${situacao}) dispatched thread ${thread} last; the beat and the Sentinel ` +
+            'do not dispatch, resume or merge it until a dispatch outside the arc or a new arc that lists it',
+        sessaoDoArco: (thread, arco, situacao, sessao) => `noctum.guarda.thread-do-arco: arc ${arco} is ${situacao}, and session ${sessao} that it dispatched still conducts thread ${thread}: ` +
+            'it does not deliver outside the arc',
+        sessaoDoArcoCorrecao: (arco) => `wait for the stop that the arc closing requests, or stop the session; with no arc session in flight, the thread is delivered by hand (ork noctum status ${arco})`,
+        reservaDoArco: (thread, arco, situacao, seq) => `noctum.guarda.thread-do-arco: arc ${arco} is ${situacao}, and reservation ${seq} that it made for thread ${thread} may have opened ` +
+            'a session without an id: it does not deliver outside the arc',
+        reservaDoArcoCorrecao: (arco) => `wait for the watcher to reconcile the reservation (it concludes it with the session or returns it); with no arc session in flight, the thread is delivered by hand (ork noctum status ${arco})`,
+    },
     publicar: {
         uso: 'usage: ork ship publicar <thread-id> [--dry-run] [--remoto R] [--json]',
         usoPista: 'usage: ork ship pista [<thread-id>] [--remoto R] [--json]',
@@ -379,7 +484,7 @@ exports.SHIP_EN = {
         linhaRemoto: (remoto, antes, depois) => `  remote        ${remoto}: ${depois} (before: ${antes})`,
         linhaPushProvado: '  push          PROVEN by ls-remote (same sha as HEAD)',
         linhaPushSemProva: '  push          without proof',
-        linhaPr: (n, criado, url) => `  PR            #${n} ${criado ? 'opened now' : 'reused'}${url ? ` (${url})` : ''}`,
+        linhaPr: (n, criado, url, gitlab = false) => `  ${gitlab ? 'MR            !' : 'PR            #'}${n} ${criado ? 'opened now' : 'reused'}${url ? ` (${url})` : ''}`,
         linhaCorpo: (corpo) => `  PR body       ${corpo}`,
         resultado: (acao) => `${acao}.`,
         acoes: { 'publicou': 'PUBLISHED', 'publicaria': 'WOULD PUBLISH', 'ja-publicada': 'ALREADY PUBLISHED', 'recusada': 'REFUSED' },
@@ -389,6 +494,7 @@ exports.SHIP_EN = {
         threadFechadaCorrecao: 'the new delivery goes in a new thread',
         modoSemPush: (tag) => `the ${tag} mode asks for the owner's authorization to push; ork ship publicar only publishes in #Auto and #Maestro`,
         modoSemPushCorrecao: (comando) => `the owner publishes from their own terminal: ${comando}`,
+        comandoDasDuasForjas: (gh, glab) => `on GitHub, ${gh}; on GitLab, ${glab}`,
         conduzida: (sessao, fase) => `session ${sessao} is conducting the thread now (phase ${fase}); the branch may change in the middle of the publication`,
         conduzidaCorrecao: (thread) => `publish after the end of the turn (ork conducao status ${thread})`,
         semBranch: (branch) => `the thread branch ${branch} does not exist in this repository`,
@@ -423,27 +529,32 @@ exports.SHIP_EN = {
         bundleCorrecao: (thread) => `run ork ci prepare ${thread} in the worktree and commit the bundle as ci(${thread}): bundle`,
         semRemoto: (remoto) => `remote ${remoto} is not configured in this repository`,
         semRemotoCorrecao: 'configure the remote (git remote add) or give another one in --remoto',
-        semForja: (remoto) => `remote ${remoto} is not a GitHub repository; ork ship publicar only opens PRs on GitHub`,
+        semForja: (remoto, motivo) => `remote ${remoto} is not a GitHub or GitLab repository${motivo ? ` (${motivo})` : ''}; ork ship publicar only opens PRs/MRs on those forges`,
         semForjaCorrecao: 'publish the branch and open the merge request through the remote forge',
         lsRemoteFalhou: (remoto, erro) => `git ls-remote ${remoto} failed: ${erro}`,
         prsFalharam: (erro) => `the branch PR list failed: ${erro}`,
         redeCorrecao: 'check the network and the gh login (gh auth status) and run it again',
-        jaPublicada: (n) => `the branch is already on the remote at HEAD and PR #${n} is open; nothing to do`,
-        jaMesclado: (n) => `PR #${n} was already merged at HEAD; nothing to publish`,
+        jaPublicada: (n, gitlab = false) => `the branch is already on the remote at HEAD and ${rotuloDoPedido(n, gitlab)} is open; nothing to do`,
+        jaMesclado: (n, gitlab = false) => `${rotuloDoPedido(n, gitlab)} was already merged at HEAD; nothing to publish`,
         registreAEntrega: (thread) => `record the delivery: ork ship registrar-pr ${thread}`,
         remotoDivergiu: (remoto, branch, sha) => `remote ${remoto} has branch ${branch} at ${sha}, with a commit the local branch does not have`,
         remotoDivergiuCorrecao: (remoto, branch) => `bring the remote into the branch through the GO session (git pull --no-rebase ${remoto} ${branch}) and publish again; never force`,
-        passoReaproveita: (n) => `reuses PR #${n}, already open`,
-        publicaria: (sha, n) => `rehearsal: would publish HEAD ${sha} and ${n ? `update PR #${n}` : 'open the PR'} (nothing was done)`,
+        passoReaproveita: (n, gitlab = false) => `reuses ${rotuloDoPedido(n, gitlab)}, already open`,
+        publicaria: (sha, n, gitlab = false) => `rehearsal: would publish HEAD ${sha} and ${n ? `update ${rotuloDoPedido(n, gitlab)}` : `open the ${gitlab ? 'MR' : 'PR'}`} (nothing was done)`,
         pushFalhou: (remoto, branch, erro) => `the push of ${branch} to ${remoto} failed: ${erro}`,
         pushSemProva: (remota, head) => `ls-remote returned ${remota ?? '(nothing)'} and HEAD is at ${head}: the push was not proven`,
         pushSemProvaCorrecao: (thread) => `check the remote and run ork ship publicar ${thread} again`,
-        corpoPadrao: (tag, branch, sha, contexto) => `Published by ork ship publicar (${tag} mode): branch ${branch} at HEAD ${sha}, proven by ls-remote. ` +
-            `The independent CHECK runs on CI (${contexto}) from this PR.`,
+        corpoPadrao: (tag, branch, sha, contexto, gitlab = false) => `Published by ork ship publicar (${tag} mode): branch ${branch} at HEAD ${sha}, proven by ls-remote. ` +
+            `The independent CHECK runs on CI (${contexto}) from this ${gitlab ? 'MR' : 'PR'}.`,
         prSemReleitura: 'the PR did not show up when the list was read again',
         prFalhou: (sha, erro) => `the branch was published and proven at HEAD ${sha}, but the PR did not open: ${erro}`,
         prFalhouCorrecao: (thread) => `check the gh login and run ork ship publicar ${thread} again (the push is already proven)`,
-        publicou: (sha, n, criado) => `HEAD ${sha} published and proven; PR #${n} ${criado ? 'opened now' : 'reused'}`,
+        prsFalharamGitlab: (erro) => `the branch MR list failed: ${erro}`,
+        redeCorrecaoGitlab: 'check the network and the glab login on the host (glab auth status) and run it again',
+        prSemReleituraGitlab: 'the MR did not show up when the list was read again',
+        prFalhouGitlab: (sha, erro) => `the branch was published and proven at HEAD ${sha}, but the MR did not open: ${erro}`,
+        prFalhouCorrecaoGitlab: (thread) => `check the glab login and run ork ship publicar ${thread} again (the push is already proven)`,
+        publicou: (sha, n, criado, gitlab = false) => `HEAD ${sha} published and proven; ${rotuloDoPedido(n, gitlab)} ${criado ? 'opened now' : 'reused'}`,
         remotoNaoLido: (remoto) => `git ls-remote ${remoto} did not answer`,
         branchPublicada: (sha) => `branch published at HEAD ${sha}`,
         branchNaoPublicada: 'branch not published yet',
@@ -451,20 +562,20 @@ exports.SHIP_EN = {
         prsNaoLidos: (erro) => `PRs not read: ${erro}`,
         prsCortados: (limite) => `the open PR list was cut at the ${limite} newest: the branch PR was not read`,
         branchSemConferir: 'the branch was left unchecked in this forge read: its PR was not read',
-        prFechado: (n) => `PR #${n} was closed without merge`,
+        prFechado: (n, gitlab = false) => `${rotuloDoPedido(n, gitlab)} was closed without merge`,
         semPr: 'no PR for the branch',
         ciSemPr: 'without a PR, CI does not run',
         ciNaoExigido: 'CI not required by the manifest',
         conflitoSemPr: 'without a PR, no conflict to measure',
-        prMesclado: (n) => `PR #${n} merged`,
+        prMesclado: (n, gitlab = false) => `${rotuloDoPedido(n, gitlab)} merged`,
         ciDoMesclado: 'PR merged; ork ship registrar-pr checks the CI on the head',
-        prRascunho: (n) => `PR #${n} open as a draft`,
-        prAberto: (n) => `PR #${n} open`,
-        ciSemCheck: (contexto, n) => `check ${contexto} has not shown up on PR #${n} yet`,
+        prRascunho: (n, gitlab = false) => `${rotuloDoPedido(n, gitlab)} open as a draft`,
+        prAberto: (n, gitlab = false) => `${rotuloDoPedido(n, gitlab)} open`,
+        ciSemCheck: (contexto, n, gitlab = false) => `check ${contexto} has not shown up on ${rotuloDoPedido(n, gitlab)} yet`,
         ciVerde: (contexto, sha) => `check ${contexto} green on head ${sha}`,
-        ciVermelho: (contexto, n) => `check ${contexto} red on PR #${n}`,
-        ciEsperando: (contexto, n) => `check ${contexto} running on PR #${n}`,
-        conflito: (n) => `PR #${n} conflicts with the base`,
+        ciVermelho: (contexto, n, gitlab = false) => `check ${contexto} red on ${rotuloDoPedido(n, gitlab)}`,
+        ciEsperando: (contexto, n, gitlab = false) => `check ${contexto} running on ${rotuloDoPedido(n, gitlab)}`,
+        conflito: (n, gitlab = false) => `${rotuloDoPedido(n, gitlab)} conflicts with the base`,
         semConflito: 'no conflict with the base',
         conflitoNaoCalculado: 'GitHub has not computed the merge with the base yet',
         entregue: 'delivered: ship_done in the ledger',
@@ -473,14 +584,14 @@ exports.SHIP_EN = {
         proximoEntregue: 'delivered; the MASTER closes the thread',
         proximoRegistrar: 'merged on the base: record the delivery',
         proximoConduzida: (sessao) => `session ${sessao} is conducting the thread now; the delivery waits for the end of the turn`,
-        proximoPublicarNoPr: (n) => `publish the new commits to PR #${n}`,
+        proximoPublicarNoPr: (n, gitlab = false) => `publish the new commits to ${rotuloDoPedido(n, gitlab)}`,
         proximoPublicar: 'publish the branch and open the PR',
         proximoDoDono: (thread, tag) => `the ${tag} mode of ${thread} asks for your push authorization: publish from your terminal`,
-        proximoConflito: (n) => `PR #${n} conflicts with the base: merge origin/main in the worktree through the GO session, run verify and write the bundle again`,
-        proximoCiVermelho: (contexto, n) => `check ${contexto} is red on PR #${n}: fix it through the GO session and publish again`,
-        proximoEsperandoCi: (contexto, n) => `waiting for check ${contexto} on PR #${n}`,
-        proximoRascunho: (n) => `PR #${n} is a draft with green CI: take it out of draft; the merge belongs to the owner or the conductor`,
-        proximoMerge: (n) => `PR #${n} is ready for the merge, which belongs to the owner or the conductor`,
+        proximoConflito: (n, gitlab = false) => `${rotuloDoPedido(n, gitlab)} conflicts with the base: merge origin/main in the worktree through the GO session, run verify and write the bundle again`,
+        proximoCiVermelho: (contexto, n, gitlab = false) => `check ${contexto} is red on ${rotuloDoPedido(n, gitlab)}: fix it through the GO session and publish again`,
+        proximoEsperandoCi: (contexto, n, gitlab = false) => `waiting for check ${contexto} on ${rotuloDoPedido(n, gitlab)}`,
+        proximoRascunho: (n, gitlab = false) => `${rotuloDoPedido(n, gitlab)} is a draft with green CI: take it out of draft; the merge belongs to the owner or the conductor`,
+        proximoMerge: (n, gitlab = false) => `${rotuloDoPedido(n, gitlab)} is ready for the merge, which belongs to the owner or the conductor`,
         cabecalhoPista: (quando, remoto, base) => `Delivery lane (read at ${quando}, base ${remoto}/${base})`,
         semPistas: 'No open thread in delivery.',
         remotoNaoRespondeu: (remoto) => `Warning: git ls-remote ${remoto} did not answer; the branch step was left unread.`,