@orkastery/cli 0.5.3 → 0.6.0

package/dist/adapters/codex.js

@@ -48,6 +48,7 @@ exports.montarComando = montarComando;
 exports.extrairThreadId = extrairThreadId;
 exports.acharRollout = acharRollout;
 exports.parseRateLimitCodex = parseRateLimitCodex;
+exports.ambienteDoFilho = ambienteDoFilho;
 exports.despachar = despachar;
 exports.logs = logs;
 const codex_controller_1 = require("./codex-controller");
@@ -58,6 +59,7 @@ const util_1 = require("../util");
 const runtime_ambiente_1 = require("../runtime-ambiente");
 const claude_bg_1 = require("./claude-bg");
 const runtime_profiles_1 = require("../runtime-profiles");
+const locale_1 = require("../locale");
 exports.NOME_ADAPTER = 'codex';
 /**
  * Variaveis que REDIRECIONAM o codex para um provider pago por token.
@@ -113,11 +115,12 @@ function casaDoCodex(perfil) {
  */
 function conferirAuth(perfil) {
     let ambiente;
+    // RM-061 (F3b, GO-FIX 1): o erro do catalogo fica registrado, e a impressao o remonta.
     try {
         ambiente = ambienteDoDespacho(process.env, perfil);
     }
     catch (e) {
-        return { ok: false, detalhe: e.message };
+        return { ok: false, detalhe: (0, locale_1.textoDoErro)(e) };
     }
     const r = exec('codex', ['login', 'status'], undefined, 30000, ambiente);
     // A14: sem codigo de saida (timeout, sinal ou binario ausente), a conferencia e inconclusiva.
@@ -351,6 +354,14 @@ function parseRateLimitCodex(saida, agoraMs = Date.now()) {
     const linha = (saida ?? '').split('\n').find((l) => frase.test(l)) ?? saida;
     return { resetEm: null, fonte: 'sem-horario', trecho: linha.trim().slice(0, 200) };
 }
+/**
+ * O ambiente do filho do despacho: o do processo, sem provider pago, com o contexto da condução POR
+ * CIMA. RM-052 (fatia 2, D2): a ordem importa, porque e o extra que neutraliza o `ORK_PROJETO` e o
+ * modo host herdados de quem despachou.
+ */
+function ambienteDoFilho(pedido, base = process.env) {
+    return { ...ambienteDoDespacho(base, pedido.perfil), ...(pedido.ambienteExtra ?? {}) };
+}
 /** Despacho governado exige vínculo: nenhum fallback implícito para codex exec. */
 function despachar(pedido) {
     if (!pedido.vinculo)
@@ -370,7 +381,7 @@ function despachar(pedido) {
     }
     let ambiente;
     try {
-        ambiente = { ...ambienteDoDespacho(process.env, pedido.perfil), ...(pedido.ambienteExtra ?? {}) };
+        ambiente = ambienteDoFilho(pedido);
     }
     catch (e) {
         return { ok: false, comando: [], sessionId: null, verificada: false, stdout: '', stderr: '', erro: e.message };

package/dist/agents-md.js

@@ -39,42 +39,51 @@ exports.atualizarAgentsMd = atualizarAgentsMd;
 /** Bloco de instrucoes do Orkastery em AGENTS.md, preservando todo texto humano. */
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
+const locale_1 = require("./locale");
 const util_1 = require("./util");
 exports.INICIO_AGENTS_ORK = '<!-- orkastery:begin -->';
 exports.FIM_AGENTS_ORK = '<!-- orkastery:end -->';
 function seguro(valor) {
     return valor.replace(/[\r\n\0`]+/g, ' ').trim();
 }
-function blocoAgentsMd(manifesto) {
+/**
+ * O bloco do `ork init` no `AGENTS.md`. RM-061 (F3a, D1 e D2): o texto sai na lingua pedida, pela familia `gerados`
+ * do catalogo; os marcadores, o titulo e as verificacoes do manifesto sao os mesmos nas duas linguas. Sem locale,
+ * pt-BR: so o `ork init` passa a lingua do dono.
+ */
+function blocoAgentsMd(manifesto, locale = locale_1.LOCALE_PADRAO) {
+    const t = (0, locale_1.msg)(locale).gerados.agents;
     const comandos = Object.entries(manifesto.verify)
         .filter((item) => typeof item[1] === 'string' && item[1].trim() !== '')
         .map(([nome, comando]) => `- ${seguro(nome)}: \`${seguro(comando)}\``);
+    const modos = manifesto.conduction.allowed_modes.map(m => `#${m[0].toUpperCase()}${m.slice(1)}`).join(', ');
     return `${exports.INICIO_AGENTS_ORK}
 ## Orkastery
 
-Projeto: **${seguro(manifesto.project.name)}** (${seguro(manifesto.project.abbrev)}). Branch base: \`${seguro(manifesto.worktree.base_branch)}\`.
+${t.projeto(seguro(manifesto.project.name), seguro(manifesto.project.abbrev), seguro(manifesto.worktree.base_branch))}
 
-- Comece com \`ork doctor\`, \`ork onboarding\` e \`ork thread status <thread>\`.
-- Conduza o ciclo GOAL → PLAN → GO → CHECK → SHIP → MASTER pelo \`ork\`.
-- Respeite o modo da thread: ${manifesto.conduction.allowed_modes.map(m => `#${m[0].toUpperCase()}${m.slice(1)}`).join(', ')}.
-- Edite produto somente na worktree vinculada; estado em \`.orkastery/\` pertence ao núcleo.
-- PLAN não implementa. GO usa commits atômicos. CHECK não corrige. SHIP acontece por \`ork ship\`.
-- Toda alegação exige claim e comando reproduzível; self-report não é evidência.
-- MASTER por omissão só da sua thread: \`ork master <thread> --aceitar-omissao\`; sem a thread, fecha também as entregas de outras frentes.
-${comandos.length ? `\nVerificações do manifesto:\n\n${comandos.join('\n')}\n` : ''}
-Este bloco é mantido por \`ork init\`. Edite livremente o restante do arquivo.
+- ${t.comece}
+- ${t.ciclo}
+- ${t.modo(modos)}
+- ${t.worktree}
+- ${t.fases}
+- ${t.claims}
+- ${t.master}
+${comandos.length ? `\n${t.verificacoes}\n\n${comandos.join('\n')}\n` : ''}
+${t.rodape}
 ${exports.FIM_AGENTS_ORK}`;
 }
-/** Cria ou substitui somente o bloco delimitado. Marcadores ambiguos recusam sem escrita. */
-function atualizarAgentsMd(raiz, manifesto) {
+/** Cria ou substitui somente o bloco delimitado, no `locale` pedido. Marcadores ambiguos recusam sem escrita. */
+function atualizarAgentsMd(raiz, manifesto, locale = locale_1.LOCALE_PADRAO) {
     const caminho = path.join(raiz, 'AGENTS.md');
     const anterior = fs.existsSync(caminho) ? fs.readFileSync(caminho, 'utf8') : '';
     const inicios = anterior.split(exports.INICIO_AGENTS_ORK).length - 1;
     const fins = anterior.split(exports.FIM_AGENTS_ORK).length - 1;
     if (inicios !== fins || inicios > 1 || (inicios === 1 && anterior.indexOf(exports.INICIO_AGENTS_ORK) > anterior.indexOf(exports.FIM_AGENTS_ORK))) {
-        throw new Error('AGENTS.md possui marcadores Orkastery ambiguos; corrija o bloco antes de rodar ork init');
+        // RM-061 (F3a): a recusa sai no locale do comando, remontada pela entrada do CLI (D14 da F2a).
+        throw new locale_1.ErroDoCatalogo((m) => m.gerados.agents.marcadoresAmbiguos);
     }
-    const bloco = blocoAgentsMd(manifesto);
+    const bloco = blocoAgentsMd(manifesto, locale);
     const proximo = inicios === 1
         ? anterior.slice(0, anterior.indexOf(exports.INICIO_AGENTS_ORK)) + bloco + anterior.slice(anterior.indexOf(exports.FIM_AGENTS_ORK) + exports.FIM_AGENTS_ORK.length)
         : anterior === '' ? bloco + '\n' : anterior + (anterior.endsWith('\n') ? '\n' : '\n\n') + bloco + '\n';

package/dist/atualizar-branch.js

@@ -0,0 +1,245 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONTRATO_DA_ATUALIZACAO = void 0;
+exports.atualizarBranchDaThread = atualizarBranchDaThread;
+exports.textoDaAtualizacao = textoDaAtualizacao;
+/**
+ * RM-063 (F7): o merge da base remota na branch da thread, com a reconciliacao deterministica do CHANGELOG.
+ *
+ * Incidente de 12 e 13/10/2026: os PRs #153 e #154 ficaram prontos e esperaram de 5 a 6 horas pelo condutor, e cada
+ * merge da outra maquina na `main` reabriu o conflito no CHANGELOG; o condutor resolvia a mao, com um script. Aqui o
+ * mesmo passo, sob a conducao da thread (`branch.atualizar`, exclusiva com despacho e verify na mesma worktree):
+ *
+ *  - traz a base remota e faz o merge dela na branch, na worktree da thread, sem commit ainda;
+ *  - conflito em qualquer arquivo que nao seja o CHANGELOG aborta o merge e volta com a lista: conflito em codigo
+ *    nunca e resolvido sozinho, e vira item da fila do dono;
+ *  - com conflito so no CHANGELOG, ou sem conflito, os itens da thread voltam a `## Não publicado`, no mesmo grupo
+ *    (`changelog-reconciliacao.ts`), e o merge e commitado;
+ *  - com `enviar`, empurra a branch sem forca e prova pelo `git ls-remote`.
+ *
+ * A worktree com alteracao nao commitada, outra branch ou um merge em curso recusa antes de tocar em qualquer coisa.
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const changelog_reconciliacao_1 = require("./changelog-reconciliacao");
+const conducao_1 = require("./conducao");
+const estado_thread_1 = require("./estado-thread");
+const noctum_guarda_1 = require("./noctum-guarda");
+const procedencia_1 = require("./procedencia");
+const thread_1 = require("./thread");
+const util_1 = require("./util");
+const worktree_1 = require("./worktree");
+const locale_1 = require("./locale");
+exports.CONTRATO_DA_ATUALIZACAO = 'ork.branch-atualizada/v1';
+/** O teto do merge e do push juntos: a conducao da thread vale por isto, com folga. */
+const PRAZO_DA_ATUALIZACAO_MS = 10 * 60 * 1000;
+const AMBIENTE_DO_GIT = () => ({ ...process.env, GIT_TERMINAL_PROMPT: '0', GIT_MERGE_AUTOEDIT: 'no',
+    GIT_SSH_COMMAND: process.env.GIT_SSH_COMMAND ?? 'ssh -o BatchMode=yes' });
+/** O CHANGELOG numa revisao; `null` quando ele nao existe nela. */
+function changelogEm(dir, ref) {
+    const r = (0, util_1.exec)('git', ['show', `${ref}:${changelog_reconciliacao_1.ARQUIVO_DO_CHANGELOG}`], dir, 30000);
+    return r.ok ? r.stdout : null;
+}
+/** Os arquivos em conflito do merge em curso. */
+function emConflito(dir) {
+    const r = (0, util_1.exec)('git', ['diff', '--name-only', '--diff-filter=U', '-z'], dir, 30000);
+    return r.ok ? r.stdout.split('\0').filter(Boolean).sort() : null;
+}
+/**
+ * Faz o merge da base remota na branch da thread, sob a conducao dela. Nunca resolve conflito em codigo: aborta e
+ * devolve a lista. Recusa (com motivo tipado) antes de mexer na worktree que nao esta pronta.
+ */
+function atualizarBranchDaThread(carregado, threadId, opcoes = {}) {
+    const raiz = (0, estado_thread_1.raizDoEstado)(carregado.raiz);
+    const remoto = carregado.manifesto.fabrica.remoto, base = carregado.manifesto.worktree.base_branch;
+    const t = (0, thread_1.lerThread)(raiz, threadId);
+    const branch = (0, worktree_1.branchDaWorktree)(t);
+    const cabeca = { contrato: exports.CONTRATO_DA_ATUALIZACAO, thread: t.id, branch, base: `${remoto}/${base}` };
+    const recusa = (motivo, detalhe) => ({ ...cabeca, acao: 'recusada', motivo, detalhe });
+    // RM-058, integracao (T1.1, D3 da ork-rm058integra): a branch da thread de um arco #Noctum e atualizada pelo passo da
+    // entrega do arco, com a regra do CHANGELOG dele; por fora, nem o comando nem a batida a mesclam.
+    const guarda = (0, noctum_guarda_1.guardaDaThread)(raiz, t.id);
+    if (guarda)
+        return recusa(guarda.motivo, guarda.texto);
+    let dir;
+    try {
+        dir = (0, procedencia_1.diretorioDaThread)(raiz, t);
+    }
+    catch (e) {
+        return recusa('worktree-ausente', e.message);
+    }
+    if (!t.worktree || !fs.existsSync(dir))
+        return recusa('worktree-ausente', `a thread ${t.id} não tem worktree nesta máquina`);
+    try {
+        // A sessao despachada que conduz a thread reentra pela identidade de despacho dela, como o `ork verify` (R3).
+        return (0, conducao_1.comConducao)(raiz, t.id, { canal: opcoes.canal ?? 'cli', correlacao: opcoes.correlacao ?? null, operacao: 'branch.atualizar',
+            fase: null, promptSha256: null, prazoMs: PRAZO_DA_ATUALIZACAO_MS, identidade: (0, conducao_1.identidadeDoAmbiente)(t.id, process.env, raiz),
+            ...(opcoes.esperarMs ? { esperarMs: opcoes.esperarMs } : {}) }, () => mesclar(dir, branch, remoto, base, opcoes, cabeca, recusa));
+    }
+    catch (e) {
+        if (e instanceof conducao_1.ErroDeConducao)
+            return recusa('conduzida', e.recusa.texto.split('\n').slice(0, 2).join(' '));
+        throw e;
+    }
+}
+function mesclar(dir, branch, remoto, base, opcoes, cabeca, recusa) {
+    const env = AMBIENTE_DO_GIT();
+    const git = (args, prazo = 60000) => (0, util_1.exec)('git', args, dir, prazo, env);
+    const atual = git(['rev-parse', '--abbrev-ref', 'HEAD']);
+    if (!atual.ok)
+        return recusa('git-sem-resposta', `git rev-parse saiu ${atual.code}: ${atual.stderr.trim().slice(0, 160)}`);
+    if (atual.stdout.trim() !== branch)
+        return recusa('branch-errada', `a worktree está na branch ${atual.stdout.trim()}, e a da thread é ${branch}`);
+    if (git(['rev-parse', '-q', '--verify', 'MERGE_HEAD']).ok)
+        return recusa('merge-em-curso', 'há um merge em curso na worktree');
+    const status = git(['status', '--porcelain', '--', '.', ':(exclude).orkastery']);
+    if (!status.ok)
+        return recusa('git-sem-resposta', `git status saiu ${status.code}`);
+    if (status.stdout.trim())
+        return recusa('worktree-suja', 'a worktree tem alteração não commitada; o merge não vai por cima dela');
+    if (opcoes.buscar !== false) {
+        const f = git(['fetch', '-q', '--no-tags', '--', remoto, `+refs/heads/${base}:refs/remotes/${remoto}/${base}`], 120000);
+        if (!f.ok)
+            return recusa('git-sem-resposta', `git fetch ${remoto} ${base} saiu ${f.error ?? f.code}: ${f.stderr.trim().split('\n')[0]?.slice(0, 160) ?? ''}`);
+    }
+    const deles = `refs/remotes/${remoto}/${base}`;
+    const ponta = git(['rev-parse', '--verify', '-q', `${deles}^{commit}`]);
+    if (!ponta.ok)
+        return recusa('base-ausente', `a cópia da base ${remoto}/${base} não existe neste repositório`);
+    if (opcoes.alinharCom && git(['rev-parse', 'HEAD']).stdout.trim() !== opcoes.alinharCom) {
+        if (!git(['merge-base', '--is-ancestor', 'HEAD', opcoes.alinharCom]).ok) {
+            return recusa('branch-desalinhada', `a branch local divergiu do head do PR (${opcoes.alinharCom.slice(0, 8)}): o merge não vai por cima`);
+        }
+        const ff = git(['merge', '--ff-only', '-q', opcoes.alinharCom], 120000);
+        if (!ff.ok)
+            return recusa('git-sem-resposta', `git merge --ff-only saiu ${ff.code}: ${(ff.stderr || ff.stdout).trim().split('\n')[0]?.slice(0, 160) ?? ''}`);
+    }
+    const shaAntes = git(['rev-parse', 'HEAD']).stdout.trim();
+    // O push nunca leva tag (push.followTags do usuario poria a tag de versao no remoto e dispararia a publicacao) nem forca.
+    const empurrar = (sha) => {
+        const p = git(['push', '-q', '--no-follow-tags', '--', remoto, `HEAD:refs/heads/${branch}`], 120000);
+        const remota = git(['ls-remote', '--', remoto, `refs/heads/${branch}`], 60000).stdout.split(/\s+/)[0] ?? '';
+        return p.ok && remota === sha ? null : `o merge ${sha.slice(0, 8)} ficou só nesta máquina: git push saiu ${p.code}` +
+            (remota ? `, e o remoto está em ${remota.slice(0, 8)}` : '');
+    };
+    if (git(['merge-base', '--is-ancestor', deles, 'HEAD']).ok) {
+        // Ja contem a base. Com `enviar`, a branch remota atras da local (o push que falhou na rodada anterior) e empurrada;
+        // a remota que andou para outro lado nao e sobrescrita.
+        let enviada = false;
+        if (opcoes.enviar) {
+            const remota = git(['ls-remote', '--', remoto, `refs/heads/${branch}`], 60000).stdout.split(/\s+/)[0] ?? '';
+            if (remota !== shaAntes) {
+                if (remota && !git(['merge-base', '--is-ancestor', remota, 'HEAD']).ok) {
+                    return recusa('push-recusado', `o remoto da ${branch} está em ${remota.slice(0, 8)}, fora da história local: nada é empurrado por cima`);
+                }
+                const falha = empurrar(shaAntes);
+                if (falha)
+                    return recusa('push-recusado', falha);
+                enviada = true;
+            }
+        }
+        return { ...cabeca, acao: 'ja-atualizada', sha: shaAntes, enviada };
+    }
+    const m = git(['merge', '--no-ff', '--no-commit', '--', deles], 120000);
+    const conflitos = emConflito(dir);
+    if (conflitos === null) {
+        git(['merge', '--abort']);
+        return recusa('git-sem-resposta', 'o git não disse os arquivos em conflito');
+    }
+    if (!m.ok && !git(['rev-parse', '-q', '--verify', 'MERGE_HEAD']).ok) {
+        return recusa('git-sem-resposta', `git merge saiu ${m.code}: ${(m.stderr || m.stdout).trim().split('\n')[0]?.slice(0, 160) ?? ''}`);
+    }
+    const emCodigo = conflitos.filter((a) => a !== changelog_reconciliacao_1.ARQUIVO_DO_CHANGELOG);
+    if (emCodigo.length) {
+        git(['merge', '--abort']);
+        return { ...cabeca, acao: 'conflito-em-codigo', arquivos: emCodigo };
+    }
+    // O CHANGELOG: os itens da thread voltam a "Não publicado", no mesmo grupo, com ou sem conflito nele.
+    let changelog = null;
+    const arquivo = path.join(dir, changelog_reconciliacao_1.ARQUIVO_DO_CHANGELOG);
+    const nosso = changelogEm(dir, 'HEAD'), delesTexto = changelogEm(dir, deles);
+    if (nosso !== null && delesTexto !== null) {
+        const mb = git(['merge-base', 'HEAD', deles]);
+        const baseTexto = mb.ok ? changelogEm(dir, mb.stdout.trim()) ?? '' : '';
+        const conflitou = conflitos.includes(changelog_reconciliacao_1.ARQUIVO_DO_CHANGELOG);
+        const mesclado = conflitou ? null : fs.readFileSync(arquivo, 'utf8');
+        const r = (0, changelog_reconciliacao_1.reconciliarChangelog)({ base: baseTexto, nosso, deles: delesTexto, mesclado });
+        // A reconciliacao so devolve itens de lista; a linha que a thread acrescentou e nao voltou (outra forma de item,
+        // edicao numa versao publicada) nunca some calada: o merge e abortado e fica com o dono.
+        if ((0, changelog_reconciliacao_1.temMarcadorDeConflito)(r.texto) || r.perdidas.length) {
+            git(['merge', '--abort']);
+            return { ...cabeca, acao: 'conflito-em-codigo', arquivos: [changelog_reconciliacao_1.ARQUIVO_DO_CHANGELOG] };
+        }
+        if (conflitou || r.texto !== mesclado) {
+            fs.writeFileSync(arquivo, r.texto, 'utf8');
+            if (!git(['add', '--', changelog_reconciliacao_1.ARQUIVO_DO_CHANGELOG]).ok) {
+                git(['merge', '--abort']);
+                return recusa('git-sem-resposta', 'git add do CHANGELOG falhou');
+            }
+        }
+        changelog = { devolvidos: r.devolvidos, itens: r.itens };
+    }
+    else if (conflitos.includes(changelog_reconciliacao_1.ARQUIVO_DO_CHANGELOG)) {
+        git(['merge', '--abort']);
+        return { ...cabeca, acao: 'conflito-em-codigo', arquivos: [changelog_reconciliacao_1.ARQUIVO_DO_CHANGELOG] };
+    }
+    const titulo = `Merge da ${remoto}/${base} na ${branch}` +
+        (changelog?.devolvidos ? `: ${changelog.devolvidos} item(ns) da thread de volta a "Não publicado" do CHANGELOG` : '');
+    const c = git(['commit', '-q', '--no-edit', '-m', titulo], 120000);
+    if (!c.ok) {
+        git(['merge', '--abort']);
+        return recusa('git-sem-resposta', `git commit do merge saiu ${c.code}: ${(c.stderr || c.stdout).trim().split('\n')[0]?.slice(0, 160) ?? ''}`);
+    }
+    const sha = git(['rev-parse', 'HEAD']).stdout.trim();
+    let enviada = false;
+    if (opcoes.enviar) {
+        const falha = empurrar(sha);
+        if (falha)
+            return recusa('push-recusado', falha);
+        enviada = true;
+    }
+    return { ...cabeca, acao: 'mesclada', sha, shaAntes, changelog, enviada };
+}
+/** Uma linha para o terminal e para o resumo ao dono. */
+function textoDaAtualizacao(r) {
+    const m = (0, locale_1.msg)().conducao.atualizacao;
+    switch (r.acao) {
+        case 'ja-atualizada': return m.atualizada(r.branch, r.base, r.enviada);
+        case 'mesclada': return m.mesclada(r.base, r.branch, r.sha.slice(0, 8), r.changelog?.devolvidos ?? 0, r.enviada);
+        case 'conflito-em-codigo': return m.conflito(r.base, r.branch, r.arquivos.join(', '));
+        default: return m.recusada(r.branch, r.motivo, r.detalhe);
+    }
+}

package/dist/auditoria.js

@@ -78,6 +78,7 @@ const gates_1 = require("./gates");
 const prompts_1 = require("./prompts");
 const util_1 = require("./util");
 const horario_1 = require("./horario");
+const locale_1 = require("./locale");
 // ---------------------------------------------------------------------------
 // Motivos tipados da auditoria
 // ---------------------------------------------------------------------------
@@ -476,9 +477,10 @@ function packAtivo(pack, estagio) {
 }
 /** Tabela de `ork audit packs`. */
 function tabelaDePacks(estagio) {
+    const m = (0, locale_1.msg)().audit.packs;
     const linhas = exports.ORDEM_DOS_PACKS.map((id) => {
         const p = exports.PACKS[id];
-        const ativo = estagio ? (packAtivo(id, estagio) ? 'sim' : 'nao') : '-';
+        const ativo = estagio ? (packAtivo(id, estagio) ? m.sim : m.nao) : '-';
         return [
             p.id,
             p.estagioMinimo,
@@ -489,31 +491,31 @@ function tabelaDePacks(estagio) {
             p.titulo,
         ];
     });
-    const cabecalho = (0, util_1.tabela)(['PACK', 'ATIVO A PARTIR DE', 'ATIVO AQUI', 'FONTE', 'REGRAS', 'POSTURA', 'TITULO'], linhas);
-    const rodape = ['', 'Hardening por estagio (visao, secao 5.2):'];
+    const cabecalho = (0, util_1.tabela)([...m.cabecalho], linhas);
+    const rodape = ['', m.hardening];
     for (const e of exports.ORDEM_DOS_ESTAGIOS) {
         rodape.push(`  ${e.padEnd(10)} ${packsAtivos(e).join(', ')}` +
-            `\n  ${' '.repeat(10)} postura: ${exports.DESCRICAO_DA_POSTURA[exports.POSTURA_DO_ESTAGIO[e]]}`);
+            `\n  ${' '.repeat(10)} ${m.posturaLinha(exports.DESCRICAO_DA_POSTURA[exports.POSTURA_DO_ESTAGIO[e]])}`);
     }
     return cabecalho + '\n' + rodape.join('\n');
 }
 /** Detalhe de um pack: as regras e as evidencias que ele exige. */
 function textoDoPack(pack, estagio) {
     const p = exports.PACKS[pack];
+    const m = (0, locale_1.msg)().audit.packs.detalhe;
     const linhas = [];
-    linhas.push(`Pack ${p.id}: ${p.titulo}`);
+    linhas.push(m.titulo(p.id, p.titulo));
     linhas.push(`  ${p.objetivo}`);
-    linhas.push(`  ativo a partir do estagio: ${p.estagioMinimo}`);
-    linhas.push(`  fonte de evidencia: ${p.fonte === 'ledger' ? 'ledger e MASTER logs' : 'arvore de codigo'}`);
+    linhas.push(m.ativoDesde(p.estagioMinimo));
+    linhas.push(m.fonte(p.fonte === 'ledger' ? m.fonteLedger : m.fonteCodigo));
     if (estagio) {
-        linhas.push(`  neste projeto (stage ${estagio}): ${packAtivo(pack, estagio) ? 'ATIVO' : 'inativo'}` +
-            (packAtivo(pack, estagio) ? `, postura ${posturaDoPack(estagio)}` : ''));
+        linhas.push(m.nesteProjeto(estagio, packAtivo(pack, estagio), posturaDoPack(estagio)));
     }
     linhas.push('');
-    linhas.push('  Regras auditadas:');
+    linhas.push(m.regras);
     for (const r of p.regras) {
         linhas.push(`    ${r.id}  ${r.regra}`);
-        linhas.push(`         evidencia: ${r.evidencia}`);
+        linhas.push(m.evidencia(r.evidencia));
     }
     linhas.push('');
     linhas.push('  Evidencias da rodada:');