@orkastery/cli 0.5.3 → 0.6.0

package/dist/locale-ship.js

@@ -0,0 +1,597 @@
+"use strict";
+/**
+ * RM-061, fatia F2b: a familia `ship` do catalogo de mensagens (`ork ship` e `ork ship registrar-pr`). O
+ * pt-BR e a fonte; o ingles e tipado por ele. Sem import do nucleo.
+ *
+ * O detalhe e a correcao de um bloqueio, a razao da autorizacao, os passos do ensaio e o motivo do
+ * `registrar-pr` vao ao ledger ou ao `--json`: o comando os monta em pt-BR, e so a impressao os remonta no
+ * locale (G2 da F2b). Comando, branch, sha e motivo tipado saem iguais nas duas linguas; a mensagem de
+ * merge do git e o que so o ledger le seguem em pt-BR fora do catalogo.
+ */
+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
+    cabecalho: (dryRun, thread) => `${dryRun ? 'ork ship (--dry-run, nada foi executado)' : 'ork ship'}: thread ${thread}`,
+    de: (branch, sha) => `  de            ${branch}${sha ? ` @ ${sha}` : ''}`,
+    para: (branch, sha) => `  para          ${branch}${sha ? ` @ ${sha}` : ''}`,
+    autorizado: (por, tipo) => `  autorizacao   AUTORIZADO por ${por} (${tipo})`,
+    /** O tipo da autorizacao e dado (ledger, --json); o texto so o traduz na impressao. */
+    tiposDeAutorizacao: { 'modo': 'modo', 'humano-no-cli': 'humano-no-cli', 'humano-antecipado': 'humano-antecipado',
+        'pendente': 'pendente' },
+    aguardandoAutorizacao: '  autorizacao   AGUARDANDO AUTORIZACAO HUMANA',
+    razao: (razao) => `                ${razao}`,
+    verificacao: (ok, sha, claimsOk, claims, comandosOk, comandos) => `  verificacao   ${ok ? 'passou' : 'REPROVOU'} no HEAD ${sha} (${claimsOk}/${claims} claims, ${comandosOk}/${comandos} comandos)`,
+    ciExigido: (estado, contexto, sha) => `  ci            ${estado} ${contexto} em ${sha}`,
+    ciNaoExigido: '  ci            não exigido',
+    leaseOcupado: (lease, thread, desde) => `  lease         ${lease} OCUPADO pela thread ${thread} (desde ${desde})`,
+    leaseTomado: (lease, thread) => `  lease         ${lease} tomado por ${thread} e liberado ao fim`,
+    leaseLivre: (lease) => `  lease         ${lease} livre`,
+    bloqueado: (motivo) => `BLOQUEADO. motivo tipado: ${motivo}`,
+    detalhe: (detalhe) => `  detalhe   ${detalhe}`,
+    correcao: (correcao) => `  correcao  ${correcao}`,
+    passosDoEnsaio: 'Passos que o ship real executaria, nesta ordem:',
+    nadaAMergear: (de, para, sha) => `Nada a mergear: ${de} ja estava em ${para}, incorporado em ${sha}.`,
+    mergeConcluido: (sha) => `Merge --no-ff concluido: ${sha}`,
+    pushProvado: (remoto, para, sha) => `Push PROVADO: ls-remote de ${remoto}/${para} devolveu ${sha}`,
+    mesmoSha: (sha) => `  e o destino local esta no mesmo sha: ${sha}`,
+    pushNaoProvado: (detalhe) => `Push nao provado: ${detalhe}`,
+    semRemotoConfigurado: 'sem remoto configurado',
+    evidencia: 'Evidencia (comandos executados):',
+    ledger: (thread) => `Ledger: ork phase list ${thread}  (evento ship_done)`,
+    // Autorizacao (vai ao ledger como dado do ship)
+    autorizadoNaLinha: (tag) => `pausa de push do modo ${tag} autorizada na linha de comando`,
+    porTag: (tag) => `#TAG ${tag} no pedido do builder`,
+    autorizadoPeloModo: (tag) => `o modo ${tag} entrega dentro de um bloco sem pausa: a #TAG e a autorizacao previa`,
+    autorizadoAntes: (quando) => `autorizacao antecipada de push registrada no ledger em ${quando}`,
+    semAutorizacao: (tag, thread) => `o modo ${tag} pausa no push e ainda nao ha autorizacao humana registrada. ` +
+        `Autorize na entrega: ork ship ${thread} --para <branch> --autorizar-push <quem>`,
+    // Bloqueios: detalhe e correcao (vao ao ledger)
+    verificacaoReprovou: (commit, motivos) => `verificacao reprovou no HEAD ${commit}: ${motivos}`,
+    rodeVerify: (thread) => 'rode `ork verify ' + thread + '` e corrija antes de entregar',
+    origemAusente: (de) => `branch de origem "${de}" nao existe neste repositorio`,
+    origemAusenteCorrecao: 'use --de <branch> ou crie a branch da thread',
+    destinoAusente: (para) => `branch de destino "${para}" nao existe neste repositorio`,
+    destinoAusenteCorrecao: 'crie a branch de destino ou informe outra em --para',
+    contratoPublico: (tocados) => `contrato publico em ciclo sem PLAN nem CHECK: ${tocados}`,
+    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}`,
+    semPushPorFlag: 'push nao executado por --sem-push (merge local concluido)',
+    semRemoto: (remoto) => `remoto "${remoto}" nao configurado: merge local concluido, sem push a provar`,
+    passoSemPush: (motivo) => `sem push: ${motivo}`,
+    passoProvaDoPush: (remoto, para) => `git ls-remote ${remoto} refs/heads/${para}   (prova do push)`,
+    passoMerge: (de) => `git merge --no-ff ${de} -m "<mensagem de ship>"`,
+    autorizeNaEntrega: (thread) => `ork ship ${thread} --para <branch> --autorizar-push <quem>`,
+    leaseComOutra: (lease, thread, desde, motivo, posicao) => `lease ${lease} esta com a thread ${thread} desde ${desde} (${motivo}); esta thread entrou na merge queue na posicao ${posicao}`,
+    desconhecida: '(desconhecida)',
+    semMotivo: 'sem motivo',
+    /** Quem autorizou o push antes, quando o ledger nao diz o nome. */
+    humano: 'humano',
+    arvoreSuja: (para, dona) => `a branch de destino "${para}" esta em check-out em ${dona} com alteracoes nao commitadas; commite ou reverta la antes do ship`,
+    arvoreNaoMontada: (para, erro) => `nao foi possivel montar a arvore de merge de "${para}": ${erro}`,
+    arvoreCorrecao: 'deixe a arvore da branch de destino limpa (ou libere a branch) e rode o ship de novo',
+    mergeFalhou: (de, para, erro) => `merge de ${de} em ${para} falhou: ${erro}`,
+    mergeFalhouCorrecao: 'resolva o conflito na branch da thread e rode o ship de novo',
+    headIlegivel: 'nao foi possivel ler o HEAD apos o merge',
+    confiraRepositorio: 'confira o repositorio',
+    naoAncestral: (de, merge) => `o commit de ${de} nao aparece como ancestral do merge ${merge}`,
+    naoEmpurre: 'nao empurre: investigue o estado do repositorio',
+    semPrimeiroPai: (de, para) => `${de} ja e ancestral de ${para}, mas o git nao achou o commit de primeiro pai que o incorporou`,
+    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, 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.',
+    nenhumaComMerge: 'Nenhuma thread aberta com merge ship(<thread>) na base.',
+    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', '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'}"`,
+    docPendenteComando: (comando) => `    ${comando}   (num PR de docs sobre a base atualizada)`,
+    registradas: (n) => `${n} entrega(s) registrada(s). Fechar pelo MASTER so a(s) desta entrega (a nota humana sobrescreve):`,
+    registrariam: (n) => `${n} entrega(s) seria(m) registrada(s). Para gravar, rode o mesmo comando sem --dry-run.`,
+    // 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}`,
+    prRegistraria: (merge) => `ensaio: registraria ship_done pelo merge ${merge} do PR (nada gravado)`,
+    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, 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}`,
+    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' },
+        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})`,
+        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: {
+        uso: 'uso: ork ship publicar <thread-id> [--dry-run] [--remoto R] [--json]',
+        usoPista: 'uso: ork ship pista [<thread-id>] [--remoto R] [--json]',
+        semAutorizarPush: 'erro: ork ship publicar não aceita --autorizar-push: ele só publica no modo que já autoriza o push ' +
+            '(#Auto e #Maestro); nos outros modos, o push é do dono, no terminal dele',
+        cabecalho: (dryRun, thread, tag) => `${dryRun ? 'ork ship publicar (--dry-run, nada foi publicado nem gravado)' : 'ork ship publicar'}: thread ${thread} (${tag})`,
+        linhaBranch: (branch, sha) => `  branch        ${branch} @ ${sha}`,
+        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, 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' },
+        // As conferencias (detalhe e correcao vao ao --json)
+        threadInexistente: (thread, erro) => `a thread ${thread} não foi lida neste projeto: ${erro}`,
+        threadInexistenteCorrecao: 'confira o id da thread (ork thread status <thread>)',
+        threadFechada: (thread) => `a thread ${thread} está fechada; nada a publicar`,
+        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`,
+        semBranchCorrecao: (thread) => `confira a worktree da thread (ork worktree ensure ${thread})`,
+        branchEBase: (base) => `a branch da thread é a base ${base}; publicar a base sem merge é o push direto que o ork ship barra`,
+        branchEBaseCorrecao: 'a entrega sai de uma branch de thread (ork/<thread>), nunca da base',
+        semProduto: (branch, base) => `a branch ${branch} não tem commit fora de ${base}; nada a publicar`,
+        semProdutoCorrecao: 'commite o trabalho da thread pela sessão de GO antes de publicar',
+        checkSemCiclo: (tag) => `o ciclo ${tag} não tem CHECK`,
+        checkAusente: 'o docs/check.md da thread ainda não foi gravado',
+        checkSemVeredito: 'o docs/check.md não tem exatamente um veredito',
+        checkOutroVeredito: (veredito) => `o veredito do CHECK é ${veredito}`,
+        checkVelho: (sha) => `o CHECK com PASSOU é anterior ao commit ${sha}`,
+        checkFeito: 'CHECK com veredito PASSOU depois do último commit de produto',
+        comandoDoCheck: (thread) => `ork phase run ${thread} CHECK --prompt "<pedido da fase>"`,
+        checkCorrecao: (thread) => `rode o CHECK da thread no HEAD e grave o veredito PASSOU (ork phase run ${thread} CHECK --prompt "<pedido da fase>")`,
+        verifyAusente: 'nenhum ork verify gravado na thread',
+        verifyReprovou: (sha, motivos) => `o último ork verify reprovou no commit ${sha} (${motivos})`,
+        verifyAntigo: (sha) => `o último ork verify verde foi no commit ${sha}, e o HEAD mudou depois dele além do bundle`,
+        verifyNoHead: (sha) => `ork verify verde no HEAD ${sha}`,
+        verifySoBundle: (sha) => `ork verify verde no commit ${sha}; depois dele, só o bundle`,
+        verifySoClaims: (sha) => `o último ork verify (commit ${sha}) rodou só as claims, sem o build e o test do manifesto`,
+        verifyCorrecao: (thread) => `rode ork verify ${thread} no HEAD e corrija antes de publicar`,
+        bundleAusente: (arquivo) => `o bundle ${arquivo} não está no HEAD`,
+        bundleInvalido: (arquivo) => `o bundle ${arquivo} no HEAD não abre como ork.ci-bundle/v1 desta thread`,
+        bundleOutraBranch: (arquivo, branch) => `o bundle ${arquivo} no HEAD é da branch ${branch}`,
+        bundleVelho: (faltam, sobram) => `o bundle no HEAD está velho` +
+            `${faltam ? `: faltam as claims ${faltam}` : ''}${sobram ? `${faltam ? ';' : ':'} sobram as claims ${sobram}` : ''}`,
+        bundleMudou: (ids) => `o bundle no HEAD está velho: o comando das claims ${ids} mudou depois dele`,
+        bundleManifestoMudou: 'o bundle no HEAD está velho: os comandos de verify do manifesto mudaram depois dele',
+        bundleFeito: (n) => `bundle no HEAD com as ${n} claims ativas e os comandos delas`,
+        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, 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, 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, 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, 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)`,
+        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}`,
+        branchNaoPublicada: 'branch ainda não publicada',
+        commitsSemPush: (remota, head) => `o remoto está em ${remota} e o HEAD em ${head}: há commits sem push`,
+        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, 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, gitlab = false) => `${rotuloDoPedido(n, gitlab)} mesclado`,
+        ciDoMesclado: 'PR mesclado; o ork ship registrar-pr confere o CI no head',
+        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, 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',
+        mergeSemRegistro: (sha) => `merge ${sha} na base, sem ship_done`,
+        semShipDone: 'sem ship_done ainda',
+        // O proximo passo
+        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, 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, 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.',
+        remotoNaoRespondeu: (remoto) => `Aviso: o git ls-remote ${remoto} não respondeu; a etapa da branch ficou sem leitura.`,
+        prsNaoResponderam: (erro) => `Aviso: os PRs não foram lidos (${erro}); PR, CI e conflito ficaram sem leitura.`,
+        linhaDaThread: (thread, tag, branch) => `  ${thread}  ${tag}  ${branch}`,
+        /** O nome e a marca de cada etapa sao a mesma palavra nas duas linguas, fora conflito e entrega. */
+        nomeDaEtapa: (id) => ({ check: 'CHECK', verify: 'verify', bundle: 'bundle', branch: 'branch', pr: 'PR', ci: 'CI',
+            conflito: 'conflito', entrega: 'entrega' }[id] ?? id),
+        marcaDaEtapa: (estado) => ({ 'feita': 'ok', 'pendente': '...', 'falhou': 'X', 'nao-lida': '?', 'nao-se-aplica': '-' }[estado] ?? estado),
+        linhaDoProximo: (texto, comando) => `    próximo: ${texto}${comando ? ` (${comando})` : ''}`,
+    },
+};
+exports.SHIP_EN = {
+    uso: 'usage: ork ship <thread-id> --para <branch> [--de <branch>] [--dry-run]',
+    cabecalho: (dryRun, thread) => `${dryRun ? 'ork ship (--dry-run, nothing was run)' : 'ork ship'}: thread ${thread}`,
+    de: (branch, sha) => `  from          ${branch}${sha ? ` @ ${sha}` : ''}`,
+    para: (branch, sha) => `  to            ${branch}${sha ? ` @ ${sha}` : ''}`,
+    autorizado: (por, tipo) => `  authorization AUTHORIZED by ${por} (${tipo})`,
+    tiposDeAutorizacao: { 'modo': 'by mode', 'humano-no-cli': 'human on the command line', 'humano-antecipado': 'human, in advance',
+        'pendente': 'pending' },
+    aguardandoAutorizacao: '  authorization WAITING FOR HUMAN AUTHORIZATION',
+    razao: (razao) => `                ${razao}`,
+    verificacao: (ok, sha, claimsOk, claims, comandosOk, comandos) => `  verification  ${ok ? 'passed' : 'FAILED'} at HEAD ${sha} (${claimsOk}/${claims} claims, ${comandosOk}/${comandos} commands)`,
+    ciExigido: (estado, contexto, sha) => `  ci            ${estado} ${contexto} at ${sha}`,
+    ciNaoExigido: '  ci            not required',
+    leaseOcupado: (lease, thread, desde) => `  lease         ${lease} HELD by thread ${thread} (since ${desde})`,
+    leaseTomado: (lease, thread) => `  lease         ${lease} taken by ${thread} and released at the end`,
+    leaseLivre: (lease) => `  lease         ${lease} free`,
+    bloqueado: (motivo) => `BLOCKED. Typed reason: ${motivo}`,
+    detalhe: (detalhe) => `  detail    ${detalhe}`,
+    correcao: (correcao) => `  fix       ${correcao}`,
+    passosDoEnsaio: 'Steps the real ship would run, in this order:',
+    nadaAMergear: (de, para, sha) => `Nothing to merge: ${de} was already in ${para}, brought in by ${sha}.`,
+    mergeConcluido: (sha) => `\`--no-ff\` merge done: ${sha}`,
+    pushProvado: (remoto, para, sha) => `Push PROVEN: ls-remote of ${remoto}/${para} returned ${sha}`,
+    mesmoSha: (sha) => `  and the local target is at the same sha: ${sha}`,
+    pushNaoProvado: (detalhe) => `Push not proven: ${detalhe}`,
+    semRemotoConfigurado: 'no remote configured',
+    evidencia: 'Evidence (commands run):',
+    ledger: (thread) => `Ledger: \`ork phase list ${thread}\`  (ship_done event)`,
+    autorizadoNaLinha: (tag) => `push pause of mode ${tag} authorized on the command line`,
+    porTag: (tag) => `#TAG ${tag} in the builder's request`,
+    autorizadoPeloModo: (tag) => `mode ${tag} ships inside a block with no pause: the #TAG is the prior authorization`,
+    autorizadoAntes: (quando) => `push authorized in advance, recorded in the ledger at ${quando}`,
+    semAutorizacao: (tag, thread) => `mode ${tag} pauses at the push and no human authorization is recorded yet. ` +
+        `Authorize it at delivery: \`ork ship ${thread} --para <branch> --autorizar-push <who>\``,
+    verificacaoReprovou: (commit, motivos) => `verification failed at HEAD ${commit}: ${motivos}`,
+    rodeVerify: (thread) => 'run `ork verify ' + thread + '` and fix it before shipping',
+    origemAusente: (de) => `source branch "${de}" does not exist in this repository`,
+    origemAusenteCorrecao: 'pass `--de <branch>` or create the thread branch',
+    destinoAusente: (para) => `target branch "${para}" does not exist in this repository`,
+    destinoAusenteCorrecao: 'create the target branch or pass another one with `--para`',
+    contratoPublico: (tocados) => `public contract in a cycle without PLAN or CHECK: ${tocados}`,
+    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}`,
+    semPushPorFlag: 'push skipped by `--sem-push` (local merge done)',
+    semRemoto: (remoto) => `remote "${remoto}" not configured: local merge done, no push to prove`,
+    passoSemPush: (motivo) => `no push: ${motivo}`,
+    passoProvaDoPush: (remoto, para) => `git ls-remote ${remoto} refs/heads/${para}   (push proof)`,
+    passoMerge: (de) => `git merge --no-ff ${de} -m "<ship message>"`,
+    autorizeNaEntrega: (thread) => `ork ship ${thread} --para <branch> --autorizar-push <who>`,
+    leaseComOutra: (lease, thread, desde, motivo, posicao) => `lease ${lease} is held by thread ${thread} since ${desde} (${motivo}); this thread joined the merge queue at position ${posicao}`,
+    desconhecida: '(unknown)',
+    semMotivo: 'no reason',
+    humano: 'a human',
+    arvoreSuja: (para, dona) => `target branch "${para}" is checked out at ${dona} with uncommitted changes; commit or revert them there before shipping`,
+    arvoreNaoMontada: (para, erro) => `could not set up the merge tree for "${para}": ${erro}`,
+    arvoreCorrecao: 'leave the target branch tree clean (or free the branch) and run ship again',
+    mergeFalhou: (de, para, erro) => `merge of ${de} into ${para} failed: ${erro}`,
+    mergeFalhouCorrecao: 'resolve the conflict on the thread branch and run ship again',
+    headIlegivel: 'could not read HEAD after the merge',
+    confiraRepositorio: 'check the repository',
+    naoAncestral: (de, merge) => `the ${de} commit is not an ancestor of merge ${merge}`,
+    naoEmpurre: 'do not push: investigate the repository state',
+    semPrimeiroPai: (de, para) => `${de} is already an ancestor of ${para}, but git found no first-parent commit that brought it in`,
+    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, 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', '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'}"`,
+    docPendenteComando: (comando) => `    ${comando}   (in a docs PR on top of the updated base)`,
+    registradas: (n) => `${n} delivery(ies) recorded. Close only this delivery through MASTER (a human score overrides):`,
+    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}`,
+    prRegistraria: (merge) => `dry run: would record ship_done from merge ${merge} of the PR (nothing written)`,
+    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, 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}`,
+    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' },
+        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})`,
+        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]',
+        semAutorizarPush: 'error: ork ship publicar does not accept --autorizar-push: it only publishes in the mode that already ' +
+            'authorizes the push (#Auto and #Maestro); in the other modes, the push belongs to the owner, in their own terminal',
+        cabecalho: (dryRun, thread, tag) => `${dryRun ? 'ork ship publicar (--dry-run, nothing was published or written)' : 'ork ship publicar'}: thread ${thread} (${tag})`,
+        linhaBranch: (branch, sha) => `  branch        ${branch} @ ${sha}`,
+        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, 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' },
+        threadInexistente: (thread, erro) => `thread ${thread} was not read in this project: ${erro}`,
+        threadInexistenteCorrecao: 'check the thread id (ork thread status <thread>)',
+        threadFechada: (thread) => `thread ${thread} is closed; nothing to publish`,
+        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`,
+        semBranchCorrecao: (thread) => `check the thread worktree (ork worktree ensure ${thread})`,
+        branchEBase: (base) => `the thread branch is the base ${base}; publishing the base without a merge is the direct push that ork ship blocks`,
+        branchEBaseCorrecao: 'the delivery comes from a thread branch (ork/<thread>), never from the base',
+        semProduto: (branch, base) => `branch ${branch} has no commit outside ${base}; nothing to publish`,
+        semProdutoCorrecao: 'commit the thread work through the GO session before publishing',
+        checkSemCiclo: (tag) => `the ${tag} cycle has no CHECK`,
+        checkAusente: 'the thread docs/check.md was not written yet',
+        checkSemVeredito: 'docs/check.md does not have exactly one verdict',
+        checkOutroVeredito: (veredito) => `the CHECK verdict is ${veredito}`,
+        checkVelho: (sha) => `the CHECK with PASSOU is older than commit ${sha}`,
+        checkFeito: 'CHECK with verdict PASSOU after the last product commit',
+        comandoDoCheck: (thread) => `ork phase run ${thread} CHECK --prompt "<phase request>"`,
+        checkCorrecao: (thread) => `run the thread CHECK on HEAD and write the verdict PASSOU (ork phase run ${thread} CHECK --prompt "<phase request>")`,
+        verifyAusente: 'no ork verify written in the thread',
+        verifyReprovou: (sha, motivos) => `the last ork verify failed at commit ${sha} (${motivos})`,
+        verifyAntigo: (sha) => `the last green ork verify was at commit ${sha}, and HEAD changed after it beyond the bundle`,
+        verifyNoHead: (sha) => `green ork verify at HEAD ${sha}`,
+        verifySoBundle: (sha) => `green ork verify at commit ${sha}; after it, only the bundle`,
+        verifySoClaims: (sha) => `the last ork verify (commit ${sha}) ran only the claims, without the manifest build and test`,
+        verifyCorrecao: (thread) => `run ork verify ${thread} on HEAD and fix it before publishing`,
+        bundleAusente: (arquivo) => `the bundle ${arquivo} is not on HEAD`,
+        bundleInvalido: (arquivo) => `the bundle ${arquivo} on HEAD does not open as this thread's ork.ci-bundle/v1`,
+        bundleOutraBranch: (arquivo, branch) => `the bundle ${arquivo} on HEAD belongs to branch ${branch}`,
+        bundleVelho: (faltam, sobram) => `the bundle on HEAD is stale` +
+            `${faltam ? `: claims ${faltam} are missing` : ''}${sobram ? `${faltam ? ';' : ':'} claims ${sobram} are left over` : ''}`,
+        bundleMudou: (ids) => `the bundle on HEAD is stale: the command of claims ${ids} changed after it`,
+        bundleManifestoMudou: 'the bundle on HEAD is stale: the manifest verify commands changed after it',
+        bundleFeito: (n) => `bundle on HEAD with the ${n} active claims and their commands`,
+        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, 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, 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, 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, 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)`,
+        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',
+        commitsSemPush: (remota, head) => `the remote is at ${remota} and HEAD at ${head}: there are commits without push`,
+        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, 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, gitlab = false) => `${rotuloDoPedido(n, gitlab)} merged`,
+        ciDoMesclado: 'PR merged; ork ship registrar-pr checks the CI on the head',
+        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, 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',
+        mergeSemRegistro: (sha) => `merge ${sha} on the base, without ship_done`,
+        semShipDone: 'no ship_done yet',
+        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, 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, 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.`,
+        prsNaoResponderam: (erro) => `Warning: the PRs were not read (${erro}); PR, CI and conflict were left unread.`,
+        linhaDaThread: (thread, tag, branch) => `  ${thread}  ${tag}  ${branch}`,
+        nomeDaEtapa: (id) => ({ check: 'CHECK', verify: 'verify', bundle: 'bundle', branch: 'branch', pr: 'PR', ci: 'CI',
+            conflito: 'conflict', entrega: 'delivery' }[id] ?? id),
+        marcaDaEtapa: (estado) => ({ 'feita': 'ok', 'pendente': '...', 'falhou': 'X', 'nao-lida': '?', 'nao-se-aplica': '-' }[estado] ?? estado),
+        linhaDoProximo: (texto, comando) => `    next: ${texto}${comando ? ` (${comando})` : ''}`,
+    },
+};