@orkastery/cli 0.5.6 → 0.6.1

package/dist/indice-vetorial.js

@@ -77,6 +77,7 @@ const node_crypto_1 = require("node:crypto");
 const estado_thread_1 = require("./estado-thread");
 const orkmind_1 = require("./orkmind");
 const policies_1 = require("./policies");
+const locale_1 = require("./locale");
 exports.CONTRATO_INDICE = 'ork.indice-vetorial/v1';
 /** D11: lote por chamada da ponte na indexacao. */
 exports.TAMANHO_DO_LOTE = 16;
@@ -360,23 +361,24 @@ function avisoDeCobertura(coerentes, entradas, alvo, onde = '') {
 }
 /** RM-038: a linha do que fica fora da busca, a mesma no `ork memory index` e no `ork memory status`. */
 function textoForaDaBusca(f) {
-    return f ? `${f.injecao} com injection_risk e ${f.expiradas} expirada(s) (governanca da biblioteca), ` +
-        `${f.outrasColecoes} em outras colecoes (fora da busca do ork); nada disso vai ao embed` : 'nao medido nesta base';
+    const m = (0, locale_1.msg)().operacao.restante.memory.indice;
+    return f ? m.foraMedido(f.injecao, f.expiradas, f.outrasColecoes) : m.foraNaoMedido;
 }
 /** Texto de `ork memory index`: de que universo, o que foi (ou seria) embedado e quanto custa estimado. */
 function textoDoIndice(r) {
-    const custo = r.custoEstimadoUsd === null ? 'nao estimado' : `US$ ${r.custoEstimadoUsd.toFixed(8)}`;
+    const m = (0, locale_1.msg)().operacao.restante.memory.indice;
+    const custo = r.custoEstimadoUsd === null ? m.custoNaoEstimado : `US$ ${r.custoEstimadoUsd.toFixed(8)}`;
     const colecoes = Object.entries(r.porColecao).map(([c, n]) => `${c} ${n}`).join(', ');
     return [
-        `Indice vetorial (${r.alvo}${r.dryRun ? ', --dry-run' : ''}): ${r.modelo ?? '(sem modelo)'}${r.dim ? ` / ${r.dim} dim` : ''}`,
-        `  universo da busca    ${r.universo} entrada(s): ${colecoes}; coerentes ${r.coerentes}`,
-        `  fora da busca        ${textoForaDaBusca(r.foraDaBusca)}`,
-        `  embedados            ${r.embedados} (reescritos ${r.reescritos}); removidos ${r.removidos}`,
-        `  fora do indice       ${r.recusados} recusada(s) por padrao de segredo, ${r.foraDoLimite} acima do limite`,
-        ...(r.truncados ? [`  truncados            ${r.truncados} acima do contexto do modelo local, embedados pelo comeco`] : []),
-        `  estimativa           ${r.tokensEstimados} token(s), ${custo}; chamadas ao provider ${r.chamadasAoProvider}`,
-        ...(r.arquivo ? [`  arquivo              ${r.arquivo}`] : []),
-        ...(r.motivo ? [`  motivo               ${r.motivo}: ${r.detalhe}`] : r.detalhe ? [`  ${r.detalhe}`] : []),
+        m.titulo(r.alvo, r.dryRun, r.modelo ?? m.semModelo, r.dim),
+        m.universo(r.universo, colecoes, r.coerentes),
+        m.fora(textoForaDaBusca(r.foraDaBusca)),
+        m.embedados(r.embedados, r.reescritos, r.removidos),
+        m.recusados(r.recusados, r.foraDoLimite),
+        ...(r.truncados ? [m.truncados(r.truncados)] : []),
+        m.estimativa(r.tokensEstimados, custo, r.chamadasAoProvider),
+        ...(r.arquivo ? [m.arquivo(r.arquivo)] : []),
+        ...(r.motivo ? [m.motivo(r.motivo, r.detalhe)] : r.detalhe ? [`  ${r.detalhe}`] : []),
     ].join('\n');
 }
 /** Vetores coerentes de um indice para o universo informado: a base da busca e da cobertura. */

package/dist/init.js

@@ -56,6 +56,7 @@ const slug_1 = require("./slug");
 const util_1 = require("./util");
 const horario_1 = require("./horario");
 const modos_1 = require("./modos");
+const detect_1 = require("./security-scan/detect");
 /** O proximo passo do `ork init` em pt-BR; o texto do CLI sai pelo catalogo (`msg().init.proximoPasso`). */
 exports.PROXIMO_PASSO_INIT = (0, locale_1.msg)('pt-BR').init.proximoPasso;
 /** Raiz do repositorio git, resolvendo tambem o caso de worktree. */
@@ -144,6 +145,7 @@ function detectar(dirInicial, nomeForcado, abbrevForcada) {
         baseBranch: baseBranchDetectada(raiz),
         gerenciador: gerenciadorDetectado(raiz),
         verify: verifyDetectado(raiz),
+        stacks: [...new Set((0, detect_1.detectStacks)(raiz).map((e) => e.stack))],
     };
 }
 /** Cada linha do texto vira comentario do YAML, com o recuo da chave em que ele fica. */
@@ -203,6 +205,10 @@ verify:
 ${linhaVerify('build', d.verify.build)}
 ${linhaVerify('test', d.verify.test)}
 ${linhaVerify('typecheck', d.verify.typecheck)}
