@orkastery/cli 0.5.6 → 0.6.0

package/dist/forja.js

@@ -1,11 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.mesmaForja = exports.rotuloDaForja = exports.executorPadrao = void 0;
+exports.apiDoGitlab = exports.mesmaForja = exports.rotuloDaForja = exports.executorPadrao = void 0;
 exports.enderecoDoRemoto = enderecoDoRemoto;
 exports.repositorioGithubNoHost = repositorioGithubNoHost;
 exports.identidadeDaForja = identidadeDaForja;
+exports.identidadeDaForjaResolvida = identidadeDaForjaResolvida;
 exports.forjaDoArgumento = forjaDoArgumento;
 exports.detalheSeguro = detalheSeguro;
+exports.detalheDoPush = detalheDoPush;
+exports.pushRecusadoPelaProtecao = pushRecusadoPelaProtecao;
 exports.classificarFalha = classificarFalha;
 exports.lerCommitsDaForja = lerCommitsDaForja;
 exports.lerDaForja = lerDaForja;
@@ -20,16 +23,19 @@ exports.lerDaForja = lerDaForja;
  *
  * GitHub responde tudo em UMA consulta: a base com `docs/roadmap`, o manifesto e os commits desde
  * `desde`, e as duas branches de estado, cada parte no commit que a propria consulta devolve.
- * GitLab devolve a mesma leitura por consultas GraphQL e pelo REST de commits; sem `glab` na
- * maquina que construiu, o esquema dele esta provado so com resposta simulada (D4 do PLAN).
+ * GitLab devolve a mesma leitura por consultas GraphQL e pelo REST de commits, pela API da CLI
+ * logada (`forja/api.ts`); o esquema esta provado com as respostas gravadas de um GitLab de verdade.
  *
  * Resposta fora do formato vira erro tipado, nunca lista vazia: quem le nao confunde "nao li" com
  * "nao tem".
  */
-const node_child_process_1 = require("node:child_process");
+const endereco_1 = require("./forja/endereco");
 const hitl_1 = require("./hitl");
 const policies_1 = require("./policies");
-const rede_forja_1 = require("./rede-forja");
+const executor_1 = require("./forja/executor");
+const api_1 = require("./forja/api");
+const consultas_1 = require("./forja/gitlab/consultas");
+const pedidos_1 = require("./forja/gitlab/pedidos");
 const PRAZO_MS = 30000;
 const SHA = /^[0-9a-f]{40}$/;
 const SEGMENTO = /^[A-Za-z0-9_.-]+$/;
@@ -41,18 +47,17 @@ const HOST = /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]*[a-z0-9]
  * usuario (`~/.local/bin` e as outras): o gateway e o cron rodam com PATH curto, e o `gh` da maquina-b
  * mora em `~/.local/bin`. Sem achar, o nome vai cru ao spawn, e o ENOENT continua `forja.ausente`.
  */
-const executorPadrao = (cmd, args, entrada, timeoutMs) => {
-    const r = (0, node_child_process_1.spawnSync)((0, rede_forja_1.acharBinario)(cmd) ?? cmd, [...args], {
-        input: entrada, encoding: 'utf8', timeout: timeoutMs, maxBuffer: 32 * 1024 * 1024,
-        env: { ...process.env, GH_PROMPT_DISABLED: '1', GH_NO_UPDATE_NOTIFIER: '1', GLAB_CHECK_UPDATE: 'false', NO_COLOR: '1' },
-    });
-    return { status: r.status, stdout: (r.stdout ?? '').toString(), stderr: (r.stderr ?? '').toString(), sinal: r.signal ?? null,
-        ...(r.error ? { erro: r.error.code ?? r.error.message } : {}) };
-};
+const executorPadrao = (cmd, args, entrada, timeoutMs) => (0, executor_1.rodarCli)({ cmd, args, entrada,
+    prazoMs: timeoutMs, maxBuffer: 32 * 1024 * 1024,
+    acrescentar: { GH_PROMPT_DISABLED: '1', GH_NO_UPDATE_NOTIFIER: '1', GLAB_CHECK_UPDATE: 'false', NO_COLOR: '1' } });
 exports.executorPadrao = executorPadrao;
 // ---------------------------------------------------------------------------
 // Identidade
 // ---------------------------------------------------------------------------
