@orkastery/cli 0.5.6 → 0.6.0

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:');

package/dist/auditrun.js

@@ -87,6 +87,7 @@ const thread_1 = require("./thread");
 const util_1 = require("./util");
 const verify_1 = require("./verify");
 const horario_1 = require("./horario");
+const locale_1 = require("./locale");
 /** Versao do formato de `run.json`. */
 exports.VERSAO_DA_RODADA = 1;
 /** Diretorio das rodadas de auditoria do projeto. */
@@ -759,9 +760,10 @@ function relatorioDaRodada(carregado, rodadaId, opcoes = {}) {
 // ---------------------------------------------------------------------------
 /** Tabela de `ork audit list`. */
 function tabelaDeRodadas(raiz) {
+    const m = (0, locale_1.msg)().audit.rodadas;
     const ids = listarRodadas(raiz);
     if (ids.length === 0) {
-        return 'Nenhuma rodada de auditoria em .orkastery/audits. Rode: ork audit run <pack>';
+        return m.vazia;
     }
     const linhas = ids.map((id) => {
         const r = lerRodada(raiz, id);
@@ -773,92 +775,93 @@ function tabelaDeRodadas(raiz) {
             r.status,
             r.motivo ?? '-',
             String(r.achados.length),
-            r.veredito ? (r.veredito.ok ? 'sustentado' : 'REPROVADO') : 'nao verificado',
+            r.veredito ? (r.veredito.ok ? m.sustentado : m.reprovado) : m.naoVerificado,
             r.escopo.since ?? 'total',
         ];
     });
-    return (0, util_1.tabela)(['RODADA', 'PACK', 'PERFIL', 'ESTAGIO', 'STATUS', 'MOTIVO', 'ACHADOS', 'CLAIMS', 'ESCOPO'], linhas);
+    return (0, util_1.tabela)([...m.cabecalho], linhas);
 }
 /** Texto de `ork audit show`. */
 function textoDaRodada(raiz, id) {
     const r = lerRodada(raiz, id);
     const achados = (0, divida_1.achadosDaRodada)(raiz, id);
     const L = [];
-    L.push(`Rodada de auditoria ${r.id}`);
-    L.push(`  pack        ${r.pack} (${auditoria_1.PACKS[r.pack].titulo})`);
-    L.push(`  produto     ${r.produto} (perfil ${r.perfil})`);
-    L.push(`  estagio     ${r.estagio}, postura ${r.postura}`);
-    L.push(`  escopo      ${r.escopo.detalhe}`);
-    L.push(`  graphify    ${r.escopo.graphify}`);
-    L.push(`  custo       effort ${r.custo.effort}, model ${r.custo.model}`);
-    L.push(`  janela      ${r.custo.janela.detalhe}`);
+    const m = (0, locale_1.msg)().audit.rodadas;
+    L.push(m.titulo(r.id));
+    L.push(m.campo(m.campos.pack, `${r.pack} (${auditoria_1.PACKS[r.pack].titulo})`));
+    L.push(m.campo(m.campos.produto, `${r.produto} ${m.perfil(r.perfil)}`));
+    L.push(m.campo(m.campos.estagio, `${r.estagio}, ${m.postura(r.postura)}`));
+    L.push(m.campo(m.campos.escopo, r.escopo.detalhe));
+    L.push(m.campo(m.campos.graphify, r.escopo.graphify));
+    L.push(m.campo(m.campos.custo, m.custo(r.custo.effort, r.custo.model)));
+    L.push(m.campo(m.campos.janela, r.custo.janela.detalhe));
     if (r.custo.autorizadaPor)
-        L.push(`  autorizada  fora da janela por ${r.custo.autorizadaPor}`);
-    L.push(`  runtime     ${r.runtime}, sessao ${r.sessionId ?? '(nao despachada)'}`);
-    L.push(`  prompt      ${r.promptPath} (sha256 ${r.promptSha256 || '(nao montado)'})`);
-    L.push(`  status      ${r.status}${r.motivo ? ` (motivo tipado: ${r.motivo})` : ''}`);
+        L.push(m.campo(m.campos.autorizada, m.autorizada(r.custo.autorizadaPor)));
+    L.push(m.campo(m.campos.runtime, `${r.runtime}, ${m.detalhes.sessao(r.sessionId ?? m.sessaoAusente)}`));
+    L.push(m.campo(m.campos.prompt, `${r.promptPath} (sha256 ${r.promptSha256 || m.promptAusente})`));
+    L.push(m.campo(m.campos.status, `${r.status}${r.motivo ? ` ${m.motivo(r.motivo)}` : ''}`));
     if (r.superficie) {
-        L.push(`  superficie  ${r.superficie.detalhe}`);
-        L.push(`              registrados ${r.superficie.registrados}, a confirmar ${r.superficie.aConfirmar}, ` +
-            `frameworks: ${r.superficie.frameworks.join(', ') || '(nenhum reconhecido)'}`);
+        L.push(m.campo(m.campos.superficie, r.superficie.detalhe));
+        L.push(`              ${m.superficieResumo(r.superficie.registrados, r.superficie.aConfirmar, r.superficie.frameworks.join(', ') || m.nenhumFramework)}`);
     }
     if (r.detalhe)
-        L.push(`  detalhe     ${r.detalhe}`);
+        L.push(m.campo(m.campos.detalhe, r.detalhe));
     L.push('');
-    L.push(`  Achados (${achados.length}):`);
+    L.push(m.achados(achados.length));
     if (achados.length === 0)
-        L.push('    (nenhum achado registrado nesta rodada ainda)');
+        L.push(m.nenhumAchado);
     for (const a of achados)
         L.push((0, divida_1.textoDoAchado)(a));
     L.push('');
     if (r.veredito) {
-        L.push(`  Claims do auditor: ${r.veredito.ok ? 'SUSTENTADAS' : 'REPROVADAS'} ` +
-            `(motivos: ${r.veredito.motivos.join(', ') || 'nenhum'}) no HEAD ${(0, util_1.shaCurto)(r.veredito.commit)}`);
+        L.push(m.claims(r.veredito.ok, r.veredito.motivos.join(', '), (0, util_1.shaCurto)(r.veredito.commit)));
     }
     else {
-        L.push(`  Claims do auditor: NAO verificadas. Rode: ork audit verify ${r.id}`);
+        L.push(m.claimsPendentes(r.id));
     }
     L.push('');
-    L.push(`  Relatorio com o bloco de propostas: ork audit report ${r.id}`);
+    L.push(m.relatorio(r.id));
     return L.join('\n');
 }
 /** Ledger de uma rodada, para `ork audit show --ledger`. */
 function tabelaDoLedgerDaRodada(raiz, id) {
+    const m = (0, locale_1.msg)().audit.rodadas;
     lerRodada(raiz, id);
     const eventos = (0, ledger_1.lerLedger)(dirRodada(raiz, id));
     if (eventos.length === 0)
-        return `Ledger vazio para a rodada ${id}.`;
+        return m.ledgerVazio(id);
     const linhas = eventos.map((e) => {
         const detalhe = [];
         if (e.pack)
             detalhe.push(String(e.pack));
         if (e.achado)
-            detalhe.push(`achado ${String(e.achado)}`);
+            detalhe.push(m.detalhes.achado(String(e.achado)));
         if (e.motivo)
-            detalhe.push(`motivo ${String(e.motivo)}`);
+            detalhe.push(m.detalhes.motivo(String(e.motivo)));
         if (e.sessionId)
-            detalhe.push(`sessao ${String(e.sessionId).slice(0, 8)}`);
+            detalhe.push(m.detalhes.sessao(String(e.sessionId).slice(0, 8)));
         if (e.veredito)
-            detalhe.push(`veredito: ${String(e.veredito)}`);
+            detalhe.push(m.detalhes.veredito(String(e.veredito)));
         if (e.destino)
-            detalhe.push(`destino ${String(e.destino)}`);
+            detalhe.push(m.detalhes.destino(String(e.destino)));
         // `e.thread` e o dono do evento, que aqui e a propria rodada: so vale imprimir quando
         // for OUTRO id, que e o caso do evento finding_to_thread.
         if (e.thread && e.thread !== id)
-            detalhe.push(`thread ${String(e.thread)}`);
+            detalhe.push(m.detalhes.thread(String(e.thread)));
         if (e.detalhe)
             detalhe.push((0, horario_1.localizarTexto)(String(e.detalhe)).slice(0, 90));
         return [(0, horario_1.formatarDataHora)(e.ts, { segundos: true }), e.tipo, detalhe.join(' | ')];
     });
-    return `${(0, util_1.tabela)(['QUANDO', 'EVENTO', 'DETALHE'], linhas)}\n${(0, horario_1.legendaDoFuso)()}`;
+    return `${(0, util_1.tabela)([...m.ledgerCabecalho], linhas)}\n${(0, horario_1.legendaDoFuso)()}`;
 }
 /** Quantos achados abertos existem por pack, para o resumo do CLI. */
 function resumoDoBoard(raiz) {
+    const m = (0, locale_1.msg)().audit.rodadas;
     const board = (0, divida_1.lerBoard)(raiz);
     if (board.length === 0)
-        return 'board de divida vazio';
+        return m.boardVazio;
     const abertos = board.filter((a) => a.estado === 'aberto').length;
-    return `${board.length} achado(s) no board de divida, ${abertos} aberto(s)`;
+    return m.board(board.length, abertos);
 }
 /**
  * Abre a thread que nasce de um achado de auditoria.
@@ -872,7 +875,10 @@ function resumoDoBoard(raiz) {
 function abrirThreadDoAchado(carregado, achadoId, opcoes = {}) {
     const { raiz, manifesto } = carregado;
     const achado = (0, divida_1.exigirAchado)(raiz, achadoId);
-    const pedido = (0, divida_1.pedidoDoAchado)(achado);
+    // RM-061 F3c: o pedido vai a arquivo (pedido-goal.md e achado.json) e vira o --prompt do GOAL: e dado, na lingua
+    // declarada do dono, nunca na de quem roda nem conforme o --json. So o resultado impresso segue o locale ativo.
+    const pedido = (0, locale_1.comLocale)((0, locale_1.linguaDeclaradaDoDono)(manifesto.owner?.language), () => (0, divida_1.pedidoDoAchado)(achado));
+    const m = (0, locale_1.msg)().thread.fromFinding;
     if (achado.estado === 'virou-thread' && achado.thread) {
         return {
             ok: false,
@@ -880,8 +886,8 @@ function abrirThreadDoAchado(carregado, achadoId, opcoes = {}) {
             thread: null,
             pedido,
             motivo: 'achado.ja-virou-thread',
-            detalhe: `o achado ${achado.id} ja originou a thread ${achado.thread}`,
-            correcao: `continue naquela thread: ork thread status ${achado.thread}`,
+            detalhe: m.jaVirouThread(achado.id, achado.thread),
+            correcao: m.continueNaThread(achado.thread),
         };
     }
     if (achado.claim.estado === 'pendente') {
@@ -891,9 +897,8 @@ function abrirThreadDoAchado(carregado, achadoId, opcoes = {}) {
             thread: null,
             pedido,
             motivo: 'claims.failed',
-            detalhe: `a claim ${achado.claim.id} do achado ainda nao foi reexecutada no HEAD real: ` +
-                'o auditor nao tem direito a self-report',
-            correcao: `prove o achado antes de abrir trabalho: ork audit verify ${achado.rodada}`,
+            detalhe: m.claimPendente(achado.claim.id),
+            correcao: m.proveOAchado(achado.rodada),
         };
     }
     if (achado.claim.estado === 'reprovado') {
@@ -903,8 +908,8 @@ function abrirThreadDoAchado(carregado, achadoId, opcoes = {}) {
             thread: null,
             pedido,
             motivo: 'claims.failed',
-            detalhe: `a claim ${achado.claim.id} do achado REPROVOU na reexecucao no HEAD real`,
-            correcao: 'o achado nao se sustenta: corrija a evidencia na rodada, ou descarte o achado, em vez de abrir thread sobre ele',
+            detalhe: m.claimReprovada(achado.claim.id),
+            correcao: m.descarteOAchado,
         };
     }
     const modo = opcoes.modo ?? manifesto.conduction.default_mode;
@@ -928,7 +933,7 @@ function abrirThreadDoAchado(carregado, achadoId, opcoes = {}) {
             worktreePor,
             worktreeFalharia,
             motivo: null,
-            detalhe: 'simulacao (--dry-run): nenhuma thread e nenhum carimbo no board foram gravados',
+            detalhe: m.simulacaoDetalhe,
             correcao: '',
         };
     }
@@ -989,8 +994,8 @@ function abrirThreadDoAchado(carregado, achadoId, opcoes = {}) {
         worktreePor,
         motivo: achado.claim.estado === 'nao-verificavel' ? 'claims.unverifiable' : null,
         detalhe: achado.claim.estado === 'nao-verificavel'
-            ? `AVISO: a claim ${achado.claim.id} do achado nao tem comando de verificacao (motivo tipado claims.unverifiable, que avisa e nao bloqueia)`
-            : `achado ${achado.id} aberto como thread ${thread.id}, com a evidencia e a claim junto`,
+            ? m.claimSemComando(achado.claim.id)
+            : m.achadoAberto(achado.id, thread.id),
         correcao: '',
     };
 }