@orkastery/cli 0.5.6 → 0.6.0

package/dist/pulse.js

@@ -3,6 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.JANELA_DAS_DECISOES_MS = exports.CONTRATO_PULSE = void 0;
 exports.apresentacaoCurtaDoItem = apresentacaoCurtaDoItem;
 exports.comporPulse = comporPulse;
+exports.comandoDaAcaoDaVarredura = comandoDaAcaoDaVarredura;
+exports.textoDaAcaoDaVarredura = textoDaAcaoDaVarredura;
+exports.varreduraDoPulse = varreduraDoPulse;
 exports.montarPulse = montarPulse;
 exports.filaDoDono = filaDoDono;
 exports.textoDoPulse = textoDoPulse;
@@ -15,6 +18,11 @@ const master_1 = require("./master");
 const master_batch_1 = require("./master-batch");
 const orquestracao_1 = require("./orquestracao");
 const impedimento_1 = require("./impedimento");
+const runtime_escada_1 = require("./runtime-escada");
+const autorizacao_duravel_1 = require("./autorizacao-duravel");
+const varredura_acoes_1 = require("./varredura-acoes");
+const conducao_batida_1 = require("./conducao-batida");
+const maquina_ociosa_1 = require("./maquina-ociosa");
 const thread_1 = require("./thread");
 const sessoes_adopt_1 = require("./sessoes-adopt");
 const ledger_1 = require("./ledger");
@@ -187,10 +195,35 @@ function comporPulse(carregado, entrada) {
                     item.evidencia.push('Pedido curto do impedimento indisponível; a correção acima vale.');
                 }
             }
+            // RM-063 (F4): a escada de recuperacao do runtime que acabou sai como o impedimento, com o comando que confere o
+            // runtime, o que retoma a fase com o mesmo prompt e o pedido curto com as tres alternativas (RM-057).
+            if (p.escada) {
+                item.impedimento = { motivo: p.motivo, comando: p.escada.conferir, retry: p.escada.retomar };
+                item.comandoResposta = p.escada.retomar;
+                try {
+                    const curto = (0, runtime_escada_1.pedidoCurtoDaEscada)({ thread: l.thread, fase: p.fase, desdeEm: p.desdeEm, escada: p.escada }, quando);
+                    item.apresentacaoCurta = { telegram: (0, hitl_curto_1.textoDoPedidoCurto)(curto, 'telegram'), terminal: (0, hitl_curto_1.textoDoPedidoCurto)(curto, 'terminal') };
+                    item.opcoes = curto.alternativas.map(a => (0, locale_1.textoDoCatalogo)((m) => `${a.chave}. ${m.pulse.alternativaDoImpedimento(a.texto)}`));
+                    const recomendada = curto.alternativas.find(a => a.recomendada);
+                    if (recomendada)
+                        item.recomendacao = `${recomendada.chave}. ${recomendada.texto}: ${recomendada.recomendada.porque}`;
+                }
+                catch {
+                    item.evidencia.push('Pedido curto da escada indisponível; a correção acima vale.');
+                }
+            }
             // I-45: vaga parada e sinal do escalonador (`ork board reap` devolve a vaga), nao pergunta ao dono.
             const esperaAutomatica = ['lease.busy', 'conducao.em-andamento', 'concurrency.limite', 'runtime.rate-limited', 'vaga.stale'].includes(p.motivo);
             (esperaAutomatica ? automaticas : humanos).push(item);
         }
+    // RM-063 (F5): o MASTER por omissao da varredura nao vira item do dono (I-45: a entrega sem nota fica na faixa
+    // automatica). Ele completa o item da entrega com o comando desta thread so (RM-008) e com quem o faz agora.
+    const v = entrada.varredura;
+    const recomendacaoDaVarredura = (a) => a.quemFaz === 'varredura' && v.autorizacao.por && v.autorizacao.ate
+        ? (0, locale_1.textoDoCatalogo)((m) => m.pulse.varredura.daVarredura(v.autorizacao.por, (0, horario_1.formatarDataHoraRotulada)(v.autorizacao.ate, { agora: quando })))
+        : a.bloqueio ? (0, locale_1.textoDoCatalogo)((m) => m.pulse.varredura.comBloqueioRecomendacao(a.thread, a.comando))
+            : (0, locale_1.textoDoCatalogo)((m) => m.pulse.varredura.doDono(a.acao));
+    const masterDaVarredura = new Map((v?.pendentes ?? []).filter(a => a.acao === 'master').map(a => [a.thread, a]));
     for (const b of batch) {
         const eventos = (0, ledger_1.lerLedger)((0, thread_1.dirThread)(carregado.raiz, b.thread.id));
         const desde = eventos.filter(e => e.tipo === 'ship_done').at(-1)?.ts ??
@@ -207,6 +240,18 @@ function comporPulse(carregado, entrada) {
             recomendacao: 'Aceitar por padrão com registro; a nota humana, quando vier, sobrescreve.',
             comandoResposta: 'ork master --aceitar-omissao',
             evidencia: [`ork master; regime ${b.regime}`], fontes: ['master'], contextoLogs: [] });