+/**
+ * O tipo pelo nome do host. So vale onde nao ha manifesto nem login para resolver: a rede le os remotos de outros
+ * projetos. A CI do projeto usa a forja resolvida (`forja/resolver.ts`), que nao decide pelo nome.
+ */
 function tipoDoHost(host) {
     if (host === 'github.com' || /(^|[.-])github([.-]|$)/.test(host))
         return 'github';
@@ -75,14 +80,9 @@ function montar(tipo, host, caminho) {
  * na URL nunca entra; caminho local e host que nao e hostname voltam null.
  */
 function enderecoDoRemoto(url) {
-    const t = url.trim();
-    const esquema = /^(?:https?|ssh|git|git\+ssh|ssh\+git):\/\/(?:[^@/]*@)?([^/:?#@]+)(?::\d+)?\/([^?#\s]+)$/i.exec(t);
-    const scp = esquema ? null : /^(?:[^@\s/:]+@)?([^:\s/@]+):(?!\/\/)([^\s]+)$/.exec(t);
-    const achado = esquema ?? scp;
-    if (!achado)
-        return null;
-    const host = achado[1].toLowerCase();
-    return HOST.test(host) ? { host, caminho: achado[2].replace(/^\/+/, '') } : null;
+    // Parser unico (forja/endereco.ts); aqui so o `HOST` com ponto e o caminho como escrito (`montar` o valida).
+    const lido = (0, endereco_1.lerHostDoRemoto)(url);
+    return lido && HOST.test(lido.host) ? { host: lido.host, caminho: lido.caminhoBruto } : null;
 }
 /**
  * RM-037 (fatia 5, A5): o `dono/nome` de um repositorio do GitHub no host do remoto, com qualquer host: o GitHub
@@ -99,7 +99,29 @@ function repositorioGithubNoHost(url) {
 function identidadeDaForja(url) {
     const endereco = enderecoDoRemoto(url);
     const tipo = endereco ? tipoDoHost(endereco.host) : null;
-    return endereco && tipo ? montar(tipo, endereco.host, endereco.caminho) : null;
+    const id = endereco && tipo ? montar(tipo, endereco.host, endereco.caminho) : null;
+    const porta = id?.tipo === 'gitlab' ? portaDaApiNoRemoto(url) : null;
+    return id && porta !== null ? { ...id, porta } : id;
+}
+/**
+ * A identidade de uma forja ja resolvida (o bloco `forja:`, o host conhecido), na forma que a leitura do roadmap usa. A
+ * porta, o caminho base e a CA so entram no GitLab: o GitHub le pelo `gh` com o host.
+ */
+function identidadeDaForjaResolvida(f) {
+    const id = montar(f.tipo, f.host, f.repo);
+    if (!id || id.tipo !== 'gitlab')
+        return id;
+    return { ...id, ...(f.porta !== null ? { porta: f.porta } : {}), ...(f.caminhoBase ? { caminhoBase: f.caminhoBase } : {}),
+        ...(f.ca ? { ca: f.ca } : {}) };
+}
+/** A porta da API num remoto https/http, quando nao e a do esquema; a porta de ssh e do ssh e nunca entra. */
+function portaDaApiNoRemoto(url) {
+    const lido = (0, endereco_1.lerHostDoRemoto)(url);
+    if (!lido || (lido.protocolo !== 'https' && lido.protocolo !== 'http') || lido.porta === null)
+        return null;
+    if (lido.porta < 1 || lido.porta > 65535 || lido.porta === (lido.protocolo === 'https' ? 443 : 80))
+        return null;
+    return lido.porta;
 }
 /** `github:dono/repo`, `gitlab:grupo/sub/repo` (com host proprio: `gitlab:host.tld/grupo/repo`) ou uma URL. */
 function forjaDoArgumento(texto) {
@@ -115,20 +137,57 @@ function forjaDoArgumento(texto) {
     return /^[a-z+]+:\/\//i.test(t) || /^[^@\s/:]+@[^:\s/]+:/.test(t) ? identidadeDaForja(t) : null;
 }
 /** Como a forja aparece para gente: `github.com/orkastery/orkastery`. */
-const rotuloDaForja = (f) => `${f.host}/${f.repo}`;
+const rotuloDaForja = (f) => `${f.host}${f.porta ? `:${f.porta}` : ''}/${f.repo}`;
 exports.rotuloDaForja = rotuloDaForja;
+/** O mesmo repositorio: tipo, host e repo. A porta da API nao entra, senao o mesmo repo por ssh, https e `gitlab:host/g/r` nao casaria. */
 const mesmaForja = (a, b) => !!a && !!b && a.tipo === b.tipo && a.host === b.host && a.repo.toLowerCase() === b.repo.toLowerCase();
 exports.mesmaForja = mesmaForja;
 // ---------------------------------------------------------------------------
 // Erros
 // ---------------------------------------------------------------------------
+/**
+ * O texto inteiro sem segredo. Os tokens do GitLab podem ter ponto (formato roteavel, `glpat-xxxx.01.yyyy`), por isso a
+ * classe inclui o ponto e nao ha `\b` no fim, que cortaria no ponto e deixaria o sufixo; o token de registro de runner
+ * legado tem o prefixo fixo `GR1348941`.
+ */
+function redigirDaForja(texto) {
+    return (0, hitl_1.redigirSegredos)(texto)
+        .replace(/\b(?:glpat|gldt|glrt|glptt|glcbt|gloas|glft|glimt|glsoat)-[A-Za-z0-9_.-]{16,}/g, '[redigido]')
+        .replace(/\bGR1348941[A-Za-z0-9_-]{20,}/g, '[redigido]')
+        .replace(/\bgithub_pat_[A-Za-z0-9_]{20,}\b/g, '[redigido]');
+}
+const OMITIDO = '[detalhe omitido: um padrão de segredo casou]';
 /** O fim da saida de erro, sem segredo: redigido, e descartado inteiro se ainda casar um padrao. */
 function detalheSeguro(texto) {
-    const redigido = (0, hitl_1.redigirSegredos)(texto)
-        .replace(/\b(?:glpat|gldt|glrt|glptt|glcbt)-[A-Za-z0-9_-]{16,}\b/g, '[redigido]')
-        .replace(/\bgithub_pat_[A-Za-z0-9_]{20,}\b/g, '[redigido]');
-    const linha = redigido.split('\n').map((l) => l.trim()).filter(Boolean).slice(-2).join(' ').slice(0, 240);
-    return (0, policies_1.procurarSegredos)(linha).length ? '[detalhe omitido: um padrão de segredo casou]' : linha;
+    const linha = redigirDaForja(texto).split('\n').map((l) => l.trim()).filter(Boolean).slice(-2).join(' ').slice(0, 240);
+    return (0, policies_1.procurarSegredos)(linha).length ? OMITIDO : linha;
+}
+/**
+ * O motivo de um `git push` recusado, sem segredo. O texto inteiro e redigido antes do corte; as linhas `hint:` saem,
+ * e fica o comeco do resto (ate 400 caracteres), onde o git poe o `! [rejected]` ou `! [remote rejected]` e o
+ * `error: failed to push`. Guardar so o fim perderia o motivo: num non-fast-forward, as ultimas linhas sao hints.
+ */
+function detalheDoPush(texto) {
+    const linhas = redigirDaForja(texto).split('\n').map((l) => l.trim()).filter((l) => l && !/^hint:/i.test(l));
+    const detalhe = linhas.join(' ').slice(0, 400);
+    return (0, policies_1.procurarSegredos)(detalhe).length ? OMITIDO : detalhe;
+}
+/**
+ * O push recusado pela protecao da branch. O GitHub diz `GH006: Protected branch update failed` e
+ * `protected branch hook declined`; o GitLab diz `You are not allowed to push code to protected branches` (ou
+ * `force push code to a protected branch`) antes do `pre-receive hook declined`. O `GH013` (regras do repositorio) e
+ * generico: tambem vem da protecao contra segredo, de regra de caminho ou de mensagem de commit. Por isso so conta com
+ * o sinal da protecao da branch na mesma saida (`Changes must be made through a pull request` ou `Cannot update this
+ * protected ref`), e nunca com `PUSH PROTECTION` / `Push cannot contain secrets`. O `pre-receive hook declined` sozinho
+ * e de qualquer gancho, e o "not allowed to push code to this project" do GitLab e falta de acesso ao projeto.
+ */
+function pushRecusadoPelaProtecao(texto) {
+    if (/PUSH PROTECTION|Push cannot contain secrets/i.test(texto))
+        return false;
+    if (/\bGH006\b|protected branch hook declined|not allowed to (?:force )?push code to (?:a )?protected branch/i.test(texto))
+        return true;
+    return /\bGH013\b|repository rule violations/i.test(texto)
+        && /Changes must be made through a pull request|Cannot update this protected ref/i.test(texto);
 }
 function erro(codigo, detalhe) {
     return { ok: false, erro: { codigo, detalhe } };
@@ -138,16 +197,16 @@ function classificarFalha(cmd, s) {
     if (s.erro === 'ENOENT')
         return { codigo: 'forja.ausente', detalhe: `${cmd} não está instalado nesta máquina` };
     if (s.erro === 'ETIMEDOUT' || s.sinal === 'SIGTERM')
-        return { codigo: 'forja.tempo-esgotado', detalhe: `${cmd} não respondeu em ${PRAZO_MS / 1000} s` };
+        return { codigo: 'forja.indisponivel', detalhe: `${cmd} não respondeu em ${PRAZO_MS / 1000} s` };
     const texto = `${s.stderr}\n${s.stdout}`;
     const detalhe = detalheSeguro(s.stderr || s.stdout || s.erro || `${cmd} saiu com ${s.status}`);
     if (/"type"\s*:\s*"NOT_FOUND"|Could not resolve to a Repository|404 Not Found|HTTP 404|project not found/i.test(texto)) {
-        return { codigo: 'forja.nao-encontrado', detalhe };
+        return { codigo: 'forja.nao-achei', detalhe };
     }
     if (/auth login|not logged|authentication|HTTP 401|Bad credentials|GH_TOKEN|GITLAB_TOKEN|unauthorized|no token/i.test(texto)) {
         return { codigo: 'forja.sem-login', detalhe };
     }
-    return { codigo: 'forja.inacessivel', detalhe };
+    return { codigo: 'forja.indisponivel', detalhe };
 }
 const obj = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
 class RespostaInvalida extends Error {
@@ -170,7 +229,7 @@ function chamarJson(executor, cmd, args, corpo) {
         const falha = classificarFalha(cmd, s.erro || s.status !== 0 ? s : { ...s, status: 1, stderr: JSON.stringify(json) });
         // `gh` sai 1 com NOT_FOUND no corpo: o tipo do erro GraphQL vale mais que a frase.
         if (erros && json.errors.some((e) => obj(e) && e.type === 'NOT_FOUND')) {
-            return { ok: false, erro: { codigo: 'forja.nao-encontrado', detalhe: falha.detalhe } };
+            return { ok: false, erro: { codigo: 'forja.nao-achei', detalhe: falha.detalhe } };
         }
         return { ok: false, erro: falha };
     }
@@ -178,10 +237,7 @@ function chamarJson(executor, cmd, args, corpo) {
         return { ok: false, erro: { codigo: 'forja.resposta-invalida', detalhe: `${cmd} não devolveu JSON` } };
     return { ok: true, json };
 }
-/**
- * O host vai sempre explicito: sem ele, o `gh` usa `GH_HOST` ou o unico host com login, e o `glab`,
- * o host do remoto do cwd; a consulta iria para outra forja.
- */
+/** So o `gh`: o host vai sempre explicito, ou ele usaria `GH_HOST` ou o unico host com login e a consulta iria para outra forja. */
 const hostnameDe = (f) => ['--hostname', f.host];
 function arquivosDoGithub(entrada, dir) {
     if (entrada === null)
@@ -220,19 +276,27 @@ function commitsDoHistorico(historico, onde) {
         parciais: obj(h.pageInfo) && h.pageInfo.hasNextPage === true,
     };
 }
-/** Os commits da base desde `desde`, pelo REST do GitLab (GET), e se vieram 100 (pagina cheia). */
-function commitsDoGitlab(forja, commit, desde, executor) {
-    const rest = executor('glab', ['api', `projects/${encodeURIComponent(forja.repo)}/repository/commits?ref_name=${encodeURIComponent(commit)}` +
-            `&since=${encodeURIComponent(desde)}&per_page=100`, ...hostnameDe(forja)], '', PRAZO_MS);
-    if (rest.erro || rest.status !== 0)
-        return { ok: false, erro: classificarFalha('glab', rest) };
-    let lista;
-    try {
-        lista = JSON.parse(rest.stdout);
-    }
-    catch {
-        lista = undefined;
+/** A API do GitLab de uma forja: o host e a porta da API, e o caminho base e a CA quando vieram do bloco `forja:`. */
+const apiDoGitlab = (forja, opcoes = {}) => (0, api_1.chamadorDaApi)({ tipo: 'gitlab', host: forja.host, porta: forja.porta ?? null, caminhoBase: forja.caminhoBase ?? '', ca: forja.ca ?? null }, opcoes);
+exports.apiDoGitlab = apiDoGitlab;
+/** Uma consulta GraphQL do GitLab; `errors` no corpo e erro tipado, nunca resposta. */
+function graphqlDoGitlab(api, query, variables) {
+    const r = api({ metodo: 'POST', caminho: 'graphql', corpo: { query, variables }, prazoMs: PRAZO_MS });
+    if (!r.ok)
+        return r;
+    const json = r.valor.corpo;
+    if (obj(json) && Array.isArray(json.errors) && json.errors.length) {
+        return { ok: false, erro: { codigo: 'forja.resposta-invalida', detalhe: detalheSeguro(JSON.stringify(json.errors)) } };
     }
+    return { ok: true, json };
+}
+/** Os commits da base desde `desde`, pelo REST do GitLab (GET), e se vieram 100 (pagina cheia). */
+function commitsDoGitlab(forja, commit, desde, api) {
+    const r = api({ metodo: 'GET', caminho: `${(0, pedidos_1.projetoNaApi)(forja.repo)}/repository/commits?ref_name=${encodeURIComponent(commit)}` +
+            `&since=${encodeURIComponent(desde)}&per_page=100`, prazoMs: PRAZO_MS });
+    if (!r.ok)
+        return r;
+    const lista = r.valor.corpo;
     exigir(Array.isArray(lista), 'commits');
     const commits = lista.map((c) => {
         exigir(obj(c) && typeof c.id === 'string' && typeof c.title === 'string' && typeof c.committed_date === 'string', 'commit');
@@ -289,30 +353,9 @@ function lerDoGithub(forja, pedido, executor, lidoEm) {
     return { ok: true, leitura: { forja, lidoEm, chamadas: 1, base: leituraDaBase,
             reservas: estado(repo.reservas, pedido.reservas), fabrica: estado(repo.fabrica, pedido.fabrica) } };
 }
-const CONSULTA_RAIZ_GITLAB = 'query($path: ID!) { project(fullPath: $path) { repository { rootRef } } }';
-const CONSULTA_ARVORES_GITLAB = `query($path: ID!, $base: String!, $dirRoadmap: String!, $refReservas: String!, $dirReservas: String!,
-  $refFabrica: String!, $dirFabrica: String!) {
-  project(fullPath: $path) { repository {
-    baseTopo: tree(ref: $base) { lastCommit { sha committedDate } }
-    baseDir: tree(ref: $base, path: $dirRoadmap) { blobs(first: 100) { pageInfo { hasNextPage } nodes { name path } } }
-    reservasTopo: tree(ref: $refReservas) { lastCommit { sha committedDate } }
-    reservasDir: tree(ref: $refReservas, path: $dirReservas) { blobs(first: 100) { pageInfo { hasNextPage } nodes { name path } } }
-    fabricaTopo: tree(ref: $refFabrica) { lastCommit { sha committedDate } }
-    fabricaDir: tree(ref: $refFabrica, path: $dirFabrica) { blobs(first: 100) { pageInfo { hasNextPage } nodes { name path } } }
-  } }
-}`;
-/** Os blobs de cada ponta que existe; so as partes pedidas entram na consulta (texto fixo, sem interpolar o pedido). */
-function consultaDeBlobsDoGitlab(partes) {
-    const sufixo = { base: 'Base', reservas: 'Reservas', fabrica: 'Fabrica' };
-    const declaracoes = ['$path: ID!', ...partes.flatMap((p) => [`$ref${sufixo[p]}: String!`, `$paths${sufixo[p]}: [String!]!`])];
-    const campos = partes.map((p) => `${p}: blobs(ref: $ref${sufixo[p]}, paths: $paths${sufixo[p]}, first: 100) ` +
-        '{ pageInfo { hasNextPage } nodes { path rawTextBlob } }');
-    return `query(${declaracoes.join(', ')}) { project(fullPath: $path) { repository { ${campos.join(' ')} } } }`;
-}
-function lerDoGitlab(forja, pedido, executor, lidoEm) {
-    const args = ['api', 'graphql', '--method', 'POST', '--input', '-', ...hostnameDe(forja)];
+function lerDoGitlab(forja, pedido, api, lidoEm) {
     let chamadas = 0;
-    const graphql = (query, variables) => { chamadas++; return chamarJson(executor, 'glab', args, JSON.stringify({ query, variables })); };
+    const graphql = (query, variables) => { chamadas++; return graphqlDoGitlab(api, query, variables); };
     const repositorio = (json) => {
         const projeto = obj(json) && obj(json.data) ? json.data.project : undefined;
         if (projeto === null)
@@ -322,13 +365,13 @@ function lerDoGitlab(forja, pedido, executor, lidoEm) {
     };
     let base = pedido.base ?? null;
     if (!base) {
-        const r = graphql(CONSULTA_RAIZ_GITLAB, { path: forja.repo });
+        const r = graphql(consultas_1.CONSULTA_RAIZ_GITLAB, { path: forja.repo });
         if (!r.ok)
             return r;
         const raiz = repositorio(r.json).rootRef;
         base = typeof raiz === 'string' && raiz ? raiz : null;
     }
-    const arvores = graphql(CONSULTA_ARVORES_GITLAB, { path: forja.repo, base: base ?? 'HEAD', dirRoadmap: pedido.dirRoadmap,
+    const arvores = graphql(consultas_1.CONSULTA_ARVORES_GITLAB, { path: forja.repo, base: base ?? 'HEAD', dirRoadmap: pedido.dirRoadmap,
         refReservas: pedido.reservas.branch, dirReservas: pedido.reservas.dir, refFabrica: pedido.fabrica.branch, dirFabrica: pedido.fabrica.dir });
     if (!arvores.ok)
         return arvores;
@@ -373,7 +416,7 @@ function lerDoGitlab(forja, pedido, executor, lidoEm) {
             variaveis[`ref${sufixo[parte]}`] = ponta.commit;
             variaveis[`paths${sufixo[parte]}`] = paths;
         }
-        const blobs = graphql(consultaDeBlobsDoGitlab(pedidos.map(([parte]) => parte)), variaveis);
+        const blobs = graphql((0, consultas_1.consultaDeBlobsDoGitlab)(pedidos.map(([parte]) => parte)), variaveis);
         if (!blobs.ok)
             return blobs;
         conteudo = repositorio(blobs.json);
@@ -394,7 +437,7 @@ function lerDoGitlab(forja, pedido, executor, lidoEm) {
     let commitsParciais = false;
     if (pontaBase) {
         chamadas++;
-        const r = commitsDoGitlab(forja, pontaBase.commit, pedido.desde, executor);
+        const r = commitsDoGitlab(forja, pontaBase.commit, pedido.desde, api);
         if (!r.ok)
             return r;
         commits = r.commits;
@@ -418,12 +461,12 @@ const CONSULTA_DE_COMMITS_GITHUB = `query($owner: String!, $name: String!, $oid:
  * So os commits de um commit da base desde `desde`, quando a janela da primeira leitura ficou curta:
  * o fuso do projeto so se conhece depois de ler o manifesto dele (achado 5 da rodada 2). So consulta.
  */
-function lerCommitsDaForja(forja, pedido, executor = exports.executorPadrao) {
+function lerCommitsDaForja(forja, pedido, executor = exports.executorPadrao, api) {
     if (!SHA.test(pedido.commit))
         return erro('forja.resposta-invalida', 'commit da base fora do formato');
     try {
         if (forja.tipo === 'gitlab')
-            return commitsDoGitlab(forja, pedido.commit, pedido.desde, executor);
+            return commitsDoGitlab(forja, pedido.commit, pedido.desde, api ?? (0, exports.apiDoGitlab)(forja));
         const [owner, name] = forja.repo.split('/');
         const r = chamarJson(executor, 'gh', ['api', 'graphql', '--method', 'POST', '--input', '-', ...hostnameDe(forja)], JSON.stringify({ query: CONSULTA_DE_COMMITS_GITHUB, variables: { owner, name, oid: pedido.commit, desde: pedido.desde } }));
         if (!r.ok)
@@ -444,14 +487,14 @@ function lerCommitsDaForja(forja, pedido, executor = exports.executorPadrao) {
  * Le da forja a base (com `docs/roadmap`, o manifesto e os commits desde `desde`) e as duas branches
  * de estado. So consulta; qualquer falha volta como erro tipado, com o detalhe redigido.
  */
-function lerDaForja(forja, pedido, executor = exports.executorPadrao) {
+function lerDaForja(forja, pedido, executor = exports.executorPadrao, api) {
     const lidoEm = pedido.lidoEm ?? new Date().toISOString();
     try {
-        return forja.tipo === 'github' ? lerDoGithub(forja, pedido, executor, lidoEm) : lerDoGitlab(forja, pedido, executor, lidoEm);
+        return forja.tipo === 'github' ? lerDoGithub(forja, pedido, executor, lidoEm) : lerDoGitlab(forja, pedido, api ?? (0, exports.apiDoGitlab)(forja), lidoEm);
     }
     catch (e) {
         if (e instanceof NaoEncontrado)
-            return erro('forja.nao-encontrado', `${(0, exports.rotuloDaForja)(forja)} não existe ou não é visível para o login da forja`);
+            return erro('forja.nao-achei', `${(0, exports.rotuloDaForja)(forja)} não existe ou não é visível para o login da forja`);
         if (e instanceof RespostaInvalida)
             return erro('forja.resposta-invalida', `resposta fora do formato esperado em ${e.message}`);
         throw e;

package/dist/handoff.js

@@ -73,7 +73,15 @@ const phase_1 = require("./phase");
 const thread_1 = require("./thread");
 const memoria_1 = require("./memoria");
 const util_1 = require("./util");
+const verify_1 = require("./verify");
 const procedencia_1 = require("./procedencia");
+const locale_1 = require("./locale");
+/** RM-037 (defeito 1 de 19 e 20/10/2026): o rotulo de cada comando da baseline no handoff, que vai em pt-BR. */
+const ROTULO_DA_BASELINE = {
+    passava: 'passava',
+    'ja-falhava': 'ja falhava',
+    'sem-veredito': 'sem veredito (estouro, sinal, relogio sob steal ou nao rodou: nao vale como ja falhava)',
+};
 /** sha256 de um arquivo em disco, a prova de proveniencia de cada item. */
 function sha256DoArquivo(caminho) {
     if (!fs.existsSync(caminho))
@@ -217,7 +225,8 @@ function exportarHandoff(carregado, threadId, opcoes = {}) {
     if (thread.baseline) {
         const b = thread.baseline;
         addInline('Baseline gravada antes do GO', `commit ${b.commit} em ${b.gravadaEm}\n` +
-            b.comandos.map((c) => `  ${c.nome}: ${c.ok ? 'passava' : 'ja falhava'} (${c.comando})`).join('\n'), proveniencia(raiz, caminhoThreadJson, 'json:baseline'));
+            // RM-037 (defeito 1 de 19 e 20/10/2026): o comando sem veredito na baseline nao e divida anterior.
+            b.comandos.map((c) => `  ${c.nome}: ${ROTULO_DA_BASELINE[(0, verify_1.vereditoDaBaseline)(c)]} (${c.comando})`).join('\n'), proveniencia(raiz, caminhoThreadJson, 'json:baseline'));
     }
     // IMPORTANTE: os prompts ja despachados, com o pedido original do builder.
     for (const s of thread.sessoes) {
@@ -509,33 +518,34 @@ function recall(carregado, threadId, ponteiro) {
 }
 /** Texto de `ork handoff export`. */
 function textoDoHandoff(h, caminho) {
+    const m = (0, locale_1.msg)().operacao.restante.handoff;
     const linhas = [];
-    linhas.push(`Handoff exportado da thread ${h.thread} (regime memory: ${h.memory})`);
-    linhas.push(`  de    ${h.de.slug} (fase ${h.de.fase})`);
-    linhas.push(`  para  ${h.para.slug} (fase ${h.para.fase})`);
-    linhas.push(`  arquivo ${caminho}`);
+    linhas.push(m.exportado(h.thread, h.memory));
+    linhas.push(m.de(h.de.slug, h.de.fase));
+    linhas.push(m.para(h.para.slug, h.para.fase));
+    linhas.push(m.arquivo(caminho));
     linhas.push('');
-    linhas.push(`CRITICO (${h.inline.length} item(ns), vao inline no prompt da nova sessao):`);
+    linhas.push(m.critico(h.inline.length));
     for (const i of h.inline) {
         linhas.push(`  ${i.id}  ${i.titulo}`);
-        linhas.push(`        proveniencia: ${i.proveniencia.location} (sha256 ${i.proveniencia.sha256.slice(0, 12)})`);
+        linhas.push(m.proveniencia(i.proveniencia.location, i.proveniencia.sha256.slice(0, 12)));
     }
     linhas.push('');
-    linhas.push(`IMPORTANTE (${h.pointers.length} ponteiro(s), recuperados sob demanda):`);
+    linhas.push(m.importante(h.pointers.length));
     for (const p of h.pointers) {
         linhas.push(`  ${p.id}  ${p.titulo}`);
         linhas.push(`        location: ${p.location}  (sha256 ${p.sha256.slice(0, 12)})`);
         if (p.orkmind)
             linhas.push(`        orkmind:  ${p.orkmind}`);
-        linhas.push(`        quando:   ${p.retrieve_when}`);
-        linhas.push(`        recuperar: ${p.retrieve_via}`);
-        linhas.push(`        no momento: ork recall ${h.thread} --fase ${p.retrieve_when}`);
+        linhas.push(m.quando(p.retrieve_when));
+        linhas.push(m.recuperar(p.retrieve_via));
+        linhas.push(m.noMomento(h.thread, p.retrieve_when));
     }
     linhas.push('');
-    linhas.push(`RESUMIVEL (${h.summaries.length} resumo(s), com proveniencia declarada):`);
+    linhas.push(m.resumivel(h.summaries.length));
     for (const s of h.summaries) {
         linhas.push(`  ${s.id}  ${s.text}`);
-        linhas.push(`        proveniencia: ${s.provenance.location} (sha256 ${s.provenance.sha256.slice(0, 12)})`);
+        linhas.push(m.proveniencia(s.provenance.location, s.provenance.sha256.slice(0, 12)));
     }
     return linhas.join('\n');
 }