@orkastery/cli 0.5.3 → 0.6.0

package/dist/ship.js

@@ -50,6 +50,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.MODOS_QUE_AUTORIZAM_PUSH = void 0;
 exports.commitQueIncorporou = commitQueIncorporou;
 exports.autorizacaoDePush = autorizacaoDePush;
 exports.arvoreComBranch = arvoreComBranch;
@@ -58,6 +59,7 @@ exports.shaDaRef = shaDaRef;
 exports.shaNoRemoto = shaNoRemoto;
 exports.remotoConfigurado = remotoConfigurado;
 exports.detectarReversaoDaEntrega = detectarReversaoDaEntrega;
+exports.unscannedCategories = unscannedCategories;
 exports.registrarReversaoDaEntrega = registrarReversaoDaEntrega;
 exports.ship = ship;
 exports.textoDoShip = textoDoShip;
@@ -70,15 +72,22 @@ const ledger_1 = require("./ledger");
 const manifest_1 = require("./manifest");
 const modos_1 = require("./modos");
 const policies_1 = require("./policies");
+const estado_thread_1 = require("./estado-thread");
+const report_1 = require("./security-scan/report");
+const types_1 = require("./security-scan/types");
 const thread_1 = require("./thread");
 const util_1 = require("./util");
 const verify_1 = require("./verify");
 const ci_1 = require("./ci");
+const forja_1 = require("./forja");
 const contrato_publico_1 = require("./contrato-publico");
 const prova_minima_1 = require("./prova-minima");
 const horario_1 = require("./horario");
 const fabrica_publicar_1 = require("./fabrica-publicar");
+const mcp_ship_transporte_1 = require("./mcp-ship-transporte");
 const branch_de_estado_1 = require("./branch-de-estado");
+const locale_1 = require("./locale");
+const noctum_guarda_1 = require("./noctum-guarda");
 /**
  * RM-037 (fatia 5, A1): o commit de primeiro pai da base que incorporou o `shaDe`: o merge que trouxe a branch, ou
  * o proprio `shaDe` quando a base avancou por fast-forward ate ele. Com a branch ja incorporada, a ponta da base e
@@ -125,8 +134,8 @@ function contratosDaEntrega(raiz, shaPara, shaDe) {
     const diff = (0, util_1.exec)('git', ['diff', '--name-only', '--no-renames', base.stdout.trim(), shaDe], raiz);
     return diff.ok ? (0, contrato_publico_1.contratosTocados)(diff.stdout.split('\n').map((l) => l.trim()).filter(Boolean)) : [];
 }
-/** Modos em que a propria #TAG do pedido autoriza o push antecipadamente. */
-const MODOS_QUE_AUTORIZAM_PUSH = ['maestro', 'auto'];
+/** Modos em que a propria #TAG do pedido autoriza o push antecipadamente (o `ork ship publicar` usa a mesma lista). */
+exports.MODOS_QUE_AUTORIZAM_PUSH = ['maestro', 'auto'];
 /**
  * Quem autoriza o push desta thread.
  *
@@ -145,15 +154,15 @@ function autorizacaoDePush(raiz, thread, opcoes) {
             autorizado: true,
             tipo: 'humano-no-cli',
             por: opcoes.autorizarPush.trim(),
-            razao: `pausa de push do modo ${tag} autorizada na linha de comando`,
+            razao: (0, locale_1.textoDoCatalogo)((m) => m.ship.autorizadoNaLinha(tag)),
         };
     }
-    if (MODOS_QUE_AUTORIZAM_PUSH.includes(thread.modo)) {
+    if (exports.MODOS_QUE_AUTORIZAM_PUSH.includes(thread.modo)) {
         return {
             autorizado: true,
             tipo: 'modo',
-            por: `#TAG ${tag} no pedido do builder`,
-            razao: `o modo ${tag} entrega dentro de um bloco sem pausa: a #TAG e a autorizacao previa`,
+            por: (0, locale_1.textoDoCatalogo)((m) => m.ship.porTag(tag)),
+            razao: (0, locale_1.textoDoCatalogo)((m) => m.ship.autorizadoPeloModo(tag)),
         };
     }
     if (thread.modo === 'classic') {
@@ -162,8 +171,9 @@ function autorizacaoDePush(raiz, thread, opcoes) {
             return {
                 autorizado: true,
                 tipo: 'humano-antecipado',
-                por: String(antecipada.autorizadoPor ?? 'humano'),
-                razao: `autorizacao antecipada de push registrada no ledger em ${antecipada.ts}`,
+                por: antecipada.autorizadoPor !== undefined && antecipada.autorizadoPor !== null ? String(antecipada.autorizadoPor)
+                    : (0, locale_1.textoDoCatalogo)((m) => m.ship.humano),
+                razao: (0, locale_1.textoDoCatalogo)((m) => m.ship.autorizadoAntes(String(antecipada.ts))),
             };
         }
     }
@@ -171,8 +181,7 @@ function autorizacaoDePush(raiz, thread, opcoes) {
         autorizado: false,
         tipo: 'pendente',
         por: '',
-        razao: `o modo ${tag} pausa no push e ainda nao ha autorizacao humana registrada. ` +
-            `Autorize na entrega: ork ship ${thread.id} --para <branch> --autorizar-push <quem>`,
+        razao: (0, locale_1.textoDoCatalogo)((m) => m.ship.semAutorizacao(tag, thread.id)),
     };
 }
 /** Diretorio temporario onde a arvore de merge e montada quando preciso. */
