@orkastery/cli 0.5.3 → 0.5.6

package/dist/locale-roadmap.js

@@ -0,0 +1,102 @@
+"use strict";
+/**
+ * RM-061, fatia F2b: a familia `roadmap` do catalogo de mensagens (`ork roadmap status` em texto; o `--json`
+ * nao muda). O pt-BR e a fonte; o ingles e tipado por ele. Sem import do nucleo.
+ *
+ * Sai como veio: o titulo e o que esta em aberto de cada item (dado do `docs/roadmap`), a pergunta que espera
+ * o dono (dado do pedido HITL), o estado e o proximo passo da entrega (familia de entregas, G5) e o bloco
+ * `Projeto consultado:` / `Não lido:` do RM-052, que os hosts leem e fica igual nas duas linguas (D14 da F2a).
+ * O titulo do grupo e dado do contrato e so se traduz na impressao, pelo id. Data em ingles em ISO (D2 da RM-061).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ROADMAP_EN = exports.ROADMAP_PT_BR = void 0;
+exports.ROADMAP_PT_BR = {
+    titulo: (projeto, p) => `Roadmap do ${projeto} (${p.dia}/${p.mes}, ${p.hora}:${p.minuto})`,
+    /** O titulo de cada grupo pelo id (o `--json` guarda o titulo pt-BR). */
+    grupos: { concluidos: 'Concluídos', disponiveis: 'Disponíveis com algo em aberto', hoje: 'Entregue hoje', piloto: 'Piloto',
+        desenvolvimento: 'Em desenvolvimento', refinamento: 'Refinamento', proposto: 'Proposto', descontinuado: 'Descontinuado' },
+    eMais: (n) => `• e mais ${n}`,
+    precisaDeVoce: 'O que precisa de você',
+    responda: (codigo, letra) => ` Responda ${codigo} ${letra} (ou outra letra).`,
+    chegaNoResumo: ' A pergunta chega no próximo resumo.',
+    nadaAgora: '• Nada agora.',
+    foraDoRoadmap: (n) => `• Fora do roadmap: ${n} thread(s) esperam você (ork pulse).`,
+    hitlDeConducao: (abertas, mediana) => `• HITL de condução: ${abertas} aberta(s); ${mediana}.`,
+    emSeguida: 'O que eu faço em seguida',
+    nadaEmAndamento: '• Nada em andamento; sigo o que você priorizar.',
+    prLido: (hora) => ` (PR lido às ${hora})`,
+    sigoComEstado: (item, thread, fase, maquina, estado, leitura) => `• ${item}: sigo ${thread} na fase ${fase}${maquina}; ${estado}${leitura}.`,
+    comEstado: (item, thread, fase, maquina, estado, leitura) => `• ${item}: ${thread} na fase ${fase}${maquina}, ${estado}${leitura}.`,
+    sigo: (item, thread, fase, maquina) => `• ${item}: sigo ${thread} na fase ${fase}${maquina}.`,
+    /** RM-063 (F2): a thread sem sessao viva verificada no runtime: desde quando e por que (o estado da entrega, quando ha). */
+    parada: (item, thread, maquina, desde, motivo, estado) => `• ${item}: ${thread}${maquina} parada${desde ? ` desde ${desde}` : ''}: ${motivo}${estado ? `; ${estado}` : ''}.`,
+    semSessaoVerificada: (item, thread, fase, maquina) => `• ${item}: ${thread} na fase ${fase}${maquina}, sem sessão verificada no runtime.`,
+    /** RM-063 (F2): a fila do `ork pulse` no fecho. */
+    filaNaoLida: (detalhe) => `• Fila do pulse não lida inteira${detalhe ? ` (${detalhe})` : ''}: confira com ork pulse.`,
+    responder: (comando) => ` Responder: ${comando}`,
+    sessaoSemThread: (id) => `sessão ${id}`,
+    /** RM-063 (F2): por que a thread parou, pelo tipo; o detalhe e dado (o ledger, o runtime). */
+    motivoDaParada: {
+        nenhumaSessao: (fase) => `nenhuma sessão despachada na fase ${fase}`,
+        despachoFalhou: (fase, detalhe) => `despacho${fase ? ` de ${fase}` : ''} falhou (${detalhe})`,
+        sessaoCaiu: (sessao, motivo) => `sessão ${sessao} caiu (${motivo})`,
+        runtimeSemResposta: (runtime, detalhe, sessao) => `runtime ${runtime} sem resposta${detalhe ? ` (${detalhe})` : ''}; a sessão ${sessao} não foi verificada`,
+        naoAparece: (sessao) => `sessão ${sessao} não aparece no runtime`,
+        fantasma: (sessao) => `sessão ${sessao} sem processo (fantasma)`,
+        encerrada: (sessao, estado) => `sessão ${sessao} encerrada (${estado})`,
+        naoLida: (detalhe) => `vida da sessão não lida (${detalhe})`,
+        semAtividade: (sessao, minutos) => `sessão ${sessao} sem atividade no rollout há ${minutos} min`,
+        retratoVelho: (minutos) => `retrato da máquina sem atualização há ${minutos} min; a sessão não foi reverificada`,
+    },
+    fabricaNaoLida: (motivo) => `Fábrica: não lido (${motivo}).`,
+    fabricaSemCopia: (branch) => `esta máquina não tem cópia local de ${branch}`,
+    fabricaClone: (branch) => `clone parcial: a cópia local de ${branch} não é lida sem rede`,
+    fabricaIlegivel: (branch) => `a cópia local de ${branch} está ilegível`,
+    fabricaVelha: (branch, ultimo) => `Fábrica: a cópia local de ${branch} está velha (${ultimo
+        ? `esta máquina publicou nela por último em ${ultimo}` : 'esta máquina não aparece nela'}); não dá para dizer quem está sem batida.`,
+    semBatida: (maquina, idade, retrato) => `${maquina} sem batida há ${idade} (último retrato ${retrato})`,
+    fabricaSemBatida: (maquinas, branch) => `Fábrica: ${maquinas}, pela cópia local de ${branch}.`,
+};
+exports.ROADMAP_EN = {
+    titulo: (projeto, p) => `${projeto} roadmap (${p.ano}-${p.mes}-${p.dia} ${p.hora}:${p.minuto})`,
+    grupos: { concluidos: 'Done', disponiveis: 'Available with something open', hoje: 'Shipped today', piloto: 'Pilot',
+        desenvolvimento: 'In development', refinamento: 'Refinement', proposto: 'Proposed', descontinuado: 'Discontinued' },
+    eMais: (n) => `• and ${n} more`,
+    precisaDeVoce: 'What needs you',
+    responda: (codigo, letra) => ` Reply ${codigo} ${letra} (or another letter).`,
+    chegaNoResumo: ' The question comes in the next summary.',
+    nadaAgora: '• Nothing right now.',
+    foraDoRoadmap: (n) => `• Outside the roadmap: ${n} thread(s) waiting for you (\`ork pulse\`).`,
+    hitlDeConducao: (abertas, mediana) => `• Conduction HITL: ${abertas} open; ${mediana}.`,
+    emSeguida: 'What I do next',
+    nadaEmAndamento: '• Nothing in progress; next is whatever you prioritize.',
+    prLido: (hora) => ` (PR read at ${hora})`,
+    sigoComEstado: (item, thread, fase, maquina, estado, leitura) => `• ${item}: I continue with ${thread} in phase ${fase}${maquina}; ${estado}${leitura}.`,
+    comEstado: (item, thread, fase, maquina, estado, leitura) => `• ${item}: ${thread} in phase ${fase}${maquina}, ${estado}${leitura}.`,
+    sigo: (item, thread, fase, maquina) => `• ${item}: I continue with ${thread} in phase ${fase}${maquina}.`,
+    parada: (item, thread, maquina, desde, motivo, estado) => `• ${item}: ${thread}${maquina} stopped${desde ? ` since ${desde}` : ''}: ${motivo}${estado ? `; ${estado}` : ''}.`,
+    semSessaoVerificada: (item, thread, fase, maquina) => `• ${item}: ${thread} in phase ${fase}${maquina}, no session verified in the runtime.`,
+    filaNaoLida: (detalhe) => `• Pulse queue not fully read${detalhe ? ` (${detalhe})` : ''}: check \`ork pulse\`.`,
+    responder: (comando) => ` Reply: ${comando}`,
+    sessaoSemThread: (id) => `session ${id}`,
+    motivoDaParada: {
+        nenhumaSessao: (fase) => `no session dispatched in phase ${fase}`,
+        despachoFalhou: (fase, detalhe) => `dispatch${fase ? ` of ${fase}` : ''} failed (${detalhe})`,
+        sessaoCaiu: (sessao, motivo) => `session ${sessao} went down (${motivo})`,
+        runtimeSemResposta: (runtime, detalhe, sessao) => `runtime ${runtime} not responding${detalhe ? ` (${detalhe})` : ''}; session ${sessao} was not verified`,
+        naoAparece: (sessao) => `session ${sessao} does not appear in the runtime`,
+        fantasma: (sessao) => `session ${sessao} with no process (ghost)`,
+        encerrada: (sessao, estado) => `session ${sessao} ended (${estado})`,
+        naoLida: (detalhe) => `session liveness not read (${detalhe})`,
+        semAtividade: (sessao, minutos) => `session ${sessao} with no rollout activity for ${minutos} min`,
+        retratoVelho: (minutos) => `machine snapshot not updated for ${minutos} min; the session was not re-verified`,
+    },
+    fabricaNaoLida: (motivo) => `Factory: not read (${motivo}).`,
+    fabricaSemCopia: (branch) => `this machine has no local copy of ${branch}`,
+    fabricaClone: (branch) => `partial clone: the local copy of ${branch} is not read without network`,
+    fabricaIlegivel: (branch) => `the local copy of ${branch} is unreadable`,
+    fabricaVelha: (branch, ultimo) => `Factory: the local copy of ${branch} is stale (${ultimo
+        ? `this machine last published to it at ${ultimo}` : 'this machine does not appear in it'}); there is no telling which machine has no heartbeat.`,
+    semBatida: (maquina, idade, retrato) => `${maquina} with no heartbeat for ${idade} (last snapshot ${retrato})`,
+    fabricaSemBatida: (maquinas, branch) => `Factory: ${maquinas}, from the local copy of ${branch}.`,
+};

