@orkastery/cli 0.5.6 → 0.6.0

package/dist/entrega-pr.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mergeDaEntrega = mergeDaEntrega;
+exports.enderecoDoRemotoDaRaiz = enderecoDoRemotoDaRaiz;
+exports.forjaDaEntrega = forjaDaEntrega;
 exports.registrarEntregaPorPr = registrarEntregaPorPr;
 exports.registrarEntregaExternaPorPr = registrarEntregaExternaPorPr;
 exports.registrarEntregasPorPr = registrarEntregasPorPr;
@@ -17,13 +19,23 @@ exports.registrarEntregasPorPr = registrarEntregasPorPr;
  * head do PR. Sem CI verde, nao registra: merge sem prova independente nao e entrega.
  */
 const branch_de_estado_1 = require("./branch-de-estado");
+const produtor_1 = require("./forja/produtor");
 const ci_1 = require("./ci");
+const api_1 = require("./forja/api");
+const cli_1 = require("./forja/cli");
+const endereco_1 = require("./forja/endereco");
+const pedidos_1 = require("./forja/gitlab/pedidos");
+const cache_1 = require("./forja/cache");
+const resolver_1 = require("./forja/resolver");
 const docs_1 = require("./docs");
 const fabrica_publicar_1 = require("./fabrica-publicar");
 const ledger_1 = require("./ledger");
 const modos_1 = require("./modos");
+const noctum_guarda_1 = require("./noctum-guarda");
 const thread_1 = require("./thread");
 const util_1 = require("./util");
