@orkastery/cli 0.5.0 → 0.5.1

package/dist/intelligence-graph-cli.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.USO_DO_GRAFO = exports.AMOSTRA_SCHEMA = exports.STATUS_SCHEMA = void 0;
+exports.CORRECAO_DO_INDICE = exports.USO_DO_GRAFO = exports.AMOSTRA_SCHEMA = exports.STATUS_SCHEMA = void 0;
 exports.lerPedido = lerPedido;
 exports.executarGrafo = executarGrafo;
 /**
@@ -46,6 +46,10 @@ exports.executarGrafo = executarGrafo;
  * O argv chega cru e o parser e estrito: subcomando conhecido, opcao conhecida uma vez so, valor
  * onde a opcao pede valor e bandeira sem valor, numero exato de posicionais. Resposta sai 0, mesmo
  * vazia; erro tipado sai 1 e, com `--json`, vem como objeto.
+ *
+ * RM-031 KG5 (D4, D5): `--teto-bytes N` limita a resposta em bytes (JSON compacto), para quem a leva
+ * ao contexto de um agente, como as tools `ork_grafo_*` do MCP; sem a opcao, a saida e a de antes. Sem
+ * o indice do HEAD, a recusa diz se ha indice de outra revisao ou de outro extrator, e a correcao.
  */
 const node_crypto_1 = require("node:crypto");
 const fs = __importStar(require("node:fs"));
@@ -60,20 +64,29 @@ exports.AMOSTRA_SCHEMA = 'ork.graph-edge-audit-sample/v0';
 exports.USO_DO_GRAFO = [
     'uso: ork grafo indexar [--verificar] [--forcar] [--json]',
     '     ork grafo status [--json]',
-    '     ork grafo vizinhos <no> [--profundidade N] [--sentido entrada|saida|ambos] [--tipo T,...] [--limite N] [--json]',
-    '     ork grafo chamadores <simbolo> [--profundidade N] [--limite N] [--json]',
-    '     ork grafo importadores <arquivo|simbolo> [--profundidade N] [--limite N] [--json]',
-    '     ork grafo caminho <de> <para> [--sentido saida|entrada|ambos] [--tipo T,...] [--json]',
+    '     ork grafo vizinhos <no> [--profundidade N] [--sentido entrada|saida|ambos] [--tipo T,...] [--limite N] [--json [--teto-bytes N]]',
+    '     ork grafo chamadores <simbolo> [--profundidade N] [--limite N] [--json [--teto-bytes N]]',
+    '     ork grafo importadores <arquivo|simbolo> [--profundidade N] [--limite N] [--json [--teto-bytes N]]',
+    '     ork grafo caminho <de> <para> [--sentido saida|entrada|ambos] [--tipo T,...] [--json [--teto-bytes N]]',
     '     ork grafo amostra [--por-estrato N] | ork grafo amostra --conferir ARQ [--json]',
     '     ork grafo limpar [--tudo] [--json]',
 ].join('\n');
+/** 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. */
+const ESTADO_DO_INDICE = Object.freeze({
+    'grafo.indice.ausente': 'nao-indexado',
+    'grafo.indice.outra-revisao': 'outra-revisao',
+    'grafo.indice.outro-extrator': 'outro-extrator',
+    'grafo.indice.corrompido': 'corrompido',
+});
 const SUBCOMANDOS = Object.freeze({
     indexar: { posicionais: 0, bandeiras: ['verificar', 'forcar', 'json'], valores: [] },
     status: { posicionais: 0, bandeiras: ['json'], valores: [] },
-    vizinhos: { posicionais: 1, bandeiras: ['json'], valores: ['profundidade', 'sentido', 'tipo', 'limite'] },
-    chamadores: { posicionais: 1, bandeiras: ['json'], valores: ['profundidade', 'limite'] },
-    importadores: { posicionais: 1, bandeiras: ['json'], valores: ['profundidade', 'limite'] },
-    caminho: { posicionais: 2, bandeiras: ['json'], valores: ['sentido', 'tipo'] },
+    vizinhos: { posicionais: 1, bandeiras: ['json'], valores: ['profundidade', 'sentido', 'tipo', 'limite', 'teto-bytes'] },
+    chamadores: { posicionais: 1, bandeiras: ['json'], valores: ['profundidade', 'limite', 'teto-bytes'] },
+    importadores: { posicionais: 1, bandeiras: ['json'], valores: ['profundidade', 'limite', 'teto-bytes'] },
+    caminho: { posicionais: 2, bandeiras: ['json'], valores: ['sentido', 'tipo', 'teto-bytes'] },
     amostra: { posicionais: 0, bandeiras: ['json'], valores: ['por-estrato', 'conferir'] },
     limpar: { posicionais: 0, bandeiras: ['tudo', 'json'], valores: [] },
 });
