@orkastery/cli 0.5.1 → 0.5.6

package/dist/ship.js

@@ -50,6 +50,8 @@ 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;
 exports.prepararArvore = prepararArvore;
@@ -62,6 +64,7 @@ exports.ship = ship;
 exports.textoDoShip = textoDoShip;
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
+const node_child_process_1 = require("node:child_process");
 const gates_1 = require("./gates");
 const leases_1 = require("./leases");
 const ledger_1 = require("./ledger");
@@ -76,6 +79,46 @@ 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 branch_de_estado_1 = require("./branch-de-estado");
+const locale_1 = require("./locale");
+/**
+ * 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
+ * outra coisa: no `ship_done` da ork-docsusuarios (27/09/2026), o unico do `ork ship` com `jaIncorporado` nos ledgers
+ * deste projeto, ela era o merge de outra thread. O que trouxe a branch e o commit mais velho do primeiro pai da base
+ * que descende do `shaDe`. GO-FIX (rodada 1 do CHECK): `--first-parent` junto com `--ancestry-path` so propaga a
+ * descendencia pelos commits de primeiro pai, e o merge do PR que recebeu "Update branch" no GitHub (o pai dele e um
+ * merge que descende do `shaDe`, nao o `shaDe`) sumia da lista; agora sao duas listas e a intersecao. `null` quando o
+ * git nao responde.
+ */
+function commitQueIncorporou(raiz, shaDe, ponta, passos = []) {
+    if (shaDe === ponta)
+        return shaDe;
+    // `passos` recebe os comandos que de fato rodaram, na ordem: e a evidencia do ship (sugestao da conferencia da rodada 2).
+    const curto = (sha) => sha.slice(0, 8);
+    // As listas crescem com o historico entre a branch e a ponta: o buffer vai alem do 1 MiB padrao do spawnSync.
+    const listar = (args) => {
+        passos.push(`git ${args.map((a) => a.replace(/^([0-9a-f]{40,64})\.\.([0-9a-f]{40,64})$/, (_, x, y) => `${curto(x)}..${curto(y)}`)).join(' ')}`);
+        const r = (0, node_child_process_1.spawnSync)('git', args, { cwd: raiz, encoding: 'utf8', timeout: 120000, maxBuffer: 256 * 1024 * 1024 });
+        return r.status === 0 && !r.error ? r.stdout.split('\n').filter((l) => /^[0-9a-f]{40,64}$/.test(l)) : null;
+    };
+    const primeiroPai = listar(['rev-list', '--first-parent', `${shaDe}..${ponta}`]);
+    const descendentes = listar(['rev-list', '--ancestry-path', `${shaDe}..${ponta}`]);
+    if (!primeiroPai || !descendentes)
+        return null;
+    const doShaDe = new Set(descendentes);
+    // Do mais velho para o mais novo: o primeiro de primeiro pai que descende do `shaDe`.
+    const maisVelho = [...primeiroPai].reverse().find((c) => doShaDe.has(c));
+    if (!maisVelho)
+        return null;
+    // O primeiro pai dele e o proprio `shaDe`: a branch ja estava no primeiro pai da base (fast-forward). Sem a resposta
+    // do git, nada e gravado: devolver o mais velho poria no `mergeSha` o filho do `shaDe` (sugestao da rodada 2).
+    passos.push(`git rev-parse ${curto(maisVelho)}^1`);
+    const pai = (0, util_1.exec)('git', ['rev-parse', `${maisVelho}^1`], raiz);
+    if (!pai.ok)
+        return null;
+    return pai.stdout.trim() === shaDe ? shaDe : maisVelho;
+}
 /** Os caminhos de contrato publico que a entrega traz sobre a base (diff desde o merge-base). */
 function contratosDaEntrega(raiz, shaPara, shaDe) {
     const base = (0, util_1.exec)('git', ['merge-base', shaPara, shaDe], raiz);
@@ -84,8 +127,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.
  *
@@ -104,15 +147,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') {
@@ -121,8 +164,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))),
             };
         }
     }
@@ -130,8 +174,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. */
@@ -178,16 +221,16 @@ 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 };
     }
     const dir = dirTemporarioDeShip(raiz, para);
     fs.mkdirSync(path.dirname(dir), { recursive: true });
