@orkastery/cli 0.5.3 → 0.6.0

package/dist/sessoes.js

@@ -54,24 +54,26 @@ const util_1 = require("./util");
 const estado_thread_1 = require("./estado-thread");
 const ledger_1 = require("./ledger");
 const thread_1 = require("./thread");
+const locale_1 = require("./locale");
 function textoDoInventario(r) {
+    const m = (0, locale_1.msg)().operacao.restante.sessions.inventario;
     const linhas = [
-        `Inventário ${r.escopo.global ? 'global' : 'do projeto'} da conta ${r.escopo.usuario}; histórico: ${r.escopo.historico ? 'incluído' : 'omitido'}.`,
-        `Fontes: ${r.fontes.map(f => `${f.origem} (${f.ausente ? 'ausente' : f.ok ? 'ok' : 'FALHA'})`).join('; ')}`,
-        `Total: ${r.total}; sem thread: ${r.semThread}; ambíguas: ${r.ambiguas}; fantasmas: ${r.fantasmas}; consulta: ${r.ok ? 'válida' : 'INCOMPLETA'}.`,
+        m.abertura(r.escopo.global, r.escopo.usuario, r.escopo.historico),
+        m.fontes(r.fontes.map(f => `${f.origem} (${f.ausente ? m.fonteEstado.ausente : f.ok ? m.fonteEstado.ok : m.fonteEstado.falha})`).join('; ')),
+        m.resumo(r.total, r.semThread, r.ambiguas, r.fantasmas, r.ok),
     ];
     // RM-056 (D4): a coluna PERFIL e o id do perfil (`processo` sem perfil), nunca o diretorio da conta.
     if (r.sessoes.length)
-        linhas.push((0, util_1.tabela)(['ID', 'RUNTIME', 'PERFIL', 'ESTADO', 'THREAD/FASE'], r.sessoes.map(s => [s.sessionId, s.runtime, s.perfil ?? 'processo',
-            `${s.state ?? s.status ?? 'unknown'}${s.fantasma ? ' (fantasma)' : ''}`,
-            s.vinculos.map(v => `${v.thread}/${v.fase}`).join(', ') || '(fora do ork)'])));
+        linhas.push((0, util_1.tabela)([...m.colunas], r.sessoes.map(s => [s.sessionId, s.runtime, s.perfil ?? m.processo,
+            `${s.state ?? s.status ?? m.desconhecido}${s.fantasma ? ` (${m.fantasma})` : ''}`,
+            s.vinculos.map(v => `${v.thread}/${v.fase}`).join(', ') || m.fora])));
     if (r.fantasmas > 0)
-        linhas.push('Fantasma: registro sem processo vivo, não ocupa vaga; `ork sessions limpar-fantasmas` solta o vínculo do ork sem tocar no runtime.');
+        linhas.push(m.explicacaoFantasma);
     for (const f of r.fontes.filter(f => !f.ok))
-        linhas.push(`Falha: ${f.detalhe}`);
+        linhas.push(m.falha(f.detalhe));
     // Fatia 2 do ensaio da 0.5.0 (P1): a fonte ausente nao e falha, mas diz o que falta e como ter.
     for (const f of r.fontes.filter(f => f.ausente))
-        linhas.push(`Ausente: ${f.detalhe}${f.correcao ? `; correção: ${f.correcao}` : ''}`);
+        linhas.push(m.ausente(f.detalhe, f.correcao ?? null));
     return linhas.join('\n');
 }
 function tabelaDeSessoes(raiz, todas = false) {
@@ -83,6 +85,7 @@ function tabelaDeSessoes(raiz, todas = false) {
  * viva). So uma conta pode responder; duas viram recusa, nenhuma mantem a mensagem de antes.
  */
 function localizarSessao(chave, raiz) {
+    const m = (0, locale_1.msg)().operacao.restante.sessions.localizar;
     let perfis = [];
     const falhas = [];
     if (raiz) {
@@ -99,10 +102,9 @@ function localizarSessao(chave, raiz) {
         return { achada: r.achadas[0] };
     if (r.achadas.length > 1) {
         const contas = r.achadas.map(a => `${a.perfil?.id ?? 'processo'} (${a.sessao.sessionId})`).join(', ');
-        return { texto: `sessao "${chave}" encontrada em mais de uma conta: ${contas}; use o id completo`, codigo: 1 };
+        return { texto: m.ambigua(chave, contas), codigo: 1 };
     }
-    return { texto: `sessao "${chave}" nao encontrada no runtime` + (falhas.length ? `; contas sem resposta: ${falhas.join('; ')}` : ''),
-        codigo: 1 };
+    return { texto: m.ausente(chave, falhas.join('; ')), codigo: 1 };
 }
 /** Logs de uma sessao pelo id curto, id completo ou nome, lidos na conta onde ela esta. */
 function logsDaSessao(chave, linhas, raiz) {
@@ -120,7 +122,7 @@ function pararSessao(chave, raiz) {
         return l;
     const { sessao, perfil, ambiente } = l.achada;
     const r = adapter.pararAchada(sessao, ambiente);
-    return { texto: r.texto || `sessao ${sessao.sessionId} parada${perfil ? ` (perfil ${perfil.id})` : ''}`, codigo: r.ok ? 0 : 1 };
+    return { texto: r.texto || (0, locale_1.msg)().operacao.restante.sessions.localizar.parada(sessao.sessionId, perfil?.id ?? null), codigo: r.ok ? 0 : 1 };
 }
 /** Comando de attach (precisa de TTY, entao o CLI imprime em vez de executar). */
 function comandoDeAttach(chave, raiz) {
@@ -138,9 +140,9 @@ const ENCERRAM_A_SESSAO = ['phase_result', 'sessao_morta', 'session_superseded']
  */
 function limparFantasmas(raiz, opcoes = {}) {
     const canonica = (0, estado_thread_1.raizDoEstado)(raiz);
-    const inv = (0, sessoes_inventario_1.inventariarSessoes)(canonica, { global: true });
+    const inv = opcoes.inventario ?? (0, sessoes_inventario_1.inventariarSessoes)(canonica, { global: true });
     const itens = [];
-    for (const s of inv.sessoes.filter(x => x.fantasma)) {
+    for (const s of inv.sessoes.filter(x => x.fantasma && (!opcoes.sessoes || opcoes.sessoes.includes(x.sessionId)))) {
         // Fechamento (RM-056, ao fechar): so os vinculos da thread que fecha; o resto fica como estava.
         const vinculos = opcoes.thread ? s.vinculos.filter(v => v.thread === opcoes.thread && v.raiz === canonica) : s.vinculos;
         if (opcoes.thread && vinculos.length === 0)
@@ -186,18 +188,18 @@ function sessoesSemFim(raiz, threadId) {
     return [...new Set(ids)].filter(id => !encerradas.has(id));
 }
 function textoDaLimpeza(r) {
+    const m = (0, locale_1.msg)().operacao.restante.sessions.limpeza;
     if (r.itens.length === 0)
-        return `Nenhuma sessão fantasma${r.ok ? '' : ' nas contas que responderam'}.` +
-            r.falhas.map(f => `\nFalha: ${f}`).join('');
+        return m.nenhuma(!r.ok) + r.falhas.map(f => `\n${m.falha(f)}`).join('');
     const verbo = {
-        solto: r.dryRun ? 'soltaria (sessao_morta no ledger)' : 'solto: sessao_morta no ledger',
-        'ja-solto': 'já encerrada no ledger', 'sem-thread': 'fora do ork: nada a soltar',
-        'outro-projeto': 'vínculo de outro projeto: rode lá',
+        solto: r.dryRun ? m.acoes.soltaria : m.acoes.solto,
+        'ja-solto': m.acoes.jaSolto, 'sem-thread': m.acoes.semThread,
+        'outro-projeto': m.acoes.outroProjeto,
     };
     return [
-        `Sessões fantasma (sem pid e sem processo)${r.dryRun ? ', ensaio: nada foi gravado' : ''}. O runtime não foi tocado.`,
-        (0, util_1.tabela)(['ID', 'PERFIL', 'THREAD/FASE', 'AÇÃO'], r.itens.map(i => [i.sessionId, i.perfil ?? 'processo',
+        m.abertura(r.dryRun),
+        (0, util_1.tabela)([...m.colunas], r.itens.map(i => [i.sessionId, i.perfil ?? m.processo,
             i.thread ? `${i.thread}/${i.fase}` : '-', verbo[i.acao]])),
-        ...r.falhas.map(f => `Falha: ${f}`),
+        ...r.falhas.map(f => m.falha(f)),
     ].join('\n');
 }

package/dist/setup.js

@@ -90,6 +90,7 @@ const manifest_1 = require("./manifest");
 const modos_1 = require("./modos");
 const runtimes_1 = require("./runtimes");
 const util_1 = require("./util");
+const locale_1 = require("./locale");
 exports.CONTRATO_DO_SETUP = 'ork.setup/v1';
 exports.NOME_SETUP = 'setup.json';
 /** I-52: o setup versionado, ao lado do `orkastery.yaml`. */
@@ -99,14 +100,14 @@ const MAX_INSTANTE_MS = 8_640_000_000_000_000;
 const CAMPOS_LIMITES = ['duracaoMs', 'maxChildren', 'maxDepth', 'maxRetries'];
 function objeto(valor, campo) {
     if (!valor || typeof valor !== 'object' || Array.isArray(valor)) {
-        throw new Error(`${campo} deve ser objeto`);
+        throw new Error((0, locale_1.msg)().setup.objeto(campo));
     }
     return valor;
 }
 function camposExatos(valor, campos, campo) {
     if (Object.keys(valor).length !== campos.length ||
         campos.some(c => !Object.hasOwn(valor, c))) {
-        throw new Error(`${campo} deve conter somente ${campos.join(', ')}`);
+        throw new Error((0, locale_1.msg)().setup.camposExatos(campo, campos.join(', ')));
     }
 }
 const ENTRADA_DE_FALLBACK = /^([a-z][a-z0-9-]*):([^\s:]+)(?::([a-z]+))?$/;
@@ -116,11 +117,11 @@ function validarFallback(lista, principal) {
     return lista.map((item) => {
         const m = ENTRADA_DE_FALLBACK.exec(item.trim());
         if (!m)
-            throw new Error(`fallback invalido: "${item}" (use runtime:modelo[:esforco], por exemplo codex:gpt-5.5)`);
+            throw new Error((0, locale_1.msg)().setup.fallbackInvalido(item));
         if (!(0, runtimes_1.runtimeConhecido)(m[1]))
-            throw new Error(`fallback com runtime desconhecido: "${m[1]}" (homologados: ${runtimes_1.ORDEM_DOS_RUNTIMES.join(', ')})`);
+            throw new Error((0, locale_1.msg)().setup.fallbackDesconhecido(m[1], runtimes_1.ORDEM_DOS_RUNTIMES.join(', ')));
         if (vistos.has(m[1]))
-            throw new Error(`fallback repete o runtime ${m[1]} (o runtime do bloco e cada fallback aparecem uma vez)`);
+            throw new Error((0, locale_1.msg)().setup.fallbackRepetido(m[1]));
         vistos.add(m[1]);
         return item.trim();
     });
@@ -164,7 +165,7 @@ function validarLimitesDeBloco(valor) {
         const n = limites[campo];
         if (typeof n !== 'number' || !Number.isSafeInteger(n) || n < (campo === 'duracaoMs' ? 1 : 0) ||
             (campo === 'duracaoMs' && n > MAX_INSTANTE_MS)) {
-            throw new Error(`limites.${campo} deve ser inteiro ${campo === 'duracaoMs' ? 'positivo' : 'nao negativo'}, finito e representavel`);
+            throw new Error((0, locale_1.msg)().setup.limiteInvalido(campo, campo === 'duracaoMs'));
         }
     }
     return {
@@ -179,14 +180,14 @@ function validarConfigComLimites(config) {
     if (typeof config.runtime !== 'string' || !(0, runtimes_1.runtimeConhecido)(config.runtime) ||
         typeof config.model !== 'string' || config.model.trim() === '' ||
         typeof config.effort !== 'string' || config.effort.trim() === '') {
-        throw new Error('bloco com limites exige runtime conhecido, model e effort explicitos validos');
+        throw new Error((0, locale_1.msg)().setup.blocoComLimites);
     }
 }
 /** Valida tambem entradas que a normalizacao antiga descartaria. */
 function validarEstruturaSetup(valor) {
     const setup = objeto(valor, 'setup');
     if (setup.contrato !== undefined && setup.contrato !== exports.CONTRATO_DO_SETUP) {
-        throw new Error('contrato de setup incompativel');
+        throw new Error((0, locale_1.msg)().setup.contratoIncompativel);
     }
     if (setup.modos === undefined)
         return;
@@ -195,13 +196,13 @@ function validarEstruturaSetup(valor) {
         if (configModo.blocos === undefined)
             continue;
         if (!Array.isArray(configModo.blocos))
-            throw new Error(`blocos de ${modo} devem ser array`);
+            throw new Error((0, locale_1.msg)().setup.blocosArray(modo));
         for (const [i, valorBloco] of configModo.blocos.entries()) {
             const config = objeto(valorBloco, `bloco ${modo}/${i + 1}`);
             validarConfigComLimites(config);
             if (Object.hasOwn(config, 'limites') && (setup.contrato !== exports.CONTRATO_DO_SETUP ||
                 !modos_1.ORDEM_DOS_MODOS.includes(modo) || i >= modos_1.MODOS[modo].blocos.length)) {
-                throw new Error('limites exigem contrato e bloco de modo conhecidos');
+                throw new Error((0, locale_1.msg)().setup.limitesConhecidos);
             }
         }
     }
@@ -273,7 +274,7 @@ function lerSetup(raiz) {
         bruto = (0, util_1.lerJson)(caminho);
     }
     catch (e) {
-        throw new Error(`setup invalido (${caminho}): ${e.message}`);
+        throw new Error((0, locale_1.msg)().setup.setupInvalido(caminho, e.message));
     }
     validarEstruturaSetup(bruto);
     const modosBrutos = (bruto.modos ?? {});
@@ -324,7 +325,7 @@ function gravarSetup(raiz, setup) {
 function versionarSetup(raiz, por = 'owner') {
     const caminho = caminhoSetupVersionado(raiz);
     if (fs.existsSync(caminho))
-        throw new Error(`setup.versionado: ${exports.NOME_SETUP_VERSIONADO} ja existe neste checkout; edite com ork setup <modo> --bloco N`);
+        throw new Error((0, locale_1.msg)().setup.versionadoExiste(exports.NOME_SETUP_VERSIONADO));
     const origem = origemDoSetup(raiz);
     const setup = lerSetup(raiz);
     validarEstruturaSetup(setup);
@@ -358,12 +359,12 @@ function limitesDoBloco(manifesto, setup, modo, fase) {
     if (!Array.isArray(permitidos) || permitidos.length === 0 ||
         permitidos.some(m => !modos_1.ORDEM_DOS_MODOS.includes(m)) ||
         !permitidos.includes(modo)) {
-        throw new Error('playbook ativo exige modo permitido valido');
+        throw new Error((0, locale_1.msg)().setup.playbookModo);
     }
     for (const permitido of permitidos) {
         const blocos = setup.modos?.[permitido]?.blocos;
         if (!blocos || blocos.length !== modos_1.MODOS[permitido].blocos.length) {
-            throw new Error(`playbook ativo exige todos os blocos de ${permitido}`);
+            throw new Error((0, locale_1.msg)().setup.playbookBlocos(permitido));
         }
         for (const config of blocos) {
             validarConfigComLimites(objeto(config, 'config do bloco'));
@@ -372,12 +373,12 @@ function limitesDoBloco(manifesto, setup, modo, fase) {
     }
     const config = configDoBloco(setup, modo, fase);
     if (!config)
-        throw new Error(`fase ${fase} fora do modo ${modo}`);
+        throw new Error((0, locale_1.msg)().setup.faseFora(fase, modo));
     return validarLimitesDeBloco(config.limites);
 }
 function instante(valor, campo) {
     if (typeof valor !== 'number' || !Number.isSafeInteger(valor) || valor < 0 || valor > MAX_INSTANTE_MS) {
-        throw new Error(`${campo} deve ser instante inteiro nao negativo e representavel`);
+        throw new Error((0, locale_1.msg)().setup.instante(campo));
     }
     return valor;
 }
@@ -389,20 +390,20 @@ function validarIdentidade(valor) {
     camposExatos(id, ['threadId', 'execucaoId', 'modo', 'bloco'], 'identidade');
     for (const campo of ['threadId', 'execucaoId']) {
         if (typeof id[campo] !== 'string' || id[campo].trim() === '') {
-            throw new Error(`identidade.${campo} deve ser texto nao vazio`);
+            throw new Error((0, locale_1.msg)().setup.identidadeTexto(campo));
         }
     }
     if (!modos_1.ORDEM_DOS_MODOS.includes(id.modo) ||
         typeof id.bloco !== 'number' || !Number.isSafeInteger(id.bloco) ||
         id.bloco < 1 || id.bloco > modos_1.MODOS[id.modo].blocos.length) {
-        throw new Error('identidade de modo/bloco invalida');
+        throw new Error((0, locale_1.msg)().setup.identidadeModo);
     }
     return { threadId: id.threadId, execucaoId: id.execucaoId, modo: id.modo, bloco: id.bloco };
 }
 function semAmpliacao(limites, origem) {
     for (const campo of CAMPOS_LIMITES) {
         if (limites[campo] > origem[campo])
-            throw new Error(`heranca nao pode ampliar limites.${campo}`);
+            throw new Error((0, locale_1.msg)().setup.herancaAmplia(campo));
     }
 }
 /**
@@ -415,7 +416,7 @@ function iniciarPrazoDoBloco(manifesto, setup, identidade, fase, agoraMs) {
         return null;
     const id = validarIdentidade(identidade);
     if (!modos_1.MODOS[id.modo].blocos[id.bloco - 1].fases.includes(fase)) {
-        throw new Error('identidade do bloco diverge da fase selecionada');
+        throw new Error((0, locale_1.msg)().setup.identidadeFase);
     }
     const inicio = instante(agoraMs, 'iniciadaEmMs');
     const deadline = somarPrazo(inicio, limites.duracaoMs);
@@ -429,11 +430,11 @@ function validarPrazo(valor, esperada) {
     camposExatos(p, ['versao', 'identidade', 'iniciadaEmMs', 'deadlineOriginalMs',
         'limitesOriginais', 'deadlineMs', 'limites', 'observadoEmMs'], 'prazo');
     if (p.versao !== 1)
-        throw new Error('versao de prazo incompativel');
+        throw new Error((0, locale_1.msg)().setup.prazoVersao);
     const identidade = validarIdentidade(p.identidade);
     const idEsperada = validarIdentidade(esperada);
     if (Object.keys(identidade).some(c => identidade[c] !== idEsperada[c])) {
-        throw new Error('identidade da execucao divergente');
+        throw new Error((0, locale_1.msg)().setup.identidadeDivergente);
     }
     const limitesOriginais = validarLimitesDeBloco(p.limitesOriginais);
     const limites = validarLimitesDeBloco(p.limites);
@@ -444,7 +445,7 @@ function validarPrazo(valor, esperada) {
     const deadlineMs = instante(p.deadlineMs, 'deadlineMs');
     if (deadlineOriginalMs !== somarPrazo(iniciadaEmMs, limitesOriginais.duracaoMs) ||
         deadlineMs !== somarPrazo(iniciadaEmMs, limites.duracaoMs) || observadoEmMs < iniciadaEmMs) {
-        throw new Error('origem/deadline do prazo inconsistente');
+        throw new Error((0, locale_1.msg)().setup.prazoInconsistente);
     }
     return { versao: 1, identidade, iniciadaEmMs, deadlineOriginalMs, limitesOriginais, deadlineMs, limites, observadoEmMs };
 }
@@ -457,7 +458,7 @@ function consumirPrazoDoBloco(snapshot, identidadeEsperada, agoraMs, atividade =
     const prazo = validarPrazo(snapshot, identidadeEsperada);
     const agoraValidado = instante(agoraMs, 'agoraMs');
     if (agoraValidado < prazo.observadoEmMs)
-        throw new Error('relogio regressivo no prazo');
+        throw new Error((0, locale_1.msg)().setup.relogioRegressivo);
     const a = objeto(atividade, 'atividade');
     if (a.tipo === 'trabalho') {
         camposExatos(a, ['tipo'], 'atividade');
@@ -465,10 +466,10 @@ function consumirPrazoDoBloco(snapshot, identidadeEsperada, agoraMs, atividade =
     else if (a.tipo === 'espera_lease' || a.tipo === 'espera_score') {
         camposExatos(a, ['tipo', 'processosAtivos'], 'atividade');
         if (a.processosAtivos !== 0)
-            throw new Error('espera exige ausencia comprovada de processos ativos');
+            throw new Error((0, locale_1.msg)().setup.esperaComProcesso);
     }
     else {
-        throw new Error('atividade de prazo desconhecida');
+        throw new Error((0, locale_1.msg)().setup.atividadeDesconhecida);
     }
     prazo.observadoEmMs = agoraValidado;
     const restanteMs = Math.max(0, prazo.deadlineMs - agoraValidado);
@@ -481,13 +482,13 @@ function consumirPrazoDoBloco(snapshot, identidadeEsperada, agoraMs, atividade =
 function herdarPrazoDoBloco(origem, identidadeEsperada, agoraMs, limitesSolicitados) {
     const consumo = consumirPrazoDoBloco(origem, identidadeEsperada, agoraMs);
     if (consumo.estado !== 'ativo')
-        throw new Error('prazo expirado: heranca recusada');
+        throw new Error((0, locale_1.msg)().setup.prazoExpirado);
     const prazo = consumo.prazo;
     const limites = validarLimitesDeBloco(limitesSolicitados === undefined ? prazo.limites : limitesSolicitados);
     semAmpliacao(limites, prazo.limites);
     const deadlineMs = somarPrazo(prazo.iniciadaEmMs, limites.duracaoMs);
     if (deadlineMs <= agoraMs)
-        throw new Error('prazo reduzido ja expirado');
+        throw new Error((0, locale_1.msg)().setup.prazoReduzido);
     return { ...prazo, limites, deadlineMs };
 }
 /** A config do bloco e o default pos-instalacao? */
@@ -525,20 +526,20 @@ function editarBloco(raiz, modo, bloco, edicao, por = 'owner') {
     if (!Number.isInteger(bloco) || bloco < 1 || bloco > def.blocos.length) {
         return {
             ...base,
-            erro: `bloco ${bloco} nao existe no modo ${def.tag}: ele tem ${def.blocos.length} bloco(s)`,
+            erro: (0, locale_1.msg)().setup.blocoInexistente(bloco, def.tag, def.blocos.length),
         };
     }
     if (edicao.runtime !== undefined && !(0, runtimes_1.runtimeConhecido)(edicao.runtime)) {
         return {
             ...base,
-            erro: `runtime desconhecido: "${edicao.runtime}" (homologados: ${runtimes_1.ORDEM_DOS_RUNTIMES.join(', ')})`,
+            erro: (0, locale_1.msg)().setup.runtimeDesconhecido(edicao.runtime, runtimes_1.ORDEM_DOS_RUNTIMES.join(', ')),
         };
     }
     const atual = setup.modos[modo].blocos[bloco - 1];
     if (edicao.runtime !== undefined && edicao.runtime !== atual.runtime && !edicao.model?.trim())
-        return { ...base, erro: 'setup.model.required: para mudar o runtime do bloco, informe --runtime e --model juntos; nenhuma configuracao foi gravada.' };
+        return { ...base, erro: (0, locale_1.msg)().setup.modeloComRuntime };
     if (!(edicao.model ?? atual.model).trim())
-        return { ...base, erro: 'setup.model.required: modelo pendente neste bloco; informe --model antes de salvar.' };
+        return { ...base, erro: (0, locale_1.msg)().setup.modeloPendente };
     const de = { ...atual };
     const runtimeNovo = edicao.runtime ?? atual.runtime;
     let fallback;
@@ -613,15 +614,15 @@ function registrarSetupNoLedger(raiz, dados) {
 function linhaDaOrigemDoSetup(raiz) {
     const origem = origemDoSetup(raiz);
     if (origem === 'versionado') {
-        return `Setup versionado em ${exports.NOME_SETUP_VERSIONADO}: vale para todas as maquinas e muda por PR.` +
-            (fs.existsSync(caminhoSetupLocal(raiz)) ? ' O .orkastery/setup.json local desta maquina fica ignorado.' : '');
+        return (0, locale_1.msg)().setup.origem.versionado(exports.NOME_SETUP_VERSIONADO, fs.existsSync(caminhoSetupLocal(raiz)));
     }
     if (origem === 'local')
-        return 'Setup local desta maquina (.orkastery/setup.json). Para valer em todas: ork setup versionar.';
-    return 'Nenhum setup gravado: vale o default. Para valer em todas as maquinas: ork setup versionar.';
+        return (0, locale_1.msg)().setup.origem.local;
+    return (0, locale_1.msg)().setup.origem.padrao;
 }
 /** Tabela de um modo: cada bloco com sua config e a marca do que saiu do default. */
 function textoDoSetup(raiz, modo) {
+    const m = (0, locale_1.msg)().setup.tabela;
     const def = (0, modos_1.definicaoDoModo)(modo);
     const setup = lerSetup(raiz);
     const linhas = def.blocos.map((b, i) => {
@@ -630,22 +631,22 @@ function textoDoSetup(raiz, modo) {
             String(i + 1),
             b.fases.join('-'),
             cfg.runtime,
-            cfg.model || '(modelo pendente)',
+            cfg.model || m.modeloPendente,
             cfg.effort,
             cfg.fallback?.join(', ') || '-',
-            ehPadrao(cfg, modo) ? 'default' : 'customizado',
+            ehPadrao(cfg, modo) ? m.default : m.customizado,
         ];
     });
     const saida = [];
-    saida.push(`Setup do modo ${def.tag} (${def.blocos.length} bloco(s), ${def.pausas} pausa(s))`);
+    saida.push(m.titulo(def.tag, def.blocos.length, def.pausas));
     saida.push('');
-    saida.push((0, util_1.tabela)(['BLOCO', 'FASES', 'RUNTIME', 'MODEL', 'EFFORT', 'FALLBACK', 'ORIGEM'], linhas));
+    saida.push((0, util_1.tabela)([...m.cabecalho], linhas));
     saida.push('');
-    saida.push(`Editar:  ork setup ${modo} --bloco N --runtime R --model M --effort E`);
-    saida.push(`Fallback: ork setup ${modo} --bloco N --fallback runtime:modelo[:esforco],...   (--fallback "" remove)`);
+    saida.push(m.editar(modo));
+    saida.push(m.fallback(modo));
     const padrao = blocoPadraoDoModo(modo);
-    saida.push(`Resetar: ork setup ${modo} --reset   (volta para ${padrao.runtime}/${padrao.model}/${padrao.effort})`);
-    saida.push(`Runtimes homologados: ${runtimes_1.ORDEM_DOS_RUNTIMES.join(', ')}`);
+    saida.push(m.resetar(modo, `${padrao.runtime}/${padrao.model}/${padrao.effort}`));
+    saida.push(m.runtimes(runtimes_1.ORDEM_DOS_RUNTIMES.join(', ')));
     saida.push('');
     saida.push(linhaDaOrigemDoSetup(raiz));
     return saida.join('\n');
@@ -658,33 +659,33 @@ function textoDoSetup(raiz, modo) {
  * o owner disser que concluiu, e todo bloco nao respondido fica no default.
  */
 function textoDaEntrevista(raiz) {
+    const m = (0, locale_1.msg)().setup.entrevista;
     const setup = lerSetup(raiz);
     const saida = [];
-    saida.push('Entrevista #setup: runtime + modelo + esforco por bloco de cada modo');
+    saida.push(m.titulo);
     saida.push('');
-    saida.push(`Ordem das perguntas: ${modos_1.ORDEM_DOS_MODOS.map((m) => modos_1.MODOS[m].tag).join(' -> ')}.`);
-    saida.push('A entrevista termina quando todos os modos forem cobertos OU quando o owner');
-    saida.push('disser que concluiu: o que nao for respondido fica no default.');
+    saida.push(m.ordem(modos_1.ORDEM_DOS_MODOS.map((modo) => modos_1.MODOS[modo].tag).join(' -> ')));
+    saida.push(m.termina1);
+    saida.push(m.termina2);
     const proprios = modos_1.ORDEM_DOS_MODOS.filter((m) => !ehPadrao(blocoPadraoDoModo(m)));
-    saida.push(`Default pos-instalacao: ${exports.BLOCO_PADRAO.runtime}/${exports.BLOCO_PADRAO.model}/${exports.BLOCO_PADRAO.effort} em todos os blocos` +
-        (proprios.length ? `, menos ${proprios.map((m) => {
-            const b = blocoPadraoDoModo(m);
-            return `${modos_1.MODOS[m].tag} (${b.runtime}/${b.model}/${b.effort}${b.fallback?.length ? `, fallback ${b.fallback.join(', ')}` : ''})`;
-        }).join(', ')}.` : '.'));
+    saida.push(m.default(`${exports.BLOCO_PADRAO.runtime}/${exports.BLOCO_PADRAO.model}/${exports.BLOCO_PADRAO.effort}`, proprios.length ? m.excecoes(proprios.map((modo) => {
+        const b = blocoPadraoDoModo(modo);
+        return `${modos_1.MODOS[modo].tag} (${b.runtime}/${b.model}/${b.effort}${b.fallback?.length ? `, fallback ${b.fallback.join(', ')}` : ''})`;
+    }).join(', ')) : '.'));
     saida.push('');
     for (const modo of modos_1.ORDEM_DOS_MODOS) {
         const def = modos_1.MODOS[modo];
         saida.push(`${def.tag}`);
         def.blocos.forEach((b, i) => {
             const cfg = setup.modos[modo].blocos[i];
-            const marca = ehPadrao(cfg, modo) ? '' : '  <- customizado';
-            saida.push(`  bloco ${i + 1}: ${b.fases.join('-')}  [${cfg.runtime}/${cfg.model || '(modelo pendente)'}/${cfg.effort}]${marca}`);
+            const marca = ehPadrao(cfg, modo) ? '' : m.customizado;
+            saida.push(m.bloco(i + 1, b.fases.join('-'), `${cfg.runtime}/${cfg.model || m.modeloPendente}/${cfg.effort}`, marca));
         });
     }
     saida.push('');
-    saida.push('Ver um modo:  ork setup <modo>');
-    saida.push('Editar bloco: ork setup <modo> --bloco N --runtime R --model M --effort E');
-    saida.push('Resetar tudo: ork setup --reset');
+    saida.push(m.ver);
+    saida.push(m.editar);
+    saida.push(m.resetar);
     saida.push('');
     saida.push(linhaDaOrigemDoSetup(raiz));
     return saida.join('\n');