+const executor_1 = require("./forja/executor");
+const registro_1 = require("./forja/registro");
 const locale_1 = require("./locale");
 /** O merge `ship(<thread>)` mais recente na base remota, com o head do PR (segundo pai). */
 function mergeDaEntrega(raiz, thread, remoto, base) {
@@ -51,6 +63,28 @@ function avancarParaShip(raiz, threadId) {
     atualizada.faseAtual = 'SHIP';
     (0, thread_1.gravarThread)(raiz, atualizada);
 }
+/** O endereco do remoto, de UM parse da URL; `null` quando o remoto nao existe ou nao tem host de forja. */
+function enderecoDoRemotoDaRaiz(raiz, remoto) {
+    // Git local sem rede escondida nem pergunta de credencial no terminal.
+    const url = (0, util_1.exec)('git', ['remote', 'get-url', '--', remoto], raiz, 60000, { ...process.env, GIT_NO_LAZY_FETCH: '1', GIT_TERMINAL_PROMPT: '0' });
+    return url.ok ? (0, endereco_1.lerEnderecoDoRemoto)(url.stdout.trim()) : null;
+}
+/**
+ * A forja do remoto, de UM parse da URL e do resolver (o bloco `forja:`, o host conhecido ou a sondagem pela CLI com
+ * login no host): o nome do host nao decide o tipo. `erro` nulo: o remoto nao existe, nao tem host de forja (caminho
+ * local) ou aponta um caminho que a forja dele nao tem (subgrupo no GitHub).
+ */
+function forjaDaEntrega(carregado, remoto, sondas = resolver_1.SONDAS_PADRAO) {
+    const endereco = enderecoDoRemotoDaRaiz(carregado.raiz, remoto);
+    if (!endereco)
+        return { ok: false, erro: null };
+    const r = (0, resolver_1.resolverForja)({ endereco, manifesto: carregado.manifesto.forja, sondas, cache: (0, cache_1.dirDoCacheDaForja)(carregado.raiz) });
+    if (!r.ok)
+        return { ok: false, erro: r.erro };
+    if (r.valor.tipo === 'github' && r.valor.repo.split('/').length !== 2)
+        return { ok: false, erro: null };
+    return { ok: true, valor: r.valor };
+}
 function resultado(thread, acao, motivo, extra = {}) {
     return { thread, acao, motivo, mergeSha: null, headSha: null, ci: null, docsPendentes: [], ...extra };
 }
@@ -66,11 +100,26 @@ function registrarEntregaPorPr(carregado, threadId, opcoes = {}) {
     const thread = (0, thread_1.lerThread)(raiz, threadId);
     if (thread.status === 'fechada')
         return resultado(threadId, 'ja-registrada', (0, locale_1.textoDoCatalogo)((m) => m.ship.prThreadFechada));
-    if (opcoes.buscar !== false)
-        (0, util_1.exec)('git', ['fetch', '-q', '--', remoto, `+refs/heads/${base}:refs/remotes/${remoto}/${base}`], raiz);
+    // RM-058, integracao (T1.1, D3 da ork-rm058integra): a entrega da thread de um arco #Noctum e do passo da entrega dele,
+    // com as provas dele; antes de qualquer git, e sem ledger.
+    const guarda = (0, noctum_guarda_1.guardaDaThread)(raiz, threadId, opcoes.arcos?.quando, { arcos: opcoes.arcos });
+    if (guarda)
+        return resultado(threadId, 'recusada', guarda.texto, { codigo: guarda.motivo });
+    if (opcoes.buscar !== false) {
+        const busca = (0, util_1.exec)('git', ['fetch', '-q', '--', remoto, `+refs/heads/${base}:refs/remotes/${remoto}/${base}`], raiz);
+        if (!busca.ok) {
+            return resultado(threadId, 'recusada', (0, locale_1.textoDoCatalogo)((m) => m.ship.prSemLeitura(remoto, base)), { codigo: 'entrega.sem-leitura' });
+        }
+    }
     const encontrado = mergeDaEntrega(raiz, threadId, remoto, base);
     if (!encontrado)
         return resultado(threadId, 'sem-merge', (0, locale_1.textoDoCatalogo)((m) => m.ship.prSemMerge(threadId, remoto, base)));
+    // Squash ou rebase: sem segundo pai o merge nao se liga ao head que a CI verificou. Com a CI exigida, a CI do commit
+    // da base nao prova o head, e a entrega e recusada antes de qualquer consulta. Sem CI exigida, registra como sempre.
+    const exigeCi = carregado.manifesto.ci.required_for_ship;
+    if (encontrado.headSha === null && exigeCi) {
+        return resultado(threadId, 'recusada', (0, locale_1.textoDoCatalogo)((m) => m.ship.prSemVinculo(threadId, encontrado.mergeSha.slice(0, 7))), { mergeSha: encontrado.mergeSha, codigo: 'entrega.sem-vinculo' });
+    }
     // RM-044 (A3): o condutor roda o registrar-pr logo depois do merge; e aqui que ele fica sabendo da pagina que
     // vai deixar o push da base vermelho, lida da base remota que o fetch acabou de trazer.
     const merge = { ...encontrado, docsPendentes: (0, docs_1.docsPendentesDoMerge)(raiz, threadId, `refs/remotes/${remoto}/${base}`) };
@@ -84,7 +133,10 @@ function registrarEntregaPorPr(carregado, threadId, opcoes = {}) {
     if (!ponta || !(0, util_1.exec)('git', ['merge-base', '--is-ancestor', merge.mergeSha, ponta], raiz).ok) {
         return resultado(threadId, 'recusada', (0, locale_1.textoDoCatalogo)((m) => m.ship.prForaDaPonta(merge.mergeSha.slice(0, 7), remoto, base)), merge);
     }
-    const ci = (0, ci_1.consultarCi)(carregado, merge.headSha ?? merge.mergeSha, remoto, opcoes.executorCi);
+    // A CI so e consultada no head do PR; sem head (squash ou rebase), so chega aqui sem CI exigida, e nada e consultado.
+    const ci = encontrado.headSha !== null
+        ? (0, ci_1.consultarCi)(carregado, encontrado.headSha, remoto, opcoes.executorCi)
+        : (0, ci_1.ciNaoExigida)(carregado, encontrado.mergeSha);
     if (ci.required && !ci.ok) {
         return resultado(threadId, 'recusada', (0, locale_1.textoDoCatalogo)((m) => m.ship.prSemCiVerde((0, locale_1.remontar)(ci.detail))), { ...merge, ci });
     }
@@ -117,23 +169,37 @@ function registrarEntregaPorPr(carregado, threadId, opcoes = {}) {
         (0, fabrica_publicar_1.publicarEmSegundoPlano)(raiz);
     return resultado(threadId, 'registrou', (0, locale_1.textoDoCatalogo)((m) => m.ship.prRegistrou(merge.mergeSha.slice(0, 7))), { ...merge, ci });
 }
-const ghApi = (caminho) => (0, util_1.exec)('gh', ['api', caminho, '-H', 'Accept: application/vnd.github+json'], process.cwd(), 120000);
-function lerJson(r) {
-    if (!r.ok)
-        return null;
-    try {
-        return JSON.parse(r.stdout);
-    }
-    catch {
-        return null;
+const ghApi = (caminho) => {
+    const r = (0, executor_1.rodarCli)({ cmd: 'gh', args: ['api', '--hostname', 'github.com', caminho, '-H', 'Accept: application/vnd.github+json'], prazoMs: 120000,
+        maxBuffer: 32 * 1024 * 1024 });
+    return { ok: r.status === 0, code: r.status ?? -1, stdout: r.stdout, stderr: r.stderr };
+};
+/**
+ * A forja do repositorio externo: a do projeto quando ela e um GitLab (o mesmo host, a mesma porta, o mesmo caminho
+ * base, outro projeto); o github.com quando a forja do projeto e o GitHub ou quando o projeto nao tem remoto de forja
+ * (sem remoto ou caminho local), como sempre. Nao ha host de reserva: o remoto que nomeia um host de forja que nao se
+ * resolve, e o projeto que declara `forja.tipo: gitlab` sem a forja resolvida, nunca caem no github.com.
+ */
+function forjaDoExterno(carregado, repo, opcoes) {
+    const remoto = opcoes.remoto ?? 'origin';
+    const doProjeto = opcoes.forja ? { ok: true, valor: opcoes.forja } : forjaDaEntrega(carregado, (0, branch_de_estado_1.exigirRemoto)(remoto, 'ship'), opcoes.sondas);
+    if (doProjeto.ok && doProjeto.valor.tipo === 'gitlab')
+        return { ok: true, gitlab: { ...doProjeto.valor, repo } };
+    if (carregado.manifesto.forja?.tipo === 'gitlab') {
+        return { ok: false, remoto, declarada: true,
+            erro: !doProjeto.ok && doProjeto.erro ? doProjeto.erro : { codigo: 'forja.desconhecida', detalhe: remoto } };
     }
+    if (!doProjeto.ok && doProjeto.erro)
+        return { ok: false, erro: doProjeto.erro, remoto, declarada: false };
+    return { ok: true, gitlab: null };
 }
 /**
  * `ork ship registrar-pr <thread> --repo <dono/nome> --pr <n>`: a thread que entrega por PR em outro
  * repositorio (os sites, por exemplo) nao tinha como virar `ship_done`, e a entrega virava decisao. A
- * exigencia e a mesma do caminho local: o merge dentro da ponta da base (pela API do GitHub, porque o
- * repositorio nao e remoto deste checkout) e o check declarado verde no head do PR. O repositorio precisa
- * estar declarado no manifesto; e o dono que diz onde, e com que check, a entrega vale. Idempotente.
+ * exigencia e a mesma do caminho local: o merge dentro da ponta da base (pela API da forja do repositorio, o GitHub
+ * ou o GitLab do projeto, porque o repositorio nao e remoto deste checkout) e o check declarado verde no head do PR.
+ * O repositorio precisa estar declarado no manifesto; e o dono que diz onde, e com que check, a entrega vale.
+ * Idempotente.
  */
 function registrarEntregaExternaPorPr(carregado, threadId, opcoes) {
     const raiz = carregado.raiz, repo = opcoes.repositorio, n = opcoes.pr;
@@ -147,66 +213,91 @@ function registrarEntregaExternaPorPr(carregado, threadId, opcoes) {
     const thread = (0, thread_1.lerThread)(raiz, threadId);
     if (thread.status === 'fechada')
         return resultado(threadId, 'ja-registrada', (0, locale_1.textoDoCatalogo)((m) => m.ship.prThreadFechada));
+    // RM-058, integracao (T1.1): a mesma guarda do PR local, antes de consultar a forja.
+    const guarda = (0, noctum_guarda_1.guardaDaThread)(raiz, threadId);
+    if (guarda)
+        return resultado(threadId, 'recusada', guarda.texto, { codigo: guarda.motivo });
     const dir = (0, thread_1.dirThread)(raiz, threadId);
     if ((0, ledger_1.lerLedger)(dir).some((e) => e.tipo === ledger_1.TIPOS_DE_EVENTO.shipConcluido && e.repositorio === repo && e.pr === n)) {
         return resultado(threadId, 'ja-registrada', (0, locale_1.textoDoCatalogo)((m) => m.ship.prExternoJaTem(n, repo)));
     }
-    const pr = lerJson(gh(`repos/${repo}/pulls/${n}`));
+    const daForja = forjaDoExterno(carregado, repo, opcoes);
+    if (!daForja.ok) {
+        const { erro, remoto, declarada } = daForja;
+        return resultado(threadId, 'recusada', (0, locale_1.textoDoCatalogo)((m) => declarada ? m.ship.prForjaDoExterno(repo, m.forja.motivo(erro, 'gitlab'))
+            : m.ship.prForjaDoProjetoNaoResolvida(repo, remoto, m.forja.motivo(erro, null))), { codigo: 'entrega.sem-leitura' });
+    }
+    const gitlab = daForja.gitlab;
+    // O GitHub so tem dono/nome: o caminho com subgrupo e recusado antes de qualquer consulta.
+    if (!gitlab && repo.split('/').length !== 2) {
+        return resultado(threadId, 'recusada', (0, locale_1.textoDoCatalogo)((m) => m.ship.prRepoComSubgrupoNoGithub(repo)), { codigo: 'entrega.forja-mista' });
+    }
+    const nomeDaForja = gitlab ? 'GitLab' : undefined;
+    const forja = (0, registro_1.adaptadorDaForja)(gitlab ? 'gitlab' : 'github');
+    const api = gitlab ? (0, api_1.chamadorDaApi)(gitlab, opcoes.api ?? {}) : undefined;
+    const pr = (0, registro_1.exigirCapacidade)(forja, 'pedidoMesclado')({ repo, numero: n, executor: gh, api });
     if (!pr)
-        return resultado(threadId, 'recusada', (0, locale_1.textoDoCatalogo)((m) => m.ship.prConsultaFalhou(n, repo)));
-    const mergeSha = typeof pr.merge_commit_sha === 'string' && /^[0-9a-f]{40}$/.test(pr.merge_commit_sha) ? pr.merge_commit_sha : null;
-    const headSha = typeof pr.head?.sha === 'string' && /^[0-9a-f]{40}$/.test(pr.head.sha) ? pr.head.sha : null;
-    const base = typeof pr.base?.ref === 'string' && /^[A-Za-z0-9._/-]{1,200}$/.test(pr.base.ref) ? pr.base.ref : null;
-    if (pr.merged !== true || !mergeSha || !headSha || !base) {
-        return resultado(threadId, 'sem-merge', (0, locale_1.textoDoCatalogo)((m) => m.ship.prNaoMesclado(n, repo)));
+        return resultado(threadId, 'recusada', (0, locale_1.textoDoCatalogo)((m) => m.ship.prConsultaFalhou(n, repo, nomeDaForja)));
+    const { mergeSha, headSha, base } = pr;
+    if (pr.mesclado && mergeSha && base && !headSha) {
+        return resultado(threadId, 'recusada', (0, locale_1.textoDoCatalogo)((m) => m.ship.prSemHead(n, repo, nomeDaForja)), { mergeSha, codigo: 'entrega.sem-head' });
+    }
+    if (!pr.mesclado || !mergeSha || !headSha || !base) {
+        return resultado(threadId, 'sem-merge', (0, locale_1.textoDoCatalogo)((m) => m.ship.prNaoMesclado(n, repo, !!gitlab)));
     }
     // Achado A4 do CHECK: o PR precisa ser DESTA thread e ter entrado na branch padrao do repositorio. Sem o
     // vinculo, qualquer PR mesclado do repositorio viraria entrega de qualquer thread; sem a base, um PR
     // empilhado numa branch de feature contaria como entrega.
-    const vinculo = [pr.title, pr.body, pr.head?.ref].filter((x) => typeof x === 'string')
+    const vinculo = [pr.titulo, pr.corpo, pr.branch].filter((x) => typeof x === 'string')
         // N4 do CHECK 2: a branch do proprio ork e `ork/<thread>-<variante>`, entao o hifen depois do id vale;
         // letra ou digito colado nao (outro id). Sem diferenciar maiusculas.
         .some((x) => new RegExp(`(^|[^a-z0-9-])${threadId.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(?![a-z0-9])`, 'i').test(x));
     if (!vinculo) {
-        return resultado(threadId, 'recusada', (0, locale_1.textoDoCatalogo)((m) => m.ship.prNaoCitaThread(n, repo, threadId)), { mergeSha, headSha });
+        return resultado(threadId, 'recusada', (0, locale_1.textoDoCatalogo)((m) => m.ship.prNaoCitaThread(n, repo, threadId, !!gitlab)), { mergeSha, headSha });
     }
-    const repositorio = lerJson(gh(`repos/${repo}`));
-    if (!repositorio)
-        return resultado(threadId, 'recusada', (0, locale_1.textoDoCatalogo)((m) => m.ship.prRepoFalhou(repo)), { mergeSha, headSha });
-    if (repositorio.default_branch !== base) {
-        return resultado(threadId, 'recusada', (0, locale_1.textoDoCatalogo)((m) => m.ship.prOutraBase(n, base, repo, repositorio.default_branch)), { mergeSha, headSha });
+    const branchPadrao = (0, registro_1.exigirCapacidade)(forja, 'branchPadrao')({ repo, executor: gh, api });
+    if (branchPadrao === null)
+        return resultado(threadId, 'recusada', (0, locale_1.textoDoCatalogo)((m) => m.ship.prRepoFalhou(repo, nomeDaForja)), { mergeSha, headSha });
+    if (branchPadrao !== base) {
+        return resultado(threadId, 'recusada', (0, locale_1.textoDoCatalogo)((m) => m.ship.prOutraBase(n, base, repo, branchPadrao || undefined, !!gitlab)), { mergeSha, headSha });
     }
     // A ponta da base AGORA, e o merge dentro dela: o push provado, pela mesma pergunta do ls-remote.
-    const ramo = lerJson(gh(`repos/${repo}/branches/${encodeURIComponent(base)}`));
-    const ponta = typeof ramo?.commit?.sha === 'string' && /^[0-9a-f]{40}$/.test(ramo.commit.sha) ? ramo.commit.sha : '';
-    const comparacao = ponta ? lerJson(gh(`repos/${repo}/compare/${mergeSha}...${ponta}`)) : null;
-    if (!ponta || !comparacao || !['ahead', 'identical'].includes(String(comparacao.status))) {
+    const ponta = (0, registro_1.exigirCapacidade)(forja, 'pontaDaBranch')({ repo, branch: base, executor: gh, api }) ?? '';
+    const comparacao = ponta ? (0, registro_1.exigirCapacidade)(forja, 'comparar')({ repo, de: mergeSha, ate: ponta, executor: gh, api }) : null;
+    if (!ponta || comparacao === null || !['ahead', 'identical'].includes(comparacao)) {
         return resultado(threadId, 'recusada', (0, locale_1.textoDoCatalogo)((m) => m.ship.prExternoForaDaPonta(mergeSha.slice(0, 7), repo, base)), { mergeSha, headSha });
     }
     const check = declarados[repo];
-    const ci = check ? (0, ci_1.consultarCiDoRepositorio)(repo, headSha, check, opcoes.executorCi) : null;
+    const ciDaForja = opcoes.ciDaForja ?? ((f, sha, contexto) => (0, ci_1.consultarCiNaForja)(f, sha, contexto, (0, produtor_1.produtoresAceitos)(carregado.manifesto, 'gitlab'), { api: opcoes.api }));
+    const ci = !check ? null : gitlab ? ciDaForja(gitlab, headSha, check)
+        : (0, ci_1.consultarCiDoRepositorio)(repo, headSha, check, opcoes.executorCi, 'github.com', (0, produtor_1.produtoresAceitos)(carregado.manifesto, 'github'));
     if (ci && !ci.ok) {
         return resultado(threadId, 'recusada', (0, locale_1.textoDoCatalogo)((m) => m.ship.prSemCiVerde((0, locale_1.remontar)(ci.detail))), { mergeSha, headSha, ci });
     }
     if (opcoes.dryRun) {
-        return resultado(threadId, 'registraria', (0, locale_1.textoDoCatalogo)((m) => m.ship.prExternoRegistraria(mergeSha.slice(0, 7), n, repo)), { mergeSha, headSha, ci });
+        return resultado(threadId, 'registraria', (0, locale_1.textoDoCatalogo)((m) => m.ship.prExternoRegistraria(mergeSha.slice(0, 7), n, repo, !!gitlab)), { mergeSha, headSha, ci });
     }
     (0, ledger_1.registrar)(dir, threadId, ledger_1.TIPOS_DE_EVENTO.shipConcluido, {
         de: thread.base?.branch ?? null,
         para: `${repo}:${base}`,
         repositorio: repo,
         pr: n,
-        url: pr.html_url ?? `https://github.com/${repo}/pull/${n}`,
+        url: pr.url ?? (gitlab ? `https://${(0, cli_1.hostDaApi)(gitlab)}${gitlab.caminhoBase}/${repo}/-/merge_requests/${n}` : `https://github.com/${repo}/pull/${n}`),
         shaDe: headSha,
         mergeSha,
         // RM-037 (fatia 5, A1; aviso da rodada 1 do CHECK): a ponta conferida vai em campo proprio, como no PR local; a
         // comparacao aceita `ahead`, e o recibo do Maestro confere o push contra ela.
         pontaDaBase: ponta,
         jaIncorporado: true,
-        remoto: `github:${repo}`,
+        remoto: `${gitlab ? 'gitlab' : 'github'}:${repo}`,
         shaRemoto: ponta,
         pushVerificado: true,
-        fonteDaProva: `gh api repos/${repo}/compare/${mergeSha}...${ponta} (status ${String(comparacao.status)}; ponta de ${base} por gh api repos/${repo}/branches/${base})`,
+        // `identical`: o merge e a propria ponta, e a comparacao nem e consultada.
+        fonteDaProva: gitlab && comparacao === 'identical'
+            ? `merge = ponta de ${base} por glab api ${(0, pedidos_1.projetoNaApi)(repo)}/repository/branches/${encodeURIComponent(base)}`
+            : gitlab
+                ? `glab api ${(0, pedidos_1.projetoNaApi)(repo)}/repository/compare?from=${ponta}&to=${mergeSha}&straight=false (status ${comparacao}; ponta de ${base} por glab api ${(0, pedidos_1.projetoNaApi)(repo)}/repository/branches/${encodeURIComponent(base)})`
+                : `gh api repos/${repo}/compare/${mergeSha}...${ponta} (status ${comparacao}; ponta de ${base} por gh api repos/${repo}/branches/${base})`,
         autorizadoPor: ci ? 'merge de PR com o CI independente verde no SHA exato' : 'merge de PR em repositorio externo declarado sem CI no manifesto',
         tipoDeAutorizacao: 'pr-externo',
         modo: thread.modo,
@@ -216,19 +307,28 @@ function registrarEntregaExternaPorPr(carregado, threadId, opcoes) {
     avancarParaShip(raiz, threadId);
     if (opcoes.publicar !== false)
         (0, fabrica_publicar_1.publicarEmSegundoPlano)(raiz);
-    return resultado(threadId, 'registrou', (0, locale_1.textoDoCatalogo)((m) => m.ship.prExternoRegistrou(mergeSha.slice(0, 7), n, repo)), { mergeSha, headSha, ci });
+    return resultado(threadId, 'registrou', (0, locale_1.textoDoCatalogo)((m) => m.ship.prExternoRegistrou(mergeSha.slice(0, 7), n, repo, !!gitlab)), { mergeSha, headSha, ci });
 }
 /** `ork ship registrar-pr --todas`: toda thread aberta que ja tem merge `ship(<thread>)` na base. */
 function registrarEntregasPorPr(carregado, opcoes = {}) {
     const remoto = (0, branch_de_estado_1.exigirRemoto)(opcoes.remoto ?? 'origin', 'ship');
     const base = carregado.manifesto.worktree.base_branch;
-    (0, util_1.exec)('git', ['fetch', '-q', '--', remoto, `+refs/heads/${base}:refs/remotes/${remoto}/${base}`], carregado.raiz);
-    const r = (0, thread_1.listarIds)(carregado.raiz)
-        .filter((id) => (0, thread_1.lerThread)(carregado.raiz, id).status !== 'fechada')
+    const busca = (0, util_1.exec)('git', ['fetch', '-q', '--', remoto, `+refs/heads/${base}:refs/remotes/${remoto}/${base}`], carregado.raiz);
+    const abertas = (0, thread_1.listarIds)(carregado.raiz).filter((id) => (0, thread_1.lerThread)(carregado.raiz, id).status !== 'fechada');
+    // Sem leitura do remoto nao ha como saber quais threads tem merge: uma recusa por thread aberta, nunca lista vazia.
+    if (!busca.ok) {
+        return abertas.map((id) => resultado(id, 'recusada', (0, locale_1.textoDoCatalogo)((m) => m.ship.prSemLeitura(remoto, base)), { codigo: 'entrega.sem-leitura' }));
+    }
+    // RM-058, integracao (T1.1): os arcos lidos uma vez para o lote; a thread do arco e pulada com o motivo, e as outras seguem.
+    const arcos = (0, noctum_guarda_1.lerArcosDaRaiz)(carregado.raiz);
+    const r = abertas
         .filter((id) => mergeDaEntrega(carregado.raiz, id, remoto, base) !== null)
         .map((id) => {
         try {
-            return registrarEntregaPorPr(carregado, id, { ...opcoes, buscar: false, publicar: false });
+            const guarda = (0, noctum_guarda_1.guardaDaThread)(carregado.raiz, id, arcos.quando, { arcos });
+            if (guarda)
+                return resultado(id, 'pulada', guarda.texto, { codigo: guarda.motivo });
+            return registrarEntregaPorPr(carregado, id, { ...opcoes, buscar: false, publicar: false, arcos });
         }
         catch (e) {
             return resultado(id, 'recusada', e instanceof locale_1.ErroDoCatalogo ? (0, locale_1.textoDoCatalogo)(e.montar) : e.message);

package/dist/esgotamentos.js

@@ -63,9 +63,10 @@ const projeto_alvo_1 = require("./projeto-alvo");
 const runtime_profiles_1 = require("./runtime-profiles");
 const thread_1 = require("./thread");
 const util_1 = require("./util");
+const locale_1 = require("./locale");
 exports.CONTRATO_ESGOTAMENTOS = 'ork.esgotamentos/v1';
-exports.LIMITE_DO_RELATORIO = 'o registro guarda so as marcas vivas (uso bem sucedido, login reconferido e prazo vencido ' +
-    'apagam a marca): o total e um piso, valido enquanto a marca existe';
+/** O limite que o `--json` leva: dado, sempre em pt-BR (RM-061, F3b: o texto mora no catalogo). */
+exports.LIMITE_DO_RELATORIO = (0, locale_1.msg)('pt-BR').accounts.limiteDoRelatorio;
 exports.NAO_REGISTRADO = 'nao registrado';
 function contaOpaca(chave) {
     return (0, node_crypto_1.createHash)('sha256').update(chave).digest('hex').slice(0, 12);
@@ -160,22 +161,23 @@ function relatorioDeEsgotamentos(opcoes = {}) {
 }
 /** Texto para o terminal, com o horario do dono e o fuso uma vez no fim. */
 function textoDosEsgotamentos(r) {
+    // RM-061 (F3b): o texto pelo catalogo; o estado da marca so se traduz aqui, e o limite do `--json` (pt-BR) sai no locale.
+    const t = (0, locale_1.msg)().accounts;
     const linhas = [
-        `Esgotamentos de conta  ${(0, horario_1.formatarDataHora)(r.periodo.desde)} ate ${(0, horario_1.formatarDataHora)(r.periodo.ate)} ${r.periodo.intervalo}`,
-        `  marcas vivas no registro: ${r.marcas.length}`,
+        t.esgotamentosTitulo((0, horario_1.formatarDataHora)(r.periodo.desde), (0, horario_1.formatarDataHora)(r.periodo.ate), r.periodo.intervalo),
+        t.marcasVivas(r.marcas.length),
     ];
     for (const m of r.marcas) {
-        const ate = m.estado === 'esgotado' ? `ate ${(0, horario_1.formatarDataHora)(m.esgotadoAte)}` : 'sem prazo';
-        linhas.push(`    conta ${m.conta}  ${m.runtime}  ${m.estado} desde ${(0, horario_1.formatarDataHora)(m.em)}, ${ate}  visto em ${m.projeto} (${m.motivo})`);
+        linhas.push(t.marca(m.conta, m.runtime, t.estado(m.estado), (0, horario_1.formatarDataHora)(m.em), m.estado === 'esgotado' ? (0, horario_1.formatarDataHora)(m.esgotadoAte) : null, m.projeto, m.motivo));
     }
-    linhas.push(`  projetos lidos: ${r.projetos.length === 0 ? 'nenhum registrado'
-        : r.projetos.map((p) => `${p.nome} (${p.presente ? `${p.despachosComPerfil} despacho(s) com perfil` : 'fora do disco'})`).join(', ')}`);
-    linhas.push(`  despachos em conta marcada por outro projeto: ${r.total}`);
+    linhas.push(t.projetosLidos(r.projetos.length === 0 ? null
+        : r.projetos.map((p) => t.projetoLido(p.nome, p.presente ? p.despachosComPerfil : null)).join(', ')));
+    linhas.push(t.despachosMarcados(r.total));
     if (r.despachos.length > 0) {
-        linhas.push((0, util_1.tabela)(['QUANDO', 'PROJETO', 'THREAD', 'FASE', 'PERFIL', 'CONTA', 'MARCADA POR'], r.despachos.map((d) => [(0, horario_1.formatarDataHora)(d.em), d.projeto, d.thread, d.fase ?? '-', d.perfil, d.conta, d.marcadaPor]))
+        linhas.push((0, util_1.tabela)([...t.colunasDosDespachos], r.despachos.map((d) => [(0, horario_1.formatarDataHora)(d.em), d.projeto, d.thread, d.fase ?? '-', d.perfil, d.conta, d.marcadaPor]))
             .split('\n').map((l) => `    ${l}`).join('\n'));
     }
-    linhas.push(`  limite: ${r.limite}`);
+    linhas.push(t.limite(r.limite === exports.LIMITE_DO_RELATORIO ? t.limiteDoRelatorio : r.limite));
     linhas.push((0, horario_1.legendaDoFuso)());
     return linhas.join('\n');
 }

package/dist/estado-thread.js

@@ -44,6 +44,7 @@ const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const node_crypto_1 = require("node:crypto");
 const util_1 = require("./util");
+const locale_1 = require("./locale");
 function raizDoEstado(raiz) {
     const local = path.resolve(raiz);
     const git = path.join(local, '.git');
@@ -51,7 +52,7 @@ function raizDoEstado(raiz) {
         return local;
     const match = /^gitdir: (.+)\s*$/m.exec(fs.readFileSync(git, 'utf8'));
     if (!match)
-        throw new Error(`.git inválido em ${local}`);
+        throw new locale_1.ErroDoCatalogo((m) => m.estado.gitInvalido(local));
     const gitdir = path.resolve(local, match[1].trim());
     const commondir = path.join(gitdir, 'commondir');
     if (!fs.existsSync(commondir))
@@ -60,13 +61,13 @@ function raizDoEstado(raiz) {
     const principal = path.dirname(comum);
     if (!fs.existsSync(path.join(principal, '.git')) ||
         fs.realpathSync(path.join(principal, '.git')) !== fs.realpathSync(comum)) {
-        throw new Error(`árvore principal não resolvida pelo git-common-dir: ${comum}`);
+        throw new locale_1.ErroDoCatalogo((m) => m.estado.arvorePrincipal(comum));
     }
     return principal;
 }
 function estadoCanonico(raiz, id) {
     if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(id))
-        throw new Error('id de thread inválido');
+        throw new locale_1.ErroDoCatalogo((m) => m.estado.idInvalido);
     const principal = raizDoEstado(raiz);
     exigirEstadoSemLink(principal, ['.orkastery', 'threads', id]);
     return path.join(principal, '.orkastery', 'threads', id);
@@ -85,8 +86,8 @@ function exigirEstadoSemLink(principal, componentes) {
         if (!stat)
             return;
         if (stat.isSymbolicLink()) {
-            throw new Error(`estado.link: ${path.relative(principal, atual)} é link simbólico; o estado do ork fica em ` +
-                'pastas de verdade dentro da raiz (um link versionado levaria a escrita para fora dela). Remova o link.');
+            const rel = path.relative(principal, atual);
+            throw new locale_1.ErroDoCatalogo((m) => m.estado.link(rel));
         }
     }
 }
@@ -97,11 +98,11 @@ function arquivos(dir, prefixo = '') {
     return fs.readdirSync(path.join(dir, prefixo), { withFileTypes: true }).flatMap(e => {
         const nome = path.join(prefixo, e.name);
         if (e.isSymbolicLink())
-            throw new Error(`estado legado contém link: ${nome}`);
+            throw new locale_1.ErroDoCatalogo((m) => m.estado.legadoComLink(nome));
         if (e.isDirectory())
             return arquivos(dir, nome);
         if (!e.isFile())
-            throw new Error(`estado legado contém arquivo especial: ${nome}`);
+            throw new locale_1.ErroDoCatalogo((m) => m.estado.legadoEspecial(nome));
         return [nome];
     });
 }
@@ -122,18 +123,18 @@ function vincularEstado(raiz, id, worktree, dryRun = false) {
     if (path.resolve(local) === alvo)
         return;
     if (raizDoEstado(worktree) !== raizDoEstado(raiz))
-        throw new Error('worktree não pertence à árvore principal');
+        throw new locale_1.ErroDoCatalogo((m) => m.estado.foraDaArvore);
     // O índice é próprio da linked worktree. A main continua versionando seu estado.
     const rastreados = (0, util_1.exec)('git', ['ls-files', '-z', '--', `.orkastery/threads/${id}/`], worktree);
     if (!rastreados.ok)
-        throw new Error(`índice da worktree indisponível: ${rastreados.stderr}`);
+        throw new locale_1.ErroDoCatalogo((m) => m.estado.indiceIndisponivel(rastreados.stderr));
     const nomes = rastreados.stdout.split('\0').filter(Boolean);
     const prepararIndice = () => {
         if (dryRun || nomes.length === 0)
             return;
         const r = (0, util_1.exec)('git', ['update-index', '--skip-worktree', '--', ...nomes], worktree);
         if (!r.ok)
-            throw new Error(`não foi possível preservar o estado versionado no índice: ${r.stderr}`);
+            throw new locale_1.ErroDoCatalogo((m) => m.estado.naoPreservou(r.stderr));
     };
     if (mesmoArquivo(local, alvo)) {
         prepararIndice();
@@ -144,11 +145,11 @@ function vincularEstado(raiz, id, worktree, dryRun = false) {
     const copiar = [];
     const existe = fs.existsSync(local);
     if (!existe && fs.lstatSync(path.dirname(local), { throwIfNoEntry: false })?.isSymbolicLink()) {
-        throw new Error('diretório de threads inesperadamente vinculado');
+        throw new locale_1.ErroDoCatalogo((m) => m.estado.threadsVinculado);
     }
     if (existe) {
         if (fs.lstatSync(local).isSymbolicLink())
-            throw new Error(`link de estado aponta para outro destino: ${local}`);
+            throw new locale_1.ErroDoCatalogo((m) => m.estado.linkOutroDestino(local));
         for (const nome of arquivos(local)) {
             const destino = path.join(alvo, nome);
             if (!fs.existsSync(destino)) {
@@ -162,11 +163,11 @@ function vincularEstado(raiz, id, worktree, dryRun = false) {
             // Prefixo JSONL já incorporado na main não é conflito nem deve ser duplicado.
             if (nome.endsWith('.jsonl') && a.toString().endsWith('\n') && b.subarray(0, a.length).equals(a))
                 continue;
-            throw new Error(`estado dividido: ${nome} diverge entre ${local} e ${alvo}; reconcilie antes do sync`);
+            throw new locale_1.ErroDoCatalogo((m) => m.estado.dividido(nome, local, alvo));
         }
     }
     else if (fs.lstatSync(local, { throwIfNoEntry: false })) {
-        throw new Error(`link de estado quebrado: ${local}`);
+        throw new locale_1.ErroDoCatalogo((m) => m.estado.linkQuebrado(local));
     }
     // O ensaio executa o mesmo preflight, sem tocar em arquivos ou no índice.
     if (dryRun)
@@ -200,7 +201,7 @@ function comEstadoParaGit(raiz, id, worktree, executar) {
     const git = (args) => {
         const r = (0, util_1.exec)('git', args, worktree);
         if (!r.ok)
-            throw new Error(`preparação do estado para Git falhou: ${r.stderr || r.stdout}`);
+            throw new locale_1.ErroDoCatalogo((m) => m.estado.preparacaoFalhou(r.stderr || r.stdout));
         return r.stdout;
     };
     const nomes = git(['ls-files', '-z', '--', prefixo]).split('\0').filter(Boolean);
@@ -220,7 +221,7 @@ function comEstadoParaGit(raiz, id, worktree, executar) {
         const mudou = materializado && (!(0, util_1.exec)('git', ['diff', '--quiet', '--', prefixo], worktree).ok ||
             git(['ls-files', '--others', '--', prefixo]).trim() !== '');
         if (mudou)
-            throw new Error(`estado local alterado durante operação Git: ${local}; cópia e main preservadas para reconciliação`);
+            throw new locale_1.ErroDoCatalogo((m) => m.estado.alteradoDuranteGit(local));
         if (fs.existsSync(local)) {
             const backup = path.join(raizDoEstado(raiz), '.orkastery', 'state-backups', `${id}-git-${(0, node_crypto_1.randomUUID)()}`);
             fs.mkdirSync(path.dirname(backup), { recursive: true });
@@ -238,7 +239,9 @@ function auditarEstado(raiz, id, worktree) {
         return fs.existsSync(file) ? fs.readFileSync(file, 'utf8').split('\n').filter(Boolean).length : 0;
     };
     const ok = mesmoArquivo(main, local);
+    // RM-061 (F3b, G4): o detalhe vai ao ledger do audit em pt-BR (escopo da gravacao) e a impressao o remonta.
+    const eventosMain = contar(main), eventosLocal = contar(local);
     return { nome: 'estado-unico', nivel: ok ? 'ok' : 'fail',
-        detalhe: `${ok ? 'mesmo estado' : 'estado dividido'}: main=${contar(main)} eventos, worktree=${contar(local)} eventos; ${main}`,
-        ...(ok ? {} : { correcao: `ork worktree sync ${id}; divergências exigem reconciliação preservando evidências` }) };
+        detalhe: (0, locale_1.textoDoCatalogo)((m) => m.estado.estadoUnico(ok, eventosMain, eventosLocal, main)),
+        ...(ok ? {} : { correcao: (0, locale_1.textoDoCatalogo)((m) => m.estado.estadoUnicoCorrecao(id)) }) };
 }