@@ -141,8 +154,40 @@ function sentido(p) {
         uso(`--sentido desconhecido: ${v}`);
     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');
+    if (teto === undefined)
+        return undefined;
+    if (!p.bandeiras.has('json'))
+        uso('--teto-bytes exige --json');
+    if (teto < 1)
+        uso('--teto-bytes precisa ser ao menos 1');
+    return teto;
+}
 const mb = (bytes) => `${(bytes / 1024 / 1024).toFixed(1)} MB`;
 const contagem = (o) => Object.entries(o).map(([k, v]) => `${k}=${v}`).join(' ');
+/** Ate cinco caminhos e quantos ficaram de fora. */
+const alguns = (lista) => (lista.length ? ` (${lista.slice(0, 5).join(', ')}${lista.length > 5 ? ` e mais ${lista.length - 5}` : ''})` : '');
+/** KG4: como a extracao rodou, a base e o que veio dela, ou por que foi completa. */
+function linhasDaExtracao(r) {
+    if (r.modo === null)
+        return [];
+    const a = r.reaproveitamento;
+    if (r.modo === 'incremental' && r.base && a) {
+        // Desestruturado: o lint de horario le o campo de nome curto do TypeScript como instante.
+        const { ts: doTs, md: doMd, mudanca } = a;
+        const ts = doTs.modo === 'inteiro' ? `TypeScript inteiro (${doTs.motivo})`
+            : doTs.modo === 'parcial' ? `TypeScript parcial, ${doTs.reextraidos.length} reextraido(s)${alguns(doTs.reextraidos)} num programa de ${doTs.programa}, ${doTs.reaproveitados} da base`
+                : `TypeScript todo da base (${doTs.reaproveitados})`;
+        return [
+            `  extracao     incremental a partir do indice de ${r.base.revision.slice(0, 12)}: ${mudanca.alterados} alterado(s), ${mudanca.novos} novo(s), ${mudanca.removidos} removido(s)`,
+            `               ${ts}`,
+            `               Markdown: ${doMd.reextraidos.length} reextraido(s)${alguns(doMd.reextraidos)}, ${doMd.reaproveitados} da base`,
+        ];
+    }
+    return [`  extracao     completa${r.motivo_completo ? `: ${r.motivo_completo}` : ''}`];
+}
 function indexar(ctx, p) {
     const r = (0, intelligence_graph_index_1.construirIndice)(ctx, { verificar: p.bandeiras.has('verificar'), forcar: p.bandeiras.has('forcar') });
     if (p.bandeiras.has('json')) {
@@ -159,12 +204,18 @@ function indexar(ctx, p) {
         `  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)})`,
+        `  lugar        ${r.dir} (${mb(m.graph_bytes + m.report_bytes + m.units_bytes)})`,
+        ...linhasDaExtracao(r),
     ];
     if (r.motivo)
         linhas.push(`  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)}, ${d.igual ? 'igual' : 'DIFERENTE'}`);
+    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'}`);
+    }
+    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'}`);
+    else if (r.determinismo)
+        linhas.push(`  incremental  nao conferido: ${r.motivo_completo ?? 'sem base'}`);
     linhas.push(`  tempo        ${r.ms} ms`);
     if (r.determinismo)
         linhas.push('aprovado');
@@ -211,9 +262,65 @@ function status(ctx, p) {
     ctx.escrever(linhas.join('\n'));
     return 0;
 }
+/**
+ * KG5 (CHECK rodada 1, A1): o que difere entre o extrator do indice guardado e o de quem consulta. A
+ * versao do Node entra no rotulo do analisador de JavaScript, entao outra instalacao ou outro Node dao
+ * outra chave com o mesmo conteudo.
+ */
+function diferencasDoExtrator(guardado, atual) {
+    const r = [];
+    for (const k of Object.keys(atual.analisadores).sort(intelligence_graph_contract_1.compararUtf8)) {
+        const antes = guardado.analisadores?.[k];
+        if (antes !== atual.analisadores[k])
+            r.push(`${k} ${antes ?? '?'} no indice, ${atual.analisadores[k]} aqui`);
+    }
+    if ((0, intelligence_graph_contract_1.canonico)(guardado.pacotes) !== (0, intelligence_graph_contract_1.canonico)(atual.pacotes))
+        r.push('pacotes dos analisadores');
+    if (guardado.codigo !== atual.codigo)
+        r.push('codigo do extrator');
+    return r;
+}
+/**
+ * KG5 (D5): sem o indice do HEAD, diz o que ha no lugar. Indice guardado do mesmo repositorio e da
+ * revisao do HEAD com outra chave e de outro extrator (instalacao, Node, analisadores ou codigo do
+ * extrator mudaram), e a recusa diz o que mudou; de outra revisao, e indice velho ou de outra arvore.
+ * Nos dois casos a correcao e indexar de novo, com a instalacao de quem consulta; sem nenhum, fica a
+ * recusa original (nao indexado). Nunca responde por um indice que nao e o do HEAD.
+ */
+function semIndiceDoHead(ctx, original) {
+    const arvore = (0, intelligence_graph_repo_1.revisaoDaArvore)(ctx.raiz);
+    if (!arvore.head)
+        throw original;
+    const perfil = (0, intelligence_graph_index_1.perfilDoIndice)(arvore.raiz, undefined, ctx.repositorio ? { repository_id: ctx.repositorio } : {});
+    const chave = (0, intelligence_graph_index_1.chaveDoIndice)(arvore.head, perfil), head = arvore.head.slice(0, 12);
+    const guardados = (0, intelligence_graph_index_1.estadoDosIndices)(ctx).indices
+        .filter((i) => i.problema === null && i.chave !== chave && i.repository_id === perfil.repository_id && i.revision !== null);
+    const doHead = guardados.find((i) => i.revision === arvore.head);
+    if (doHead) {
+        const diferencas = diferencasDoExtrator((0, intelligence_graph_index_1.lerIndice)(ctx, doHead.chave, { grafo: false }).manifesto, perfil);
+        throw new Error(`grafo.indice.outro-extrator: ha indice do HEAD ${head} de outro extrator (${diferencas.join('; ') || 'perfil diferente'}); `
+            + `rode ${exports.CORRECAO_DO_INDICE} com a mesma instalacao do ork e o mesmo Node de quem consulta (o servidor MCP consulta com a dele)`);
+    }
+    if (guardados.length) {
+        const revisoes = [...new Set(guardados.map((i) => i.revision.slice(0, 12)))].sort(intelligence_graph_contract_1.compararUtf8);
+        // CHECK rodada 2 (N7): a ressalva da instalacao ja na primeira recusa, a de cada commit do GO.
+        throw new Error(`grafo.indice.outra-revisao: o HEAD ${head} nao tem indice; o guardado e de outra revisao${alguns(revisoes)}; `
+            + `rode ${exports.CORRECAO_DO_INDICE} com a mesma instalacao do ork e o mesmo Node de quem consulta`);
+    }
+    throw original;
+}
 /** O indice do HEAD pronto para consulta, com a concessao local e o cabecalho; `grafo` ja vem filtrado por ela. */
 function consultavel(ctx) {
-    const { arvore, perfil, chave, indice } = (0, intelligence_graph_index_1.indiceDoHead)(ctx);
+    let doHead;
+    try {
+        doHead = (0, intelligence_graph_index_1.indiceDoHead)(ctx);
+    }
+    catch (e) {
+        if (String(e.message).startsWith('grafo.indice.ausente'))
+            semIndiceDoHead(ctx, e);
+        throw e;
+    }
+    const { arvore, perfil, chave, indice } = doHead;
     const concessao = (0, intelligence_graph_index_1.concessaoLocal)(arvore.raiz, perfil);
     const grafo = (0, intelligence_graph_query_1.filtrarGrafo)(indice.grafo, concessao), m = indice.manifesto;
     const cabecalho = {
@@ -227,18 +334,59 @@ 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));
     return 0;
 }
