@orkastery/cli 0.5.1 → 0.5.6

package/dist/intelligence-graph-extract-md.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TETO_DE_LINHAS_DE_TABELA = exports.TOKENS_SEM_MENCAO = exports.CHAVES_DO_FRONTMATTER = exports.PADRAO_DE_ID = void 0;
 exports.slugDeTexto = slugDeTexto;
+exports.caminhoDaCitacao = caminhoDaCitacao;
 exports.estruturarMarkdown = estruturarMarkdown;
 exports.extrairMarkdown = extrairMarkdown;
 exports.ligarMarkdown = ligarMarkdown;
@@ -191,9 +192,10 @@ function estruturar(fonte, aceitaFragmento, analisar, referencia) {
             comDelimitador = true;
     }
     if (linhasDeTabela > exports.TETO_DE_LINHAS_DE_TABELA) {
-        return { fonte, secoes: [], links: [], textoDeMencao: [], frontmatter, frontmatterInvalido, tabelaGrande: true };
+        return { fonte, secoes: [], links: [], citacoes: [], textoDeMencao: [], frontmatter, frontmatterInvalido, tabelaGrande: true };
     }
     const secoes = [], links = [], semMencao = [];
+    const citacoes = [];
     const slug = contadorDeSlugs(), abertos = [];
     // B5: referencia de caractere pelo decodificador do micromark (as entidades do HTML5); a crua fica.
     const decodificada = (i, f) => referencia(corpo.slice(i + 1, f - 1)) ?? corpo.slice(i, f);
@@ -239,6 +241,10 @@ function estruturar(fonte, aceitaFragmento, analisar, referencia) {
                 semMencao.push([e.inicio, e.fim]);
             }
             // Titulo, lido em paralelo: o texto dele junta dado, codigo, escape e entidade.
+            if (e.tipo === 'codeTextData' && !emExcesso)
+                citacoes.push({
+                    destino: corpo.slice(e.inicio, e.fim), inicio: no(e.inicio), fim: no(e.fim),
+                });
             if (e.tipo === 'atxHeading' || e.tipo === 'setextHeading')
                 titulo = { inicio: no(e.inicio), fim: no(e.fim), partes: [], noTexto: 0, foraDoTexto: 0, noCodigo: 0 };
             else if (titulo) {
@@ -304,7 +310,7 @@ function estruturar(fonte, aceitaFragmento, analisar, referencia) {
         }
     }
     const textoDeMencao = linhasDe(apagarTrechos(corpo, semMencao)).map((l) => ({ inicio: no(l.inicio), texto: l.texto }));
-    return { fonte, secoes: secoes.sort((a, b) => a.inicio - b.inicio), links, textoDeMencao, frontmatter, frontmatterInvalido, tabelaGrande: false };
+    return { fonte, secoes: secoes.sort((a, b) => a.inicio - b.inicio), links, citacoes, textoDeMencao, frontmatter, frontmatterInvalido, tabelaGrande: false };
 }
 /** Caminho relativo a raiz a partir do arquivo do link; `null` se sair do repositorio. */
 function resolverCaminho(base, destino) {
@@ -323,6 +329,23 @@ function resolverCaminho(base, destino) {
     }
     return r.join('/');
 }