+${comentario(c.securityScan)}
+  ${d.stacks.length > 0 ? '' : '# '}security_scan: "ork security-scan"
+  ${d.stacks.length > 0 ? '' : '# '}timeout_ms_por_comando:
+  ${d.stacks.length > 0 ? '' : '# '}  security_scan: 900000
 
 ci:
 ${comentario(c.ci)}
@@ -283,6 +289,9 @@ function init(dirInicial, opcoes = {}) {
     (0, util_1.gravar)(caminho, manifestoYaml(deteccao, opcoes.locale));
     const estado = path.join(deteccao.raiz, manifest_1.DIR_ESTADO);
     fs.mkdirSync(path.join(estado, 'threads'), { recursive: true });
-    // Fatia 2 do ensaio da 0.5.0 (P3): o estado e da maquina; fica fora do git sem mexer no `.gitignore` do usuario.
-    return { caminho, criado: true, deteccao, estadoIgnorado: (0, util_1.ignorarPastaNoGit)(estado, deteccao.raiz) };
+    // RM-061 F3c: so o arquivo do estado criado pelo `init` segue a lingua pedida. O `*` e a protecao
+    // contra sobrescrita continuam no util; a pasta de worktrees preserva o default historico.
+    const locale = opcoes.locale ?? locale_1.LOCALE_PADRAO;
+    const gitignore = `# ${(0, locale_1.msg)(locale).gerados.gitignoreDaMaquina}\n*\n`;
+    return { caminho, criado: true, deteccao, estadoIgnorado: (0, util_1.ignorarPastaNoGit)(estado, deteccao.raiz, gitignore) };
 }

package/dist/integracoes-locais.js

@@ -20,4 +20,8 @@ exports.TESTES_DE_INTEGRACAO_LOCAL = new Set([
     'rm038-universo-ponte.test.js',
     // RM-059 (T0.10): a conferencia pontual com o sandbox real do codex, como o mcp-verify.test.js.
     'claims-conferir-sandbox.test.js',
+    // Security scan (Task 13a): o scanner com o Docker real e as imagens do catalogo.
+    'security-scan-integracao.test.js',
+    // RM-067 (F4c, D11): o grok falso confinado pelo Landlock do kernel, com o lancador em python3.
+    'rm067-grok-landlock.test.js',
 ]);

package/dist/intelligence-graph-cli.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CORRECAO_DO_INDICE = exports.USO_DO_GRAFO = exports.AMOSTRA_SCHEMA = exports.REDACAO_DOS_ANALISADORES = exports.STATUS_SCHEMA = void 0;
+exports.CORRECAO_DO_INDICE = exports.TEXTOS_DO_GRAFO = exports.USO_DO_GRAFO = exports.AMOSTRA_SCHEMA = exports.REDACAO_DOS_ANALISADORES = exports.STATUS_SCHEMA = void 0;
 exports.descreverVersoes = descreverVersoes;
 exports.correcaoDosAnalisadores = correcaoDosAnalisadores;
 exports.checarAnalisadoresDoGrafo = checarAnalisadoresDoGrafo;
@@ -125,6 +125,62 @@ exports.USO_DO_GRAFO = [
     '     ork grafo amostra [--por-estrato N] | ork grafo amostra --conferir ARQ [--json]',
     '     ork grafo limpar [--tudo] [--json]',
 ].join('\n');