-    const r = (0, util_1.exec)('git', ['worktree', 'add', dir, para], raiz);
+    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 };
 }
@@ -211,18 +254,18 @@ function shaDaRef(dir, ref) {
  * codigo de saida do `git push` nao prova que o remoto ficou com o commit certo.
  */
 function shaNoRemoto(dir, remoto, branch) {
-    const r = (0, util_1.exec)('git', ['ls-remote', remoto, `refs/heads/${branch}`], dir, 120000);
+    // 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);
     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;
 }
 /** O remoto esta configurado neste repositorio? */
 function remotoConfigurado(dir, remoto) {
-    return (0, util_1.exec)('git', ['remote', 'get-url', remoto], dir).ok;
+    return (0, util_1.exec)('git', ['remote', 'get-url', '--', (0, branch_de_estado_1.exigirRemoto)(remoto, 'ship')], dir).ok;
 }
 function baseDoResultado(thread, de, opcoes) {
     return {
@@ -237,6 +280,7 @@ function baseDoResultado(thread, de, opcoes) {
         shaDe: '',
         shaParaAntes: '',
         mergeSha: null,
+        pontaDaBase: null,
         jaIncorporado: false,
         remoto: opcoes.remoto ?? 'origin',
         shaRemoto: null,
@@ -277,7 +321,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();
@@ -287,7 +333,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')) {
@@ -329,7 +375,10 @@ function ship(carregado, threadId, opcoes) {
     const dir = (0, thread_1.dirThread)(raiz, threadId);
     const de = opcoes.de ?? thread.base.branch;
     const para = opcoes.para;
-    const remoto = opcoes.remoto ?? 'origin';
+    // RM-047: o `--remoto` vem da linha de comando. Antes de qualquer git (inclusive a leitura da reversao),
+    // 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 r = baseDoResultado(thread, de, opcoes);
     // 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
@@ -366,7 +415,7 @@ function ship(carregado, threadId, opcoes) {
     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).
@@ -417,20 +466,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;
@@ -438,31 +488,37 @@ 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)));
     }
     // 4. Lease `main-tree`: so uma thread mergeia por vez.
     if (r.dryRun) {
-        const ocupado = (0, leases_1.lerLease)(raiz, leases_1.LEASE_MAIN_TREE);
+        const ocupado = (0, leases_1.leasesColidentes)(raiz, leases_1.LEASE_MAIN_TREE)[0] ?? null;
         r.leaseOcupadoPor = ocupado;
         // 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 || !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>"`,
-            `git push ${remoto} ${para}`,
-            `git ls-remote ${remoto} refs/heads/${para}   (prova do push)`,
+            r.detalhe,
+            (0, locale_1.textoDoCatalogo)((m) => m.ship.passoMerge(de)),
+            ...(semPushNoReal ? [(0, locale_1.textoDoCatalogo)((m) => m.ship.passoSemPush(semPushNoReal(m)))] : [
+                `git push ${remoto} ${para}`,
+                (0, locale_1.textoDoCatalogo)((m) => m.ship.passoProvaDoPush(remoto, para)),
+            ]),
         ];
         (0, ledger_1.registrar)(dir, threadId, ledger_1.TIPOS_DE_EVENTO.shipIniciado, {
             de,
@@ -493,11 +549,9 @@ function ship(carregado, threadId, opcoes) {
             posicao: aquisicao.posicaoNaFila,
             naFrente: (0, leases_1.esperandoPor)(raiz, leases_1.LEASE_MAIN_TREE).length,
             bloqueadaPor: dono?.thread ?? '(desconhecida)',
-            motivo: 'lease.busy',
+            motivo: aquisicao.motivo ?? 'lease.busy',
         });
-        return bloquear('lease.busy', `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}`, `espere a vez na fila (ork lease list), ou libere com: ork lease release ${leases_1.LEASE_MAIN_TREE} --forcar`);
+        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, {
@@ -524,7 +578,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);
@@ -532,6 +586,9 @@ function ship(carregado, threadId, opcoes) {
         const jaIncorporado = (0, util_1.exec)('git', ['merge-base', '--is-ancestor', shaDe, shaPara], raiz).ok;
         r.jaIncorporado = jaIncorporado;
         let mergeSha = shaPara;
+        // RM-037 (fatia 5, A1): a ponta que o push prova. Com o merge feito aqui, e ele; com a branch ja incorporada, a
+        // ponta de antes, que pode trazer outros merges depois do que entregou esta thread.
+        let pontaDaBase = shaPara;
         if (!jaIncorporado) {
             const mensagem = opcoes.mensagem ??
                 `ship(${threadId}): merge de ${de} em ${para}\n\n` +
@@ -539,59 +596,68 @@ function ship(carregado, threadId, opcoes) {
                     `modo: ${(0, modos_1.tagDoModo)(thread.modo)}\n` +
                     `autorizado por: ${autorizacao.por} (${autorizacao.tipo})\n` +
                     `verificado em: HEAD ${verificacao.commit}\n`;
-            const merge = (0, util_1.exec)('git', ['merge', '--no-ff', de, '-m', mensagem], arvore.dir, 300000);
+            // RM-047: o merge e do sha verificado, e nao do nome que veio de `--de` (nome nunca vira opcao do git).
+            const merge = (0, util_1.exec)('git', ['merge', '--no-ff', '-m', mensagem, shaDe], arvore.dir, 300000);
             passos.push(`git merge --no-ff ${de}`);
             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;
             // Verificacao independente do merge: a origem precisa ser ancestral do resultado.
             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 {
-            passos.push(`(nada a mergear: ${de} ja e ancestral de ${para})`);
+            // 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', (0, locale_1.textoDoCatalogo)((m) => m.ship.semPrimeiroPai(de, para)), (0, locale_1.textoDoCatalogo)((m) => m.ship.semPrimeiroPaiCorrecao));
+            }
+            mergeSha = incorporadoEm;
+            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);
         r.remoto = temRemoto ? remoto : null;
         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 argsPush = existeNoRemoto
-                ? ['push', remoto, `${para}:refs/heads/${para}`]
-                : ['push', '-u', remoto, `${para}:refs/heads/${para}`];
+                ? ['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(' ')}`);
             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 = (push.stderr || push.stdout).trim().slice(0, 400);
+                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}`);
             r.shaRemoto = shaRemoto;
-            r.pushVerificado = shaRemoto !== null && shaRemoto === mergeSha;
+            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 ${mergeSha}: ` +
-                    '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;
@@ -609,6 +675,8 @@ function ship(carregado, threadId, opcoes) {
             shaDe,
             shaParaAntes: shaPara,
             mergeSha,
+            // RM-037 (fatia 5, A1): a ponta da base vai em campo proprio; o `mergeSha` e o merge que entregou a thread.
+            pontaDaBase,
             jaIncorporado,
             remoto: r.remoto,
             shaRemoto: r.shaRemoto,
@@ -651,74 +719,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}.`
-        : `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.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();
 }

package/dist/steal.js

@@ -0,0 +1,77 @@
+"use strict";
+/**
+ * RM-037 (fatia 6): o steal da CPU durante o `ork verify`, medido em `/proc/stat`.
+ *
+ * Em 23 e 24/09/2026 a VPS perdeu de 67% a 92% da CPU para o hipervisor (sar), e a mesma suite que
+ * leva 3,4 min com CPU livre levou de 24 a 30 min. Teste que mede relogio reprova nessa hora sem que
+ * o codigo tenha mudado. O verify passa a medir o steal na janela de cada comando e da rodada e a
+ * gravar a medida no `verify_run`; a reprovacao de teste com relogio sob steal acima de 40% vira
+ * `verify.timeout` (o retry reexecuta), nunca regressao.
+ *
+ * A linha agregada `cpu` do `/proc/stat` traz, em jiffies desde o boot: user, nice, system, idle,
+ * iowait, irq, softirq, steal, guest e guest_nice. guest e guest_nice ja estao contados em user e
+ * nice, entao o total da janela soma so os oito primeiros.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lerProcStat = exports.FONTE_STEAL = exports.LIMIAR_STEAL_PCT = void 0;
+exports.amostraDoProcStat = amostraDoProcStat;
+exports.stealDaJanela = stealDaJanela;
+exports.abrirJanela = abrirJanela;
+exports.reprovacaoSoDeRelogio = reprovacaoSoDeRelogio;
+exports.stealAlto = stealAlto;
+const node_fs_1 = require("node:fs");
+/** Limiar da recomendada da RM-037: acima dele, o relogio do teste nao julga o codigo. */
+exports.LIMIAR_STEAL_PCT = 40;
+exports.FONTE_STEAL = '/proc/stat';
+const lerProcStat = () => {
+    try {
+        return (0, node_fs_1.readFileSync)(exports.FONTE_STEAL, 'utf8');
+    }
+    catch {
+        return null;
+    }
+};
+exports.lerProcStat = lerProcStat;
+/** A linha `cpu ` (agregada) do `/proc/stat`. Kernel antigo, sem a coluna de steal, nao tem medida. */
+function amostraDoProcStat(conteudo) {
+    if (!conteudo)
+        return null;
+    const linha = conteudo.split('\n').find((l) => /^cpu\s/.test(l));
+    if (!linha)
+        return null;
+    const campos = linha.trim().split(/\s+/).slice(1).map(Number);
+    if (campos.length < 8 || campos.slice(0, 8).some((n) => !Number.isFinite(n) || n < 0))
+        return null;
+    const total = campos.slice(0, 8).reduce((s, n) => s + n, 0);
+    return { steal: campos[7], total };
+}
+/** Steal da janela entre duas amostras, em porcentagem com uma casa. Janela vazia nao tem medida. */
+function stealDaJanela(inicio, fim) {
+    if (!inicio || !fim)
+        return null;
+    const total = fim.total - inicio.total;
+    const steal = fim.steal - inicio.steal;
+    if (total <= 0 || steal < 0)
+        return null;
+    return Math.round((steal / total) * 1000) / 10;
+}
+/** Abre a janela agora; `fechar()` devolve o steal dela (ou `null` sem medida). */
+function abrirJanela(leitor = exports.lerProcStat) {
+    const inicio = amostraDoProcStat(leitor());
+    return { fechar: () => stealDaJanela(inicio, amostraDoProcStat(leitor())) };
+}
+/**
+ * A reprovacao do comando e so de teste com relogio? Todo teste que caiu precisa ser de relogio:
+ * pela assinatura de prazo do runner (estouro do teste ou cancelado pelo pai que estourou) ou pelo
+ * registro de instabilidade. Comando sem teste nomeado (build, tsc, script) nunca entra.
+ */
+function reprovacaoSoDeRelogio(falhas, registro = new Set()) {
+    if (!falhas || falhas.length === 0)
+        return null;
+    const todas = falhas.every((f) => f.relogio || registro.has(f.nome));
+    return todas ? falhas.map((f) => f.nome) : null;
+}
+/** Steal acima do limiar? A medida ausente nunca atenua nada. */
+function stealAlto(pct) {
+    return typeof pct === 'number' && pct > exports.LIMIAR_STEAL_PCT;
+}

package/dist/thread-close.js

@@ -48,6 +48,7 @@ const estado_thread_1 = require("./estado-thread");
 const util_1 = require("./util");
 const fabrica_publicar_1 = require("./fabrica-publicar");
 const fechamento_1 = require("./fechamento");
+const locale_1 = require("./locale");
 function validarArtefato(raiz, arquivo, sha256) {
     if (!/^[a-f0-9]{64}$/.test(sha256))
         throw new Error('sha256 inválido');
@@ -80,10 +81,10 @@ function provaDeEntrega(raiz, id) {
 function exigirEntrega(raiz, id) {
     const t = (0, thread_1.lerThread)(raiz, id);
     if (t.fechamentoAdmin)
-        throw new Error('thread encerrada administrativamente não pode receber MASTER');
+        throw new locale_1.ErroDoCatalogo((m) => m.master.encerradaAdmin);
     const prova = provaDeEntrega(raiz, id);
     if (!prova)
-        throw new Error('MASTER exige entrega: ship_done ou artefato existente com hash verificado');
+        throw new locale_1.ErroDoCatalogo((m) => m.master.exigeEntrega);
     return prova;
 }
 function registrarArtefato(raiz, id, arquivo, sha256, por) {