+/**
+ * KG5 (D4): a resposta em JSON compacto que cabe em `teto` bytes. Se a pedida nao cabe, vale o maior
+ * limite que cabe: as arestas mais longe do alvo saem primeiro, pela mesma ordem do `--limite`, e
+ * `consulta.limite` passa a ser o efetivo. O tamanho cresce com o limite (cada aresta a mais so soma
+ * bytes), entao a busca binaria acha o maior que cabe, sempre o mesmo. Aresta nunca sai sem toda a
+ * evidencia; o caminho nao se corta.
+ */
+function respostaComTeto(perguntar, limite, teto) {
+    const pedida = perguntar(limite);
+    const limitePedido = pedida.consulta.limite;
+    const comTeto = (r, cortado) => JSON.stringify({ ...r, teto: { bytes: teto, limite_pedido: limitePedido, cortado } });
+    const inteira = comTeto(pedida, false);
+    if (Buffer.byteLength(inteira) <= teto)
+        return inteira;
+    const ehCaminho = pedida.consulta.tipo === 'caminho';
+    // So chega aqui o que nao cabe nem com a aresta mais perto do alvo: estreitar a consulta nao ajuda.
+    const excedido = (resposta, bytes) => {
+        throw new intelligence_graph_query_1.ErroDeConsulta('grafo.consulta.teto-excedido', `${resposta} tem ${bytes} bytes, acima do teto de ${teto}; ${ehCaminho ? 'o caminho nao se corta: ' : ''}use --teto-bytes maior`);
+    };
+    if (ehCaminho)
+        excedido(`o caminho de ${pedida.arestas.length} passo(s)`, Buffer.byteLength(inteira));
+    if (pedida.arestas.length <= 1)
+        excedido(`a resposta com ${pedida.arestas.length} aresta(s)`, Buffer.byteLength(inteira));
+    let menor = 1, maior = pedida.arestas.length - 1, melhor = null;
+    while (menor <= maior) {
+        const k = Math.floor((menor + maior) / 2), texto = comTeto(perguntar(k), true);
+        if (Buffer.byteLength(texto) <= teto) {
+            melhor = texto;
+            menor = k + 1;
+        }
+        else
+            maior = k - 1;
+    }
+    return melhor ?? excedido('a resposta com 1 aresta', Buffer.byteLength(comTeto(perguntar(1), true)));
+}
 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);