+/** Citacao nao e resolucao de runtime: so caminho literal dentro do manifesto. */
+function caminhoDaCitacao(base, literal, modulo = false) {
+    if (!literal || /[\s\\:#?%\u0000-\u001f\u007f]/u.test(literal) || literal.startsWith('/') || literal.startsWith('~'))
+        return null;
+    if (literal.split('/').some((p) => p === '.git' || p === '.orkastery'))
+        return null;
+    // Argumento sem prefixo de caminho e nome de pacote, nao candidato local.
+    if (modulo && !/^\.{1,2}\//.test(literal))
+        return null;
+    // Palavras e diretorios nao sao citacoes de arquivo. Modulos podem omitir extensao.
+    if (!modulo && (!literal.includes('/') || !/\.(?:[cm]?[jt]s|[jt]sx|json|md|markdown|ya?ml|toml|py|rs|go|c|h|css|html|svg|png|jpe?g|gif|webp|pdf|txt|sh|sql)$/i.test(literal)))
+        return null;
+    if (['', '.', '..'].includes(literal.split('/').at(-1)))
+        return null;
+    const caminho = literal.startsWith('./') || literal.startsWith('../') ? resolverCaminho(base, literal) : literal;
+    return caminho || null;
+}
 const decodificar = (t) => {
     try {
         return decodeURIComponent(t);
@@ -339,7 +362,7 @@ function estruturarMarkdown(fonte, e) {
             mencoes.push({ inicio: l.inicio + m.index, id: m[0] });
     const d = s.frontmatter?.dados;
     return {
-        path: fonte.path, secoes: s.secoes, links: s.links, mencoes,
+        path: fonte.path, secoes: s.secoes, links: s.links, citacoes: s.citacoes, mencoes,
         frontmatter: s.frontmatter && d
             ? { id: typeof d.id === 'string' ? d.id : null, tipo: typeof d.tipo === 'string' && d.tipo !== '', valores: s.frontmatter.valores }
             : null,
@@ -414,6 +437,13 @@ function ligarMarkdown(e) {
     };
     for (const s of estruturas) {
         const path = s.path, arquivo = { kind: 'file', path, fragment: null };
+        const citar = (alvo, k, metodo) => {
+            if (alvo === null || alvo === path || !arquivos.has(alvo))
+                return false;
+            aresta('cites', secaoEm(s, arquivo, k.inicio), { kind: 'file', path: alvo, fragment: null }, e.extratorMd, metodo, { path, inicio: k.inicio, fim: k.fim });
+            return true;
+        };
+        const linksReferenciados = [];
         for (const x of s.secoes) {
             if (x.slug === null) {
                 lacuna('secao-recusada', path, x.inicio, null);
@@ -438,7 +468,15 @@ function ligarMarkdown(e) {
                 lacuna('link-invalido', path, k.inicio, destino);
                 continue;
             }
-            const alvo = caminhoDecodificado === '' ? path : resolverCaminho(path, caminhoDecodificado);
+            const relativo = caminhoDecodificado === '' ? path : resolverCaminho(path, caminhoDecodificado);
+            // Links seguem o diretorio do documento; a citacao tambem admite caminho desde a raiz.
+            const literal = caminhoDaCitacao(path, caminhoDecodificado);
+            // Uma referencia ao arquivo ou a uma secao ja representa esta ocorrencia do link.
+            if (relativo === null || !arquivos.has(relativo)) {
+                if (citar(literal, k, 'explicit-link'))
+                    linksReferenciados.push(k);
+            }
+            const alvo = relativo;
             if (alvo === null) {
                 lacuna('link-fora-do-repositorio', path, k.inicio, destino);
                 continue;
@@ -450,6 +488,7 @@ function ligarMarkdown(e) {
             const secoesDoAlvo = slugs.get(alvo);
             if (ancora && secoesDoAlvo?.has(ancora)) {
                 aresta('references', origem, { kind: 'section', path: alvo, fragment: ancora }, e.extratorMd, 'explicit-link', t);
+                linksReferenciados.push(k);
                 continue;
             }
             // P6: ancora que nao bate fica declarada; o link ainda prova a referencia ao arquivo.
@@ -458,6 +497,19 @@ function ligarMarkdown(e) {
             if (alvo === path)
                 continue;
             aresta('references', origem, { kind: 'file', path: alvo, fragment: null }, e.extratorMd, 'explicit-link', t);
+            linksReferenciados.push(k);
+        }
+        // Codigo inline no rotulo pertence a mesma ocorrencia do link ja resolvido.
+        // Varredura por spans preserva citacoes independentes, inclusive na mesma linha.
+        linksReferenciados.sort((a, b) => a.inicio - b.inicio || b.fim - a.fim);
+        let link = 0;
+        for (const k of s.citacoes) {
+            while (link < linksReferenciados.length && linksReferenciados[link].fim <= k.inicio)
+                link++;
+            const l = linksReferenciados[link];
+            if (l && l.inicio <= k.inicio && k.fim <= l.fim)
+                continue;
+            citar(caminhoDaCitacao(path, k.destino), k, 'text-location');
         }
         const artefato = s.frontmatter && s.frontmatter.id !== null ? artefatos.get(s.frontmatter.id) : undefined;
         if (artefato && artefato.path === path && s.frontmatter) {

package/dist/intelligence-graph-extract-ts.js

@@ -3,9 +3,26 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.OPCOES_TS_DESCRITAS = void 0;
 exports.casaSonda = casaSonda;
 exports.extrairTypeScript = extrairTypeScript;
+const intelligence_graph_extract_md_1 = require("./intelligence-graph-extract-md");
 /** Extensoes que o extrator TS le; as do `extensaoDe` do KG2. */
 const EXTENSOES_DO_PROGRAMA = ['.cjs', '.cts', '.js', '.jsx', '.mjs', '.mts', '.ts', '.tsx'];
 const DECLARACOES_TS = ['.d.ts', '.d.mts', '.d.cts'];
+/** KG5: candidatos literais; dist -> src e uma convencao de citacao, nunca prova de import. */
+function candidatosDaCitacao(base) {
+    const formas = (p) => {
+        const semJs = p.replace(/\.(?:[cm]?js|jsx)$/, '');
+        if (semJs !== p)
+            return [semJs + '.ts', semJs + '.tsx', semJs + '.mts', semJs + '.cts'];
+        if (/\.[^/]+$/.test(p))
+            return [];
+        return EXTENSOES_DO_PROGRAMA.flatMap((ext) => [p + ext, p + '/index' + ext]);
+    };
+    const grupos = [[base], formas(base)];
+    const fonte = base.replace(/(^|\/)dist\//, '$1src/');
+    if (fonte !== base)
+        grupos.push([fonte], formas(fonte));
+    return grupos;
+}
 /** A base sem a extensao (o TypeScript troca `.js` por `.ts`, e `.d.ts` conta inteira). */
 function semExtensao(base) {
     const nome = base.slice(base.lastIndexOf('/') + 1);
@@ -283,12 +300,19 @@ function extrairTypeScript(e, ts) {
     /** Fonte TypeScript, que o compilador transforma; JavaScript roda como esta. */
     const compiladoEm = (arquivo) => !EXTENSOES_JS.includes(extensao(arquivo));
     /** Chaves de todos os imports dentro de um no. */
-    function especificadoresEm(raiz) {
+    function especificadoresEm(raiz, literais) {
         const r = [], compilado = compiladoEm(raiz.getSourceFile().fileName);
         const coletar = (n) => {
             const chave = chaveDoImport(n, compilado);
-            if (chave !== null)
+            if (chave !== null) {
                 r.push(chave);
+                const esp = ts.isImportDeclaration(n) || ts.isExportDeclaration(n) ? n.moduleSpecifier
+                    : ts.isImportEqualsDeclaration(n) && ts.isExternalModuleReference(n.moduleReference) ? n.moduleReference.expression
+                        : ts.isImportTypeNode(n) && ts.isLiteralTypeNode(n.argument) ? n.argument.literal
+                            : ts.isCallExpression(n) ? n.arguments[0] : undefined;
+                if (esp)
+                    literais?.set(esp, chave);
+            }
             ts.forEachChild(n, coletar);
         };
         coletar(raiz);
@@ -597,13 +621,15 @@ function extrairTypeScript(e, ts) {
     const divergentesGlobais = new Set();
     // KG4 (D3): por fonte, os caminhos a que as referencias de modulo resolvem e as bases das relativas.
     const dependenciasDe = new Map(), sondasDe = new Map();
+    const citacoesDe = new Map();
     for (const fonte of e.fontes) {
         const sf = programa.getSourceFile(absoluto(fonte.path));
         if (!sf || sf.fileName !== absoluto(fonte.path))
             continue;
         const ext = extensao(fonte.path), mapa = new Map();
         const dependencias = new Set(), sondas = new Set();
-        for (const chave of especificadoresEm(sf)) {
+        const literaisDeModulo = new Map();
+        for (const chave of especificadoresEm(sf, literaisDeModulo)) {
             if (mapa.has(chave))
                 continue;
             const esp = especificadorDaChave(chave), doCompilador = resolver(esp, fonte.path);
@@ -632,6 +658,46 @@ function extrairTypeScript(e, ts) {
             if (divergente)
                 divergentesGlobais.add(`${fonte.path}\u0000${chave}`);
         }
+        // Strings so em testes/scripts. Comentarios, interpolacoes e concatenacoes nao sao avaliados.
+        const citacoes = [];
+        if (/(?:^|\/)(?:tests?|__tests__|scripts?)\/|\.(?:test|spec)\.[cm]?[jt]sx?$/.test(fonte.path)) {
+            const citar = (literal, n, modulo = false) => {
+                const base = (0, intelligence_graph_extract_md_1.caminhoDaCitacao)(fonte.path, literal, modulo);
+                if (base === null)
+                    return;
+                const grupos = candidatosDaCitacao(base);
+                // Inclui ausentes e diretorios: a troca para arquivo invalida a unidade incremental.
+                // So arquivos presentes podem virar alvo; diretorios conservam apenas a sonda.
+                for (const grupo of grupos)
+                    for (const p of grupo)
+                        sondas.add(p);
+                for (const grupo of grupos) {
+                    const presentes = grupo.filter((p) => arquivos.has(p));
+                    if (!presentes.length)
+                        continue;
+                    if (presentes.length === 1 && presentes[0] !== fonte.path) {
+                        dependencias.add(presentes[0]);
+                        citacoes.push({ alvo: presentes[0], trecho: { path: fonte.path, inicio: n.getStart(sf), fim: n.getEnd() } });
+                    }
+                    break; // Ambiguidade nao autoriza escolher uma fonte nem tentar outro grupo.
+                }
+            };
+            const literais = (n) => {
+                if (ts.isStringLiteral(n) || ts.isNoSubstitutionTemplateLiteral(n)) {
+                    const chave = literaisDeModulo.get(n);
+                    // O resolver de import ja provou esta ocorrencia; outra string igual ainda pode citar.
+                    if (chave !== undefined && mapa.get(chave)?.alvo != null)
+                        return;
+                    citar(n.text, n, chave !== undefined);
+                    // Codigo citado por fixture: so argumentos literais de require/import dentro da string.
+                    for (const m of n.text.matchAll(/\b(?:require|import)\s*\(\s*(['"])([^'"\r\n]+)\1\s*\)/g))
+                        citar(m[2], n, true);
+                }
+                ts.forEachChild(n, literais);
+            };
+            literais(sf);
+        }
+        citacoesDe.set(fonte.path, citacoes);
         // O que o TypeScript coleta e a varredura nao ve (tipo importado no JSDoc) tambem liga o checker a outro arquivo.
         for (const nome of nomesDeModulo(sf)) {
             sondar(baseDaSonda(fonte.path, nome), sondas);
@@ -739,6 +805,8 @@ function extrairTypeScript(e, ts) {
         const aresta = (kind, from, to, t) => {
             saida.arestas.push({ kind, from, to, extrator: e.extrator, metodo: 'ast', trecho: t });
         };
+        for (const c of citacoesDe.get(fonte.path) ?? [])
+            aresta('cites', arquivo, { kind: 'file', path: c.alvo, fragment: null }, c.trecho);
         const lacuna = (categoria, n, detalhe = null) => {
             saida.lacunas.push({ categoria, path: fonte.path, inicio: n ? n.getStart(sf) : null, detalhe });
         };

package/dist/intelligence-graph-parsers.js

@@ -46,10 +46,12 @@ exports.carregarAnalisadores = carregarAnalisadores;
  * `typescript` e os pacotes do micromark so valem dentro da instalacao do `ork` que roda (o
  * `node_modules` do pacote `@orkastery/cli` que contem este modulo), nunca do diretorio atual, do
  * `NODE_PATH` nem de uma pasta acima, como a do projeto que instalou o `ork` como dependencia: o
- * repositorio lido e dado, e codigo dele nunca e carregado. Eles nao sao dependencias de runtime do
- * pacote publicado (D1: dependencia nova e decisao de produto); onde faltam ou estao fora da
- * instalacao, a recusa e `grafo.parser.indisponivel: <pacote>`. `pacotesDosAnalisadores` lista o
- * fecho de dependencias deles, com versao, para a chave do indice (CHECK rodada 1, A10).
+ * repositorio lido e dado, e codigo dele nunca e carregado. Desde a correcao de empacotamento da
+ * RM-031 eles sao dependencias de runtime do pacote publicado, com versao exata, e o
+ * `npm install -g` os poe dentro da instalacao; onde faltam ou estao fora dela (o `ork` instalado
+ * dentro de um projeto ou pelo `npx`, que icam as dependencias), a recusa e
+ * `grafo.parser.indisponivel: <pacote>`, e o `ork doctor` diz a correcao. `pacotesDosAnalisadores`
+ * lista o fecho de dependencias deles, com versao, para a chave do indice (CHECK rodada 1, A10).
  *
  * O juiz de sintaxe e o V8 do Node que roda a extracao, o mesmo que carregaria o arquivo. CommonJS
  * compila aqui, em funcao com as variaveis do modulo, como o carregador faz. ESM compila num unico

package/dist/intelligence-graph-query.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.rotuloDoNo = exports.ErroDeConsulta = 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.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;
@@ -23,6 +23,10 @@ exports.textoDaResposta = textoDaResposta;
  *
  * D7: a resposta e a mesma para o mesmo grafo e a mesma pergunta, byte a byte, em texto e em JSON
  * (`ork.code-graph-query/v0`, provisorio e fora do contrato): ordem por code point, sem horario.
+ *
+ * RM-031 KG5 fatia 5 (D2 a D4, D9, D10): a resposta traz `fontes`, o sha256 e o blob de cada caminho
+ * citado, e cada aresta diz se as fontes dela conferem com a arvore. Quem chama passa a situacao de
+ * cada caminho (o CLI le os bytes); sem ela, tudo vale `igual`, e a consulta continua sem arquivo.
  */
 const intelligence_graph_contract_1 = require("./intelligence-graph-contract");
 exports.CONSULTA_SCHEMA = 'ork.code-graph-query/v0';
@@ -32,6 +36,9 @@ 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';
+/** Sem saber da arvore, toda fonte vale `igual`: e o que a arvore limpa garante. */
+const TUDO_IGUAL = () => 'igual';
+exports.TUDO_IGUAL = TUDO_IGUAL;
 /** Erro tipado da consulta; `candidatos` so no nome ambiguo, e so com nos visiveis. */
 class ErroDeConsulta extends Error {
     codigo;
@@ -101,7 +108,11 @@ function prepararConsulta(grafoInteiro, concessao) {
         lista.sort(ordem((a) => rotulos.get(a.from)));
     for (const lista of porFragmento.values())
         lista.sort((x, y) => (0, intelligence_graph_contract_1.compararUtf8)((0, exports.rotuloDoNo)(x), (0, exports.rotuloDoNo)(y)));
-    return { repository_id: grafo.repository_id, snapshot_id: grafo.snapshot.snapshot_id, nos, rotulos, porLocalizador, arquivos, porFragmento, saida, entrada };
+    const fontes = new Map();
+    for (const m of grafo.snapshot.source_manifest)
+        if (visivel(m.access, concessao))
+            fontes.set(m.path, { source_hash: m.source_hash, source_version: m.source_version });
+    return { repository_id: grafo.repository_id, snapshot_id: grafo.snapshot.snapshot_id, nos, rotulos, porLocalizador, arquivos, porFragmento, saida, entrada, fontes };
 }
 function ambiguo(texto, candidatos) {
     const rotulos = candidatos.map(exports.rotuloDoNo).sort(intelligence_graph_contract_1.compararUtf8);
@@ -169,6 +180,31 @@ function arestaDaResposta(g, a, distancia) {
         || (0, intelligence_graph_contract_1.compararUtf8)(x.extractor_id, y.extractor_id) || (0, intelligence_graph_contract_1.compararUtf8)(x.extraction_method, y.extraction_method));
     return { kind: a.kind, from: g.rotulos.get(a.from), to: g.rotulos.get(a.to), edge_id: a.edge_id, distancia, evidencias };
 }
+/**
+ * KG5 fatia 5 (D4): a aresta so e `igual` quando as fontes dela inteiras conferem: o arquivo da origem, o
+ * do alvo (calls e imports resolvem o alvo nele) e os das evidencias. So as devolvidas pedem a situacao.
+ * Com teto, a busca binaria monta respostas com limites diferentes, e o CLI le os arquivos citados pela
+ * maior delas, a do limite pedido, mesmo os que o corte tira (CHECK rodada 1, S4).
+ */
+function comArvore(g, a, r, situacao) {
+    const caminhos = [g.nos.get(a.from).locator.path, g.nos.get(a.to).locator.path, ...r.evidencias.map((e) => e.path)];
+    const { evidencias, ...resto } = r;
+    return { ...resto, arvore: caminhos.every((p) => situacao(p) === 'igual') ? 'igual' : 'modificada', evidencias };
+}
+/** KG5 fatia 5 (D2, D10): uma entrada por caminho dos nos e das evidencias da resposta, em ordem UTF-8. */
+function fontesDaResposta(g, nos, arestas, situacao) {
+    const caminhos = new Set(nos.map((n) => n.path));
+    for (const a of arestas)
+        for (const e of a.evidencias)
+            caminhos.add(e.path);
+    const fontes = [];
+    for (const p of [...caminhos].sort(intelligence_graph_contract_1.compararUtf8)) {
+        const f = g.fontes.get(p);
+        if (f)
+            fontes.push({ path: p, source_hash: f.source_hash, source_version: f.source_version, arvore: situacao(p) });
+    }
+    return fontes;
+}
 /** CHECK rodada 1 (A2): primeiro as arestas mais perto do alvo, e o limite corta as mais longe. */
 const ordemDasArestas = (x, y) => (x.distancia - y.distancia)
     || (0, intelligence_graph_contract_1.compararUtf8)(x.kind, y.kind) || (0, intelligence_graph_contract_1.compararUtf8)(x.from, y.from) || (0, intelligence_graph_contract_1.compararUtf8)(x.to, y.to) || (0, intelligence_graph_contract_1.compararUtf8)(x.edge_id, y.edge_id);
@@ -204,7 +240,7 @@ function tiposValidos(tipos) {
  * cada uma com a distancia do no que a explorou. `limite` corta pela distancia e pela ordem fixa, e
  * a lista de nos so traz o alvo e as pontas das arestas devolvidas.
  */
-function vizinhanca(g, cabecalho, tipo, texto, opcoes) {
+function vizinhanca(g, cabecalho, tipo, texto, opcoes, situacao) {
     const profundidade = inteiroEntre('profundidade', opcoes.profundidade ?? 1, 1, exports.PROFUNDIDADE_MAXIMA);
     const limite = inteiroEntre('limite', opcoes.limite ?? exports.LIMITE_PADRAO, 1, exports.LIMITE_MAXIMO);
     const sentido = opcoes.sentido ?? 'ambos';
@@ -228,8 +264,8 @@ function vizinhanca(g, cabecalho, tipo, texto, opcoes) {
         }
         camada = proxima;
     }
-    const todas = [...vistas.values()].map(({ aresta, d }) => arestaDaResposta(g, aresta, d)).sort(ordemDasArestas);
-    const devolvidas = todas.slice(0, limite);
+    const todas = [...vistas.values()].map(({ aresta, d }) => ({ aresta, r: arestaDaResposta(g, aresta, d) })).sort((x, y) => ordemDasArestas(x.r, y.r));
+    const devolvidas = todas.slice(0, limite).map(({ aresta, r }) => comArvore(g, aresta, r, situacao));
     const idPorRotulo = new Map([...distancia.keys()].map((id) => [g.rotulos.get(id), id]));
     const pontas = new Set([alvo.node_id, ...devolvidas.flatMap((a) => [idPorRotulo.get(a.from), idPorRotulo.get(a.to)])]);
     const nos = [...pontas].map((id) => noDaResposta(g, g.nos.get(id), distancia.get(id)))
@@ -239,31 +275,31 @@ function vizinhanca(g, cabecalho, tipo, texto, opcoes) {
         consulta: { tipo, alvo: texto, para: null, profundidade, sentido, tipos, limite },
         indice: cabecalho, alvo: noDaResposta(g, alvo, 0), para: null, nos, total_nos: distancia.size,
         arestas: devolvidas, total_arestas: todas.length, truncado: todas.length > limite,
-        caminho: null, nos_explorados: null, parcial: exports.AVISO_DE_PARCIALIDADE,
+        caminho: null, nos_explorados: null, fontes: fontesDaResposta(g, nos, devolvidas, situacao), parcial: exports.AVISO_DE_PARCIALIDADE,
     };
 }
-function vizinhos(g, cabecalho, alvo, opcoes = {}) {
-    return vizinhanca(g, cabecalho, 'vizinhos', alvo, opcoes);
+function vizinhos(g, cabecalho, alvo, opcoes = {}, situacao = exports.TUDO_IGUAL) {
+    return vizinhanca(g, cabecalho, 'vizinhos', alvo, opcoes, situacao);
 }
 /** Quem chama o simbolo: as arestas `calls` que chegam, ate `profundidade` saltos. */
-function chamadores(g, cabecalho, alvo, opcoes = {}) {
+function chamadores(g, cabecalho, alvo, opcoes = {}, situacao = exports.TUDO_IGUAL) {
     if (resolverNo(g, alvo).kind !== 'symbol')
         throw new ErroDeConsulta('grafo.consulta.alvo-invalido', 'chamadores pede um simbolo; para arquivo, use importadores ou vizinhos');
-    return vizinhanca(g, cabecalho, 'chamadores', alvo, { ...opcoes, sentido: 'entrada', tipos: ['calls'] });
+    return vizinhanca(g, cabecalho, 'chamadores', alvo, { ...opcoes, sentido: 'entrada', tipos: ['calls'] }, situacao);
 }
 /** Quem importa o arquivo ou o simbolo: as arestas `imports` que chegam, ate `profundidade` saltos. */
-function importadores(g, cabecalho, alvo, opcoes = {}) {
+function importadores(g, cabecalho, alvo, opcoes = {}, situacao = exports.TUDO_IGUAL) {
     const kind = resolverNo(g, alvo).kind;
     if (kind !== 'file' && kind !== 'symbol')
         throw new ErroDeConsulta('grafo.consulta.alvo-invalido', 'importadores pede um arquivo ou um simbolo');
-    return vizinhanca(g, cabecalho, 'importadores', alvo, { ...opcoes, sentido: 'entrada', tipos: ['imports'] });
+    return vizinhanca(g, cabecalho, 'importadores', alvo, { ...opcoes, sentido: 'entrada', tipos: ['imports'] }, situacao);
 }
 /**
  * D5: o menor caminho de `de` a `para`, pelas arestas no sentido pedido (padrao: `saida`, a direcao
  * da aresta). Busca em largura com a expansao na ordem fixa: entre caminhos do mesmo tamanho, sai
  * sempre o mesmo. Sem caminho, `caminho` e `null`, com os nos explorados.
  */
-function caminho(g, cabecalho, de, para, opcoes = {}) {
+function caminho(g, cabecalho, de, para, opcoes = {}, situacao = exports.TUDO_IGUAL) {
     const sentido = opcoes.sentido ?? 'saida';
     if (!['entrada', 'saida', 'ambos'].includes(sentido))
         throw new ErroDeConsulta('grafo.consulta.uso', `sentido desconhecido: ${sentido}`);
@@ -284,20 +320,20 @@ function caminho(g, cabecalho, de, para, opcoes = {}) {
     if (anterior.has(destino.node_id)) {
         const cadeia = [];
         for (let id = destino.node_id, atual = anterior.get(id); atual; id = atual.de, atual = anterior.get(id)) {
-            cadeia.push({ id, passo: { sentido: atual.sentido, aresta: arestaDaResposta(g, atual.aresta, 0) } });
+            cadeia.push({ id, sentido: atual.sentido, aresta: atual.aresta });
         }
         cadeia.reverse();
-        cadeia.forEach((c, n) => { c.passo.aresta.distancia = n; });
-        passos = cadeia.map((c) => c.passo);
+        passos = cadeia.map((c, n) => ({ sentido: c.sentido, aresta: comArvore(g, c.aresta, arestaDaResposta(g, c.aresta, n), situacao) }));
         nos = [origem.node_id, ...cadeia.map((c) => c.id)].map((id, d) => noDaResposta(g, g.nos.get(id), d));
     }
+    const arestas = passos ? passos.map((p) => p.aresta) : [];
     return {
         schema: exports.CONSULTA_SCHEMA,
         consulta: { tipo: 'caminho', alvo: de, para, profundidade: null, sentido, tipos, limite: null },
         indice: cabecalho, alvo: noDaResposta(g, origem, 0), para: noDaResposta(g, destino, passos ? passos.length : null),
         nos, total_nos: nos.length,
-        arestas: passos ? passos.map((p) => p.aresta) : [], total_arestas: passos ? passos.length : 0, truncado: false,
-        caminho: passos, nos_explorados: anterior.size, parcial: exports.AVISO_DE_PARCIALIDADE,
+        arestas, total_arestas: arestas.length, truncado: false,
+        caminho: passos, nos_explorados: anterior.size, fontes: fontesDaResposta(g, nos, arestas, situacao), parcial: exports.AVISO_DE_PARCIALIDADE,
     };
 }
 function jsonDaResposta(r) {
@@ -310,8 +346,18 @@ function linhasDaEvidencia(e) {
         : `${e.path} 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 = '  ') {
-    return [`${prefixo}${a.kind}  ${a.from} -> ${a.to}`, ...a.evidencias.map(linhasDaEvidencia)];
+    const marca = a.arvore === 'modificada' ? '  [fonte modificada na arvore]' : '';
+    return [`${prefixo}${a.kind}  ${a.from} -> ${a.to}${marca}`, ...a.evidencias.map(linhasDaEvidencia)];
+}
+/** 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) {
+    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}`];
 }
 function textoDaResposta(r) {
     const c = r.consulta, i = r.indice;
@@ -320,6 +366,7 @@ function textoDaResposta(r) {
     ];
     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(', ')}`);
     if (c.tipo === 'caminho') {
         const para = r.para;