package/dist/locale-ship.js

@@ -0,0 +1,494 @@
+"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;
+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`,
+    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}`,
+    pushFalhouCorrecao: 'resolva o acesso ao remoto e rode o ship de novo (o merge local ja aconteceu)',
+    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`,
+    ciConsultaFalhou: 'consulta ao GitHub falhou',
+    ciRespostaInvalida: 'GitHub devolveu uma resposta de checks inválida',
+    ciSemCheck: (contexto) => `check ${contexto} não encontrado no commit`,
+    ciVerde: 'CHECK independente verde no GitHub',
+    ciEstado: (contexto, status, conclusao) => `check ${contexto}: ${status}/${conclusao || 'sem conclusão'}`,
+    // 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' },
+    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}`,
+    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) => `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'}`,
+    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}`,
+    // 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) => `  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}`,
+        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) => `o remoto ${remoto} não é um repositório do GitHub; o ork ship publicar abre PR só no GitHub`,
+        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`,
+        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)`,
+        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.`,
+        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'}`,
+        // 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) => `o PR #${n} 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`,
+        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}`,
+        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`,
+        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) => `publique os commits novos no PR #${n}`,
+        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`,
+        // 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`,
+    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}`,
+    pushFalhouCorrecao: 'fix the access to the remote and run ship again (the local merge already happened)',
+    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`,
+    ciConsultaFalhou: 'GitHub query failed',
+    ciRespostaInvalida: 'GitHub returned an invalid checks response',
+    ciSemCheck: (contexto) => `check ${contexto} not found on the commit`,
+    ciVerde: 'independent CHECK green on GitHub',
+    ciEstado: (contexto, status, conclusao) => `check ${contexto}: ${status}/${conclusao || 'no conclusion'}`,
+    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' },
+    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}`,
+    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) => `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'}`,
+    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}`,
+    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) => `  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}`,
+        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) => `remote ${remoto} is not a GitHub repository; ork ship publicar only opens PRs on GitHub`,
+        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`,
+        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)`,
+        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.`,
+        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'}`,
+        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) => `PR #${n} 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`,
+        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`,
+        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`,
+        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) => `publish the new commits to PR #${n}`,
+        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`,
+        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})` : ''}`,
+    },
+};