@@ -219,8 +228,7 @@ function prepararArvore(raiz, para) {
     const dona = arvoreComBranch(raiz, para);
     if (dona) {
         if (temAlteracaoNaoCommitada(dona)) {
-            throw new Error(`a branch de destino "${para}" esta em check-out em ${dona} com alteracoes nao commitadas; ` +
-                'commite ou reverta la antes do ship');
+            throw new locale_1.ErroDoCatalogo((m) => m.ship.arvoreSuja(para, dona));
         }
         return { dir: dona, temporaria: false };
     }
@@ -228,17 +236,23 @@ function prepararArvore(raiz, para) {
     fs.mkdirSync(path.dirname(dir), { recursive: true });
     const r = (0, util_1.exec)('git', ['worktree', 'add', '--', dir, para], raiz);
     if (!r.ok) {
-        throw new Error(`nao foi possivel montar a arvore de merge de "${para}": ${(r.stderr || r.stdout).trim()}`);
+        const erro = (r.stderr || r.stdout).trim();
+        throw new locale_1.ErroDoCatalogo((m) => m.ship.arvoreNaoMontada(para, erro));
     }
     return { dir, temporaria: true };
 }
 /** Remove a worktree temporaria do merge (best effort: o lease ja foi liberado). */
-function descartarArvore(raiz, arvore) {
+function descartarArvore(raiz, arvore, trava = []) {
     if (!arvore.temporaria)
         return;
-    (0, util_1.exec)('git', ['worktree', 'remove', '--force', arvore.dir], raiz);
-    (0, util_1.exec)('git', ['worktree', 'prune'], raiz);
+    (0, util_1.exec)('git', [...trava, 'worktree', 'remove', '--force', arvore.dir], raiz);
+    (0, util_1.exec)('git', [...trava, 'worktree', 'prune'], raiz);
 }
+/**
+ * O git local que o transporte fixado roda no projeto depois da ultima conferencia: nenhum hook (o
+ * `reference-transaction` do `update-ref`, inclusive) e nenhum fsmonitor, que o agente pode ter posto ali durante o push.
+ */
+const TRAVA_LOCAL_DO_FIXADO = ['-c', 'core.hooksPath=/dev/null', '-c', 'core.fsmonitor='];
 /** sha de uma referencia local, ou null quando ela nao existe. */
 function shaDaRef(dir, ref) {
     const r = (0, util_1.exec)('git', ['rev-parse', '--verify', '--quiet', ref], dir);
@@ -251,17 +265,49 @@ function shaDaRef(dir, ref) {
  * E o unico jeito aceito de provar push nesta maquina: `gh api` e imprevisivel aqui, e o
  * codigo de saida do `git push` nao prova que o remoto ficou com o commit certo.
  */
-function shaNoRemoto(dir, remoto, branch) {
+function shaNoRemoto(dir, remoto, branch, config = []) {
     // RM-047: so nome de remoto chega ao git, e depois do `--` (nunca vira opcao nem transporte).
-    const r = (0, util_1.exec)('git', ['ls-remote', '--', (0, branch_de_estado_1.exigirRemoto)(remoto, 'ship'), `refs/heads/${branch}`], dir, 120000);
+    const r = (0, util_1.exec)('git', [...configDoRemotoValida(config), 'ls-remote', '--', (0, branch_de_estado_1.exigirRemoto)(remoto, 'ship'), `refs/heads/${branch}`], dir, 120000);
+    return shaDoLsRemote(r, branch);
+}
+function validarUrlFixada(url, config) {
+    const protocolo = (0, mcp_ship_transporte_1.protocoloDaConfigDeRede)(config);
+    const recusa = () => { throw new locale_1.ErroDoCatalogo((m) => m.ship.configDoRemotoInvalida('urlFixada')); };
+    if (!protocolo || typeof url !== 'string' || /[\x00-\x20\x7f]/.test(url) || url.startsWith('-'))
+        return recusa();
+    try {
+        const e = (0, mcp_ship_transporte_1.enderecoDoOrigin)(protocolo === 'ssh' ? 'forja-ssh' : 'forja-https', url);
+        if (e.transporte === 'forja-https' && (0, mcp_ship_transporte_1.urlDaConfigDeRede)(config) !== url)
+            return recusa();
+    }
+    catch {
+        return recusa();
+    }
+    return { url, protocolo };
+}
+/** O git que vai a rede no transporte fixado: do gitdir privado, so com o protocolo do modo. */
+function gitDoRemotoFixado(f, args, timeoutMs) {
+    return (0, util_1.exec)('git', [`--git-dir=${f.gitdir}`, ...f.config, ...args], f.gitdir, timeoutMs, { ...process.env, GIT_ALLOW_PROTOCOL: f.protocolo });
+}
+function shaNoRemotoFixado(f, branch) {
+    return shaDoLsRemote(gitDoRemotoFixado(f, ['ls-remote', '--', f.url, `refs/heads/${branch}`], 120000), branch);
+}
+function shaDoLsRemote(r, branch) {
     if (!r.ok)
         return null;
-    const linha = r.stdout.split('\n').find((l) => l.trim() !== '');
-    if (!linha)
-        return null;
-    const sha = linha.split(/\s+/)[0];
+    // RM-059 (S1 da revisao da ork-rm059pista): o padrao do ls-remote casa por sufixo; vale so a linha da ref exata.
+    const linha = r.stdout.split('\n').map((l) => l.trim().split(/\s+/)).find((partes) => partes[1] === `refs/heads/${branch}`);
+    const sha = linha?.[0] ?? '';
     return /^[0-9a-f]{40}$/.test(sha) ? sha : null;
 }
+/** So a lista que `configDeRede` emite, chave e valor: nenhuma outra opcao, chave ou valor chega antes do subcomando de rede. */
+function configDoRemotoValida(config) {
+    const recusada = (0, mcp_ship_transporte_1.chaveRecusadaDaConfigDeRede)(config);
+    // Nunca ecoa o valor: so a chave (ate 80 caracteres) mostra o que foi recusado.
+    if (recusada !== null)
+        throw new locale_1.ErroDoCatalogo((m) => m.ship.configDoRemotoInvalida(recusada.slice(0, 80)));
+    return config;
+}
 /** O remoto esta configurado neste repositorio? */
 function remotoConfigurado(dir, remoto) {
     return (0, util_1.exec)('git', ['remote', 'get-url', '--', (0, branch_de_estado_1.exigirRemoto)(remoto, 'ship')], dir).ok;
@@ -320,7 +366,9 @@ function detectarReversaoDaEntrega(raiz, thread, para) {
     const entregas = (0, ledger_1.lerLedger)(dir)
         .filter((e) => e.tipo === ledger_1.TIPOS_DE_EVENTO.shipConcluido && typeof e.mergeSha === 'string')
         .map((e) => ({ mergeSha: String(e.mergeSha), para: para ?? String(e.para ?? '') }))
-        .filter((e) => e.para.length > 0);
+        // RM-047 (fronteira de confiança): o ledger pode vir do clone. Só sha hexadecimal e nome de branch
+        // chegam ao `git log`; qualquer outro valor viraria opção dele e é ignorado.
+        .filter((e) => e.para.length > 0 && (0, branch_de_estado_1.shaValido)(e.mergeSha) && (0, branch_de_estado_1.branchValida)(e.para));
     if (entregas.length === 0)
         return null;
     const perguntados = new Set();
@@ -330,7 +378,7 @@ function detectarReversaoDaEntrega(raiz, thread, para) {
             continue;
         perguntados.add(intervalo);
         // O historico e append-only: o merge continua la, e o revert vem DEPOIS dele.
-        const log = (0, util_1.exec)('git', ['log', '--format=%H%x1f%B%x1e', intervalo], raiz, 60000);
+        const log = (0, util_1.exec)('git', ['log', '--format=%H%x1f%B%x1e', '--end-of-options', intervalo], raiz, 60000);
         if (!log.ok)
             continue;
         for (const bruto of log.stdout.split('\x1e')) {
@@ -344,6 +392,23 @@ function detectarReversaoDaEntrega(raiz, thread, para) {
     }
     return null;
 }
+/**
+ * Loop categories (secret, dependency, sast, iac, workflow) not scanned for `sha` (spec 11.2): `[]` without
+ * `verify.security_scan` and with `ci.required_for_ship` (the scan is then in the CI bundle, which the independent CI
+ * check covers). Otherwise the report of `sha` decides: a loop tool `unavailable` or `failed` leaves its category
+ * unscanned (the spec says `unavailable`; a `failed` loop tool is equally not scanned, never clean), except the
+ * "nothing to scan" reasons excused by `isExcusedUnscanned` (same rule as the exit code), and no report at all leaves
+ * every loop category unscanned (no evidence is not clean). Sorted, distinct.
+ */
+function unscannedCategories(carregado, sha) {
+    if (carregado.manifesto.verify.security_scan === undefined || carregado.manifesto.ci.required_for_ship)
+        return [];
+    const report = (0, report_1.readReport)((0, estado_thread_1.raizDoEstado)(carregado.raiz), sha);
+    if (!report)
+        return [...types_1.LOOP_CATEGORIES].sort();
+    const missing = (0, report_1.unscannedLoopTools)(report).map(t => t.category);
+    return [...new Set(missing)].sort();
+}
 /**
  * Grava `rollback_done` quando a reversao e nova, e devolve o que encontrou.
  *
@@ -376,7 +441,20 @@ function ship(carregado, threadId, opcoes) {
     // so nome de remoto passa; o resto recusa com `ship.remoto-invalido`, e o ship nao entrega sem push provado
     // por um remoto que nunca existiu.
     const remoto = (0, branch_de_estado_1.exigirRemoto)(opcoes.remoto ?? 'origin', 'ship');
+    const configDoRemoto = configDoRemotoValida(opcoes.configDoRemoto ?? []);
+    const comConfig = (args) => `git ${[...configDoRemoto, ...args].join(' ')}`;
+    const urlFixada = opcoes.urlFixada === undefined ? null : validarUrlFixada(opcoes.urlFixada, configDoRemoto);
+    // Nos passos, o gitdir privado e a URL fixada vao por nome: o caminho temporario nao diz nada a quem le.
     const r = baseDoResultado(thread, de, opcoes);
+    // RM-058, integracao (T1.1, D3 da ork-rm058integra): a thread de um arco #Noctum que a guarda e entregue pelo passo da
+    // entrega do arco, nunca por aqui (nem pelo `ork_ship` do MCP, que chama este mesmo ship). A recusa vem antes de qualquer
+    // git e nao vai ao ledger da thread: um `ship_blocked` ou um gate por uma tentativa de fora pesaria no indice da thread e
+    // apareceria como pausa do dono na fila do arco.
+    const guarda = (0, noctum_guarda_1.guardaDaThread)(raiz, threadId);
+    if (guarda) {
+        return { ...r, autorizacao: autorizacaoDePush(raiz, thread, opcoes), bloqueado: true, ok: false, motivo: 'policy.violation',
+            codigo: guarda.motivo, detalhe: guarda.detalhe, correcao: guarda.correcao };
+    }
     // I-43 (T7): antes de qualquer coisa, se a entrega ANTERIOR desta thread foi
     // revertida na base, isso vira `rollback_done`. E o insumo de maior peso do indice
     // de qualidade, e o unico fato que diz sem interpretacao que a entrega nao servia.
@@ -385,7 +463,18 @@ function ship(carregado, threadId, opcoes) {
         registrarReversaoDaEntrega(raiz, thread, para);
     }
     catch { /* git indisponivel nao barra o ship */ }
-    const bloquear = (motivo, detalhe, correcao) => {
+    // O push pode ter saido: a troca do origin ou da config durante ele bloqueia o gate no ledger e sobe tipada.
+    const conferirDepoisDoPush = (passos) => {
+        try {
+            opcoes.conferirDepoisDoPush?.();
+        }
+        catch (e) {
+            r.passos = passos;
+            bloquear('runtime.unavailable', e instanceof locale_1.ErroDoCatalogo ? (0, locale_1.textoDoCatalogo)(e.montar) : e.message, (0, locale_1.textoDoCatalogo)((m) => m.ship.pushSemProvaCorrecao), 'transport.mudou-no-push');
+            throw e;
+        }
+    };
+    const bloquear = (motivo, detalhe, correcao, codigo) => {
         (0, gates_1.registrarGateBloqueado)(dir, threadId, {
             gate: 'ship',
             motivo,
@@ -401,18 +490,19 @@ function ship(carregado, threadId, opcoes) {
             de,
             para,
             motivo,
+            ...(codigo ? { codigo } : {}),
             detalhe,
             correcao,
             modo: thread.modo,
             dryRun: r.dryRun,
         });
-        return { ...r, bloqueado: true, ok: false, motivo, detalhe, correcao };
+        return { ...r, bloqueado: true, ok: false, motivo, detalhe, correcao, ...(codigo ? { codigo } : {}) };
     };
     // 1. Autorizacao de push pelo gate do modo de conducao.
     const autorizacao = autorizacaoDePush(raiz, thread, opcoes);
     r.autorizacao = autorizacao;
     if (!autorizacao.autorizado) {
-        return bloquear('human.pending', autorizacao.razao, `ork ship ${threadId} --para <branch> --autorizar-push <quem>`);
+        return bloquear('human.pending', autorizacao.razao, (0, locale_1.textoDoCatalogo)((m) => m.ship.autorizeNaEntrega(threadId)));
     }
     // 2. Policies do manifesto que valem no gate `ship`. RM-008 (fatia 3): a branch da thread
     // atras da base e fato do git, calculado aqui (a ponta da base nao esta contida na branch).
@@ -463,20 +553,21 @@ function ship(carregado, threadId, opcoes) {
         return bloquear('policy.violation', bloqueiam.map((v) => `${v.policy}: ${v.detalhe}`).join('; '), bloqueiam.map((v) => v.correcao).join('; '));
     }
     // 3. Verificacao independente: reexecuta claims e comandos no HEAD real da thread.
-    const verificacao = (0, verify_1.verificar)(carregado, threadId, { executor: opcoes.executorVerify });
+    const verificacao = (0, verify_1.verificar)(carregado, threadId, { executor: opcoes.executorVerify,
+        conducao: { filaPesada: { ...opcoes.avisoDaFilaPesada, esperarMs: opcoes.esperarFilaPesadaMs } } });
     r.verificacao = verificacao;
     if (!verificacao.ok) {
         const motivo = verificacao.motivos.find((m) => m !== 'claims.unverifiable');
-        return bloquear(motivo, `verificacao reprovou no HEAD ${verificacao.commit}: ${verificacao.motivos.join(', ')}`, 'rode `ork verify ' + threadId + '` e corrija antes de entregar');
+        return bloquear(motivo, (0, locale_1.textoDoCatalogo)((m) => m.ship.verificacaoReprovou(verificacao.commit, verificacao.motivos.join(', '))), (0, locale_1.textoDoCatalogo)((m) => m.ship.rodeVerify(threadId)));
     }
     // Referencias locais, resolvidas antes de tomar o lease.
     const shaDe = shaDaRef(raiz, `refs/heads/${de}`);
     const shaPara = shaDaRef(raiz, `refs/heads/${para}`);
     if (!shaDe) {
-        return bloquear('artifact.missing', `branch de origem "${de}" nao existe neste repositorio`, `use --de <branch> ou crie a branch da thread`);
+        return bloquear('artifact.missing', (0, locale_1.textoDoCatalogo)((m) => m.ship.origemAusente(de)), (0, locale_1.textoDoCatalogo)((m) => m.ship.origemAusenteCorrecao));
     }
     if (!shaPara) {
-        return bloquear('artifact.missing', `branch de destino "${para}" nao existe neste repositorio`, `crie a branch de destino ou informe outra em --para`);
+        return bloquear('artifact.missing', (0, locale_1.textoDoCatalogo)((m) => m.ship.destinoAusente(para)), (0, locale_1.textoDoCatalogo)((m) => m.ship.destinoAusenteCorrecao));
     }
     r.shaDe = shaDe;
     r.shaParaAntes = shaPara;
@@ -484,14 +575,29 @@ function ship(carregado, threadId, opcoes) {
     // por git direto. Ciclo sem PLAN nem CHECK nao entrega contrato publico.
     const tocados = (0, prova_minima_1.cicloSemCheck)(thread) ? contratosDaEntrega(raiz, shaPara, shaDe) : [];
     if (tocados.length > 0) {
-        return bloquear('policy.violation', `contrato publico em ciclo sem PLAN nem CHECK: ${tocados.join(', ')}`, 'refaca a mudanca numa thread #Classic, #Maestro ou #Auto');
+        return bloquear('policy.violation', (0, locale_1.textoDoCatalogo)((m) => m.ship.contratoPublico(tocados.join(', '))), (0, locale_1.textoDoCatalogo)((m) => m.ship.contratoPublicoCorrecao));
     }
     // O recibo vem do provedor e pertence ao SHA exato da candidata. Teste local
     // verde ou status de outro commit não libera a entrega.
     const ci = (0, ci_1.consultarCi)(carregado, shaDe, remoto, opcoes.executorCi);
     r.ci = ci;
     if (!ci.ok) {
-        return bloquear('ci.failed', `${ci.detail} (commit ${shaDe}, contexto ${ci.context})`, `publique a branch, aguarde o check ${ci.context} verde no GitHub e repita o SHIP`);
+        return bloquear('ci.failed', (0, locale_1.textoDoCatalogo)((m) => m.ship.ciReprovou((0, locale_1.remontar)(ci.detail), shaDe, ci.context)), (0, locale_1.textoDoCatalogo)((m) => m.ship.ciReprovouCorrecao(ci.context)));
+    }
+    // Security scan (spec 11.2): com `verify.security_scan` e sem o scan no bundle do CI, categoria do laco sem varredura
+    // no SHA da candidata pede autorizacao humana, antes de qualquer push.
+    const naoVarridas = unscannedCategories(carregado, shaDe);
+    let autorizariaSemScan = null;
+    if (naoVarridas.length > 0) {
+        const quem = opcoes.allowUnscanned?.trim();
+        if (!quem) {
+            return bloquear('human.pending', (0, locale_1.textoDoCatalogo)((m) => m.ship.scanNaoVarrido(naoVarridas.join(', '), shaDe)), (0, locale_1.textoDoCatalogo)((m) => m.ship.scanNaoVarridoCorrecao(threadId)));
+        }
+        // O ensaio nao grava a autorizacao: so diz, nos passos, o que o ship real gravaria.
+        if (r.dryRun)
+            autorizariaSemScan = (0, locale_1.textoDoCatalogo)((m) => m.ship.passoAutorizariaSemScan(quem, naoVarridas.join(', '), shaDe));
+        else
+            (0, ledger_1.registrar)(dir, threadId, ledger_1.TIPOS_DE_EVENTO.entregaSemScanAutorizada, { por: quem, categorias: naoVarridas, sha: shaDe });
     }
     // 4. Lease `main-tree`: so uma thread mergeia por vez.
     if (r.dryRun) {
@@ -500,20 +606,21 @@ function ship(carregado, threadId, opcoes) {
         // O ensaio tambem responde ONDE o merge aconteceria e se aquela arvore esta limpa:
         // descobrir isso so na hora do merge real seria descobrir tarde demais.
         const dona = arvoreComBranch(raiz, para);
-        const arvoreDoMerge = dona
-            ? `${dona} (arvore que tem ${para} em check-out; ${temAlteracaoNaoCommitada(dona) ? 'SUJA, o ship reprovaria com tree.blocked' : 'limpa'})`
-            : `worktree temporaria em ${path.join((0, manifest_1.dirEstado)(raiz), 'tmp')} (ninguem tem ${para} em check-out)`;
-        r.detalhe = `arvore de merge: ${arvoreDoMerge}`;
+        const suja = dona ? temAlteracaoNaoCommitada(dona) : false;
+        const temporaria = path.join((0, manifest_1.dirEstado)(raiz), 'tmp');
+        const arvoreDoMerge = (m) => dona ? m.ship.arvoreDona(dona, para, suja) : m.ship.arvoreTemporaria(temporaria, para);
+        r.detalhe = (0, locale_1.textoDoCatalogo)((m) => m.ship.arvoreDeMerge(arvoreDoMerge(m)));
         // Ensaio de 03/10 (R5): sem remoto (ou com --sem-push), o ensaio diz o mesmo que o ship real, e nao
         // promete um push e uma prova que nao vao acontecer.
-        const semPushNoReal = opcoes.semPush ? 'push nao executado por --sem-push (merge local concluido)'
-            : !remotoConfigurado(raiz, remoto) ? `remoto "${remoto}" nao configurado: merge local concluido, sem push a provar` : null;
+        const semPushNoReal = opcoes.semPush || !remotoConfigurado(raiz, remoto)
+            ? (m) => opcoes.semPush ? m.ship.semPushPorFlag : m.ship.semRemoto(remoto) : null;
         r.passos = [
-            `arvore de merge: ${arvoreDoMerge}`,
-            `git merge --no-ff ${de} -m "<mensagem de ship>"`,
-            ...(semPushNoReal ? [`sem push: ${semPushNoReal}`] : [
+            r.detalhe,
+            ...(autorizariaSemScan ? [autorizariaSemScan] : []),
+            (0, locale_1.textoDoCatalogo)((m) => m.ship.passoMerge(de)),
+            ...(semPushNoReal ? [(0, locale_1.textoDoCatalogo)((m) => m.ship.passoSemPush(semPushNoReal(m)))] : [
                 `git push ${remoto} ${para}`,
-                `git ls-remote ${remoto} refs/heads/${para}   (prova do push)`,
+                (0, locale_1.textoDoCatalogo)((m) => m.ship.passoProvaDoPush(remoto, para)),
             ]),
         ];
         (0, ledger_1.registrar)(dir, threadId, ledger_1.TIPOS_DE_EVENTO.shipIniciado, {
@@ -547,9 +654,7 @@ function ship(carregado, threadId, opcoes) {
             bloqueadaPor: dono?.thread ?? '(desconhecida)',
             motivo: aquisicao.motivo ?? 'lease.busy',
         });
-        return bloquear(aquisicao.motivo ?? 'lease.busy', aquisicao.falhaRetomada ? aquisicao.detalhe : `lease ${leases_1.LEASE_MAIN_TREE} esta com a thread ${dono?.thread ?? '(desconhecida)'} ` +
-            `desde ${dono?.adquiridoEm ?? '?'} (${dono?.motivo ?? 'sem motivo'}); ` +
-            `esta thread entrou na merge queue na posicao ${aquisicao.posicaoNaFila}`, aquisicao.correcao);
+        return bloquear(aquisicao.motivo ?? 'lease.busy', aquisicao.falhaRetomada ? aquisicao.detalhe : (0, locale_1.textoDoCatalogo)((m) => m.ship.leaseComOutra(leases_1.LEASE_MAIN_TREE, dono?.thread ?? m.ship.desconhecida, dono?.adquiridoEm ?? '?', dono?.motivo ?? m.ship.semMotivo, aquisicao.posicaoNaFila)), aquisicao.correcao);
     }
     r.lease = aquisicao.lease;
     (0, ledger_1.registrar)(dir, threadId, ledger_1.TIPOS_DE_EVENTO.leaseAdquirido, {
@@ -576,7 +681,7 @@ function ship(carregado, threadId, opcoes) {
         }
         catch (e) {
             // Arvore de destino indisponivel e reprovacao tipada, nao excecao vazando pelo CLI.
-            return bloquear('tree.blocked', e.message, 'deixe a arvore da branch de destino limpa (ou libere a branch) e rode o ship de novo');
+            return bloquear('tree.blocked', e instanceof locale_1.ErroDoCatalogo ? (0, locale_1.textoDoCatalogo)(e.montar) : e.message, (0, locale_1.textoDoCatalogo)((m) => m.ship.arvoreCorrecao));
         }
         const passos = [];
         opcoes.revalidarGit?.('merge', arvore.dir);
@@ -600,11 +705,12 @@ function ship(carregado, threadId, opcoes) {
             if (!merge.ok) {
                 (0, util_1.exec)('git', ['merge', '--abort'], arvore.dir);
                 r.passos = [...passos, 'git merge --abort'];
-                return bloquear('artifact.missing', `merge de ${de} em ${para} falhou: ${(merge.stderr || merge.stdout).trim().slice(0, 400)}`, 'resolva o conflito na branch da thread e rode o ship de novo');
+                const erro = (merge.stderr || merge.stdout).trim().slice(0, 400);
+                return bloquear('artifact.missing', (0, locale_1.textoDoCatalogo)((m) => m.ship.mergeFalhou(de, para, erro)), (0, locale_1.textoDoCatalogo)((m) => m.ship.mergeFalhouCorrecao));
             }
             const novo = shaDaRef(arvore.dir, 'HEAD');
             if (!novo) {
-                return bloquear('artifact.missing', 'nao foi possivel ler o HEAD apos o merge', 'confira o repositorio');
+                return bloquear('artifact.missing', (0, locale_1.textoDoCatalogo)((m) => m.ship.headIlegivel), (0, locale_1.textoDoCatalogo)((m) => m.ship.confiraRepositorio));
             }
             mergeSha = novo;
             pontaDaBase = novo;
@@ -612,50 +718,87 @@ function ship(carregado, threadId, opcoes) {
             const incorporou = (0, util_1.exec)('git', ['merge-base', '--is-ancestor', shaDe, mergeSha], arvore.dir).ok;
             passos.push(`git merge-base --is-ancestor ${shaDe.slice(0, 8)} ${mergeSha.slice(0, 8)}`);
             if (!incorporou) {
-                return bloquear('artifact.missing', `o commit de ${de} nao aparece como ancestral do merge ${mergeSha}`, 'nao empurre: investigue o estado do repositorio');
+                return bloquear('artifact.missing', (0, locale_1.textoDoCatalogo)((m) => m.ship.naoAncestral(de, mergeSha)), (0, locale_1.textoDoCatalogo)((m) => m.ship.naoEmpurre));
             }
         }
         else {
             // RM-037 (fatia 5, A1): o merge que trouxe a branch, e nao a ponta da base.
             const incorporadoEm = commitQueIncorporou(raiz, shaDe, shaPara, passos);
             if (!incorporadoEm) {
-                return bloquear('artifact.missing', `${de} ja e ancestral de ${para}, mas o git nao achou o commit de primeiro pai que o incorporou`, 'confira o repositorio: o ship_done precisa do merge que entregou a thread');
+                return bloquear('artifact.missing', (0, locale_1.textoDoCatalogo)((m) => m.ship.semPrimeiroPai(de, para)), (0, locale_1.textoDoCatalogo)((m) => m.ship.semPrimeiroPaiCorrecao));
             }
             mergeSha = incorporadoEm;
-            passos.push(`(nada a mergear: ${de} ja e ancestral de ${para}, incorporado em ${mergeSha.slice(0, 8)})`);
+            const incorporado = mergeSha.slice(0, 8);
+            passos.push((0, locale_1.textoDoCatalogo)((m) => m.ship.passoJaIncorporado(de, para, incorporado)));
         }
         r.mergeSha = mergeSha;
         r.pontaDaBase = pontaDaBase;
         opcoes.revalidarGit?.('push', arvore.dir);
         // 6. Push PROVADO por ls-remote.
-        const temRemoto = remotoConfigurado(arvore.dir, remoto);
+        const temRemoto = urlFixada !== null || remotoConfigurado(arvore.dir, remoto);
         r.remoto = temRemoto ? remoto : null;
-        if (opcoes.semPush || !temRemoto) {
+        if (urlFixada && !opcoes.semPush) {
+            const fixado = { gitdir: (0, mcp_ship_transporte_1.criarGitdirDoPush)(raiz), ...urlFixada, config: configDoRemoto };
+            const comFixado = (args) => `git --git-dir=<gitdir privado> ${[...configDoRemoto, ...args].join(' ')}`.replaceAll(urlFixada.url, '<origin fixado>');
+            try {
+                // O sha e o decidido aqui. Sem `-u`: o gitdir privado nao tem branch para rastrear, e gravar o upstream na
+                // config do projeto mudaria a config conferida; o `ls-remote` que so decidia o `-u` sai junto.
+                const argsPush = ['push', '--', urlFixada.url, `${pontaDaBase}:refs/heads/${para}`];
+                const push = gitDoRemotoFixado(fixado, argsPush, 300000);
+                passos.push(comFixado(argsPush));
+                if (!push.ok) {
+                    r.passos = passos;
+                    const erro = (0, forja_1.detalheDoPush)(push.stderr || push.stdout);
+                    if ((0, forja_1.pushRecusadoPelaProtecao)(`${push.stderr}\n${push.stdout}`)) {
+                        return bloquear('runtime.unavailable', (0, locale_1.textoDoCatalogo)((m) => m.ship.pushBaseProtegida(remoto, para, erro)), (0, locale_1.textoDoCatalogo)((m) => m.ship.pushBaseProtegidaCorrecao(threadId)), 'entrega.base-protegida');
+                    }
+                    return bloquear('runtime.unavailable', (0, locale_1.textoDoCatalogo)((m) => m.ship.pushFalhou(remoto, para, erro)), (0, locale_1.textoDoCatalogo)((m) => m.ship.pushFalhouCorrecao));
+                }
+                const shaRemoto = shaNoRemotoFixado(fixado, para);
+                passos.push(comFixado(['ls-remote', '--', urlFixada.url, `refs/heads/${para}`]));
+                conferirDepoisDoPush(passos);
+                r.shaRemoto = shaRemoto;
+                r.pushVerificado = shaRemoto !== null && shaRemoto === pontaDaBase;
+                if (!r.pushVerificado) {
+                    r.passos = passos;
+                    return bloquear('runtime.unavailable', (0, locale_1.textoDoCatalogo)((m) => m.ship.pushSemProva(shaRemoto, pontaDaBase)), (0, locale_1.textoDoCatalogo)((m) => m.ship.pushSemProvaCorrecao));
+                }
+                // A ref de rastreio do projeto acompanha o remoto provado, como no push por nome; local, sem rede.
+                (0, util_1.exec)('git', [...TRAVA_LOCAL_DO_FIXADO, 'update-ref', '--', `refs/remotes/${remoto}/${para}`, pontaDaBase], raiz);
+            }
+            finally {
+                fs.rmSync(fixado.gitdir, { recursive: true, force: true });
+            }
+        }
+        else if (opcoes.semPush || !temRemoto) {
             r.pushVerificado = false;
-            r.detalhe = opcoes.semPush
-                ? 'push nao executado por --sem-push (merge local concluido)'
-                : `remoto "${remoto}" nao configurado: merge local concluido, sem push a provar`;
+            r.detalhe = (0, locale_1.textoDoCatalogo)((m) => opcoes.semPush ? m.ship.semPushPorFlag : m.ship.semRemoto(remoto));
         }
         else {
-            const existeNoRemoto = shaNoRemoto(arvore.dir, remoto, para) !== null;
+            const existeNoRemoto = shaNoRemoto(arvore.dir, remoto, para, configDoRemoto) !== null;
             const argsPush = existeNoRemoto
                 ? ['push', '--', remoto, `refs/heads/${para}:refs/heads/${para}`]
                 : ['push', '-u', '--', remoto, `refs/heads/${para}:refs/heads/${para}`];
-            const push = (0, util_1.exec)('git', argsPush, arvore.dir, 300000);
-            passos.push(`git ${argsPush.join(' ')}`);
+            const push = (0, util_1.exec)('git', [...configDoRemoto, ...argsPush], arvore.dir, 300000);
+            passos.push(comConfig(argsPush));
             if (!push.ok) {
                 r.passos = passos;
-                return bloquear('runtime.unavailable', `push para ${remoto}/${para} falhou: ${(push.stderr || push.stdout).trim().slice(0, 400)}`, 'resolva o acesso ao remoto e rode o ship de novo (o merge local ja aconteceu)');
+                const erro = (0, forja_1.detalheDoPush)(push.stderr || push.stdout);
+                // A protecao da base recusou: a entrega e por PR/MR e o registro dele. O motivo do gate nao muda, so a orientacao.
+                if ((0, forja_1.pushRecusadoPelaProtecao)(`${push.stderr}\n${push.stdout}`)) {
+                    return bloquear('runtime.unavailable', (0, locale_1.textoDoCatalogo)((m) => m.ship.pushBaseProtegida(remoto, para, erro)), (0, locale_1.textoDoCatalogo)((m) => m.ship.pushBaseProtegidaCorrecao(threadId)), 'entrega.base-protegida');
+                }
+                return bloquear('runtime.unavailable', (0, locale_1.textoDoCatalogo)((m) => m.ship.pushFalhou(remoto, para, erro)), (0, locale_1.textoDoCatalogo)((m) => m.ship.pushFalhouCorrecao));
             }
             // A prova: o sha que o REMOTO devolve tem que ser o mesmo do destino local.
-            const shaRemoto = shaNoRemoto(arvore.dir, remoto, para);
-            passos.push(`git ls-remote ${remoto} refs/heads/${para}`);
+            const shaRemoto = shaNoRemoto(arvore.dir, remoto, para, configDoRemoto);
+            passos.push(comConfig(['ls-remote', remoto, `refs/heads/${para}`]));
+            conferirDepoisDoPush(passos);
             r.shaRemoto = shaRemoto;
             r.pushVerificado = shaRemoto !== null && shaRemoto === pontaDaBase;
             if (!r.pushVerificado) {
                 r.passos = passos;
-                return bloquear('runtime.unavailable', `ls-remote devolveu ${shaRemoto ?? '(nada)'} e o destino local esta em ${pontaDaBase}: ` +
-                    'o push nao ficou provado', 'rode o ship de novo e confira o remoto');
+                return bloquear('runtime.unavailable', (0, locale_1.textoDoCatalogo)((m) => m.ship.pushSemProva(shaRemoto, pontaDaBase)), (0, locale_1.textoDoCatalogo)((m) => m.ship.pushSemProvaCorrecao));
             }
         }
         r.passos = passos;
@@ -693,7 +836,9 @@ function ship(carregado, threadId, opcoes) {
                 passos,
             },
         });
-        (0, fabrica_publicar_1.publicarEmSegundoPlano)(raiz);
+        // A publicacao da fabrica empurra pelo origin do projeto, sem o transporte fixado: no fixado, nao sai daqui.
+        if (!urlFixada)
+            (0, fabrica_publicar_1.publicarEmSegundoPlano)(raiz);
         const atualizada = (0, thread_1.lerThread)(raiz, threadId);
         // I-42: ciclo sem SHIP (o `#Fast`) entrega sem trocar de fase; `faseAtual` fica sempre
         // dentro do ciclo, porque board, pulse e prompt resolvem o bloco a partir dela.
@@ -708,7 +853,7 @@ function ship(carregado, threadId, opcoes) {
     }
     finally {
         if (arvore)
-            descartarArvore(raiz, arvore);
+            descartarArvore(raiz, arvore, urlFixada ? TRAVA_LOCAL_DO_FIXADO : []);
         const solto = (0, leases_1.liberar)(raiz, leases_1.LEASE_MAIN_TREE, threadId);
         (0, ledger_1.registrar)(dir, threadId, ledger_1.TIPOS_DE_EVENTO.leaseLiberado, {
             lease: leases_1.LEASE_MAIN_TREE,
@@ -717,74 +862,75 @@ function ship(carregado, threadId, opcoes) {
         });
     }
 }
-/** Texto de `ork ship` para o CLI. */
+/**
+ * Texto de `ork ship` para o CLI. A razao, o detalhe, a correcao e os passos que o ship montou pelo catalogo
+ * vieram em pt-BR (como o ledger os guarda) e saem remontados no locale ativo (G2 da F2b).
+ */
 function textoDoShip(r) {
+    const m = (0, locale_1.msg)().ship;
     const linhas = [];
     // I-35: horários no fuso do dono, sem rótulo por linha; o fuso é dito uma vez, no fim.
     let comHorario = false;
     const local = (texto) => {
-        const localizado = (0, horario_1.localizarTexto)(texto);
-        if (localizado !== texto)
+        const remontado = (0, locale_1.remontar)(texto);
+        const localizado = (0, horario_1.localizarTexto)(remontado);
+        if (localizado !== remontado)
             comHorario = true;
         return localizado;
     };
     const fechar = () => (comHorario ? [...linhas, (0, horario_1.legendaDoFuso)()] : linhas).join('\n');
-    const cabecalho = r.dryRun ? 'ork ship (--dry-run, nada foi executado)' : 'ork ship';
-    linhas.push(`${cabecalho}: thread ${r.thread}`);
-    linhas.push(`  de            ${r.de}${r.shaDe ? ` @ ${r.shaDe.slice(0, 8)}` : ''}`);
-    linhas.push(`  para          ${r.para}${r.shaParaAntes ? ` @ ${r.shaParaAntes.slice(0, 8)}` : ''}`);
-    linhas.push(`  autorizacao   ${r.autorizacao.autorizado ? `AUTORIZADO por ${r.autorizacao.por} (${r.autorizacao.tipo})` : 'AGUARDANDO AUTORIZACAO HUMANA'}`);
-    linhas.push(`                ${local(r.autorizacao.razao)}`);
+    linhas.push(m.cabecalho(r.dryRun, r.thread));
+    linhas.push(m.de(r.de, r.shaDe ? r.shaDe.slice(0, 8) : ''));
+    linhas.push(m.para(r.para, r.shaParaAntes ? r.shaParaAntes.slice(0, 8) : ''));
+    linhas.push(r.autorizacao.autorizado
+        ? m.autorizado((0, locale_1.remontar)(r.autorizacao.por), m.tiposDeAutorizacao[r.autorizacao.tipo] ?? r.autorizacao.tipo) : m.aguardandoAutorizacao);
+    linhas.push(m.razao(local(r.autorizacao.razao)));
     if (r.verificacao) {
         const v = r.verificacao;
-        linhas.push(`  verificacao   ${v.ok ? 'passou' : 'REPROVOU'} no HEAD ${(0, util_1.shaCurto)(v.commit)} ` +
-            `(${v.claims.filter((c) => c.verificado).length}/${v.claims.length} claims, ` +
-            `${v.comandos.filter((c) => c.ok).length}/${v.comandos.length} comandos)`);
+        linhas.push(m.verificacao(v.ok, (0, util_1.shaCurto)(v.commit), v.claims.filter((c) => c.verificado).length, v.claims.length, v.comandos.filter((c) => c.ok).length, v.comandos.length));
     }
     if (r.ci) {
-        linhas.push(`  ci            ${r.ci.required ? `${r.ci.state.toUpperCase()} ${r.ci.context} em ${r.ci.sha.slice(0, 8)}` : 'não exigido'}`);
+        linhas.push(r.ci.required ? m.ciExigido(r.ci.state.toUpperCase(), r.ci.context, r.ci.sha.slice(0, 8)) : m.ciNaoExigido);
     }
     linhas.push(...(0, policies_1.linhasDeAviso)(r.violacoes ?? []));
     if (r.leaseOcupadoPor) {
         comHorario = true;
-        linhas.push(`  lease         ${leases_1.LEASE_MAIN_TREE} OCUPADO pela thread ${r.leaseOcupadoPor.thread} (desde ${(0, horario_1.formatarDataHora)(r.leaseOcupadoPor.adquiridoEm)})`);
+        linhas.push(m.leaseOcupado(leases_1.LEASE_MAIN_TREE, r.leaseOcupadoPor.thread, (0, horario_1.formatarDataHora)(r.leaseOcupadoPor.adquiridoEm)));
     }
     else if (r.lease) {
-        linhas.push(`  lease         ${leases_1.LEASE_MAIN_TREE} tomado por ${r.thread} e liberado ao fim`);
+        linhas.push(m.leaseTomado(leases_1.LEASE_MAIN_TREE, r.thread));
     }
     else if (r.dryRun) {
-        linhas.push(`  lease         ${leases_1.LEASE_MAIN_TREE} livre`);
+        linhas.push(m.leaseLivre(leases_1.LEASE_MAIN_TREE));
     }
     if (r.bloqueado) {
         linhas.push('');
-        linhas.push(`BLOQUEADO. motivo tipado: ${r.motivo}`);
-        linhas.push(`  detalhe   ${local(r.detalhe)}`);
-        linhas.push(`  correcao  ${r.correcao}`);
+        linhas.push(m.bloqueado(String(r.motivo)));
+        linhas.push(m.detalhe(local(r.detalhe)));
+        linhas.push(m.correcao((0, locale_1.remontar)(r.correcao)));
         return fechar();
     }
     if (r.dryRun) {
         linhas.push('');
-        linhas.push('Passos que o ship real executaria, nesta ordem:');
+        linhas.push(m.passosDoEnsaio);
         for (const p of r.passos)
-            linhas.push(`  ${p}`);
+            linhas.push(`  ${(0, locale_1.remontar)(p)}`);
         return fechar();
     }
     linhas.push('');
-    linhas.push(r.jaIncorporado
-        ? `Nada a mergear: ${r.de} ja estava em ${r.para}, incorporado em ${r.mergeSha}.`
-        : `Merge --no-ff concluido: ${r.mergeSha}`);
+    linhas.push(r.jaIncorporado ? m.nadaAMergear(r.de, r.para, String(r.mergeSha)) : m.mergeConcluido(String(r.mergeSha)));
     if (r.pushVerificado) {
-        linhas.push(`Push PROVADO: ls-remote de ${r.remoto}/${r.para} devolveu ${r.shaRemoto}`);
-        linhas.push(`  e o destino local esta no mesmo sha: ${r.pontaDaBase ?? r.mergeSha}`);
+        linhas.push(m.pushProvado(String(r.remoto), r.para, String(r.shaRemoto)));
+        linhas.push(m.mesmoSha(r.pontaDaBase ?? String(r.mergeSha)));
     }
     else {
-        linhas.push(`Push nao provado: ${local(r.detalhe) || 'sem remoto configurado'}`);
+        linhas.push(m.pushNaoProvado(local(r.detalhe) || m.semRemotoConfigurado));
     }
     linhas.push('');
-    linhas.push('Evidencia (comandos executados):');
+    linhas.push(m.evidencia);
     for (const p of r.passos)
-        linhas.push(`  ${p}`);
+        linhas.push(`  ${(0, locale_1.remontar)(p)}`);
     linhas.push('');
-    linhas.push(`Ledger: ork phase list ${r.thread}  (evento ship_done)`);
+    linhas.push(m.ledger(r.thread));
     return fechar();
 }