+exports.TEXTOS_DO_GRAFO = {
+    uso: exports.USO_DO_GRAFO.split('\n'),
+    erroUso: (motivo) => `grafo.uso: ${motivo}`,
+    motivos: {
+        semSub: 'falta o subcomando', desconhecido: (sub) => `subcomando desconhecido: ${sub}`,
+        repetida: (nome) => `--${nome} repetida`, semValor: (nome) => `--${nome} nao leva valor`,
+        exigeValor: (nome) => `--${nome} exige valor`, opcao: (sub, valor) => `opcao desconhecida para ${sub}: ${valor}`,
+        argumentos: (sub, esperados, recebidos) => `${sub} pede ${esperados} argumento(s), veio ${recebidos}`,
+        inteiro: (nome) => `--${nome} precisa ser inteiro`, tipo: (tipo, lista) => `--tipo desconhecido: ${tipo} (use ${lista})`,
+        sentido: (valor) => `--sentido desconhecido: ${valor}`, tetoJson: '--teto-bytes exige --json', tetoMin: '--teto-bytes precisa ser ao menos 1',
+        amostraExclusiva: '--conferir e --por-estrato nao combinam', estratoMin: '--por-estrato precisa ser ao menos 1',
+    },
+    indexar: {
+        titulo: (repositorio, estado) => `indice do grafo de ${repositorio}: ${estado}`,
+        // O rotulo ocupa 13 colunas antes do valor, como na base: 12 do nome e um espaco.
+        campo: (nome, valor) => `  ${nome.padEnd(12)} ${valor}`,
+        campos: { revisao: 'revisao', chave: 'chave', snapshot: 'snapshot', digest: 'digest', conferencia: 'conferencia',
+            nos: 'nos', arestas: 'arestas', lugar: 'lugar', motivo: 'motivo', tempo: 'tempo' },
+        conferencia: (fontes, evidencias) => `conferirFontes verificada: ${fontes} fontes e ${evidencias} evidencias contra os bytes`,
+        determinismo: (ordem, digest, relatorio, unidades, igual) => `  determinismo ${ordem}: digest ${digest}, relatorio ${relatorio}, unidades ${unidades}, ${igual ? 'igual' : 'DIFERENTE'}`,
+        incremental: (base, igual) => `  incremental  a partir do indice de ${base}: ${igual ? 'igual a completa nos quatro arquivos' : 'DIFERENTE'}`,
+        naoConferido: (motivo) => `  incremental  nao conferido: ${motivo}`,
+        aprovado: 'aprovado',
+        semBase: 'sem base',
+    },
+    status: {
+        titulo: (head, arvore) => `grafo: HEAD ${head}, arvore ${arvore}`,
+        indice: (chave, estado) => `  indice do HEAD  ${chave} ${estado}`,
+        ausente: '(ausente: rode ork grafo indexar)',
+        semAnalisadores: '(sem os analisadores nesta instalacao, nem a consulta nem o indexar rodam)',
+        semChave: '(sem a chave do indice: o erro esta na linha de baixo)',
+        analisadores: (versoes) => `  analisadores    ${versoes}`,
+        correcao: (correcao) => `  correcao        ${correcao}`,
+        pasta: (dir, indices, tamanho) => `  pasta           ${dir} (${indices} indice(s), ${tamanho})`,
+        semCommit: 'sem commit', indisponivel: 'indisponivel', naoCriada: 'ainda nao criada',
+        sobras: (sobras) => `  sobras          ${sobras}`,
+    },
+    contexto: {
+        titulo: (thread, revisao) => `Contexto ${thread} @ ${revisao}`,
+        resumo: (sementes, total, arestas, ligacoes, bytes) => `  ${sementes}/${total} sementes, ${arestas}/${ligacoes} ligacoes agregadas; ${bytes} bytes JSON`,
+        tamanho: (bytes) => `  tamanho dos arquivos no pacote (nao descoberta): ${bytes} bytes (revisao indexada); tokens: unavailable`,
+        diff: (diff) => `  diff: ${diff}`,
+        mudadas: (n) => `  ligacoes com fonte modificada na arvore: ${n}`,
+        final: (truncado, arvore) => `  truncado: ${truncado}; arvore: ${arvore}; use --json para nos e evidencias`,
+    },
+    amostra: {
+        titulo: (arestas, estratos, revisao) => `amostra: ${arestas} arestas em ${estratos} estratos, auditada na revisao ${revisao}`,
+        vereditos: (vereditos) => `  vereditos ${vereditos}`,
+        conferidas: (ok, total) => `  conferidas contra o indice do HEAD: ${ok} de ${total}`,
+        falha: (falha) => `FALHA ${falha}`,
+        reprovado: (n) => `reprovado: ${n} falha(s)`,
+        aprovado: 'aprovado',
+    },
+    limpar: (removidos, tamanho) => `grafo limpar: ${removidos} removido(s), ${tamanho}`,
+    consulta: intelligence_graph_query_1.TEXTOS_DA_CONSULTA,
+};
 /** KG5 (D5): a correcao das recusas de indice que a proxima indexacao resolve. */
 exports.CORRECAO_DO_INDICE = 'ork grafo indexar';
 /** KG5 (D5): o estado do indice do HEAD que cada recusa declara no JSON, ao lado da correcao. */
@@ -134,6 +190,7 @@ const ESTADO_DO_INDICE = Object.freeze({
     'grafo.indice.outro-extrator': 'outro-extrator',
     'grafo.indice.corrompido': 'corrompido',
 });
