@orkastery/cli 0.5.3 → 0.6.0

package/dist/intelligence-graph-cli.js

@@ -33,11 +33,12 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CORRECAO_DO_INDICE = exports.USO_DO_GRAFO = exports.AMOSTRA_SCHEMA = 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;
 exports.lerPedido = lerPedido;
+exports.situacaoNaArvore = situacaoNaArvore;
 exports.executarGrafo = executarGrafo;
 /**
  * RM-031 KG3 (D7, D8): `ork grafo`, o CLI do indice e da consulta do grafo de codigo.
@@ -78,17 +79,21 @@ const RECUSA_DOS_ANALISADORES = 'grafo.parser.indisponivel';
  * de `MODULOS_DO_EXTRATOR`, para a redacao nao entrar na chave do indice; a versao vem de quem chama
  * (o `index.ts`), porque o CLI do grafo so importa a propria familia (fronteira do KG3).
  */
-function correcaoDosAnalisadores(motivo, versao) {
-    if (/ERR_REQUIRE_ESM/.test(motivo)) {
-        return `o micromark e so ESM, e este Node (${process.version}) nao o carrega por require: use Node 20.19, 22.12 ou mais novo, ` +
-            'sem a opcao --no-experimental-require-module (na linha de comando ou no NODE_OPTIONS)';
-    }
+function correcaoDosAnalisadores(motivo, versao, redacao = exports.REDACAO_DOS_ANALISADORES) {
+    if (/ERR_REQUIRE_ESM/.test(motivo))
+        return redacao.soEsm(process.version);
     // Sem a versao do pacote (`0.0.0-desconhecida` quando o package.json dele nao e achado), o comando
     // sai sem `@<versao>` e o npm instala a ultima publicada.
     const fixada = versao && /^\d+\.\d+\.\d+/.test(versao) && !versao.startsWith('0.0.0') ? `@${versao}` : '';
-    return `reinstale o ork global, que traz os analisadores como dependencias: npm install -g @orkastery/cli${fixada}` +
-        ' (instalado dentro de um projeto ou pelo npx, o npm deixa os analisadores fora do pacote do ork, e o grafo os recusa)';
+    return redacao.reinstale(fixada);
 }
+exports.REDACAO_DOS_ANALISADORES = {
+    recusa: (motivo) => `${motivo}: o ork grafo indexar recusa nesta instalacao, e sem o indice as consultas e as tools ork_grafo_* tambem`,
+    soEsm: (versaoDoNode) => `o micromark e so ESM, e este Node (${versaoDoNode}) nao o carrega por require: use Node 20.19, 22.12 ou mais novo, ` +
+        'sem a opcao --no-experimental-require-module (na linha de comando ou no NODE_OPTIONS)',
+    reinstale: (fixada) => `reinstale o ork global, que traz os analisadores como dependencias: npm install -g @orkastery/cli${fixada}` +
+        ' (instalado dentro de um projeto ou pelo npx, o npm deixa os analisadores fora do pacote do ork, e o grafo os recusa)',
+};
 /**
  * RM-031 (pacote do npm): o check "analisadores do grafo" do `ork doctor`. Carrega o que o
  * `ork grafo indexar` carrega (`carregarAnalisadores`), entao diz o que o indexar faria, inclusive no
@@ -96,7 +101,7 @@ function correcaoDosAnalisadores(motivo, versao) {
  * fase. Fora da familia do grafo so o `index.ts` e o worker do MCP a abrem (fronteira do KG1), entao o
  * `index.ts` passa este check ao doctor, que nao importa o grafo.
  */
-function checarAnalisadoresDoGrafo(versao, carregar = intelligence_graph_parsers_1.carregarAnalisadores, versoes = intelligence_graph_parsers_1.versoesDosAnalisadores) {
+function checarAnalisadoresDoGrafo(versao, carregar = intelligence_graph_parsers_1.carregarAnalisadores, versoes = intelligence_graph_parsers_1.versoesDosAnalisadores, redacao = exports.REDACAO_DOS_ANALISADORES) {
     const nome = 'analisadores do grafo';
     try {
         carregar();
@@ -104,9 +109,7 @@ function checarAnalisadoresDoGrafo(versao, carregar = intelligence_graph_parsers
     }
     catch (e) {
         const motivo = e.message;
-        return { nome, nivel: 'warn',
-            detalhe: `${motivo}: o ork grafo indexar recusa nesta instalacao, e sem o indice as consultas e as tools ork_grafo_* tambem`,
-            correcao: correcaoDosAnalisadores(motivo, versao) };
+        return { nome, nivel: 'warn', detalhe: redacao.recusa(motivo), correcao: correcaoDosAnalisadores(motivo, versao, redacao) };
     }
 }
 /** O mesmo schema da amostra do KG2: as amostras auditadas continuam validas. */
@@ -122,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. */
@@ -131,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: [] },
@@ -142,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];
@@ -162,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`;
@@ -247,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;
 }
@@ -301,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;
 }
@@ -366,7 +424,10 @@ function semIndiceDoHead(ctx, original) {
     }
     throw original;
 }
-/** O indice do HEAD pronto para consulta, com a concessao local e o cabecalho; `grafo` ja vem filtrado por ela. */
+/**
+ * O indice do HEAD pronto para consulta, com a concessao local e o cabecalho; `grafo` ja vem filtrado por ela.
+ * KG5 fatia 5 (D3): `situacao` so le a arvore quando o cabecalho diz `modificada`; limpa, tudo vale `igual`.
+ */
 function consultavel(ctx) {
     let doHead;
     try {
@@ -385,10 +446,11 @@ function consultavel(ctx) {
         arvore: arvore.motivo === null ? 'limpa' : 'modificada',
         extratores: grafo.snapshot.extractors.map((e) => ({ extractor_id: e.extractor_id, extractor_version: e.extractor_version })),
     };
-    return { g: (0, intelligence_graph_query_1.prepararConsulta)(grafo, concessao), cabecalho, grafo, raiz: arvore.raiz };
+    const situacao = cabecalho.arvore === 'limpa' ? intelligence_graph_query_1.TUDO_IGUAL : situacaoNaArvore(arvore.raiz, grafo.snapshot.source_manifest);
+    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;
 }
 /**
@@ -428,17 +490,18 @@ 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 { g, cabecalho } = consultavel(ctx);
+    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) => {
         if (p.sub === 'vizinhos')
-            return (0, intelligence_graph_query_1.vizinhos)(g, cabecalho, a, { profundidade, limite: lim, sentido: s, tipos: t });
+            return (0, intelligence_graph_query_1.vizinhos)(g, cabecalho, a, { profundidade, limite: lim, sentido: s, tipos: t }, situacao);
         if (p.sub === 'chamadores')
-            return (0, intelligence_graph_query_1.chamadores)(g, cabecalho, a, { profundidade, limite: lim });
+            return (0, intelligence_graph_query_1.chamadores)(g, cabecalho, a, { profundidade, limite: lim }, situacao);
         if (p.sub === 'importadores')
-            return (0, intelligence_graph_query_1.importadores)(g, cabecalho, a, { profundidade, limite: lim });
-        return (0, intelligence_graph_query_1.caminho)(g, cabecalho, a, b, { sentido: s, tipos: t });
+            return (0, intelligence_graph_query_1.importadores)(g, cabecalho, a, { profundidade, limite: lim }, situacao);
+        return (0, intelligence_graph_query_1.caminho)(g, cabecalho, a, b, { sentido: s, tipos: t }, situacao);
     };
     if (teto === undefined)
         return responder(ctx, p, perguntar(limite));
@@ -446,25 +509,27 @@ 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)
         throw new intelligence_graph_query_1.ErroDeConsulta('grafo.contexto.indisponivel', 'borda sem leitor da thread');
     const lido = ctx.contextoDaThread(p.posicionais[0]);
-    const { grafo, cabecalho } = consultavel({ ...ctx, raiz: lido.raiz });
+    const { grafo, cabecalho, situacao } = consultavel({ ...ctx, raiz: lido.raiz });
     if (lido.head !== cabecalho.revision)
         throw new intelligence_graph_query_1.ErroDeConsulta('grafo.contexto.revisao-mudou', 'HEAD mudou durante a leitura; repita a consulta');
-    const json = (0, intelligence_graph_contexto_1.pacoteDeContexto)(grafo, cabecalho, lido.entrada, teto);
+    const json = (0, intelligence_graph_contexto_1.pacoteDeContexto)(grafo, cabecalho, lido.entrada, teto, situacao);
     if (p.bandeiras.has('json'))
         ctx.escrever(json);
     else {
         const r = JSON.parse(json);
-        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}`,
-            `  truncado: ${r.truncado}; arvore: ${r.indice.arvore}; use --json para nos e evidencias`, json].join('\n'));
+        // 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;
+        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;
 }