+        const daVarredura = masterDaVarredura.get(b.thread.id);
+        if (daVarredura) {
+            const item = automaticas[automaticas.length - 1];
+            item.comandoResposta = comandoDaAcaoDaVarredura(daVarredura);
+            item.recomendacao = recomendacaoDaVarredura(daVarredura);
+            if (daVarredura.bloqueio || daVarredura.recusa)
+                item.pergunta = `${item.pergunta} ${textoDaAcaoDaVarredura(daVarredura)}`;
+            item.evidencia.push(daVarredura.evidencia);
+            if (!item.fontes.includes('varredura'))
+                item.fontes.push('varredura');
+            masterDaVarredura.delete(b.thread.id);
+        }
     }
     for (const o of orfas) {
         if (ehRegistro(o.thread))
@@ -220,6 +265,20 @@ function comporPulse(carregado, entrada) {
             evidencia: [...o.evidencia, `retry ${o.retry.tentativas}/${o.retry.limite}`], fontes: ['liveness'], contextoLogs: [] };
         (o.retry.automatica ? automaticas : humanos).push(item);
     }
+    // RM-063 (F5): cada acao da varredura e um item. Sem a autorizacao do dono para ela (ou com bloqueio, ou com a tentativa
+    // recusada), e do dono, com o comando pronto; autorizada, e acao automatica da proxima batida. O MASTER ja foi no item
+    // da entrega sem nota; so o que sobrou dele (sem item de entrega) entra aqui, na faixa automatica.
+    for (const a of v?.pendentes ?? []) {
+        if (a.acao === 'master' && !masterDaVarredura.has(a.thread))
+            continue;
+        const daVarredura = a.quemFaz === 'varredura' || a.acao === 'master';
+        const item = { id: `varredura:${a.acao}:${a.thread}${a.sessionId ? `:${a.sessionId.slice(0, 8)}` : ''}`,
+            classe: 'varredura', motivo: `varredura.${a.acao}`, thread: a.thread, fase: a.fase, sessionId: null, desdeEm: a.desdeEm,
+            paradaHaMin: minutos(a.desdeEm, quando), impacto: impacto(a.fase), pergunta: textoDaAcaoDaVarredura(a), opcoes: [],
+            recomendacao: recomendacaoDaVarredura(a), comandoResposta: comandoDaAcaoDaVarredura(a), evidencia: [a.evidencia],
+            fontes: ['varredura'], contextoLogs: [] };
+        (daVarredura ? automaticas : humanos).push(item);
+    }
     const unicos = (items) => [...new Map(items.map(i => [i.id, i])).values()].sort(ordenar);
     const h = unicos(humanos), a = unicos(automaticas);
     for (const item of h) {
@@ -256,7 +315,30 @@ function comporPulse(carregado, entrada) {
     }
     return { contrato: exports.CONTRATO_PULSE, consultadoEm: quando, runtime: { ok: radar.runtimeConsultado, detalhe: radar.runtimeDetalhe },
         precisaDeHumanoAgora: h, acoesAutomaticas: a, resumo: { humanos: h.length, automaticas: a.length, scores: batch.length, fasesOrfas: orfas.length },
-        ...(entregas?.parados.length ? { paradoNoCondutor: entregas.parados } : {}) };
+        ...(entregas?.parados.length ? { paradoNoCondutor: entregas.parados } : {}),
+        ...(v && (v.pendentes.length || v.feitas.length || v.autorizacao.estado !== 'ausente') ? { varredura: v } : {}) };
+}
+/** RM-063 (F5): com bloqueio, o comando do dono e olhar a thread: a acao iria por cima do trabalho que esta nela. */
+function comandoDaAcaoDaVarredura(a) {
+    return a.bloqueio ? `ork thread status ${a.thread}` : a.comando;
+}
+/** RM-063 (F5): o que a acao faz, com o motivo da ultima recusa ou do bloqueio quando ha. */
+function textoDaAcaoDaVarredura(a) {
+    return a.recusa ? (0, locale_1.textoDoCatalogo)((m) => m.pulse.varredura.comRecusa(a.oQue, a.recusa.detalhe))
+        : a.bloqueio ? (0, locale_1.textoDoCatalogo)((m) => m.pulse.varredura.comBloqueio(a.oQue, a.bloqueio)) : a.oQue;
+}
+/** RM-063 (F5): os estados em que a sessao da consulta ja nao trabalha na worktree. */
+const TERMINAIS_DA_CONSULTA = ['failed', 'done', 'stopped', 'completed', 'exited'];
+/** RM-063 (F5): a autorizacao e as acoes como o pulse as leva: cada acao com quem a faz agora. */
+function varreduraDoPulse(leitura, pendentes, feitas) {
+    const a = leitura.valida ? leitura.autorizacao : null;
+    return {
+        autorizacao: { estado: leitura.valida ? 'valida' : leitura.motivo === 'autorizacao.ausente' ? 'ausente' : 'invalida',
+            motivo: leitura.valida ? null : leitura.motivo, detalhe: leitura.valida ? null : leitura.detalhe,
+            por: a?.por ?? null, ate: a?.ate ?? null, pode: a ? [...a.pode] : [] },
+        pendentes: pendentes.map((p) => ({ ...p, quemFaz: (0, autorizacao_duravel_1.autorizada)(leitura, p.acao) && !p.bloqueio && !p.recusa ? 'varredura' : 'dono' })),
+        feitas: feitas.map((f) => ({ acao: f.acao, thread: f.thread, detalhe: f.detalhe, em: f.em, eventId: f.eventId })),
+    };
 }
 function montarPulse(carregado, opcoes = {}) {
     if (opcoes.registrar)
@@ -289,7 +371,8 @@ function montarPulse(carregado, opcoes = {}) {
     let entregas;
     try {
         entregas = (0, parado_no_condutor_1.entregasDoProjeto)(carregado, { quando, sessoes: radar.sessoes, lerPrs: opcoes.semForja ? () => null : (candidatas) => {
-                const leitura = (0, parado_no_condutor_1.lerPrsDaForja)(carregado, { quando, executor: opcoes.executorDoGh, candidatas });
+                const leitura = (0, parado_no_condutor_1.lerPrsDaForja)(carregado, { quando, executor: opcoes.executorDoGh, candidatas, rodar: opcoes.rodarDaForja,
+                    sondas: opcoes.sondasDaForja });
                 if (leitura.ok) {
                     try {
                         (0, parado_no_condutor_1.gravarRetratoDePrs)(carregado.raiz, leitura.retrato);
@@ -319,7 +402,31 @@ function montarPulse(carregado, opcoes = {}) {
     catch (e) {
         diagnosticos.push(`entregas.indisponiveis: ${e.message.slice(0, 120)}`);
     }
-    const pulse = comporPulse(carregado, { radar, monitor, orfas, batch: (0, master_1.pendentesDeScore)(carregado.raiz), ...(entregas ? { entregas } : {}) });
+    // RM-063 (F5): o que a varredura faria sozinha, com a autorizacao duravel desta maquina. Leitura; falhar aqui nunca
+    // derruba a fila de atencao.
+    let varredura;
+    try {
+        const leitura = (0, autorizacao_duravel_1.lerAutorizacao)(carregado.raiz, { projeto: carregado.manifesto.project.name, agora: new Date(quando) });
+        // Com a consulta injetada (os testes) ou sem o runtime, as sessoes vem dela: sem a leitura, nada se afirma, e o
+        // registro e o MASTER ficam com o dono (`sessoes-sem-leitura`).
+        const injetada = opcoes.fantasmas || opcoes.consulta || opcoes.semRuntime;
+        const consultada = consulta;
+        const pendentes = (0, varredura_acoes_1.acoesPendentes)(carregado, { quando, ...(injetada ? {
+                fantasmas: opcoes.fantasmas ?? (() => null),
+                vivas: () => consultada.ok ? consultada.sessoes.filter((s) => typeof s.cwd === 'string' && !TERMINAIS_DA_CONSULTA.includes((0, hitl_1.estadoBruto)(s)))
+                    .map((s) => ({ sessionId: s.sessionId, cwd: s.cwd })) : null,
+            } : {}) });
+        // RM-063 (F7): o merge e o despacho que a ultima batida da conducao deixou pendentes (check pendente, sem autorizacao,
+        // conflito em codigo, PR em rascunho, fase sem prompt gravado), do retrato dela, enquanto ele vale.
+        pendentes.push(...(0, conducao_batida_1.pendentesDaUltimaBatida)(carregado.raiz, quando));
+        const feitas = (0, varredura_acoes_1.acoesFeitasDesde)(carregado.raiz, new Date(Date.parse(quando) - exports.JANELA_DAS_DECISOES_MS).toISOString());
+        varredura = varreduraDoPulse(leitura, pendentes, feitas);
+    }
+    catch (e) {
+        diagnosticos.push(`varredura.indisponivel: ${e.message.slice(0, 120)}`);
+    }
+    const pulse = comporPulse(carregado, { radar, monitor, orfas, batch: (0, master_1.pendentesDeScore)(carregado.raiz), ...(entregas ? { entregas } : {}),
+        ...(varredura ? { varredura } : {}) });
     // RM-061 (F2b, G2): a linha de conducao e da familia `thread` e segue o locale ativo; o JSON a guarda em pt-BR.
     const conducoes = monitor.linhas.filter((l) => l.conducao)
         .map((l) => ({ thread: l.thread, linha: (0, locale_1.textoDoCatalogo)(() => (0, conducao_texto_1.linhaDeConducao)(l.conducao, { agora: quando })) }));
@@ -343,6 +450,15 @@ function montarPulse(carregado, opcoes = {}) {
     catch (e) {
         diagnosticos.push(`hitl-conducao.indisponivel: ${e.message.slice(0, 120)}`);
     }
+    // RM-063 (F6): a maquina ociosa, leitura pura das vagas, das reservas locais e do passo do condutor.
+    try {
+        const ociosa = (0, maquina_ociosa_1.maquinaOciosa)(carregado, { quando });
+        if (ociosa)
+            pulse.maquinaOciosa = ociosa;
+    }
+    catch (e) {
+        diagnosticos.push(`ociosidade.indisponivel: ${e.message.slice(0, 120)}`);
+    }
     if (diagnosticos.length)
         pulse.runtime.detalhe = [pulse.runtime.detalhe, ...diagnosticos].filter(Boolean).join('; ');
     return pulse;
@@ -408,5 +524,22 @@ function textoDoPulse(p) {
     // RM-061 (F2b, D4): o item do radar sem tipo de HITL usa a classe como motivo; ela sai pelo id, o motivo tipado fica.
     for (const i of p.acoesAutomaticas)
         linhas.push(m.automatica(String(i.thread), i.motivo === i.classe ? m.classe(i.motivo) : i.motivo, (0, locale_1.remontar)(i.comandoResposta)));
+    // RM-063 (F5): a autorizacao da varredura e o que ela fez sozinha na semana.
+    if (p.varredura) {
+        const v = p.varredura, a = v.autorizacao;
+        linhas.push('', a.estado === 'valida' ? m.varredura.autorizacaoValida(String(a.por), (0, horario_1.formatarDataHoraRotulada)(String(a.ate), { agora: p.consultadoEm }), a.pode.join(', ')) : a.estado === 'ausente' ? m.varredura.autorizacaoAusente : m.varredura.autorizacaoInvalida(String(a.motivo), String(a.detalhe)));
+        if (v.feitas.length) {
+            linhas.push(m.varredura.feitas(v.feitas.length));
+            for (const f of v.feitas)
+                linhas.push(m.varredura.feita(f.thread, f.acao, f.detalhe));
+        }
+    }
+    // RM-063 (F6): a maquina ociosa e as proximas threads sugeridas.
+    if (p.maquinaOciosa) {
+        const o = p.maquinaOciosa;
+        linhas.push('', m.ociosa.linha(o.maquina, o.livres, o.limite, o.reservados));
+        for (const s of o.sugeridas)
+            linhas.push(m.ociosa.sugerida(s.item, s.thread ? `${s.thread}, ${s.fase}` : m.ociosa.semThread, (0, locale_1.remontar)(s.passo), s.comando));
+    }
     return linhas.join('\n');
 }

package/dist/ratelimit.js

@@ -59,6 +59,7 @@ exports.dirRetry = dirRetry;
 exports.caminhoDaFila = caminhoDaFila;
 exports.lerFilaDeRetomada = lerFilaDeRetomada;
 exports.janelaPadraoMs = janelaPadraoMs;
+exports.arcoDoPedido = arcoDoPedido;
 exports.enfileirar = enfileirar;
 exports.prazoDaConta = prazoDaConta;
 exports.prazoDaCotaVista = prazoDaCotaVista;
@@ -104,6 +105,11 @@ function lerFilaDeRetomada(raiz) {
 function janelaPadraoMs(manifesto) {
     return manifesto.retry.janela_padrao_min * 60 * 1000;
 }
+/** RM-058 N4 (D17): o arco #Noctum do pedido, quando o despacho que caiu no limite de uso era dele. */
+function arcoDoPedido(pedido) {
+    const c = pedido.correlacao;
+    return typeof c === 'string' && c.startsWith('noctum:') && c.length > 'noctum:'.length ? c.slice('noctum:'.length) : null;
+}
 /**
  * Enfileira a fase morta por rate limit.
  *
@@ -137,6 +143,7 @@ function enfileirar(carregado, novo, agoraMs = Date.now()) {
         ...(novo.runtime !== undefined ? { runtime: novo.runtime } : {}),
         ...(novo.perfil !== undefined ? { perfil: novo.perfil } : {}),
         ...(novo.motivo !== undefined ? { motivo: novo.motivo } : {}),
+        ...(novo.correlacao ? { correlacao: novo.correlacao } : {}),
     };
     (0, util_1.anexarJsonl)(caminhoDaFila(raiz), pedido);
     return pedido;
@@ -214,18 +221,19 @@ function faltaPara(pedido, quando = (0, util_1.agora)()) {
 /** Tabela de `ork retry list`. */
 function tabelaDaFila(raiz, quando = (0, util_1.agora)()) {
     const fila = lerFilaDeRetomada(raiz).sort((a, b) => a.id.localeCompare(b.id, 'en', { numeric: true }));
+    const m = (0, locale_1.msg)().retry.complementar;
     if (fila.length === 0) {
-        return 'Fila de rate limit vazia: nenhuma fase morreu por limite de uso neste projeto.';
+        return m.filaVazia;
     }
     const linhas = fila.map((p) => [
         p.id,
         p.thread,
         p.fase,
-        p.estado,
+        m.estados[p.estado] ?? p.estado,
         (0, horario_1.formatarDataHora)(p.liberaEm, { agora: quando }),
-        p.janelaEstimada ? `estimada (${p.sinal.fonte})` : `dita pelo runtime (${p.sinal.fonte})`,
+        p.janelaEstimada ? m.horaEstimada(p.sinal.fonte) : m.horaRuntime(p.sinal.fonte),
         p.estado === 'aguardando' ? faltaPara(p, quando) : '',
         String(p.tentativas),
     ]);
-    return (0, util_1.tabela)(['ID', 'THREAD', 'FASE', 'ESTADO', 'LIBERA EM', 'ORIGEM DA HORA', 'FALTA', 'TENT'], linhas) + `\n${(0, horario_1.legendaDoFuso)(undefined, quando)}`;
+    return (0, util_1.tabela)([...m.colunasFila], linhas) + `\n${(0, horario_1.legendaDoFuso)(undefined, quando)}`;
 }

package/dist/recall.js

@@ -65,6 +65,7 @@ const memoria_1 = require("./memoria");
 const orkmind_1 = require("./orkmind");
 const thread_1 = require("./thread");
 const util_1 = require("./util");
+const locale_1 = require("./locale");
 /** Momento do ponteiro e momento pedido casam? Comparacao exata, sem case. */
 function momentoCasa(ponteiro, momento) {
     return ponteiro.retrieve_when.trim().toLowerCase() === momento.trim().toLowerCase();
@@ -291,18 +292,18 @@ function recallDaThread(carregado, memoria, threadId, opcoes = {}) {
 }
 /** Texto de `ork recall`. */
 function textoDoRecall(r, comConteudo = true) {
+    const m = (0, locale_1.msg)().operacao.restante.recall;
     const linhas = [];
-    linhas.push(`Recall da thread ${r.thread} no momento ${r.momento ?? '(todos)'} ` +
-        `(regime efetivo ${r.regime}, handoff escrito em regime ${r.regimeDoHandoff})`);
+    linhas.push(m.titulo(r.thread, r.momento ?? m.todos, r.regime, r.regimeDoHandoff));
     linhas.push('');
-    linhas.push(`RESOLVIDOS (${r.resolvidos.length}, entram no contexto agora):`);
+    linhas.push(m.resolvidos(r.resolvidos.length));
     for (const p of r.resolvidos) {
         linhas.push(`  ${p.id}  ${p.titulo}`);
-        linhas.push(`        via       ${p.via} (${p.metodo})`);
-        linhas.push(`        location  ${p.location}`);
+        linhas.push(m.via(p.via, p.metodo));
+        linhas.push(m.location(p.location));
         if (p.orkmind)
             linhas.push(`        orkmind   ${p.orkmind}`);
-        linhas.push(`        quando    ${p.retrieve_when}`);
+        linhas.push(m.quando(p.retrieve_when));
         if (comConteudo) {
             linhas.push('');
             for (const l of p.conteudo.split('\n'))
@@ -311,20 +312,20 @@ function textoDoRecall(r, comConteudo = true) {
         }
     }
     linhas.push('');
-    linhas.push(`ADIADOS (${r.adiados.length}, existem e NAO entram agora):`);
+    linhas.push(m.adiados(r.adiados.length));
     for (const p of r.adiados) {
         linhas.push(`  ${p.id}  ${p.titulo}`);
-        linhas.push(`        quando    ${p.retrieve_when}`);
-        linhas.push(`        onde      ${p.location}`);
-        linhas.push(`        recuperar ork recall ${r.thread} --fase ${p.retrieve_when}`);
+        linhas.push(m.quando(p.retrieve_when));
+        linhas.push(m.onde(p.location));
+        linhas.push(m.recuperar(r.thread, p.retrieve_when));
     }
     if (r.falhas.length > 0) {
         linhas.push('');
-        linhas.push(`FALHAS (${r.falhas.length}):`);
+        linhas.push(m.falhas(r.falhas.length));
         for (const p of r.falhas) {
             linhas.push(`  ${p.id}  ${p.titulo}`);
-            linhas.push(`        motivo    ${p.motivo}`);
-            linhas.push(`        detalhe   ${p.detalhe}`);
+            linhas.push(m.motivo(p.motivo));
+            linhas.push(m.detalhe(p.detalhe));
         }
     }
     return linhas.join('\n');

package/dist/rede-adesao.js

@@ -64,6 +64,7 @@ const path = __importStar(require("node:path"));
 const maquina_1 = require("./maquina");
 const monitor_lock_1 = require("./monitor-lock");
 const util_1 = require("./util");
+const locale_1 = require("./locale");
 exports.CONTRATO_DA_ADESAO = 'ork.rede/v1';
 exports.REPOSITORIO_PADRAO = 'orkastery-network';
 /**
@@ -78,6 +79,8 @@ exports.pastaDaRede = pastaDaRede;
 const arquivoDaConfig = () => path.join((0, maquina_1.pastaDoUsuario)(), 'rede.json');
 const arquivoDaTentativa = () => path.join((0, exports.pastaDaRede)(), 'tentativa.json');
 const IDENTIFICADOR = /^[A-Za-z0-9][A-Za-z0-9._-]{0,99}$/;
+/** O dono da casa: o login, ou o caminho de um grupo com subgrupos (`time/sub`). */
+const DONO = /^[A-Za-z0-9][A-Za-z0-9._-]{0,99}(?:\/[A-Za-z0-9][A-Za-z0-9._-]{0,99}){0,19}$/;
 const HOST = /^[A-Za-z0-9.-]+(?::\d+)?$/;
 const texto = (v, padrao) => typeof v === 'string' && padrao.test(v) ? v : null;
 function lerConfigDaRede() {
@@ -88,7 +91,7 @@ function lerConfigDaRede() {
         return {
             contrato: exports.CONTRATO_DA_ADESAO, membro: bruto.membro,
             forja: bruto.forja === 'github' || bruto.forja === 'gitlab' ? bruto.forja : null,
-            host: texto(bruto.host, HOST), dono: texto(bruto.dono, IDENTIFICADOR), repositorio: texto(bruto.repositorio, IDENTIFICADOR),
+            host: texto(bruto.host, HOST), dono: texto(bruto.dono, DONO), repositorio: texto(bruto.repositorio, IDENTIFICADOR),
             atualizadoEm: typeof bruto.atualizadoEm === 'string' ? bruto.atualizadoEm : '',
         };
     }
@@ -108,11 +111,13 @@ function gravarConfigDaRede(mudanca) {
         repositorio: mudanca.repositorio !== undefined ? mudanca.repositorio : atual?.repositorio ?? null,
         atualizadoEm: new Date().toISOString(),
     };
-    if (config.host !== null && !HOST.test(config.host))
-        throw new Error(`rede.config: host invalido ("${config.host}")`);
-    for (const [campo, valor] of [['dono', config.dono], ['repositorio', config.repositorio]]) {
-        if (valor !== null && !IDENTIFICADOR.test(valor))
-            throw new Error(`rede.config: ${campo} invalido ("${valor}")`);
+    if (config.host !== null && !HOST.test(config.host)) {
+        const host = config.host;
+        throw new locale_1.ErroDoCatalogo((m) => m.network.hostInvalido(host));
+    }
+    for (const [campo, valor, padrao] of [['dono', config.dono, DONO], ['repositorio', config.repositorio, IDENTIFICADOR]]) {
+        if (valor !== null && !padrao.test(valor))
+            throw new locale_1.ErroDoCatalogo((m) => m.network.campoInvalido(campo, valor));
     }
     const dir = (0, maquina_1.pastaDoUsuario)();
     fs.mkdirSync(dir, { recursive: true });
@@ -180,7 +185,7 @@ function idDaMaquina() {
     }
     const persistido = lerId(arquivo);
     if (!persistido)
-        throw new Error(`rede.id: nao consegui gravar nem ler ${arquivo}`);
+        throw new locale_1.ErroDoCatalogo((m) => m.network.idNaoGravou(arquivo));
     return persistido;
 }
 function gravarTemporario(conteudo) {
@@ -290,7 +295,7 @@ function trocarIdInvalido(arquivo, st) {
             return;
     }
     else {
-        throw new Error(`rede.id: ${arquivo} nao e um arquivo; apague-o e rode de novo`);
+        throw new locale_1.ErroDoCatalogo((m) => m.network.idNaoArquivo(arquivo));
     }
     // X6 do CHECK 6: a reserva da troca e chaveada pelo que todo host ve igual do arquivo ruim (conteudo,
     // tamanho e hora); `dev` e local a cada host e fica so no id derivado, o caminho de quando a reserva falha.

package/dist/rede-forja.js

@@ -33,11 +33,12 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ORDEM_DAS_FORJAS = void 0;
+exports.helperDeCredencialDaCli = exports.ORDEM_DAS_FORJAS = void 0;
 exports.pastasDeBinarios = pastasDeBinarios;
 exports.acharBinario = acharBinario;
 exports.versaoDoBinario = versaoDoBinario;
 exports.comGitIsolado = comGitIsolado;
+exports.gitlabSemSuporteNaRede = gitlabSemSuporteNaRede;
 exports.forjaPorNome = forjaPorNome;
 exports.forjasDaMaquina = forjasDaMaquina;
 exports.ehNomeDeForja = ehNomeDeForja;
@@ -58,7 +59,12 @@ const node_child_process_1 = require("node:child_process");
 const fs = __importStar(require("node:fs"));
 const os = __importStar(require("node:os"));
 const path = __importStar(require("node:path"));
+const api_1 = require("./forja/api");
+const executor_1 = require("./forja/executor");
+const pedidos_1 = require("./forja/gitlab/pedidos");
+const texto_1 = require("./forja/texto");
 const redacao_url_1 = require("./redacao-url");
+const locale_1 = require("./locale");
 exports.ORDEM_DAS_FORJAS = ['github', 'gitlab'];
 const LOGIN = /^[A-Za-z0-9](?:[A-Za-z0-9._-]{0,254})$/;
 const HOST = /^[A-Za-z0-9.-]+(?::\d+)?$/;
@@ -170,7 +176,8 @@ function comGitIsolado(f, identidade, opcoes = {}) {
 const naoEncontrado = (s) => /HTTP 404|404 Not Found|"status"\s*:\s*"?404/i.test(`${s.stdout}\n${s.stderr}`);
 function falhou(cli, rota, s) {
     const linha = (0, redacao_url_1.redigirCredenciaisUrl)(s.stderr.trim().split('\n').pop() ?? '').slice(0, 200);
-    return new Error(`rede.forja: ${cli} api ${rota} falhou${linha ? `: ${linha}` : ''}`);
+    const montarLinha = (0, locale_1.montadorDe)(linha);
+    return new locale_1.ErroDoCatalogo((m) => m.network.apiFalhou(cli, rota, montarLinha(m)));
 }
 /** A resposta de quem nao tem login (ou tem credencial recusada), no `gh` e no `glab`. */
 const SEM_LOGIN = /auth login|not logged|not authenticated|authentication|HTTP 401|401 Unauthorized|Bad credentials|no token/i;
@@ -178,13 +185,17 @@ const SEM_LOGIN = /auth login|not logged|not authenticated|authentication|HTTP 4
 function falhaDoLogin(cli, s) {
     if (!s.ok && SEM_LOGIN.test(`${s.stderr}\n${s.stdout}`))
         return {};
+    // RM-061 (F3b): a falha entra no detalhe da lacuna da casa, que a impressao remonta no locale do comando.
     if (s.ok)
-        return { falha: `${cli} api user devolveu uma resposta sem login legivel` };
-    return { falha: falhou(cli, 'user', s.stderr.trim() ? s : { ...s, stderr: 'sem resposta da forja no prazo' }).message.replace(/^rede\.forja: /, '') };
+        return { falha: (0, locale_1.textoDoCatalogo)((m) => m.network.respostaSemLogin(cli)) };
+    const erro = falhou(cli, 'user', s.stderr.trim() ? s : { ...s, stderr: (0, locale_1.textoDoCatalogo)((m) => m.network.semRespostaNoPrazo) });
+    return { falha: (0, locale_1.textoDoCatalogo)((m) => erro.montar(m).replace(/^rede\.forja: /, '')) };
 }
 /** Caminho seguro para o shell que o git usa no helper: aspas simples, com `'` escapada (B10). */
 const citar = (caminho) => /^[A-Za-z0-9_./+-]+$/.test(caminho) ? caminho : `'${caminho.replace(/'/g, `'\\''`)}'`;
 const helper = (binario) => `!${citar(binario)} auth git-credential`;
+/** O mesmo helper do cache da rede, para o transporte `forja-https` do SHIP. */
+exports.helperDeCredencialDaCli = helper;
 /**
  * Privado de verdade (B1): no GitHub, `internal` vem com `private: true`, e a empresa inteira le.
  * Quando a forja diz a visibilidade, so `private` conta; sem ela, o booleano.
@@ -198,7 +209,7 @@ function github(binario, amb, host = 'github.com') {
     // B2: a casa vai sempre por HTTPS, com o helper da propria CLI; SSH pediria agente, que o cron nao tem.
     const repositorioDe = (v) => {
         if (!v)
-            throw new Error('rede.forja: gh devolveu um repositorio ilegivel');
+            throw new locale_1.ErroDoCatalogo((m) => m.network.repositorioIlegivel);
         return { existe: true, privado: privadoDe(v), url: typeof v.clone_url === 'string' ? v.clone_url : null };
     };
     // B9: o host da casa vai em toda chamada; o cron nao tem o ambiente do terminal.
@@ -235,38 +246,111 @@ function hostDoGitlab(amb) {
     const bruto = (ambienteDe(amb).GITLAB_HOST ?? '').trim().replace(/^https?:\/\//, '').replace(/\/.*$/, '');
     return HOST.test(bruto) ? bruto : 'gitlab.com';
 }
+/**
+ * O que a casa da rede ainda nao suporta no GitLab da maquina: o `rede.json` guarda so `host[:porta]`, entao um GitLab em
+ * subcaminho (`https://host/gitlab`) ou com CA propria (`GLAB_CA_CERT`) nao teria como ser lembrado em outra maquina.
+ */
+function gitlabSemSuporteNaRede(amb, host = hostDoGitlab(amb)) {
+    const env = ambienteDe(amb);
+    const bruto = (env.GITLAB_HOST ?? '').trim().replace(/^https?:\/\//, '');
+    // So o subcaminho do proprio host da casa conta: o `GITLAB_HOST` do terminal pode ser de outra instancia.
+    const subcaminho = /^([^/]+)\/+[^/]/.exec(bruto);
+    if (subcaminho && subcaminho[1].toLowerCase() === host.toLowerCase())
+        return 'subcaminho';
+    if ((env.GLAB_CA_CERT ?? '').trim() && host !== 'gitlab.com')
+        return 'ca';
+    return null;
+}
+/** O `rodarCli` com o ambiente e o PATH da maquina da rede (o cron tem outro ambiente que o terminal). */
+const rodarNaMaquina = (amb) => (c) => {
+    if (!amb.env)
+        return (0, executor_1.rodarCli)(c);
+    // O ambiente da maquina da rede no lugar do do `ork`, e reduzido como o do `ork` seria: so o que a CLI le chega a ela.
+    return (0, executor_1.rodarCli)({ ...c, base: c.reduzido ? (0, executor_1.ambienteReduzido)(amb.env) : amb.env });
+};
+/** `host` ou `host:porta` da casa como alvo da API; a rede nao guarda caminho base nem CA. */
+function alvoDoGitlab(host) {
+    const m = /^(.+?)(?::(\d+))?$/.exec(host);
+    return { tipo: 'gitlab', host: m[1].toLowerCase(), porta: m[2] ? Number(m[2]) : null, caminhoBase: '', ca: null };
+}
+const objeto = (v) => (v && typeof v === 'object' && !Array.isArray(v) ? v : null);
+/** A falha da API com o motivo tipado da forja (`forja.*`) no lugar da ultima linha do stderr. */
+const falhouNaApi = (rota, erro) => new locale_1.ErroDoCatalogo((m) => m.network.apiFalhou('glab', rota, m.forja.motivo(erro, 'gitlab')));
+/** `usuario: null` so e falta de login quando a forja disse isso (`forja.sem-login`); o resto e falha da leitura. */
+function falhaDaApi(r) {
+    if (r.ok)
+        return { falha: (0, locale_1.textoDoCatalogo)((m) => m.network.respostaSemLogin('glab')) };
+    if (r.erro.codigo === 'forja.sem-login')
+        return {};
+    const erro = r.erro;
+    return { falha: (0, locale_1.textoDoCatalogo)((m) => m.network.apiFalhou('glab', 'user', m.forja.motivo(erro, 'gitlab')).replace(/^rede\.forja: /, '')) };
+}
+/**
+ * O GitLab da casa pela API da CLI logada (`chamarApi`): o host (com porta) vai por GITLAB_HOST, nunca por
+ * `--hostname` (o glab recusa a porta); o login e conferido antes da primeira chamada (sem ele o glab faria o pedido
+ * anonimo); o corpo vai pelo stdin com o Content-Type; o erro sai tipado pelo status HTTP.
+ */
 function gitlab(binario, amb, hostPedido) {
     const host = hostPedido ?? hostDoGitlab(amb);
+    const alvo = alvoDoGitlab(host);
+    const opcoes = { rodar: rodarNaMaquina(amb), logins: new Map() };
+    const pedir = (metodo, caminho, corpo, prazoMs = 15000) => (0, api_1.chamarApi)(alvo, { metodo, caminho, prazoMs, ...(corpo !== undefined ? { corpo } : {}) }, opcoes);
     const repositorioDe = (v) => {
         if (!v)
-            throw new Error('rede.forja: glab devolveu um projeto ilegivel');
+            throw new locale_1.ErroDoCatalogo((m) => m.network.projetoIlegivel);
         return { existe: true, privado: privadoDe(v), url: typeof v.http_url_to_repo === 'string' ? v.http_url_to_repo : null };
     };
-    const api = (args, timeoutMs) => rodar(binario, ['api', '--hostname', host, ...args], amb, timeoutMs);
+    const repositorio = (dono, nome) => {
+        const rota = (0, pedidos_1.projetoNaApi)(`${dono}/${nome}`);
+        const r = pedir('GET', rota);
+        if (r.ok)
+            return repositorioDe(objeto(r.valor.corpo));
+        if (r.erro.codigo === 'forja.nao-achei')
+            return { existe: false, privado: null, url: null };
+        throw falhouNaApi(rota, r.erro);
+    };
     return {
         nome: 'gitlab', host, cli: 'glab', binario,
         identidade() {
-            const r = api(['user'], 15000);
-            const login = r.ok ? json(r.stdout)?.username : null;
+            const r = pedir('GET', 'user');
+            const login = r.ok ? objeto(r.valor.corpo)?.username : null;
             const usuario = typeof login === 'string' && LOGIN.test(login) ? login : null;
-            return { forja: 'gitlab', host, cli: 'glab', versao: versaoDoBinario(binario, amb), usuario, ...(usuario ? {} : falhaDoLogin('glab', r)) };
+            return { forja: 'gitlab', host, cli: 'glab', versao: versaoDoBinario(binario, amb), usuario, ...(usuario ? {} : falhaDaApi(r)) };
         },
-        repositorio(dono, nome) {
-            const rota = `projects/${encodeURIComponent(`${dono}/${nome}`)}`;
-            const r = api([rota], 15000);
-            if (!r.ok) {
-                if (naoEncontrado(r))
-                    return { existe: false, privado: null, url: null };
-                throw falhou('glab', rota, r);
+        repositorio,
+        criarPrivado(nome, descricao, dono, namespaceId) {
+            const r = pedir('POST', 'projects', { name: nome, path: nome, visibility: 'private', description: descricao,
+                ...(namespaceId ? { namespace_id: namespaceId } : {}) }, 30000);
+            if (r.ok) {
+                const criado = objeto(r.valor.corpo), pedido = `${dono ?? ''}${dono ? '/' : ''}${nome}`;
+                // O projeto tem de nascer no caminho pedido: outro namespace seria uma casa que a rede nunca acharia.
+                const caminho = typeof criado?.path_with_namespace === 'string' ? criado.path_with_namespace : null;
+                if (dono && caminho !== null && caminho.toLowerCase() !== pedido.toLowerCase()) {
+                    const visto = (0, texto_1.deFora)(caminho, 200);
+                    throw new locale_1.ErroDoCatalogo((m) => m.network.projetoEmOutroCaminho(pedido, visto));
+                }
+                return repositorioDe(criado);
             }
-            return repositorioDe(json(r.stdout));
+            // Escrita nunca se repete sozinha: relida a casa, o projeto que a forja criou antes de a resposta se perder vale. A
+            // releitura que falha nao apaga o motivo do POST.
+            if (dono) {
+                let relido = null;
+                try {
+                    relido = repositorio(dono, nome);
+                }
+                catch {
+                    relido = null;
+                }
+                if (relido?.existe)
+                    return relido;
+            }
+            throw falhouNaApi('projects', r.erro);
         },
-        criarPrivado(nome, descricao) {
-            const r = api(['-X', 'POST', 'projects', '-f', `name=${nome}`, '-f', 'visibility=private',
-                '-f', `description=${descricao}`], 30000);
-            if (!r.ok)
-                throw falhou('glab', 'projects', r);
-            return repositorioDe(json(r.stdout));
+        donoDaRede(dono) {
+            // Carga tardia: o registro chega a este modulo pelo executor da forja; importar no topo fecharia um ciclo de carga.
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            const { adaptadorDaForja, exigirCapacidade } = require('./forja/registro');
+            return exigirCapacidade(adaptadorDaForja('gitlab'), 'donoDaRede')({ api: (p) => (0, api_1.chamarApi)(alvo, p, opcoes), dono });
         },
         helperDeCredencial: () => helper(binario),
     };