@orkastery/cli 0.5.3 → 0.6.0

package/dist/ship-publicar.js

@@ -0,0 +1,971 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ETAPAS = exports.MODOS_QUE_PUBLICAM = exports.CONTRATO_DA_PISTA = exports.CONTRATO_DA_PUBLICACAO = void 0;
+exports.conferirCheck = conferirCheck;
+exports.conferirBundle = conferirBundle;
+exports.manifestoDaBranch = manifestoDaBranch;
+exports.tituloDoPr = tituloDoPr;
+exports.entreAspas = entreAspas;
+exports.comandoDoDono = comandoDoDono;
+exports.publicarEntrega = publicarEntrega;
+exports.linhasDaPublicacao = linhasDaPublicacao;
+exports.pistaDeEntrega = pistaDeEntrega;
+/**
+ * RM-059 (fatia F7, T7.1; DD4 do plano dos mods): a publicacao provada da branch e do PR, e a pista da entrega.
+ *
+ * Ate aqui, quem publicava a branch de uma thread #Auto e abria o PR era o script do condutor externo, fora do
+ * nucleo e sem prova pelo remoto. O `ork ship publicar` faz o mesmo pelo nucleo, e so no modo que ja autoriza o
+ * push pela #TAG (#Auto e #Maestro, a mesma lista do `ork ship`):
+ *
+ *  1. confere, antes de qualquer efeito, a thread, o modo, a conducao, a branch, o CHECK, o verify e o bundle no
+ *     HEAD, o remoto, a ponta da branch nele e os PRs da branch; a recusa volta tipada e nada vai ao ledger (D2 da
+ *     thread ork-rm059pista);
+ *  2. empurra sem forca o sha conferido, e nao a ref, com refspec explicito, e prova pelo `git ls-remote` (a prova do
+ *     `ork ship`);
+ *  3. reaproveita o PR (MR no GitLab) aberto da branch ou abre um com o texto do `pr-body.md` da thread, e prova pela releitura da
+ *     lista;
+ *  4. grava `ship_published` com a prova, so quando houve efeito; o push sem prova tambem vai. Repetido, ou com o PR
+ *     ja mesclado no HEAD, devolve `ja-publicada`.
+ *
+ * A pista (`ork ship pista`) e a leitura que a Pista de Entrega do Claude Code desenha: por thread aberta que ja
+ * esta na entrega, as etapas do CHECK ao `ship_done` e o proximo passo que o nucleo declara disponivel. Ela nao
+ * grava nada: uma leitura do remoto (`git ls-remote --heads`) e uma da forja (`lerPrsDaForja`) por chamada.
+ *
+ * Merge, tag e promocao de site continuam fora daqui: o merge e do dono ou do condutor, e o `ship_done` do PR e do
+ * `ork ship registrar-pr`.
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const branch_de_estado_1 = require("./branch-de-estado");
+const ci_1 = require("./ci");
+const api_1 = require("./forja/api");
+const cli_1 = require("./forja/cli");
+const pedidos_1 = require("./forja/gitlab/pedidos");
+const registro_1 = require("./forja/registro");
+const resolver_1 = require("./forja/resolver");
+const cache_1 = require("./forja/cache");
+const texto_1 = require("./forja/texto");
+const claims_1 = require("./claims");
+const ledger_1 = require("./ledger");
+const manifest_1 = require("./manifest");
+const modos_1 = require("./modos");
+const parado_no_condutor_1 = require("./parado-no-condutor");
+const entrega_pr_1 = require("./entrega-pr");
+const noctum_guarda_1 = require("./noctum-guarda");
+const ship_1 = require("./ship");
+const session_watcher_claude_1 = require("./session-watcher-claude");
+const thread_1 = require("./thread");
+const util_1 = require("./util");
+const verify_1 = require("./verify");
+const worktree_1 = require("./worktree");
+const locale_1 = require("./locale");
+exports.CONTRATO_DA_PUBLICACAO = 'ork.ship-publicar/v1';
+exports.CONTRATO_DA_PISTA = 'ork.ship-pista/v1';
+/** Os modos em que a #TAG ja autoriza o push: a mesma lista do `ork ship` (`autorizacaoDePush`); o `publicar` so age neles. */
+exports.MODOS_QUE_PUBLICAM = ship_1.MODOS_QUE_AUTORIZAM_PUSH;
+const SHA = /^[0-9a-f]{40}$/;
+/** O `pr-body.md` maior que isto nao e corpo de PR: o `publicar` usa o corpo padrao. */
+const TETO_DO_CORPO = 64 * 1024;
+/**
+ * Prazos de cada chamada de rede. No pior caso, ls-remote, lista de PRs, push, ls-remote, criacao e releitura somam
+ * 435 s, abaixo dos 10 min que o motor do Claude Code da a um processo de mod (a Pista espera 9 min pelo publicar).
+ */
+const PRAZO_DO_GH_MS = 45000;
+const PRAZO_DO_PUSH_MS = 180000;
+const PRAZO_DO_LS_REMOTE_MS = 60000;
+/** Git local sem rede escondida nem pergunta de credencial no terminal. */
+function git(raiz, args, prazoMs = 60000) {
+    return (0, util_1.exec)('git', args, raiz, prazoMs, { ...process.env, GIT_NO_LAZY_FETCH: '1', GIT_TERMINAL_PROMPT: '0' });
+}
+const curto = (sha) => (sha ? sha.slice(0, 7) : '-');
+exports.ETAPAS = ['check', 'verify', 'bundle', 'branch', 'pr', 'ci', 'conflito', 'entrega'];
+const etapa = (id, estado, texto) => ({ id, estado, texto });
+/** Os caminhos mudados so cabem no bundle (`.ork-ci/`)? Lista vazia tambem nao e produto. */
+function soOBundle(caminhos) {
+    return caminhos.split('\n').map((l) => l.trim()).filter(Boolean).every((l) => l.startsWith('.ork-ci/'));
+}
+/**
+ * O ultimo commit de produto da branch, com a hora do commit. Merge nao conta, nem o commit que so mexe em `.ork-ci/`
+ * (o bundle): decide o conteudo do commit, e nao o assunto, porque `ci(` tambem e o tipo de commit de workflow.
+ */
+function ultimoCommitDeProduto(raiz, baseRef, head) {
+    const r = git(raiz, ['log', '--no-merges', '--format=%H%x09%ct', baseRef ? `${baseRef}..${head}` : head, '-n', '200']);
+    if (!r.ok)
+        return null;
+    for (const linha of r.stdout.split('\n')) {
+        const [sha, ct] = linha.split('\t');
+        if (!sha || !SHA.test(sha))
+            continue;
+        const mudou = git(raiz, ['diff-tree', '--no-commit-id', '--name-only', '-r', '--root', sha]);
+        if (mudou.ok && soOBundle(mudou.stdout))
+            continue;
+        const em = Number(ct) * 1000;
+        if (Number.isFinite(em))
+            return { sha, em };
+    }
+    return null;
+}
+/**
+ * O CHECK: exatamente um veredito, PASSOU, gravado depois do ultimo commit de produto. RM-063 (F7): a batida da conducao
+ * tambem o le antes do merge do PR, para nada entrar na base sem ter passado pelo CHECK.
+ */
+function conferirCheck(raiz, t, baseRef, head) {
+    if (!(t.fases ?? []).includes('CHECK')) {
+        return { etapa: etapa('check', 'nao-se-aplica', (0, locale_1.textoDoCatalogo)((m) => m.ship.publicar.checkSemCiclo((0, modos_1.tagDoModo)(t.modo)))), passou: true };
+    }
+    const artefato = (0, session_watcher_claude_1.estadoDoArtefato)(raiz, t.id, 'docs/check.md');
+    if (artefato.texto === null || artefato.mtimeMs === null) {
+        return { etapa: etapa('check', 'pendente', (0, locale_1.textoDoCatalogo)((m) => m.ship.publicar.checkAusente)), passou: false };
+    }
+    const veredito = (0, session_watcher_claude_1.vereditoDoParecer)(artefato.texto);
+    if (veredito === null)
+        return { etapa: etapa('check', 'pendente', (0, locale_1.textoDoCatalogo)((m) => m.ship.publicar.checkSemVeredito)), passou: false };
+    if (veredito !== 'PASSOU') {
+        return { etapa: etapa('check', 'pendente', (0, locale_1.textoDoCatalogo)((m) => m.ship.publicar.checkOutroVeredito(veredito))), passou: false };
+    }
+    const ultimo = head ? ultimoCommitDeProduto(raiz, baseRef, head) : null;
+    if (ultimo && artefato.mtimeMs < ultimo.em) {
+        return { etapa: etapa('check', 'pendente', (0, locale_1.textoDoCatalogo)((m) => m.ship.publicar.checkVelho(curto(ultimo.sha)))), passou: true };
+    }
+    return { etapa: etapa('check', 'feita', (0, locale_1.textoDoCatalogo)((m) => m.ship.publicar.checkFeito)), passou: true };
+}
+/**
+ * O verify: o ultimo `verify_run` passou, com os comandos do manifesto (`esperados`, o build e o test), no HEAD ou num
+ * ancestral dele com so `.ork-ci/` mudando depois.
+ */
+function conferirVerify(raiz, eventos, head, esperados) {
+    const ultimo = [...eventos].reverse().find((e) => e.tipo === ledger_1.TIPOS_DE_EVENTO.verificacao);
+    if (!ultimo)
+        return etapa('verify', 'pendente', (0, locale_1.textoDoCatalogo)((m) => m.ship.publicar.verifyAusente));
+    const commit = typeof ultimo.commit === 'string' && SHA.test(ultimo.commit) ? ultimo.commit : null;
+    if (ultimo.veredito !== 'verdade sustentada') {
+        const motivos = Array.isArray(ultimo.motivos) ? ultimo.motivos.map(String).join(', ') : '';
+        return etapa('verify', 'pendente', (0, locale_1.textoDoCatalogo)((m) => m.ship.publicar.verifyReprovou(curto(commit), motivos || '-')));
+    }
+    // S2 da revisao: o `ork verify --so-claims` nao roda o build nem o test do manifesto; nao vale como verify do HEAD.
+    if (esperados > 0 && (!Array.isArray(ultimo.comandos) || ultimo.comandos.length === 0)) {
+        return etapa('verify', 'pendente', (0, locale_1.textoDoCatalogo)((m) => m.ship.publicar.verifySoClaims(curto(commit))));
+    }
+    if (!commit || !head)
+        return etapa('verify', 'pendente', (0, locale_1.textoDoCatalogo)((m) => m.ship.publicar.verifyAntigo(curto(commit))));
+    if (commit === head)
+        return etapa('verify', 'feita', (0, locale_1.textoDoCatalogo)((m) => m.ship.publicar.verifyNoHead(curto(head))));
+    const ancestral = git(raiz, ['merge-base', '--is-ancestor', commit, head]).ok;
+    const diff = ancestral ? git(raiz, ['diff', '--name-only', '--no-renames', commit, head]) : null;
+    const soBundle = !!diff?.ok && soOBundle(diff.stdout);
+    return soBundle ? etapa('verify', 'feita', (0, locale_1.textoDoCatalogo)((m) => m.ship.publicar.verifySoBundle(curto(commit))))
+        : etapa('verify', 'pendente', (0, locale_1.textoDoCatalogo)((m) => m.ship.publicar.verifyAntigo(curto(commit))));
+}
+/**
+ * O bundle no HEAD: desta thread, desta branch, com exatamente as claims ativas (sem claim retirada nem faltando), o
+ * comando de cada uma como esta agora e os comandos do manifesto que o runner roda.
+ */
+function conferirBundle(raiz, t, branch, head, comandos) {
+    const arquivo = `.ork-ci/${t.id}.json`;
+    if (!head)
+        return etapa('bundle', 'pendente', (0, locale_1.textoDoCatalogo)((m) => m.ship.publicar.bundleAusente(arquivo)));
+    const r = git(raiz, ['show', `${head}:${arquivo}`]);
+    if (!r.ok)
+        return etapa('bundle', 'pendente', (0, locale_1.textoDoCatalogo)((m) => m.ship.publicar.bundleAusente(arquivo)));
+    let bundle;
+    try {
+        bundle = JSON.parse(r.stdout);
+        if (bundle.schema !== 'ork.ci-bundle/v1' || bundle.thread !== t.id || !Array.isArray(bundle.claims))
+            throw new Error('formato');
+    }
+    catch {
+        return etapa('bundle', 'pendente', (0, locale_1.textoDoCatalogo)((m) => m.ship.publicar.bundleInvalido(arquivo)));
+    }
+    if (typeof bundle.branch === 'string' && bundle.branch !== branch) {
+        return etapa('bundle', 'pendente', (0, locale_1.textoDoCatalogo)((m) => m.ship.publicar.bundleOutraBranch(arquivo, String(bundle.branch))));
+    }
+    const noBundle = new Set([...bundle.claims.map((c) => c.id), ...(bundle.deferredClaims ?? []).map((c) => c.id)]);
+    let claimsAtivas = [];
+    try {
+        claimsAtivas = (0, claims_1.lerClaims)(raiz, t.id).filter((c) => c.estado !== 'retirada');
+    }
+    catch { /* sem claims: lista vazia */ }
+    const ativas = claimsAtivas.map((c) => c.id);
+    const faltam = ativas.filter((id) => !noBundle.has(id));
+    const sobram = [...noBundle].filter((id) => !ativas.includes(id));
+    if (faltam.length || sobram.length) {
+        return etapa('bundle', 'pendente', (0, locale_1.textoDoCatalogo)((m) => m.ship.publicar.bundleVelho(faltam.join(', '), sobram.join(', '))));
+    }
+    // A14 da revisao (rodada 2): a claim que mudou de comando sem mudar de id (o `ork claims anexar`) deixa o bundle velho,
+    // e o runner rodaria o comando antigo; o mesmo vale para os comandos do manifesto que o bundle leva.
+    const comandoDe = new Map(claimsAtivas.map((c) => [c.id, JSON.stringify(c.verificar)]));
+    const mudaram = bundle.claims.filter((c) => comandoDe.has(c.id) && comandoDe.get(c.id) !== JSON.stringify(c.verificar)).map((c) => c.id);
+    if (mudaram.length)
+        return etapa('bundle', 'pendente', (0, locale_1.textoDoCatalogo)((m) => m.ship.publicar.bundleMudou(mudaram.join(', '))));
+    if (JSON.stringify(bundle.commands ?? []) !== JSON.stringify(comandos)) {
+        return etapa('bundle', 'pendente', (0, locale_1.textoDoCatalogo)((m) => m.ship.publicar.bundleManifestoMudou));
+    }
+    return etapa('bundle', 'feita', (0, locale_1.textoDoCatalogo)((m) => m.ship.publicar.bundleFeito(ativas.length)));
+}
+/**
+ * O manifesto que vale para o verify e o bundle de uma branch: o do HEAD dela (A15 da revisao, rodada 3). O `ork verify`
+ * e o `ork ci prepare` rodam na worktree, com o `orkastery.yaml` da branch, e o runner do CI roda o codigo dela; quem
+ * chama o publicar (a Pista, o condutor) pode estar noutro checkout, com outro manifesto. Sem manifesto versionado no
+ * HEAD, ou ilegivel, vale o de quem chama.
+ */
+function manifestoDaBranch(carregado, head) {
+    if (!head)
+        return carregado;
+    for (const nome of [manifest_1.NOME_MANIFESTO, manifest_1.NOME_MANIFESTO_LEGADO]) {
+        const r = git(carregado.raiz, ['show', `${head}:./${nome}`]);
+        if (!r.ok)
+            continue;
+        const doHead = (0, manifest_1.comandosDoTextoDoManifesto)(r.stdout);
+        if (!doHead)
+            return carregado;
+        return { ...carregado, manifesto: { ...carregado.manifesto,
+                verify: { ...carregado.manifesto.verify, typecheck: doHead.typecheck, build: doHead.build, test: doHead.test, security_scan: doHead.securityScan },
+                ci: { ...carregado.manifesto.ci, command: doHead.ciCommand } } };
+    }
+    return carregado;
+}
+function fatosDaThread(carregado, t, refs, baseRef, quando) {
+    const raiz = carregado.raiz;
+    let eventos = [];
+    try {
+        eventos = (0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, t.id));
+    }
+    catch { /* ledger ilegivel: sem verify nem conducao provada */ }
+    const branch = (0, worktree_1.branchDaWorktree)(t);
+    const head = (0, branch_de_estado_1.branchValida)(branch) ? refs.get(`refs/heads/${branch}`) ?? null : null;
+    const daBranch = manifestoDaBranch(carregado, head);
+    const esperados = (0, verify_1.comandosDoManifesto)(daBranch.manifesto).length;
+    const contagem = head && baseRef ? git(raiz, ['rev-list', '--count', `${baseRef}..${head}`]) : null;
+    const comProduto = !!contagem?.ok && Number(contagem.stdout.trim()) > 0;
+    const check = conferirCheck(raiz, t, baseRef, head);
+    return {
+        t, eventos, branch, head, comProduto, conducao: (0, parado_no_condutor_1.conducaoAgora)(raiz, t, eventos, quando),
+        check: check.etapa, checkPassou: check.passou, verify: conferirVerify(raiz, eventos, head, esperados),
+        bundle: conferirBundle(raiz, t, branch, head, (0, ci_1.comandosDoBundle)(daBranch)),
+    };
+}
+/** A base de comparacao: a copia do remoto primeiro (a base local desta maquina pode estar parada). */
+function refDaBase(refs, remoto, base) {
+    return [`refs/remotes/${remoto}/${base}`, `refs/heads/${base}`].find((r) => refs.has(r)) ?? null;
+}
+// ---------------------------------------------------------------------------
+// O remoto e a forja.
+// ---------------------------------------------------------------------------
+/**
+ * A ponta da branch no remoto pelo `ls-remote`: `null` quando ela nao existe la; `erro` quando o git nao respondeu. Vale
+ * so a linha da ref exata: o padrao do `ls-remote` casa por sufixo (`refs/heads/a/refs/heads/<branch>` tambem casaria).
+ */
+function pontaNoRemoto(raiz, remoto, branch) {
+    const r = git(raiz, ['ls-remote', '--', remoto, `refs/heads/${branch}`], PRAZO_DO_LS_REMOTE_MS);
+    if (!r.ok)
+        return { sha: null, erro: (0, texto_1.deFora)(r.stderr || r.stdout || `codigo ${r.code}`) };
+    const alvo = `refs/heads/${branch}`;
+    const linha = r.stdout.split('\n').map((l) => l.trim().split(/\s+/)).find((partes) => partes[1] === alvo);
+    const sha = linha?.[0] ?? '';
+    return { sha: SHA.test(sha) ? sha : null, erro: null };
+}
+/**
+ * O sha do remoto esta contido no HEAD local? Sem o objeto nesta copia, a resposta tambem e nao: se ele fosse ancestral
+ * do HEAD, a copia o teria (A3 da revisao). `null` so quando o git nao respondeu.
+ */
+function remotoContido(raiz, remota, head) {
+    if (!git(raiz, ['cat-file', '-e', `${remota}^{commit}`]).ok)
+        return false;
+    const r = git(raiz, ['merge-base', '--is-ancestor', remota, head]);
+    return r.code === 0 ? true : r.code === 1 ? false : null;
+}
+/** As pontas de todas as branches do remoto numa chamada so. */
+function pontasNoRemoto(raiz, remoto) {
+    const r = git(raiz, ['ls-remote', '--heads', '--', remoto], PRAZO_DO_LS_REMOTE_MS);
+    if (!r.ok)
+        return null;
+    const mapa = new Map();
+    for (const linha of r.stdout.split('\n')) {
+        const [sha, ref] = linha.trim().split(/\s+/);
+        if (sha && ref && SHA.test(sha) && ref.startsWith('refs/heads/'))
+            mapa.set(ref.slice('refs/heads/'.length), sha);
+    }
+    return mapa;
+}
+/**
+ * O tipo da forja sem rede nem CLI, para o comando que o dono roda: o fixado, o bloco `forja:`, o host conhecido ou a
+ * sondagem que ja esta no cache de 24 h. Remoto sem host (caminho local) segue o GitHub de sempre; host proprio que
+ * nada disso resolve da `null`, e o comando do dono mostra as duas forjas.
+ */
+function tipoSemRede(carregado, remoto, fixado) {
+    if (fixado)
+        return fixado;
+    if (carregado.manifesto.forja?.tipo)
+        return carregado.manifesto.forja.tipo;
+    const endereco = (0, entrega_pr_1.enderecoDoRemotoDaRaiz)(carregado.raiz, remoto);
+    if (!endereco)
+        return 'github';
+    const r = (0, resolver_1.resolverForja)({ endereco, manifesto: carregado.manifesto.forja, sondas: {}, cache: (0, cache_1.dirDoCacheDaForja)(carregado.raiz) });
+    return r.ok ? r.valor.tipo : null;
+}
+function pedidosDoGithub(forja, executor) {
+    const gh = (0, registro_1.adaptadorDaForja)('github');
+    return {
+        tipo: 'github',
+        listar: (base, branch) => (0, registro_1.exigirCapacidade)(gh, 'pedidosDaBranch')({ ...forja, base, branch, executor, prazoMs: PRAZO_DO_GH_MS }),
+        abrir: (base, branch, titulo, corpo) => (0, registro_1.exigirCapacidade)(gh, 'abrirPedido')({ ...forja, base, branch, titulo, corpo, executor,
+            prazoMs: PRAZO_DO_GH_MS }),
+        passoDaLista: (branch) => `gh pr list --head ${branch} --state all`,
+        passoDaCriacao: (base, branch) => `gh pr create --base ${base} --head ${branch}`,
+        ensaioDaCriacao: (base, branch, titulo, corpo) => `gh pr create --base ${base} --head ${branch} --title "${titulo}" --body-file <${corpo}>`,
+    };
+}
+/** O GitLab pela API com a CLI logada; o gh nunca roda aqui. */
+function pedidosDoGitlab(f, opcoes) {
+    const gl = (0, registro_1.adaptadorDaForja)('gitlab');
+    const semGh = () => ({ status: 1, stdout: '', stderr: 'o gh não fala com o GitLab' });
+    const comum = { host: (0, cli_1.hostDaApi)(f), repositorio: f.repo, executor: semGh, prazoMs: PRAZO_DO_GH_MS, api: (0, api_1.chamadorDaApi)(f, opcoes) };
+    const projeto = (0, pedidos_1.projetoNaApi)(f.repo);
+    return {
+        tipo: 'gitlab',
+        listar: (base, branch) => (0, registro_1.exigirCapacidade)(gl, 'pedidosDaBranch')({ ...comum, base, branch }),
+        abrir: (base, branch, titulo, corpo) => (0, registro_1.exigirCapacidade)(gl, 'abrirPedido')({ ...comum, base, branch, titulo, corpo }),
+        passoDaLista: (branch) => `glab api ${(0, pedidos_1.caminhoDosMrsDaBranch)(f.repo, branch)}`,
+        passoDaCriacao: (base, branch) => `glab api --method POST ${projeto}/merge_requests (source_branch=${branch}, target_branch=${base})`,
+        ensaioDaCriacao: (base, branch, titulo, corpo) => `glab api --method POST ${projeto}/merge_requests (source_branch=${branch}, target_branch=${base}, title="${titulo}", description <${corpo}>)`,
+    };
+}
+/** Os pedidos da entrega: o GitHub fixo dos testes, a forja fixada, ou a resolvida do remoto. */
+function pedidosDaEntrega(carregado, remoto, opcoes) {
+    const executor = opcoes.executorGh ?? parado_no_condutor_1.ghPadrao;
+    if (opcoes.forja)
+        return { ok: true, pedidos: pedidosDoGithub(opcoes.forja, executor) };
+    const r = opcoes.forjaResolvida ? { ok: true, valor: opcoes.forjaResolvida } : (0, entrega_pr_1.forjaDaEntrega)(carregado, remoto, opcoes.sondas);
+    if (!r.ok)
+        return r;
+    return { ok: true, pedidos: r.valor.tipo === 'gitlab' ? pedidosDoGitlab(r.valor, opcoes.api ?? {})
+            : pedidosDoGithub({ host: r.valor.host, repositorio: r.valor.repo }, executor) };
+}
+// ---------------------------------------------------------------------------
+// O corpo e o titulo do PR.
+// ---------------------------------------------------------------------------
+/** O `pr-body.md` da thread, quando e arquivo comum e cabe no teto. */
+function corpoDaThread(raiz, threadId) {
+    const arquivo = path.join((0, thread_1.dirThread)(raiz, threadId), 'pr-body.md');
+    try {
+        const st = fs.lstatSync(arquivo);
+        if (!st.isFile() || st.size === 0 || st.size > TETO_DO_CORPO)
+            return null;
+        const texto = fs.readFileSync(arquivo, 'utf8');
+        // O corpo vai ao gh por um arquivo temporario 600, nunca pelo argv; com NUL ele nao e texto de PR, e vale o corpo padrao.
+        return texto.includes('\0') ? null : { arquivo, texto };
+    }
+    catch {
+        return null;
+    }
+}
+/** O titulo do PR: `ship(<thread>): ` e o primeiro cabecalho do corpo, ou o nome da thread. */
+function tituloDoPr(t, corpo) {
+    let titulo = null;
+    for (const linha of (corpo ?? '').split('\n')) {
+        const l = linha.trim();
+        if (!l)
+            continue;
+        const m = /^#{1,6}\s+(.+)$/.exec(l);
+        titulo = m ? (0, texto_1.umaLinha)(m[1], 120) : null;
+        break;
+    }
+    const prefixo = `ship(${t.id})`;
+    if (titulo?.startsWith(prefixo))
+        return titulo;
+    return `${prefixo}: ${titulo ?? (0, texto_1.umaLinha)(t.nome || t.id, 120)}`;
+}
+/** Uma palavra do shell entre aspas simples: nada dentro dela vira comando, nem `;`, `$`, crase ou barra. */
+function entreAspas(s) {
+    return `'${s.replace(/'/g, "'\\''")}'`;
+}
+/**
+ * O que o dono roda no proprio terminal quando o modo da thread nao autoriza o push. A branch e a base vem do estado e do
+ * manifesto, que podem ser do clone: cada parte vai entre aspas simples (A4 da revisao). No GitLab, a descricao vai pelo
+ * `--description-file` (ou o titulo, sem `pr-body.md`) e nunca pelo `--fill`, que empurra a branch e pode trocar o titulo;
+ * o `glab mr create` nao arma merge.
+ */
+function comandoDoDono(remoto, base, branch, titulo, comCorpo, tipo = 'github') {
+    if (tipo === null) {
+        const gh = comandoDoDono(remoto, base, branch, titulo, comCorpo, 'github'), glab = comandoDoDono(remoto, base, branch, titulo, comCorpo, 'gitlab');
+        return (0, locale_1.textoDoCatalogo)((m) => m.ship.publicar.comandoDasDuasForjas(gh, glab));
+    }
+    const push = `git push -u ${entreAspas(remoto)} ${entreAspas(branch)}`;
+    if (tipo === 'gitlab') {
+        return `${push} && glab mr create --source-branch ${entreAspas(branch)} --target-branch ${entreAspas(base)} --title ${entreAspas(titulo)} ` +
+            `${comCorpo ? `--description-file ${entreAspas(comCorpo)}` : `--description ${entreAspas(titulo)}`} --yes`;
+    }
+    return `${push} && gh pr create --base ${entreAspas(base)} --head ${entreAspas(branch)} ` +
+        `--title ${entreAspas(titulo)} ${comCorpo ? `--body-file ${entreAspas(comCorpo)}` : '--fill'}`;
+}
+/**
+ * `ork ship publicar <thread>`: publica a branch da thread e abre (ou reaproveita) o PR, com prova, so no modo que
+ * ja autoriza push. Nunca lanca por reprovacao: a recusa antes de qualquer efeito volta tipada e nada vai ao ledger; o
+ * push que aconteceu vai sempre ao ledger, provado ou nao (B1 da revisao).
+ */
+function publicarEntrega(carregado, threadId, opcoes = {}) {
+    const raiz = carregado.raiz, base = carregado.manifesto.worktree.base_branch;
+    const remoto = (0, branch_de_estado_1.exigirRemoto)(opcoes.remoto ?? 'origin', 'ship');
+    const quando = opcoes.quando ?? new Date().toISOString();
+    const dryRun = opcoes.dryRun === true;
+    const p = (m) => m.ship.publicar;
+    const r = {
+        contrato: exports.CONTRATO_DA_PUBLICACAO, thread: threadId, modo: null, tag: null, acao: 'recusada', motivo: null,
+        detalhe: '', correcao: '', branch: null, base, remoto, head: null, remotaAntes: null, remota: null, pushVerificado: false,
+        pr: null, corpo: null, passos: [], dryRun,
+    };
+    const recusar = (motivo, detalhe, correcao) => ({ ...r, acao: 'recusada', motivo, detalhe, correcao });
+    // 1. A thread que existe e esta aberta. S3 da revisao: a que nao se le tambem volta como recusa tipada, no contrato.
+    let lida;
+    try {
+        lida = (0, thread_1.lerThread)(raiz, threadId);
+    }
+    catch (e) {
+        return recusar('artifact.missing', (0, locale_1.textoDoCatalogo)((m) => p(m).threadInexistente((0, texto_1.umaLinha)(threadId, 80), (0, texto_1.deFora)(e.message))), (0, locale_1.textoDoCatalogo)((m) => p(m).threadInexistenteCorrecao));
+    }
+    const t = lida;
+    r.thread = t.id;
+    r.modo = t.modo;
+    r.tag = (0, modos_1.tagDoModo)(t.modo);
+    if (t.status === 'fechada') {
+        return recusar('artifact.missing', (0, locale_1.textoDoCatalogo)((m) => p(m).threadFechada(t.id)), (0, locale_1.textoDoCatalogo)((m) => p(m).threadFechadaCorrecao));
+    }
+    // RM-058, integração (T1.1, D3 da ork-rm058integra): a thread de um arco #Noctum que a guarda só é publicada pelo próprio
+    // arco (`doArco`). Antes de qualquer git, e sem ledger, como as outras recusas daqui.
+    const guarda = (0, noctum_guarda_1.guardaDaThread)(raiz, t.id, quando, { doArco: opcoes.doArco });
+    if (guarda)
+        return { ...recusar('policy.violation', guarda.detalhe, guarda.correcao), codigo: guarda.motivo };
+    const refs = (0, parado_no_condutor_1.refsLocais)(raiz, remoto);
+    const baseRef = refDaBase(refs, remoto, base);
+    const f = fatosDaThread(carregado, t, refs, baseRef, quando);
+    r.branch = f.branch;
+    r.head = f.head;
+    const corpo = corpoDaThread(raiz, t.id);
+    // 2. O modo que ja autoriza push (D1): fora dele, o push e do dono, e a correcao diz o comando dele.
+    if (!exports.MODOS_QUE_PUBLICAM.includes(t.modo)) {
+        const comando = comandoDoDono(remoto, base, f.branch, tituloDoPr(t, corpo?.texto ?? null), corpo ? path.relative(raiz, corpo.arquivo) : null, tipoSemRede(carregado, remoto, opcoes.forja ? 'github' : opcoes.forjaResolvida?.tipo));
+        return recusar('human.pending', (0, locale_1.textoDoCatalogo)((m) => p(m).modoSemPush((0, modos_1.tagDoModo)(t.modo))), (0, locale_1.textoDoCatalogo)((m) => p(m).modoSemPushCorrecao(comando)));
+    }
+    // 3. Ninguem conduz a thread agora: a branch pode mudar no meio da publicacao.
+    if (f.conducao) {
+        const sessao = f.conducao.sessao ? f.conducao.sessao.slice(0, 8) : f.conducao.canal;
+        return recusar('conducao.em-andamento', (0, locale_1.textoDoCatalogo)((m) => p(m).conduzida(sessao, f.conducao?.fase ?? '-')), (0, locale_1.textoDoCatalogo)((m) => p(m).conduzidaCorrecao(t.id)));
+    }
+    // 4. A branch com produto, que nao e a base.
+    if (!(0, branch_de_estado_1.branchValida)(f.branch) || !f.head) {
+        return recusar('artifact.missing', (0, locale_1.textoDoCatalogo)((m) => p(m).semBranch(f.branch)), (0, locale_1.textoDoCatalogo)((m) => p(m).semBranchCorrecao(t.id)));
+    }
+    const head = f.head;
+    if (f.branch === base) {
+        return recusar('policy.violation', (0, locale_1.textoDoCatalogo)((m) => p(m).branchEBase(base)), (0, locale_1.textoDoCatalogo)((m) => p(m).branchEBaseCorrecao));
+    }
+    if (!f.comProduto) {
+        return recusar('artifact.missing', (0, locale_1.textoDoCatalogo)((m) => p(m).semProduto(f.branch, base)), (0, locale_1.textoDoCatalogo)((m) => p(m).semProdutoCorrecao));
+    }
+    // 5 a 7. O CHECK, o verify e o bundle no HEAD.
+    if (f.check.estado === 'pendente')
+        return recusar('artifact.missing', f.check.texto, (0, locale_1.textoDoCatalogo)((m) => p(m).checkCorrecao(t.id)));
+    if (f.verify.estado === 'pendente')
+        return recusar('verify.failed', f.verify.texto, (0, locale_1.textoDoCatalogo)((m) => p(m).verifyCorrecao(t.id)));
+    if (f.bundle.estado === 'pendente')
+        return recusar('artifact.missing', f.bundle.texto, (0, locale_1.textoDoCatalogo)((m) => p(m).bundleCorrecao(t.id)));
+    // 8. O remoto e a forja. S3 da revisao: sem o remoto, a publicacao nao tem para onde ir (runtime.unavailable).
+    if (!git(raiz, ['remote', 'get-url', '--', remoto]).ok) {
+        return recusar('runtime.unavailable', (0, locale_1.textoDoCatalogo)((m) => p(m).semRemoto(remoto)), (0, locale_1.textoDoCatalogo)((m) => p(m).semRemotoCorrecao));
+    }
+    const daForja = pedidosDaEntrega(carregado, remoto, opcoes);
+    if (!daForja.ok) {
+        const erro = daForja.erro;
+        return recusar('runtime.unavailable', (0, locale_1.textoDoCatalogo)((m) => p(m).semForja(remoto, erro ? m.forja.motivo(erro, null) : null)), (0, locale_1.textoDoCatalogo)((m) => p(m).semForjaCorrecao));
+    }
+    const pedidos = daForja.pedidos;
+    const noGitlab = pedidos.tipo === 'gitlab';
+    const rede = (m) => (noGitlab ? p(m).redeCorrecaoGitlab : p(m).redeCorrecao);
+    // 9. A ponta no remoto e os PRs da branch, antes de qualquer efeito.
+    const provaDoPush = `git ls-remote ${remoto} refs/heads/${f.branch}`;
+    const antes = pontaNoRemoto(raiz, remoto, f.branch);
+    r.passos.push(provaDoPush);
+    if (antes.erro !== null) {
+        return recusar('runtime.unavailable', (0, locale_1.textoDoCatalogo)((m) => p(m).lsRemoteFalhou(remoto, antes.erro ?? '-')), (0, locale_1.textoDoCatalogo)(rede));
+    }
+    r.remotaAntes = antes.sha;
+    r.remota = antes.sha;
+    const lidos = pedidos.listar(base, f.branch);
+    r.passos.push(pedidos.passoDaLista(f.branch));
+    if (lidos.erro !== null) {
+        const erro = lidos.erro;
+        return recusar('runtime.unavailable', (0, locale_1.textoDoCatalogo)((m) => noGitlab ? p(m).prsFalharamGitlab(erro) : p(m).prsFalharam(erro)), (0, locale_1.textoDoCatalogo)(rede));
+    }
+    const aberto = lidos.prs.find((x) => x.estado === 'aberto') ?? null;
+    const mesclado = lidos.prs.find((x) => x.estado === 'mesclado' && x.head === head) ?? null;
+    const noRemoto = antes.sha === head;
+    r.pushVerificado = noRemoto;
+    // A2 da revisao: o PR mesclado no HEAD ja e a entrega, com ou sem a branch no remoto (o GitHub pode te-la apagado).
+    if (mesclado && !aberto) {
+        return { ...r, acao: 'ja-publicada', pr: { numero: mesclado.numero, url: mesclado.url, criado: false, head: mesclado.head },
+            detalhe: (0, locale_1.textoDoCatalogo)((m) => p(m).jaMesclado(mesclado.numero, noGitlab)), correcao: (0, locale_1.textoDoCatalogo)((m) => p(m).registreAEntrega(t.id)) };
+    }
+    if (noRemoto && aberto) {
+        return { ...r, acao: 'ja-publicada', pr: { numero: aberto.numero, url: aberto.url, criado: false, head: aberto.head },
+            detalhe: (0, locale_1.textoDoCatalogo)((m) => p(m).jaPublicada(aberto.numero, noGitlab)) };
+    }
+    // O remoto com commit que a branch local nao tem, ou que esta copia nem conhece (A3 da revisao): o push sem forca
+    // seria recusado. Nunca forcar.
+    if (antes.sha && !noRemoto && remotoContido(raiz, antes.sha, head) === false) {
+        return recusar('tree.blocked', (0, locale_1.textoDoCatalogo)((m) => p(m).remotoDivergiu(remoto, f.branch, curto(antes.sha))), (0, locale_1.textoDoCatalogo)((m) => p(m).remotoDivergiuCorrecao(remoto, f.branch)));
+    }
+    r.corpo = corpo ? 'pr-body.md' : 'padrao';
+    const titulo = tituloDoPr(t, corpo?.texto ?? null);
+    // A5 da revisao: o corpo e o texto lido agora, gravado num arquivo temporario 600 so para o `gh pr create`
+    // (`--body-file`); o gh nunca reabre o `pr-body.md`.
+    const textoDoCorpo = corpo?.texto ?? (0, locale_1.textoDoCatalogo)((m) => p(m).corpoPadrao((0, modos_1.tagDoModo)(t.modo), f.branch, curto(head), carregado.manifesto.ci.context || 'ork-verify', noGitlab));
+    // B1 da revisao: o push leva o sha conferido, e nao a ref: o commit que chegue a branch depois das conferencias fica
+    // fora desta publicacao.
+    const refspec = `${head}:refs/heads/${f.branch}`;
+    if (dryRun) {
+        const passos = [...r.passos];
+        if (!noRemoto)
+            passos.push(`git push -- ${remoto} ${refspec}`, provaDoPush);
+        passos.push(aberto ? (0, locale_1.textoDoCatalogo)((m) => p(m).passoReaproveita(aberto.numero, noGitlab))
+            : pedidos.ensaioDaCriacao(base, f.branch, titulo, corpo ? 'pr-body.md' : 'padrao'));
+        return { ...r, acao: 'publicaria', passos, pr: aberto ? { numero: aberto.numero, url: aberto.url, criado: false, head: aberto.head } : null,
+            detalhe: (0, locale_1.textoDoCatalogo)((m) => p(m).publicaria(curto(head), aberto?.numero ?? null, noGitlab)) };
+    }
+    // A evidencia de cada efeito, com a prova ou a falta dela.
+    let pushFeito = false;
+    const gravar = (extra) => (0, ledger_1.registrar)((0, thread_1.dirThread)(raiz, t.id), t.id, ledger_1.TIPOS_DE_EVENTO.shipPublicado, {
+        branch: f.branch, base, remoto, head, remotaAntes: r.remotaAntes, shaRemoto: r.remota, pushFeito, pushVerificado: r.pushVerificado,
+        fonteDaProva: provaDoPush, corpo: r.corpo, modo: t.modo, tag: (0, modos_1.tagDoModo)(t.modo),
+        autorizadoPor: (0, locale_1.textoDoCatalogo)((m) => m.ship.porTag((0, modos_1.tagDoModo)(t.modo))), tipoDeAutorizacao: 'modo', passos: r.passos, ...extra,
+    });
+    // Efeito 1: o push sem forca do sha conferido, provado pelo ls-remote.
+    if (!noRemoto) {
+        const conferido = opcoes.antesDoEfeito?.('push') ?? null;
+        if (conferido)
+            return recusar('policy.violation', conferido.recusa, conferido.correcao);
+        const argv = ['push', '--', remoto, refspec];
+        const push = (opcoes.executorGit ?? ((args, prazoMs) => git(raiz, args, prazoMs)))(argv, PRAZO_DO_PUSH_MS);
+        r.passos.push(`git ${argv.join(' ')}`);
+        const depois = pontaNoRemoto(raiz, remoto, f.branch);
+        r.passos.push(provaDoPush);
+        r.remota = depois.sha;
+        r.pushVerificado = depois.sha === head;
+        // O push que saiu com erro mas chegou (o prazo venceu depois da escrita no remoto) conta: quem decide e o ls-remote.
+        pushFeito = push.ok || r.pushVerificado;
+        if (!pushFeito) {
+            const erro = (0, texto_1.deFora)(push.stderr || push.stdout || `codigo ${push.code}`, 300);
+            const recusado = /rejected|non-fast-forward|fetch first|stale info|failed to update ref/i.test(erro);
+            return recusar(recusado ? 'tree.blocked' : 'runtime.unavailable', (0, locale_1.textoDoCatalogo)((m) => p(m).pushFalhou(remoto, f.branch, erro)), (0, locale_1.textoDoCatalogo)((m) => recusado ? p(m).remotoDivergiuCorrecao(remoto, f.branch) : rede(m)));
+        }
+        if (!r.pushVerificado) {
+            // B1 da revisao: o push aconteceu e o remoto nao mostra o HEAD; a tentativa vai ao ledger com o que ele respondeu.
+            gravar({ pr: null, ...(depois.erro !== null ? { erroDaProva: depois.erro } : {}) });
+            return recusar('runtime.unavailable', (0, locale_1.textoDoCatalogo)((m) => p(m).pushSemProva(depois.sha ? curto(depois.sha) : null, curto(head))), (0, locale_1.textoDoCatalogo)((m) => p(m).pushSemProvaCorrecao(t.id)));
+        }
+    }
+    // Efeito 2: o PR aberto da branch, ou um novo, provado pela releitura da lista.
+    let pr = aberto ? { numero: aberto.numero, url: aberto.url, criado: false, head: aberto.head } : null;
+    let erroDoPr = null;
+    if (!pr) {
+        const conferido = opcoes.antesDoEfeito?.('pr', { titulo, corpo: textoDoCorpo }) ?? null;
+        if (conferido) {
+            // O push desta chamada aconteceu: ele vai ao ledger com a prova, e o PR fica para depois (B1 da revisao).
+            if (pushFeito)
+                gravar({ pr: null, prRecusado: conferido.recusa.slice(0, 300) });
+            return recusar('policy.violation', conferido.recusa, conferido.correcao);
+        }
+        const criado = pedidos.abrir(base, f.branch, titulo, textoDoCorpo);
+        r.passos.push(pedidos.passoDaCriacao(base, f.branch));
+        const relidos = pedidos.listar(base, f.branch);
+        r.passos.push(`${pedidos.passoDaLista(f.branch)}   (prova do PR)`);
+        const achado = relidos.prs.find((x) => x.estado === 'aberto') ?? null;
+        if (achado)
+            pr = { numero: achado.numero, url: achado.url, criado: criado.status === 0, head: achado.head };
+        else {
+            erroDoPr = criado.status !== 0 ? (0, texto_1.deFora)(criado.stderr || criado.stdout || `codigo ${criado.status ?? '-'}`)
+                : relidos.erro ?? (0, locale_1.textoDoCatalogo)((m) => noGitlab ? p(m).prSemReleituraGitlab : p(m).prSemReleitura);
+        }
+    }
+    r.pr = pr;
+    // A evidencia: so com efeito (push ou PR novo), com a prova.
+    if (pushFeito || pr?.criado || erroDoPr) {
+        gravar({ pr: pr ? { numero: pr.numero, url: pr.url, criado: pr.criado, head: pr.head } : null,
+            ...(pr ? { provaDoPr: pedidos.passoDaLista(f.branch) } : {}), ...(erroDoPr ? { erroDoPr } : {}) });
+    }
+    if (erroDoPr) {
+        const erro = erroDoPr;
+        return recusar('runtime.unavailable', (0, locale_1.textoDoCatalogo)((m) => noGitlab ? p(m).prFalhouGitlab(curto(head), erro) : p(m).prFalhou(curto(head), erro)), (0, locale_1.textoDoCatalogo)((m) => noGitlab ? p(m).prFalhouCorrecaoGitlab(t.id) : p(m).prFalhouCorrecao(t.id)));
+    }
+    // S7 da revisao: sem push e sem PR aberto por este processo, quem publicou foi outro; a entrega ja estava publicada.
+    if (!pushFeito && !pr?.criado) {
+        return { ...r, acao: 'ja-publicada', motivo: null, correcao: '', detalhe: (0, locale_1.textoDoCatalogo)((m) => p(m).jaPublicada(pr?.numero ?? 0, noGitlab)) };
+    }
+    return { ...r, acao: 'publicou', motivo: null, correcao: '',
+        detalhe: (0, locale_1.textoDoCatalogo)((m) => p(m).publicou(curto(head), pr?.numero ?? 0, pr?.criado === true, noGitlab)) };
+}
+/** As linhas da saida de texto do `ork ship publicar`, no locale ativo. */
+function linhasDaPublicacao(r) {
+    const m = (0, locale_1.msg)().ship;
+    const p = m.publicar;
+    const curtoOuTraco = (sha) => (sha ? sha.slice(0, 7) : '-');
+    const linhas = [p.cabecalho(r.dryRun, r.thread, r.tag ?? '-')];
+    if (r.branch)
+        linhas.push(p.linhaBranch(r.branch, curtoOuTraco(r.head)));
+    if (r.passos.length) {
+        linhas.push(p.linhaRemoto(r.remoto, curtoOuTraco(r.remotaAntes), curtoOuTraco(r.remota)));
+        // O PR ja mesclado no HEAD com a branch apagada no remoto nao tem push a provar: a linha some.
+        if (!r.dryRun && r.acao !== 'recusada' && (r.pushVerificado || r.remota !== null)) {
+            linhas.push(r.pushVerificado ? p.linhaPushProvado : p.linhaPushSemProva);
+        }
+    }
+    // O MR do GitLab se reconhece pelos passos, que dizem a CLI de cada forja.
+    if (r.pr)
+        linhas.push(p.linhaPr(r.pr.numero, r.pr.criado, r.pr.url ?? '', r.passos.some((x) => x.startsWith('glab '))));
+    if (r.corpo)
+        linhas.push(p.linhaCorpo(r.corpo));
+    if (r.acao === 'recusada')
+        linhas.push(m.bloqueado(r.motivo ?? '-'), m.detalhe((0, locale_1.remontar)(r.detalhe)));
+    else {
+        linhas.push(p.resultado(p.acoes[r.acao] ?? r.acao));
+        if (r.detalhe)
+            linhas.push(m.detalhe((0, locale_1.remontar)(r.detalhe)));
+    }
+    if (r.correcao)
+        linhas.push(m.correcao((0, locale_1.remontar)(r.correcao)));
+    if (r.passos.length) {
+        linhas.push(m.evidencia);
+        for (const passo of r.passos)
+            linhas.push(`  ${(0, locale_1.remontar)(passo)}`);
+    }
+    return linhas;
+}
+/**
+ * O PR que vale para a pista: o aberto mais novo, senao o mesclado no HEAD, senao o mais novo da branch quando ele foi
+ * fechado sem merge. O mesclado de outro head e de uma entrega anterior (A1 da revisao): nao vale para a ponta nova.
+ */
+function prDaBranchNaLista(prs, branch, head) {
+    const daBranch = prs.filter((x) => x.branch === branch).sort((a, b) => b.numero - a.numero);
+    const aberto = daBranch.find((x) => x.estado === 'aberto');
+    if (aberto)
+        return aberto;
+    const mesclado = daBranch.find((x) => x.estado === 'mesclado' && x.head === head);
+    if (mesclado)
+        return mesclado;
+    return daBranch[0]?.estado === 'fechado' ? daBranch[0] : null;
+}
+function entregaLocal(raiz, f, remotas, remoto, base) {
+    const remota = remotas?.get(f.branch) ?? null;
+    const ships = f.eventos.filter((e) => e.tipo === ledger_1.TIPOS_DE_EVENTO.shipConcluido);
+    const entregue = (!!f.head && ships.some((e) => e.shaDe === f.head || e.mergeSha === f.head)) || (!f.comProduto && ships.length > 0);
+    const merge = f.head ? (0, entrega_pr_1.mergeDaEntrega)(raiz, f.t.id, remoto, base) : null;
+    const mergeSemRegistro = !!merge && !ships.some((e) => e.mergeSha === merge.mergeSha);
+    // So entra na pista quem ja esta na entrega: passou do CHECK (ciclo sem CHECK: o turno acabou) com produto, publicou,
+    // tem merge sem registro ou ja foi entregue e espera o MASTER.
+    const passouDoCheck = f.check.estado === 'nao-se-aplica' ? !f.conducao : f.checkPassou;
+    const naEntrega = (passouDoCheck && f.comProduto) || (!!remota && f.comProduto) || mergeSemRegistro || entregue;
+    return { remota, entregue, merge, mergeSemRegistro, naEntrega };
+}
+/** Quantas branches a pista confere uma a uma no GitLab por chamada; as outras ficam "sem conferir". */
+const MRS_CONFERIDOS_POR_LEITURA = 20;
+/** Os MRs das branches candidatas, uma leitura por branch; a primeira que falha deixa a lista sem leitura. */
+function lerMrsDasCandidatas(pedidos, base, candidatas) {
+    const prs = [], semConferir = [];
+    for (const [i, branch] of [...new Set(candidatas)].entries()) {
+        if (i >= MRS_CONFERIDOS_POR_LEITURA) {
+            semConferir.push(branch);
+            continue;
+        }
+        const lidos = pedidos.listar(base, branch);
+        if (lidos.erro !== null)
+            return { erro: lidos.erro };
+        prs.push(...lidos.prs);
+    }
+    return { prs, semConferir };
+}
+/**
+ * A etapa `ci` do MR aberto pela CI do head. O mesmo mapa do rollup do GitHub: `success` e `bloqueado` (`manual`,
+ * `skipped`) sao verdes, vermelho e falhou, pendente e ausente esperam, e a leitura que falhou nao e lida.
+ */
+function etapaDaCiNoHead(ci, contexto, pr) {
+    const c = (m) => m.ship.publicar;
+    if (ci.state === 'success' || (ci.state === 'failure' && ci.bloqueado)) {
+        return etapa('ci', 'feita', (0, locale_1.textoDoCatalogo)((m) => c(m).ciVerde(contexto, curto(pr.head))));
+    }
+    if (ci.state === 'failure')
+        return etapa('ci', 'falhou', (0, locale_1.textoDoCatalogo)((m) => c(m).ciVermelho(contexto, pr.numero, true)));
+    if (ci.state === 'pending')
+        return etapa('ci', 'pendente', (0, locale_1.textoDoCatalogo)((m) => c(m).ciEsperando(contexto, pr.numero, true)));
+    if (ci.state === 'missing')
+        return etapa('ci', 'pendente', (0, locale_1.textoDoCatalogo)((m) => c(m).ciSemCheck(contexto, pr.numero, true)));
+    return etapa('ci', 'nao-lida', ci.detail);
+}
+/**
+ * O GitLab do remoto, quando e ele; `null` deixa a pista no caminho do GitHub de sempre. `erro` quando o remoto e do
+ * GitLab (pelo bloco `forja:` ou pelo host conhecido) e a forja nao resolveu: a pista diz "sem leitura", nunca "sem MR".
+ */
+function gitlabDaPista(carregado, remoto, opcoes) {
+    if (opcoes.forja)
+        return null;
+    if (opcoes.forjaResolvida)
+        return opcoes.forjaResolvida.tipo === 'gitlab' ? opcoes.forjaResolvida : null;
+    // So o remoto que ja se sabe do GitLab, sem rede, passa pela resolucao aqui; o host proprio sem tipo e resolvido
+    // uma vez pela pista, como o pulse o resolveria, e o resto segue pelo caminho do GitHub.
+    if (tipoSemRede(carregado, remoto) !== 'gitlab')
+        return null;
+    const r = (0, entrega_pr_1.forjaDaEntrega)(carregado, remoto, opcoes.sondas);
+    if (r.ok)
+        return r.valor.tipo === 'gitlab' ? r.valor : null;
+    return r.erro ? { erro: r.erro } : null;
+}
+/** O que a pista de uma thread diz, das leituras ja feitas. */
+function pistaDaThread(carregado, f, local, leitura) {
+    const { t } = f;
+    const gl = leitura.tipo === 'gitlab';
+    const raiz = carregado.raiz;
+    const { remota, entregue, merge, mergeSemRegistro } = local;
+    const pr = leitura.prs ? prDaBranchNaLista(leitura.prs, f.branch, f.head) : null;
+    const prMesclado = pr?.estado === 'mesclado' && pr.head === f.head;
+    if (!(local.naEntrega || !!pr) || !f.head)
+        return null;
+    const c = (m) => m.ship.publicar;
+    const publicavel = exports.MODOS_QUE_PUBLICAM.includes(t.modo);
+    // A branch no remoto. A3 da revisao: o sha do remoto que esta copia nem conhece tambem e divergencia.
+    let branchEtapa;
+    if (!leitura.remotasLidas)
+        branchEtapa = etapa('branch', 'nao-lida', (0, locale_1.textoDoCatalogo)((m) => c(m).remotoNaoLido(leitura.remoto)));
+    else if (remota === f.head)
+        branchEtapa = etapa('branch', 'feita', (0, locale_1.textoDoCatalogo)((m) => c(m).branchPublicada(curto(f.head))));
+    else if (!remota)
+        branchEtapa = etapa('branch', 'pendente', (0, locale_1.textoDoCatalogo)((m) => c(m).branchNaoPublicada));
+    else if (remotoContido(raiz, remota, f.head) === false) {
+        branchEtapa = etapa('branch', 'falhou', (0, locale_1.textoDoCatalogo)((m) => c(m).remotoDivergiu(leitura.remoto, f.branch, curto(remota))));
+    }
+    else
+        branchEtapa = etapa('branch', 'pendente', (0, locale_1.textoDoCatalogo)((m) => c(m).commitsSemPush(curto(remota), curto(f.head))));
+    // O PR, o CI e o conflito.
+    const corte = leitura.corte(f.branch);
+    let prEtapa, ciEtapa, conflitoEtapa;
+    if (!leitura.prs) {
+        prEtapa = etapa('pr', 'nao-lida', (0, locale_1.textoDoCatalogo)((m) => c(m).prsNaoLidos(leitura.prsNaoLidos ?? '-')));
+        ciEtapa = etapa('ci', 'nao-lida', (0, locale_1.textoDoCatalogo)((m) => c(m).prsNaoLidos(leitura.prsNaoLidos ?? '-')));
+        conflitoEtapa = etapa('conflito', 'nao-lida', (0, locale_1.textoDoCatalogo)((m) => c(m).prsNaoLidos(leitura.prsNaoLidos ?? '-')));
+    }
+    else if ((!pr || pr.estado === 'fechado') && corte) {
+        // A7 da revisao: a lista dos abertos cortada, ou a branch sem conferir nesta leitura, nao diz "sem PR" (a R1 do pulse).
+        const texto = (0, locale_1.textoDoCatalogo)((m) => corte === 'parcial' ? c(m).prsCortados(parado_no_condutor_1.LIMITE_DE_PRS) : c(m).branchSemConferir);
+        prEtapa = etapa('pr', 'nao-lida', texto);
+        ciEtapa = etapa('ci', 'nao-lida', texto);
+        conflitoEtapa = etapa('conflito', 'nao-lida', texto);
+    }
+    else if (!pr || pr.estado === 'fechado') {
+        prEtapa = etapa('pr', 'pendente', pr ? (0, locale_1.textoDoCatalogo)((m) => c(m).prFechado(pr.numero, gl)) : (0, locale_1.textoDoCatalogo)((m) => c(m).semPr));
+        ciEtapa = etapa('ci', leitura.ciExigido ? 'pendente' : 'nao-se-aplica', (0, locale_1.textoDoCatalogo)((m) => leitura.ciExigido ? c(m).ciSemPr : c(m).ciNaoExigido));
+        conflitoEtapa = etapa('conflito', 'nao-se-aplica', (0, locale_1.textoDoCatalogo)((m) => c(m).conflitoSemPr));
+    }
+    else if (pr.estado === 'mesclado') {
+        prEtapa = etapa('pr', 'feita', (0, locale_1.textoDoCatalogo)((m) => c(m).prMesclado(pr.numero, gl)));
+        ciEtapa = etapa('ci', 'nao-se-aplica', (0, locale_1.textoDoCatalogo)((m) => c(m).ciDoMesclado));
+        conflitoEtapa = etapa('conflito', 'feita', (0, locale_1.textoDoCatalogo)((m) => c(m).prMesclado(pr.numero, gl)));
+    }
+    else {
+        prEtapa = etapa('pr', 'feita', (0, locale_1.textoDoCatalogo)((m) => pr.rascunho ? c(m).prRascunho(pr.numero, gl) : c(m).prAberto(pr.numero, gl)));
+        const check = pr.checks.find((k) => k.nome === leitura.contexto);
+        ciEtapa = !leitura.ciExigido ? etapa('ci', 'nao-se-aplica', (0, locale_1.textoDoCatalogo)((m) => c(m).ciNaoExigido))
+            : leitura.ciDoPedido ? leitura.ciDoPedido(pr)
+                : !check ? etapa('ci', 'pendente', (0, locale_1.textoDoCatalogo)((m) => c(m).ciSemCheck(leitura.contexto, pr.numero, gl)))
+                    : check.situacao === 'verde' ? etapa('ci', 'feita', (0, locale_1.textoDoCatalogo)((m) => c(m).ciVerde(leitura.contexto, curto(pr.head))))
+                        : check.situacao === 'vermelho' ? etapa('ci', 'falhou', (0, locale_1.textoDoCatalogo)((m) => c(m).ciVermelho(leitura.contexto, pr.numero, gl)))
+                            : etapa('ci', 'pendente', (0, locale_1.textoDoCatalogo)((m) => c(m).ciEsperando(leitura.contexto, pr.numero, gl)));
+        conflitoEtapa = pr.conflito === true ? etapa('conflito', 'falhou', (0, locale_1.textoDoCatalogo)((m) => c(m).conflito(pr.numero, gl)))
+            : pr.conflito === false ? etapa('conflito', 'feita', (0, locale_1.textoDoCatalogo)((m) => c(m).semConflito))
+                : etapa('conflito', 'nao-lida', (0, locale_1.textoDoCatalogo)((m) => c(m).conflitoNaoCalculado));
+    }
+    const entregaEtapa = entregue ? etapa('entrega', 'feita', (0, locale_1.textoDoCatalogo)((m) => c(m).entregue))
+        : etapa('entrega', 'pendente', (0, locale_1.textoDoCatalogo)((m) => mergeSemRegistro ? c(m).mergeSemRegistro(curto(merge?.mergeSha)) : c(m).semShipDone));
+    // O proximo passo, a primeira regra que vale.
+    const corpo = corpoDaThread(raiz, t.id);
+    const nada = (texto, comando = null) => ({ acao: null, disponivel: false, texto, comando });
+    let proximo;
+    if (entregue)
+        proximo = nada((0, locale_1.textoDoCatalogo)((m) => c(m).proximoEntregue));
+    else if (mergeSemRegistro || prMesclado) {
+        proximo = { acao: 'registrar', disponivel: true, texto: (0, locale_1.textoDoCatalogo)((m) => c(m).proximoRegistrar), comando: `ork ship registrar-pr ${t.id}` };
+    }
+    else if (f.conducao) {
+        const sessao = f.conducao.sessao ? f.conducao.sessao.slice(0, 8) : f.conducao.canal;
+        proximo = nada((0, locale_1.textoDoCatalogo)((m) => c(m).proximoConduzida(sessao)), `ork conducao status ${t.id}`);
+    }
+    else if (f.check.estado === 'pendente')
+        proximo = nada(f.check.texto, (0, locale_1.textoDoCatalogo)((m) => c(m).comandoDoCheck(t.id)));
+    else if (f.verify.estado === 'pendente')
+        proximo = nada(f.verify.texto, `ork verify ${t.id}`);
+    else if (f.bundle.estado === 'pendente')
+        proximo = nada(f.bundle.texto, `ork ci prepare ${t.id}`);
+    else if (branchEtapa.estado === 'falhou')
+        proximo = nada(branchEtapa.texto, null);
+    else if (branchEtapa.estado === 'nao-lida')
+        proximo = nada(branchEtapa.texto, `ork ship pista ${t.id}`);
+    else if (branchEtapa.estado === 'pendente' || (prEtapa.estado === 'pendente')) {
+        proximo = publicavel
+            ? { acao: 'publicar', disponivel: true, comando: `ork ship publicar ${t.id}`,
+                texto: (0, locale_1.textoDoCatalogo)((m) => pr?.estado === 'aberto' ? c(m).proximoPublicarNoPr(pr.numero, gl) : c(m).proximoPublicar) }
+            : { acao: 'publicar', disponivel: false, texto: (0, locale_1.textoDoCatalogo)((m) => c(m).proximoDoDono(t.id, (0, modos_1.tagDoModo)(t.modo))),
+                comando: comandoDoDono(leitura.remoto, leitura.base, f.branch, tituloDoPr(t, corpo?.texto ?? null), corpo ? path.relative(raiz, corpo.arquivo) : null, leitura.tipo) };
+    }
+    else if (prEtapa.estado === 'nao-lida')
+        proximo = nada(prEtapa.texto, `ork ship pista ${t.id}`);
+    else if (conflitoEtapa.estado === 'falhou')
+        proximo = nada((0, locale_1.textoDoCatalogo)((m) => c(m).proximoConflito(pr?.numero ?? 0, gl)));
+    else if (ciEtapa.estado === 'falhou')
+        proximo = nada((0, locale_1.textoDoCatalogo)((m) => c(m).proximoCiVermelho(leitura.contexto, pr?.numero ?? 0, gl)));
+    else if (ciEtapa.estado === 'pendente' || ciEtapa.estado === 'nao-lida') {
+        proximo = nada((0, locale_1.textoDoCatalogo)((m) => c(m).proximoEsperandoCi(leitura.contexto, pr?.numero ?? 0, gl)), pr ? `ork ci status --sha ${pr.head}` : null);
+    }
+    else
+        proximo = nada((0, locale_1.textoDoCatalogo)((m) => pr?.rascunho ? c(m).proximoRascunho(pr.numero, gl) : c(m).proximoMerge(pr?.numero ?? 0, gl)));
+    return {
+        thread: t.id, nome: t.nome, modo: t.modo, tag: (0, modos_1.tagDoModo)(t.modo), publicavel, conduzida: !!f.conducao, branch: f.branch, head: f.head,
+        remota, pr: pr ? { numero: pr.numero, url: pr.url, estado: pr.estado, rascunho: pr.rascunho, head: pr.head } : null,
+        etapas: [f.check, f.verify, f.bundle, branchEtapa, prEtapa, ciEtapa, conflitoEtapa, entregaEtapa], proximo,
+    };
+}
+/** `ork ship pista [<thread>]`: as etapas e o proximo passo de cada thread aberta que ja esta na entrega. Nao grava nada. */
+function pistaDeEntrega(carregado, opcoes = {}) {
+    const raiz = carregado.raiz, base = carregado.manifesto.worktree.base_branch;
+    const remoto = (0, branch_de_estado_1.exigirRemoto)(opcoes.remoto ?? 'origin', 'ship');
+    const lidoEm = opcoes.quando ?? new Date().toISOString();
+    const contexto = carregado.manifesto.ci.context || 'ork-verify';
+    const ciExigido = carregado.manifesto.ci.required_for_ship === true;
+    const refs = (0, parado_no_condutor_1.refsLocais)(raiz, remoto);
+    const baseRef = refDaBase(refs, remoto, base);
+    const ids = opcoes.thread ? [opcoes.thread] : (0, thread_1.listarIds)(raiz);
+    const fatos = [];
+    for (const id of ids) {
+        let t;
+        try {
+            t = (0, thread_1.lerThread)(raiz, id);
+        }
+        catch {
+            if (opcoes.thread)
+                throw new Error(`ship.pista: a thread ${id} nao existe`);
+            continue;
+        }
+        if (t.status === 'fechada')
+            continue;
+        fatos.push(fatosDaThread(carregado, t, refs, baseRef, lidoEm));
+    }
+    const comBranch = fatos.filter((f) => f.head && (0, branch_de_estado_1.branchValida)(f.branch));
+    const remotas = comBranch.length ? pontasNoRemoto(raiz, remoto) : new Map();
+    const locais = new Map(fatos.map((f) => [f.t.id, entregaLocal(raiz, f, remotas, remoto, base)]));
+    // A7 da revisao: so a branch da thread que ja esta na entrega pelo que se le sem a forja vai a leitura dos PRs, que
+    // confere uma a uma a que nao aparece nas listas; sem nenhuma, a forja nem e lida.
+    const candidatas = comBranch.filter((f) => locais.get(f.t.id)?.naEntrega === true).map((f) => f.branch);
+    let prs = [];
+    let prsNaoLidos = null;
+    let parcial = false;
+    let semConferir = new Set();
+    let ciDoPedido;
+    let prsNaoLidosDoGitlab = false;
+    let doHostProprio;
+    if (candidatas.length) {
+        let gitlab = gitlabDaPista(carregado, remoto, opcoes);
+        // Host proprio sem o bloco `forja:` (um GitLab como o de um piloto, ou um GitHub Enterprise): a forja e resolvida uma
+        // vez, como o pulse a resolve, e a leitura segue pela forja certa, com o mesmo criterio do gate no GitLab.
+        let naoResolvida = null;
+        if (!gitlab && !opcoes.forja && !opcoes.forjaResolvida && tipoSemRede(carregado, remoto) === null) {
+            const lido = (0, parado_no_condutor_1.forjaDoRemotoDoPulse)(carregado, remoto, { executor: opcoes.executorGh, sondas: opcoes.sondas });
+            if (!lido.ok)
+                naoResolvida = lido.erro;
+            else if (lido.forja.tipo === 'gitlab')
+                gitlab = lido.forja;
+            else
+                doHostProprio = lido.forja;
+        }
+        if (naoResolvida !== null) {
+            prs = null;
+            prsNaoLidos = (0, texto_1.deFora)(naoResolvida);
+        }
+        else if (gitlab && 'erro' in gitlab) {
+            prs = null;
+            prsNaoLidos = (0, locale_1.textoDoCatalogo)((m) => m.forja.motivo(gitlab.erro, 'gitlab'));
+            prsNaoLidosDoGitlab = true;
+        }
+        else if (gitlab) {
+            const lidos = lerMrsDasCandidatas(pedidosDoGitlab(gitlab, opcoes.api ?? {}), base, candidatas);
+            if ('erro' in lidos) {
+                prs = null;
+                prsNaoLidos = (0, texto_1.deFora)(lidos.erro);
+            }
+            else {
+                prs = lidos.prs;
+                semConferir = new Set(lidos.semConferir);
+            }
+            const ciDoHead = opcoes.ciDoHead ?? ((sha) => (0, ci_1.consultarCi)(carregado, sha, remoto, undefined, undefined, opcoes.sondas, opcoes.api));
+            ciDoPedido = (pr) => etapaDaCiNoHead(ciDoHead(pr.head), contexto, pr);
+        }
+        else {
+            const fixada = opcoes.forja ?? (opcoes.forjaResolvida?.tipo === 'github'
+                ? { host: (0, cli_1.hostDaApi)(opcoes.forjaResolvida), repositorio: opcoes.forjaResolvida.repo } : undefined);
+            const leitura = (0, parado_no_condutor_1.lerPrsDaForja)(carregado, { quando: lidoEm, executor: opcoes.executorGh, remoto, candidatas, forja: fixada,
+                resolvida: doHostProprio, sondas: opcoes.sondas });
+            if (leitura.ok) {
+                prs = leitura.retrato.prs;
+                parcial = leitura.retrato.parcial;
+                semConferir = new Set(leitura.retrato.semConferir ?? []);
+            }
+            else {
+                prs = null;
+                prsNaoLidos = (0, texto_1.deFora)(leitura.erro);
+            }
+        }
+    }
+    const tipo = ciDoPedido || prsNaoLidosDoGitlab ? 'gitlab' : doHostProprio ? 'github'
+        : tipoSemRede(carregado, remoto, opcoes.forja ? 'github' : opcoes.forjaResolvida?.tipo);
+    // S8 da revisao (rodada 2): a candidata sem nenhum PR na leitura foi conferida uma a uma pelo `--head`, que a lista
+    // cortada nao limita; so a que nao foi conferida, ou que so tem PR achado na lista cortada, fica em duvida.
+    const comPrNaLeitura = new Set((prs ?? []).map((x) => x.branch));
+    const conferida = (branch) => candidatas.includes(branch) && !comPrNaLeitura.has(branch);
+    const corte = (branch) => (semConferir.has(branch) ? 'sem-conferir'
+        : parcial && !conferida(branch) ? 'parcial' : null);
+    const pistas = fatos.flatMap((f) => {
+        const local = locais.get(f.t.id);
+        const x = local ? pistaDaThread(carregado, f, local, { remoto, base, remotasLidas: remotas !== null, prs, prsNaoLidos, corte, ciExigido, contexto, tipo, ciDoPedido })
+            : null;
+        return x ? [x] : [];
+    });
+    return { contrato: exports.CONTRATO_DA_PISTA, lidoEm, base, remoto, remotoLido: remotas !== null, prsLidos: prs !== null, prsNaoLidos,
+        ciExigido, contextoDoCi: contexto, pistas };
+}