@@ -507,6 +572,66 @@ function leitorDaArvore(raiz, grafo) {
         return bytes;
     };
 }
+/**
+ * KG5 fatia 5 (D3, D6): a situacao de cada fonte do indice na arvore, pelos bytes. So caminho do manifesto;
+ * sem seguir link, nem no ultimo nome nem numa pasta do caminho: o caminho real tem de ser o proprio caminho
+ * indexado dentro da raiz (CHECK rodada 1, A1). So arquivo regular; tamanho diferente do indexado e
+ * `modificada` sem ler, e o sha256 dos bytes decide o resto, lidos ate o tamanho indexado mais um. O arquivo
+ * aberto tem de ser o mesmo do `lstat` (dispositivo e inode, CHECK rodada 1, S3): troca entre a conferencia e
+ * a abertura vira `ausente`; duas trocas no intervalo ainda passam, e revelariam so se os bytes sao os
+ * indexados. Qualquer falha e `ausente`: nao ha arquivo regular legivel no caminho. Cada caminho e lido uma
+ * vez, sob demanda, e nada e escrito.
+ */
+function situacaoNaArvore(raiz, manifesto) {
+    const porCaminho = new Map(manifesto.map((m) => [m.path, m]));
+    const vistas = new Map();
+    let raizReal = null;
+    const ler = (p) => {
+        const m = porCaminho.get(p);
+        if (!m)
+            return 'ausente';
+        const absoluto = path.join(raiz, p);
+        try {
+            raizReal ??= fs.realpathSync(raiz);
+            const st = fs.lstatSync(absoluto, { throwIfNoEntry: false });
+            if (!st || !st.isFile())
+                return 'ausente';
+            // CHECK rodada 2 (R2-S1): caminho de manifesto adulterado com `..` coincidiria com o real fora da raiz.
+            const real = fs.realpathSync(absoluto);
+            if (real !== path.join(raizReal, p) || !real.startsWith(raizReal + path.sep))
+                return 'ausente';
+            if (st.size !== m.size_bytes)
+                return 'modificada';
+            const fd = fs.openSync(absoluto, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW | fs.constants.O_NONBLOCK);
+            try {
+                const aberto = fs.fstatSync(fd);
+                if (!aberto.isFile() || aberto.dev !== st.dev || aberto.ino !== st.ino)
+                    return 'ausente';
+                if (aberto.size !== m.size_bytes)
+                    return 'modificada';
+                const bytes = Buffer.alloc(m.size_bytes + 1);
+                let lidos = 0;
+                for (let n = 1; n > 0 && lidos < bytes.length; lidos += n)
+                    n = fs.readSync(fd, bytes, lidos, bytes.length - lidos, null);
+                return lidos === m.size_bytes && sha256(bytes.subarray(0, lidos)) === m.source_hash ? 'igual' : 'modificada';
+            }
+            finally {
+                fs.closeSync(fd);
+            }
+        }
+        catch {
+            return 'ausente';
+        }
+    };
+    return (p) => {
+        const vista = vistas.get(p);
+        if (vista !== undefined)
+            return vista;
+        const s = ler(p);
+        vistas.set(p, s);
+        return s;
+    };
+}
 const localizadorDe = (g) => new Map(g.nodes.map((n) => [n.node_id, { kind: n.kind, path: n.locator.path, fragment: n.locator.fragment }]));
 const rotulo = (l) => `${l.kind}:${l.path}${l.fragment === null ? '' : `#${l.fragment}`}`;
 const chaveDaAresta = (kind, de, para) => `${kind} ${rotulo(de)} -> ${rotulo(para)}`;
@@ -547,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}`] };
@@ -575,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;
 }
@@ -617,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. */
@@ -638,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.