+    const profundidade = inteiro(p, 'profundidade'), limite = inteiro(p, 'limite'), s = sentido(p), t = tipos(p), teto = tetoDeBytes(p);
     const { g, cabecalho } = consultavel(ctx);
-    if (p.sub === 'vizinhos')
-        return responder(ctx, p, (0, intelligence_graph_query_1.vizinhos)(g, cabecalho, a, { profundidade, limite, sentido: s, tipos: t }));
-    if (p.sub === 'chamadores')
-        return responder(ctx, p, (0, intelligence_graph_query_1.chamadores)(g, cabecalho, a, { profundidade, limite }));
-    if (p.sub === 'importadores')
-        return responder(ctx, p, (0, intelligence_graph_query_1.importadores)(g, cabecalho, a, { profundidade, limite }));
-    return responder(ctx, p, (0, intelligence_graph_query_1.caminho)(g, cabecalho, a, b, { sentido: s, tipos: t }));
+    const perguntar = (lim) => {
+        if (p.sub === 'vizinhos')
+            return (0, intelligence_graph_query_1.vizinhos)(g, cabecalho, a, { profundidade, limite: lim, sentido: s, tipos: t });
+        if (p.sub === 'chamadores')
+            return (0, intelligence_graph_query_1.chamadores)(g, cabecalho, a, { profundidade, limite: lim });
+        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 });
+    };
+    if (teto === undefined)
+        return responder(ctx, p, perguntar(limite));
+    ctx.escrever(respostaComTeto(perguntar, limite, teto));
+    return 0;
 }
 const sha256 = (b) => (0, node_crypto_1.createHash)('sha256').update(b).digest('hex');
 /**
@@ -392,15 +540,21 @@ function limpar(ctx, p) {
         ctx.escrever([`grafo limpar: ${r.removidos.length} removido(s), ${mb(r.bytes)}`, ...r.removidos.map((x) => `  ${x.nome} ${mb(x.bytes)}`)].join('\n'));
     return 0;
 }
-const erroEmJson = (ctx, e) => {
+/** KG5 (D4, D5): com `--teto-bytes` o erro tambem sai compacto; recusa de indice traz o estado e a correcao. */
+const erroEmJson = (ctx, e, compacto) => {
     const [codigo, ...detalhe] = String(e.message).split('\n')[0].split(': ');
-    ctx.escrever(JSON.stringify({
-        schema: intelligence_graph_query_1.CONSULTA_SCHEMA, erro: { codigo, detalhe: detalhe.join(': ') || null, candidatos: e instanceof intelligence_graph_query_1.ErroDeConsulta ? e.candidatos : [] },
-    }, null, 2));
+    const doIndice = Object.prototype.hasOwnProperty.call(ESTADO_DO_INDICE, codigo)
+        ? { estado_do_indice: ESTADO_DO_INDICE[codigo], correcao: exports.CORRECAO_DO_INDICE } : {};
+    const r = {
+        schema: intelligence_graph_query_1.CONSULTA_SCHEMA,
+        erro: { codigo, detalhe: detalhe.join(': ') || null, candidatos: e instanceof intelligence_graph_query_1.ErroDeConsulta ? e.candidatos : [], ...doIndice },
+    };
+    ctx.escrever(compacto ? JSON.stringify(r) : JSON.stringify(r, null, 2));
     return 1;
 };
 /** `ork grafo <subcomando> ...`: devolve o codigo de saida; sem `--json`, o erro de uso ou tipado e lancado. */
 function executarGrafo(argv, ctx) {
+    const compacto = argv.some((a) => a === '--teto-bytes' || a.startsWith('--teto-bytes='));
     let p;
     try {
         p = lerPedido(argv);
@@ -408,7 +562,7 @@ function executarGrafo(argv, ctx) {
     catch (e) {
         // Com `--json` no argv, tambem o erro de uso sai como objeto, como os demais.
         if (argv.includes('--json'))
-            return erroEmJson(ctx, e);
+            return erroEmJson(ctx, e, compacto);
         throw e;
     }
     try {
@@ -425,6 +579,6 @@ function executarGrafo(argv, ctx) {
     catch (e) {
         if (!p.bandeiras.has('json'))
             throw e;
-        return erroEmJson(ctx, e);
+        return erroEmJson(ctx, e, compacto);
     }
 }

package/dist/intelligence-graph-contract.js

@@ -10,6 +10,7 @@ exports.derivarIds = derivarIds;
 exports.caminhoValido = caminhoValido;
 exports.validarGrafo = validarGrafo;
 exports.conferirFontes = conferirFontes;
+exports.conferirFontesDoGrafoValidado = conferirFontesDoGrafoValidado;
 /**
  * I-31 KG1 (D1 a D5, D9, D10): contrato `ork.code-artifact-graph/v1` do grafo deterministico
  * de codigo e artefatos.
@@ -134,19 +135,70 @@ function compararUtf8(a, b) {
     }
     return a.length - b.length;
 }
-/** D2: JSON canonico. Chaves na ordem de bytes UTF-8, sem espaco, so numero finito. */
+const FORMAS = new Map();
+const TETO_DE_FORMAS = 4096;
+let formasGuardadas = 0;
+function formaDe(chaves) {
+    const primeira = chaves.length ? chaves[0] : '', candidatas = FORMAS.get(primeira);
+    if (candidatas) {
+        for (const f of candidatas) {
+            if (f.chaves.length !== chaves.length)
+                continue;
+            let igual = true;
+            for (let i = 1; i < chaves.length && igual; i++)
+                igual = f.chaves[i] === chaves[i];
+            if (igual)
+                return f.ordem;
+        }
+    }
+    const ordem = [...chaves].sort(compararUtf8).map((k) => [k, `${JSON.stringify(k)}:`]);
+    if (formasGuardadas < TETO_DE_FORMAS) {
+        formasGuardadas++;
+        if (candidatas)
+            candidatas.push({ chaves: [...chaves], ordem });
+        else
+            FORMAS.set(primeira, [{ chaves: [...chaves], ordem }]);
+    }
+    return ordem;
+}
+/**
+ * D2: JSON canonico. Chaves na ordem de bytes UTF-8, sem espaco, so numero finito. KG4 (D6): mesma
+ * saida da forma original (`map` e `join`, com o buraco de array esparso vazio), sem ordenar as
+ * chaves a cada objeto; a ordem de visita, e com ela o primeiro erro, e a mesma.
+ */
 function canonico(v) {
-    if (v === null || typeof v === 'boolean' || typeof v === 'string')
-        return JSON.stringify(v);
-    if (typeof v === 'number')
-        return Number.isFinite(v) ? JSON.stringify(v) : falha('grafo.canonico.numero-invalido');
-    if (Array.isArray(v))
-        return `[${v.map(canonico).join(',')}]`;
-    if (typeof v === 'object') {
-        const o = v;
-        return `{${Object.keys(o).sort(compararUtf8).map((k) => `${JSON.stringify(k)}:${canonico(o[k])}`).join(',')}}`;
+    if (v === null)
+        return 'null';
+    switch (typeof v) {
+        case 'string':
+            return JSON.stringify(v);
+        case 'boolean':
+            return v ? 'true' : 'false';
+        case 'number':
+            return Number.isFinite(v) ? JSON.stringify(v) : falha('grafo.canonico.numero-invalido');
+        case 'object': {
+            if (Array.isArray(v)) {
+                let s = '[';
+                for (let i = 0; i < v.length; i++) {
+                    if (i > 0)
+                        s += ',';
+                    if (i in v)
+                        s += canonico(v[i]);
+                }
+                return `${s}]`;
+            }
+            const o = v, forma = formaDe(Object.keys(o));
+            let s = '{';
+            for (let i = 0; i < forma.length; i++) {
+                if (i > 0)
+                    s += ',';
+                s += forma[i][1] + canonico(o[forma[i][0]]);
+            }
+            return `${s}}`;
+        }
+        default:
+            return falha('grafo.canonico.tipo-invalido');
     }
-    return falha('grafo.canonico.tipo-invalido');
 }
 /** SHA-256 sobre os bytes UTF-8 do conteudo canonico. */
 const sha256DoCanonico = (v) => (0, node_crypto_1.createHash)('sha256').update(canonico(v), 'utf8').digest('hex');
@@ -508,7 +560,14 @@ function linhaDoByte(quebras, o) {
  * parser interpretou a relacao certo; essa prova vem da auditoria de arestas do benchmark.
  */
 function conferirFontes(entrada, fontes) {
-    const g = validarGrafo(entrada);
+    return conferirFontesDoGrafoValidado(validarGrafo(entrada), fontes);
+}
+/**
+ * RM-031 KG4 (D6): a conferencia de `conferirFontes` sobre o grafo que `validarGrafo` acabou de
+ * devolver, sem validar de novo. So para o produtor que tem esse retorno em maos (a construcao do
+ * indice, logo depois da extracao); qualquer outra entrada passa por `conferirFontes`.
+ */
+function conferirFontesDoGrafoValidado(g, fontes) {
     const manifesto = new Map(g.snapshot.source_manifest.map((m) => [m.path, m]));
     for (const [p, f] of fontes) {
         if (!manifesto.has(p))

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

@@ -2,7 +2,9 @@
 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.estruturarMarkdown = estruturarMarkdown;
 exports.extrairMarkdown = extrairMarkdown;
+exports.ligarMarkdown = ligarMarkdown;
 const yaml_1 = require("./yaml");
 /** D6: ID de artefato governado (`RM-031`, `FEAT-018`). */
 exports.PADRAO_DE_ID = /^[A-Z][A-Z0-9]*-[0-9]+$/;
@@ -329,7 +331,25 @@ const decodificar = (t) => {
         return null;
     }
 };
+function estruturarMarkdown(fonte, e) {
+    const s = estruturar(fonte, e.aceitaFragmento, e.analisar, e.referencia);
+    const mencoes = [];
+    for (const l of s.textoDeMencao)
+        for (const m of l.texto.matchAll(MENCAO))
+            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,
+        frontmatter: s.frontmatter && d
+            ? { id: typeof d.id === 'string' ? d.id : null, tipo: typeof d.tipo === 'string' && d.tipo !== '', valores: s.frontmatter.valores }
+            : null,
+        frontmatterInvalido: s.frontmatterInvalido, tabelaGrande: s.tabelaGrande,
+    };
+}
 function extrairMarkdown(e) {
+    return ligarMarkdown({ ...e, estruturas: e.fontes.map((f) => estruturarMarkdown(f, e)) });
+}
+function ligarMarkdown(e) {
     const saida = { nos: [], arestas: [], diagnosticos: [], lacunas: [] };
     const arquivos = new Set(e.arquivos), diretorios = new Set();
     for (const p of e.arquivos) {
@@ -337,8 +357,8 @@ function extrairMarkdown(e) {
         for (let i = 1; i < partes.length; i++)
             diretorios.add(partes.slice(0, i).join('/'));
     }
-    const estruturas = e.fontes.map((f) => estruturar(f, e.aceitaFragmento, e.analisar, e.referencia));
-    const slugs = new Map(estruturas.map((s) => [s.fonte.path, new Set(s.secoes.map((x) => x.slug).filter((x) => x !== null))]));
+    const estruturas = e.estruturas;
+    const slugs = new Map(estruturas.map((s) => [s.path, new Set(s.secoes.map((x) => x.slug).filter((x) => x !== null))]));
     const aresta = (kind, from, to, extrator, metodo, t) => {
         saida.arestas.push({ kind, from, to, extrator, metodo, trecho: t });
     };
@@ -349,17 +369,17 @@ function extrairMarkdown(e) {
     const donos = new Map();
     for (const s of estruturas) {
         if (s.frontmatterInvalido)
-            lacuna('frontmatter-invalido', s.fonte.path, 0, null);
+            lacuna('frontmatter-invalido', s.path, 0, null);
         if (s.tabelaGrande)
-            lacuna('markdown-tabela-grande', s.fonte.path, null, null);
-        const nome = s.fonte.path.slice(s.fonte.path.lastIndexOf('/') + 1), d = s.frontmatter?.dados;
-        if (!d || nome.startsWith('_') || typeof d.id !== 'string' || !exports.PADRAO_DE_ID.test(d.id) || typeof d.tipo !== 'string' || !d.tipo)
+            lacuna('markdown-tabela-grande', s.path, null, null);
+        const nome = s.path.slice(s.path.lastIndexOf('/') + 1), d = s.frontmatter;
+        if (!d || nome.startsWith('_') || d.id === null || !exports.PADRAO_DE_ID.test(d.id) || !d.tipo)
             continue;
         if (!e.aceitaFragmento(d.id)) {
-            lacuna('artefato-recusado', s.fonte.path, 0, null);
+            lacuna('artefato-recusado', s.path, 0, null);
             continue;
         }
-        donos.set(d.id, [...(donos.get(d.id) ?? []), s.fonte.path]);
+        donos.set(d.id, [...(donos.get(d.id) ?? []), s.path]);
     }
     const artefatos = new Map();
     for (const [id, caminhos] of donos) {
@@ -385,20 +405,15 @@ function extrairMarkdown(e) {
         const atual = baixo > 0 ? s.secoes[baixo - 1] : null;
         return atual && atual.slug !== null ? { kind: 'section', path: arquivo.path, fragment: atual.slug } : arquivo;
     };
-    const mencoes = (fonte, linhas, origem) => {
-        for (const l of linhas) {
-            for (const m of l.texto.matchAll(MENCAO)) {
-                const alvo = artefatos.get(m[0]), inicio = l.inicio + m.index;
-                if (!alvo) {
-                    lacuna('id-sem-artefato', fonte.path, inicio, m[0]);
-                    continue;
-                }
-                aresta('references', origem(inicio), alvo, e.extratorId, 'text-location', { path: fonte.path, inicio, fim: inicio + m[0].length });
-            }
-        }
+    const mencao = (path, inicio, id, origem) => {
+        const alvo = artefatos.get(id);
+        if (!alvo)
+            lacuna('id-sem-artefato', path, inicio, id);
+        else
+            aresta('references', origem(inicio), alvo, e.extratorId, 'text-location', { path, inicio, fim: inicio + id.length });
     };
     for (const s of estruturas) {
-        const path = s.fonte.path, arquivo = { kind: 'file', path, fragment: null };
+        const path = s.path, arquivo = { kind: 'file', path, fragment: null };
         for (const x of s.secoes) {
             if (x.slug === null) {
                 lacuna('secao-recusada', path, x.inicio, null);
@@ -444,7 +459,7 @@ function extrairMarkdown(e) {
                 continue;
             aresta('references', origem, { kind: 'file', path: alvo, fragment: null }, e.extratorMd, 'explicit-link', t);
         }
-        const artefato = s.frontmatter && typeof s.frontmatter.dados.id === 'string' ? artefatos.get(s.frontmatter.dados.id) : undefined;
+        const artefato = s.frontmatter && s.frontmatter.id !== null ? artefatos.get(s.frontmatter.id) : undefined;
         if (artefato && artefato.path === path && s.frontmatter) {
             for (const v of s.frontmatter.valores) {
                 const [kind, destino] = exports.CHAVES_DO_FRONTMATTER[v.chave].split(':');
@@ -459,11 +474,14 @@ function extrairMarkdown(e) {
                     lacuna('frontmatter-sem-alvo', path, v.inicio, `${v.chave}: ${v.valor}`);
             }
         }
-        mencoes(s.fonte, s.textoDeMencao, (o) => secaoEm(s, arquivo, o));
+        for (const m of s.mencoes)
+            mencao(path, m.inicio, m.id, (o) => secaoEm(s, arquivo, o));
     }
     for (const f of e.codigo) {
         const arquivo = { kind: 'file', path: f.path, fragment: null };
-        mencoes(f, linhasDe(f.texto), () => arquivo);
+        for (const l of linhasDe(f.texto))
+            for (const m of l.texto.matchAll(MENCAO))
+                mencao(f.path, l.inicio + m.index, m[0], () => arquivo);
     }
     return saida;
 }