+const textosDe = (ctx) => ctx.textos ?? exports.TEXTOS_DO_GRAFO;
 const SUBCOMANDOS = Object.freeze({
     indexar: { posicionais: 0, bandeiras: ['verificar', 'forcar', 'json'], valores: [] },
     status: { posicionais: 0, bandeiras: ['json'], valores: [] },
@@ -145,16 +202,16 @@ const SUBCOMANDOS = Object.freeze({
     amostra: { posicionais: 0, bandeiras: ['json'], valores: ['por-estrato', 'conferir'] },
     limpar: { posicionais: 0, bandeiras: ['tudo', 'json'], valores: [] },
 });
-function uso(motivo) {
-    throw new Error(`grafo.uso: ${motivo}\n${exports.USO_DO_GRAFO}`);
+function uso(motivo, t) {
+    throw new Error(`${t.erroUso(motivo)}\n${t.uso.join('\n')}`);
 }
-function lerPedido(argv) {
+function lerPedido(argv, t = exports.TEXTOS_DO_GRAFO) {
     const [sub, ...resto] = argv;
     if (!sub)
-        uso('falta o subcomando');
+        uso(t.motivos.semSub, t);
     const esp = SUBCOMANDOS[sub];
     if (!Object.prototype.hasOwnProperty.call(SUBCOMANDOS, sub) || !esp)
-        uso(`subcomando desconhecido: ${sub}`);
+        uso(t.motivos.desconhecido(sub), t);
     const posicionais = [], bandeiras = new Set(), valores = new Map();
     for (let i = 0; i < resto.length; i++) {
         const a = resto[i];
@@ -165,59 +222,59 @@ function lerPedido(argv) {
         const igual = a.indexOf('=');
         const nome = igual > 0 ? a.slice(2, igual) : a.slice(2);
         if (bandeiras.has(nome) || valores.has(nome))
-            uso(`--${nome} repetida`);
+            uso(t.motivos.repetida(nome), t);
         if (esp.bandeiras.includes(nome)) {
             if (igual > 0)
-                uso(`--${nome} nao leva valor`);
+                uso(t.motivos.semValor(nome), t);
             bandeiras.add(nome);
         }
         else if (esp.valores.includes(nome)) {
             const valor = igual > 0 ? a.slice(igual + 1) : resto[++i];
             if (valor === undefined || valor === '' || (igual < 0 && valor.startsWith('--')))
-                uso(`--${nome} exige valor`);
+                uso(t.motivos.exigeValor(nome), t);
             valores.set(nome, valor);
         }
         else {
-            uso(`opcao desconhecida para ${sub}: ${a}`);
+            uso(t.motivos.opcao(sub, a), t);
         }
     }
     if (posicionais.length !== esp.posicionais)
-        uso(`${sub} pede ${esp.posicionais} argumento(s), veio ${posicionais.length}`);
+        uso(t.motivos.argumentos(sub, esp.posicionais, posicionais.length), t);
     return { sub, posicionais, bandeiras, valores };
 }
-function inteiro(p, nome) {
+function inteiro(p, nome, t) {
     const v = p.valores.get(nome);
     if (v === undefined)
         return undefined;
     if (!/^[0-9]{1,6}$/.test(v))
-        uso(`--${nome} precisa ser inteiro`);
+        uso(t.motivos.inteiro(nome), t);
     return Number(v);
 }
-function tipos(p) {
+function tipos(p, t) {
     const v = p.valores.get('tipo');
     if (v === undefined)
         return undefined;
     const lista = v.split(',');
-    for (const t of lista)
-        if (!intelligence_graph_contract_1.TIPOS_DE_ARESTA.includes(t))
-            uso(`--tipo desconhecido: ${t} (use ${intelligence_graph_contract_1.TIPOS_DE_ARESTA.join(',')})`);
+    for (const x of lista)
+        if (!intelligence_graph_contract_1.TIPOS_DE_ARESTA.includes(x))
+            uso(t.motivos.tipo(x, intelligence_graph_contract_1.TIPOS_DE_ARESTA.join(',')), t);
     return lista;
 }
-function sentido(p) {
+function sentido(p, t) {
     const v = p.valores.get('sentido');
     if (v !== undefined && !['entrada', 'saida', 'ambos'].includes(v))
-        uso(`--sentido desconhecido: ${v}`);
+        uso(t.motivos.sentido(v), t);
     return v;
 }
 /** KG5 (D4): o teto vale para o JSON, que e o que vai ao contexto de quem consulta. */
-function tetoDeBytes(p) {
-    const teto = inteiro(p, 'teto-bytes');
+function tetoDeBytes(p, t) {
+    const teto = inteiro(p, 'teto-bytes', t);
     if (teto === undefined)
         return undefined;
     if (!p.bandeiras.has('json'))
-        uso('--teto-bytes exige --json');
+        uso(t.motivos.tetoJson, t);
     if (teto < 1)
-        uso('--teto-bytes precisa ser ao menos 1');
+        uso(t.motivos.tetoMin, t);
     return teto;
 }
 const mb = (bytes) => `${(bytes / 1024 / 1024).toFixed(1)} MB`;
@@ -250,30 +307,27 @@ function indexar(ctx, p) {
         return 0;
     }
     const m = r.manifesto;
+    const mi = textosDe(ctx).indexar;
     const linhas = [
-        `indice do grafo de ${m.repository_id}: ${r.estado}`,
-        `  revisao      ${m.revision}`,
-        `  chave        ${r.chave}`,
-        `  snapshot     ${m.snapshot_id}`,
-        `  digest       ${m.graph_digest}`,
-        `  conferencia  conferirFontes verificada: ${m.conferencia.fontes} fontes e ${m.conferencia.evidencias} evidencias contra os bytes`,
-        `  nos          ${contagem(m.contagens.nos)}`,
-        `  arestas      ${contagem(m.contagens.arestas)}`,
-        `  lugar        ${r.dir} (${mb(m.graph_bytes + m.report_bytes + m.units_bytes)})`,
+        mi.titulo(m.repository_id, r.estado), mi.campo(mi.campos.revisao, m.revision), mi.campo(mi.campos.chave, r.chave),
+        mi.campo(mi.campos.snapshot, m.snapshot_id), mi.campo(mi.campos.digest, m.graph_digest),
+        mi.campo(mi.campos.conferencia, mi.conferencia(m.conferencia.fontes, m.conferencia.evidencias)),
+        mi.campo(mi.campos.nos, contagem(m.contagens.nos)), mi.campo(mi.campos.arestas, contagem(m.contagens.arestas)),
+        mi.campo(mi.campos.lugar, `${r.dir} (${mb(m.graph_bytes + m.report_bytes + m.units_bytes)})`),
         ...linhasDaExtracao(r),
     ];
     if (r.motivo)
-        linhas.push(`  motivo       ${r.motivo}`);
+        linhas.push(mi.campo(mi.campos.motivo, r.motivo));
     for (const d of r.determinismo ?? []) {
-        linhas.push(`  determinismo ${d.ordem}: digest ${d.digest.slice(0, 16)}, relatorio ${d.relatorio.slice(0, 16)}, unidades ${d.unidades.slice(0, 16)}, ${d.igual ? 'igual' : 'DIFERENTE'}`);
+        linhas.push(mi.determinismo(d.ordem, d.digest.slice(0, 16), d.relatorio.slice(0, 16), d.unidades.slice(0, 16), d.igual));
     }
     if (r.incremental)
-        linhas.push(`  incremental  a partir do indice de ${r.incremental.base.slice(0, 12)}: ${r.incremental.igual ? 'igual a completa nos quatro arquivos' : 'DIFERENTE'}`);
+        linhas.push(mi.incremental(r.incremental.base.slice(0, 12), r.incremental.igual));
     else if (r.determinismo)
-        linhas.push(`  incremental  nao conferido: ${r.motivo_completo ?? 'sem base'}`);
-    linhas.push(`  tempo        ${r.ms} ms`);
+        linhas.push(mi.naoConferido(r.motivo_completo ?? mi.semBase));
+    linhas.push(mi.campo(mi.campos.tempo, `${r.ms} ms`));
     if (r.determinismo)
-        linhas.push('aprovado');
+        linhas.push(mi.aprovado);
     ctx.escrever(linhas.join('\n'));
     return 0;
 }
@@ -304,21 +358,22 @@ function status(ctx, p) {
         ctx.escrever(JSON.stringify(r, null, 2));
         return 0;
     }
+    const ms = textosDe(ctx).status;
     const linhas = [
-        `grafo: HEAD ${arvore.head ? arvore.head.slice(0, 12) : 'sem commit'}, arvore ${r.arvore}`,
-        `  indice do HEAD  ${chave ?? 'indisponivel'} ${r.indice_do_head === 'ausente' ? '(ausente: rode ork grafo indexar)'
+        ms.titulo(arvore.head ? arvore.head.slice(0, 12) : ms.semCommit, r.arvore),
+        ms.indice(chave ?? ms.indisponivel, r.indice_do_head === 'ausente' ? ms.ausente
             : r.indice_do_head === 'indisponivel'
-                ? (correcao ? '(sem os analisadores nesta instalacao, nem a consulta nem o indexar rodam)' : '(sem a chave do indice: o erro esta na linha de baixo)')
-                : `(${r.indice_do_head})`}`,
-        `  analisadores    ${erro ?? descreverVersoes(analisadores)}`,
-        ...(correcao ? [`  correcao        ${correcao}`] : []),
-        `  pasta           ${estado.dir ?? 'ainda nao criada'} (${estado.indices.length} indice(s), ${mb(estado.bytes)})`,
+                ? (correcao ? ms.semAnalisadores : ms.semChave)
+                : `(${r.indice_do_head})`),
+        ms.analisadores(erro ?? descreverVersoes(analisadores)),
+        ...(correcao ? [ms.correcao(correcao)] : []),
+        ms.pasta(estado.dir ?? ms.naoCriada, estado.indices.length, mb(estado.bytes)),
     ];
     for (const i of estado.indices) {
         linhas.push(`  ${i.chave.slice(0, 20)}  ${i.revision ? i.revision.slice(0, 12) : '?'}  ${i.repository_id ?? '?'}  ${mb(i.bytes)}  ${i.problema ?? 'ok'}`);
     }
     if (estado.sobras.length)
-        linhas.push(`  sobras          ${estado.sobras.join(', ')}`);
+        linhas.push(ms.sobras(estado.sobras.join(', ')));
     ctx.escrever(linhas.join('\n'));
     return 0;
 }
@@ -395,7 +450,7 @@ function consultavel(ctx) {
     return { g: (0, intelligence_graph_query_1.prepararConsulta)(grafo, concessao), cabecalho, grafo, raiz: arvore.raiz, situacao };
 }
 function responder(ctx, p, r) {
-    ctx.escrever(p.bandeiras.has('json') ? (0, intelligence_graph_query_1.jsonDaResposta)(r) : (0, intelligence_graph_query_1.textoDaResposta)(r));
+    ctx.escrever(p.bandeiras.has('json') ? (0, intelligence_graph_query_1.jsonDaResposta)(r) : (0, intelligence_graph_query_1.textoDaResposta)(r, textosDe(ctx).consulta));
     return 0;
 }
 /**
@@ -435,8 +490,8 @@ function respostaComTeto(perguntar, limite, teto) {
 }
 function consultar(ctx, p) {
     // As opcoes sao conferidas antes de carregar o indice: erro de uso nao custa a leitura do grafo.
-    const [a, b] = p.posicionais;
-    const profundidade = inteiro(p, 'profundidade'), limite = inteiro(p, 'limite'), s = sentido(p), t = tipos(p), teto = tetoDeBytes(p);
+    const [a, b] = p.posicionais, x = textosDe(ctx);
+    const profundidade = inteiro(p, 'profundidade', x), limite = inteiro(p, 'limite', x), s = sentido(p, x), t = tipos(p, x), teto = tetoDeBytes(p, x);
     const { g, cabecalho, situacao } = consultavel(ctx);
     // A busca binaria do teto pergunta de novo com outro limite; a situacao guarda o que ja leu da arvore.
     const perguntar = (lim) => {
@@ -454,7 +509,7 @@ function consultar(ctx, p) {
     return 0;
 }
 function contexto(ctx, p) {
-    const teto = tetoDeBytes(p);
+    const teto = tetoDeBytes(p, textosDe(ctx));
     if (teto !== undefined && (teto < 4096 || teto > 65536))
         throw new intelligence_graph_query_1.ErroDeConsulta('grafo.contexto.teto-invalido', 'teto deve ser inteiro de 4096 a 65536 bytes');
     if (!ctx.contextoDaThread)
@@ -470,12 +525,11 @@ function contexto(ctx, p) {
         const r = JSON.parse(json);
         // KG5 fatia 5 (D9): o resumo conta as ligacoes cuja fonte mudou na arvore, como o JSON marca.
         const mudadas = r.arestas.filter((a) => a.arvore === 'modificada').length;
-        ctx.escrever([`Contexto ${r.thread} @ ${r.indice.revision}`,
-            `  ${r.sementes.length}/${r.total_sementes} sementes, ${r.arestas.length}/${r.total_ligacoes} ligacoes agregadas; ${r.medida.pacote_bytes} bytes JSON`,
-            `  tamanho dos arquivos no pacote (nao descoberta): ${r.medida.leitura_crua_bytes} bytes (revisao indexada); tokens: unavailable`,
-            `  diff: ${r.fontes.diff}`,
-            ...(mudadas ? [`  ligacoes com fonte modificada na arvore: ${mudadas}`] : []),
-            `  truncado: ${r.truncado}; arvore: ${r.indice.arvore}; use --json para nos e evidencias`, json].join('\n'));
+        const mc = textosDe(ctx).contexto;
+        ctx.escrever([mc.titulo(r.thread, r.indice.revision),
+            mc.resumo(r.sementes.length, r.total_sementes, r.arestas.length, r.total_ligacoes, r.medida.pacote_bytes),
+            mc.tamanho(r.medida.leitura_crua_bytes), mc.diff(r.fontes.diff), ...(mudadas ? [mc.mudadas(mudadas)] : []),
+            mc.final(r.truncado, r.indice.arvore), json].join('\n'));
     }
     return 0;
 }
@@ -618,7 +672,7 @@ function amostrar(grafo, ler, porEstrato, digest) {
     };
 }
 /** Confere a amostra auditada contra o indice do HEAD: aresta, trecho pelo hash, veredito com nota. */
-function conferirAmostra(grafo, ler, arquivo) {
+function conferirAmostra(grafo, ler, arquivo, ma) {
     const amostra = JSON.parse(fs.readFileSync(arquivo, 'utf8'));
     if (amostra.schema !== exports.AMOSTRA_SCHEMA || !Array.isArray(amostra.arestas))
         return { linhas: [], falhas: [`schema da amostra: ${amostra.schema}`] };
@@ -646,32 +700,32 @@ function conferirAmostra(grafo, ler, arquivo) {
         if (!bate)
             falhas.push(`${chave}: nenhuma evidencia com o trecho auditado`);
     }
-    const linhas = [
-        `amostra: ${amostra.arestas.length} arestas em ${estratos.size} estratos, auditada na revisao ${amostra.revision ?? amostra.revision_unavailable_reason}`,
-        `  vereditos ${Object.entries(vereditos).sort(([x], [y]) => (0, intelligence_graph_contract_1.compararUtf8)(x, y)).map(([k, v]) => `${k}=${v}`).join(' ')}`,
-        `  conferidas contra o indice do HEAD: ${amostra.arestas.length - falhas.length} de ${amostra.arestas.length}`,
-    ];
+    const linhas = [ma.titulo(amostra.arestas.length, estratos.size, amostra.revision ?? amostra.revision_unavailable_reason),
+        ma.vereditos(Object.entries(vereditos).sort(([x], [y]) => (0, intelligence_graph_contract_1.compararUtf8)(x, y)).map(([k, v]) => `${k}=${v}`).join(' ')),
+        ma.conferidas(amostra.arestas.length - falhas.length, amostra.arestas.length)];
     return { linhas, falhas };
 }
 function amostra(ctx, p) {
+    const t = textosDe(ctx);
     if (p.valores.has('conferir') && p.valores.has('por-estrato'))
-        uso('--conferir e --por-estrato nao combinam');
+        uso(t.motivos.amostraExclusiva, t);
     const { grafo, raiz, cabecalho } = consultavel(ctx);
     const ler = leitorDaArvore(raiz, grafo);
     const arquivo = p.valores.get('conferir');
     if (arquivo === undefined) {
-        const n = inteiro(p, 'por-estrato') ?? 3;
+        const n = inteiro(p, 'por-estrato', t) ?? 3;
         if (n < 1)
-            uso('--por-estrato precisa ser ao menos 1');
+            uso(t.motivos.estratoMin, t);
         ctx.escrever(JSON.stringify(amostrar(grafo, ler, n, cabecalho.graph_digest), null, 2));
         return 0;
     }
-    const { linhas, falhas } = conferirAmostra(grafo, ler, arquivo);
+    const { linhas, falhas } = conferirAmostra(grafo, ler, arquivo, t.amostra);
     if (p.bandeiras.has('json')) {
         ctx.escrever(JSON.stringify({ schema: exports.AMOSTRA_SCHEMA, conferencia: linhas, falhas, aprovado: falhas.length === 0 }, null, 2));
     }
     else {
-        ctx.escrever([...linhas, ...falhas.map((f) => `FALHA ${f}`), falhas.length ? `reprovado: ${falhas.length} falha(s)` : 'aprovado'].join('\n'));
+        const ma = t.amostra;
+        ctx.escrever([...linhas, ...falhas.map((f) => ma.falha(f)), falhas.length ? ma.reprovado(falhas.length) : ma.aprovado].join('\n'));
     }
     return falhas.length ? 1 : 0;
 }
@@ -688,7 +742,7 @@ function limpar(ctx, p) {
     if (p.bandeiras.has('json'))
         ctx.escrever(JSON.stringify({ schema: exports.STATUS_SCHEMA, manter, manter_revisoes: manterRevisoes, ...r }, null, 2));
     else
-        ctx.escrever([`grafo limpar: ${r.removidos.length} removido(s), ${mb(r.bytes)}`, ...r.removidos.map((x) => `  ${x.nome} ${mb(x.bytes)}`)].join('\n'));
+        ctx.escrever([textosDe(ctx).limpar(r.removidos.length, mb(r.bytes)), ...r.removidos.map((x) => `  ${x.nome} ${mb(x.bytes)}`)].join('\n'));
     return 0;
 }
 /** KG5 (D4, D5): com `--teto-bytes` o erro tambem sai compacto; recusa de indice traz o estado e a correcao. */
@@ -709,7 +763,7 @@ function executarGrafo(argv, ctx) {
     const compacto = argv[0] === 'contexto' || argv.some((a) => a === '--teto-bytes' || a.startsWith('--teto-bytes='));
     let p;
     try {
-        p = lerPedido(argv);
+        p = lerPedido(argv, textosDe(ctx));
     }
     catch (e) {
         // Com `--json` no argv, tambem o erro de uso sai como objeto, como os demais.

package/dist/intelligence-graph-query.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.rotuloDoNo = exports.ErroDeConsulta = exports.TUDO_IGUAL = exports.AVISO_DE_PARCIALIDADE = exports.CANDIDATOS_LISTADOS = exports.LIMITE_MAXIMO = exports.LIMITE_PADRAO = exports.PROFUNDIDADE_MAXIMA = exports.CONSULTA_SCHEMA = void 0;
+exports.rotuloDoNo = exports.ErroDeConsulta = exports.TUDO_IGUAL = exports.TEXTOS_DA_CONSULTA = exports.AVISO_DE_PARCIALIDADE = exports.CANDIDATOS_LISTADOS = exports.LIMITE_MAXIMO = exports.LIMITE_PADRAO = exports.PROFUNDIDADE_MAXIMA = exports.CONSULTA_SCHEMA = void 0;
 exports.filtrarGrafo = filtrarGrafo;
 exports.prepararConsulta = prepararConsulta;
 exports.resolverNo = resolverNo;
@@ -36,6 +36,22 @@ exports.LIMITE_MAXIMO = 10_000;
 /** Candidatos listados quando um nome solto e ambiguo. */
 exports.CANDIDATOS_LISTADOS = 20;
 exports.AVISO_DE_PARCIALIDADE = 'parcial: so arestas que o extrator prova; chamada por despacho de tipo, import nao resolvido e as lacunas do relatorio de extracao ficam fora';
+exports.TEXTOS_DA_CONSULTA = {
+    titulo: (repositorio, revisao, chave, snapshot) => `grafo de ${repositorio} na revisao ${revisao}, indice ${chave}, snapshot ${snapshot}`,
+    arvore: 'aviso: a arvore tem mudanca rastreada; a resposta e do HEAD, nao da arvore',
+    fontes: (lista, resto) => `fontes que mudaram na arvore: ${lista}${resto ? ` e mais ${resto}` : ''}`,
+    marca: '  [fonte modificada na arvore]',
+    pagina: (pagina) => `pagina ${pagina}`,
+    extratores: (lista) => `extratores: ${lista}`,
+    semCaminho: (de, para, sentido, nos) => `sem caminho de ${de} para ${para} (sentido ${sentido}): ${nos} nos explorados`,
+    caminho: (de, para, sentido, passos) => `caminho de ${de} para ${para} (sentido ${sentido}): ${passos} passo(s)`,
+    contra: '(contra a aresta) ',
+    todos: 'todos',
+    resultado: (tipo, alvo, profundidade, filtro, arestas, nos) => `${tipo} de ${alvo} (profundidade ${profundidade}${filtro}): ${arestas} aresta(s), ${nos} no(s)`,
+    filtro: (sentido, tipos) => `, sentido ${sentido}, tipos ${tipos}`,
+    truncado: (devolvidas, total) => `truncado: ${devolvidas} de ${total} arestas, as mais perto do alvo; use --limite`,
+    parcial: exports.AVISO_DE_PARCIALIDADE,
+};
 /** Sem saber da arvore, toda fonte vale `igual`: e o que a arvore limpa garante. */
 const TUDO_IGUAL = () => 'igual';
 exports.TUDO_IGUAL = TUDO_IGUAL;
@@ -339,53 +355,52 @@ function caminho(g, cabecalho, de, para, opcoes = {}, situacao = exports.TUDO_IG
 function jsonDaResposta(r) {
     return JSON.stringify(r, null, 2);
 }
-function linhasDaEvidencia(e) {
+function linhasDaEvidencia(e, m) {
     const s = e.span;
     const onde = s.type === 'text'
         ? `${e.path}:${s.line_start ?? '?'}${s.line_end !== null && s.line_end !== s.line_start ? `-${s.line_end}` : ''}`
-        : `${e.path} pagina ${s.page}`;
+        : `${e.path} ${m.pagina(s.page)}`;
     return `      ${e.extractor_id} ${e.extraction_method} ${onde} bytes ${s.byte_start}-${s.byte_end}`;
 }
 /** KG5 fatia 5 (D9): a aresta cuja fonte mudou diz isso na propria linha, como o JSON diz no campo `arvore`. */
-function linhasDaAresta(a, prefixo = '  ') {
-    const marca = a.arvore === 'modificada' ? '  [fonte modificada na arvore]' : '';
-    return [`${prefixo}${a.kind}  ${a.from} -> ${a.to}${marca}`, ...a.evidencias.map(linhasDaEvidencia)];
+function linhasDaAresta(a, m, prefixo = '  ') {
+    const marca = a.arvore === 'modificada' ? m.marca : '';
+    return [`${prefixo}${a.kind}  ${a.from} -> ${a.to}${marca}`, ...a.evidencias.map((e) => linhasDaEvidencia(e, m))];
 }
 /** KG5 fatia 5 (D9): ate cinco fontes que nao tem na arvore os bytes do indice, com a situacao de cada uma. */
-function linhaDasFontesMudadas(fontes) {
+function linhaDasFontesMudadas(fontes, m) {
     const mudaram = fontes.filter((f) => f.arvore !== 'igual');
     if (!mudaram.length)
         return [];
-    const resto = mudaram.length > 5 ? ` e mais ${mudaram.length - 5}` : '';
-    return [`fontes que mudaram na arvore: ${mudaram.slice(0, 5).map((f) => `${f.path} (${f.arvore})`).join(', ')}${resto}`];
+    return [m.fontes(mudaram.slice(0, 5).map((f) => `${f.path} (${f.arvore})`).join(', '), Math.max(0, mudaram.length - 5))];
 }
-function textoDaResposta(r) {
+function textoDaResposta(r, m = exports.TEXTOS_DA_CONSULTA) {
     const c = r.consulta, i = r.indice;
     const linhas = [
-        `grafo de ${i.repository_id} na revisao ${i.revision.slice(0, 12)}, indice ${i.chave.slice(0, 16)}, snapshot ${i.snapshot_id.slice(0, 17)}`,
+        m.titulo(i.repository_id, i.revision.slice(0, 12), i.chave.slice(0, 16), i.snapshot_id.slice(0, 17)),
     ];
     if (i.arvore === 'modificada')
-        linhas.push('aviso: a arvore tem mudanca rastreada; a resposta e do HEAD, nao da arvore');
-    linhas.push(...linhaDasFontesMudadas(r.fontes));
-    linhas.push(`extratores: ${i.extratores.map((e) => `${e.extractor_id} ${e.extractor_version}`).join(', ')}`);
+        linhas.push(m.arvore);
+    linhas.push(...linhaDasFontesMudadas(r.fontes, m));
+    linhas.push(m.extratores(i.extratores.map((e) => `${e.extractor_id} ${e.extractor_version}`).join(', ')));
     if (c.tipo === 'caminho') {
         const para = r.para;
         if (!r.caminho) {
-            linhas.push(`sem caminho de ${r.alvo.rotulo} para ${para.rotulo} (sentido ${c.sentido}): ${r.nos_explorados} nos explorados`);
+            linhas.push(m.semCaminho(r.alvo.rotulo, para.rotulo, c.sentido, r.nos_explorados));
         }
         else {
-            linhas.push(`caminho de ${r.alvo.rotulo} para ${para.rotulo} (sentido ${c.sentido}): ${r.caminho.length} passo(s)`);
-            r.caminho.forEach((p, n) => linhas.push(...linhasDaAresta(p.aresta, `  ${n + 1}. ${p.sentido === 'entrada' ? '(contra a aresta) ' : ''}`)));
+            linhas.push(m.caminho(r.alvo.rotulo, para.rotulo, c.sentido, r.caminho.length));
+            r.caminho.forEach((p, n) => linhas.push(...linhasDaAresta(p.aresta, m, `  ${n + 1}. ${p.sentido === 'entrada' ? m.contra : ''}`)));
         }
     }
     else {
-        const filtro = c.tipo === 'vizinhos' ? `, sentido ${c.sentido}, tipos ${c.tipos.length === intelligence_graph_contract_1.TIPOS_DE_ARESTA.length ? 'todos' : c.tipos.join(',')}` : '';
-        linhas.push(`${c.tipo} de ${r.alvo.rotulo} (profundidade ${c.profundidade}${filtro}): ${r.total_arestas} aresta(s), ${r.total_nos - 1} no(s)`);
+        const filtro = c.tipo === 'vizinhos' ? m.filtro(c.sentido, c.tipos.length === intelligence_graph_contract_1.TIPOS_DE_ARESTA.length ? m.todos : c.tipos.join(',')) : '';
+        linhas.push(m.resultado(c.tipo, r.alvo.rotulo, c.profundidade, filtro, r.total_arestas, r.total_nos - 1));
         for (const a of r.arestas)
-            linhas.push(...linhasDaAresta(a));
+            linhas.push(...linhasDaAresta(a, m));
         if (r.truncado)
-            linhas.push(`truncado: ${r.arestas.length} de ${r.total_arestas} arestas, as mais perto do alvo; use --limite`);
+            linhas.push(m.truncado(r.arestas.length, r.total_arestas));
     }
-    linhas.push(r.parcial);
+    linhas.push(m.parcial);
     return linhas.join('\n');
 }