@orkastery/cli 0.5.1 → 0.5.3

package/dist/indice-vetorial.js

@@ -56,13 +56,19 @@ exports.decodificarVetor = decodificarVetor;
 exports.lerIndice = lerIndice;
 exports.serializarIndice = serializarIndice;
 exports.gravarIndice = gravarIndice;
-exports.universoDoTenant = universoDoTenant;
+exports.conferirUniverso = conferirUniverso;
+exports.universoDaBusca = universoDaBusca;
+exports.codigoDaFalha = codigoDaFalha;
 exports.conteudoRecusado = conteudoRecusado;
+exports.indexavel = indexavel;
 exports.tokensEstimados = tokensEstimados;
 exports.dimDoModeloLocal = dimDoModeloLocal;
 exports.codigoDeEmbedding = codigoDeEmbedding;
 exports.espacoDoAlvo = espacoDoAlvo;
 exports.indexar = indexar;
+exports.avisoDeCobertura = avisoDeCobertura;
+exports.textoForaDaBusca = textoForaDaBusca;
+exports.textoDoIndice = textoDoIndice;
 exports.vetoresCoerentes = vetoresCoerentes;
 const fs = __importStar(require("node:fs"));
 const os = __importStar(require("node:os"));
@@ -170,18 +176,48 @@ function gravarIndice(arquivo, indice) {
     return true;
 }
 /**
- * Universo do tenant: o export governado das colecoes do ork (filtro de injecao e visibilidade
- * da biblioteca), com checagem EXPLICITA do tenant antes de qualquer texto ir ao embed.
+ * RM-038 (D6): a fronteira do universo no `ork`, num lugar so. Entrada de outro tenant, de colecao
+ * fora do ork ou com id repetido e violacao tipada, nunca descarte silencioso: nada disso vai ao embed.
  */
-function universoDoTenant(fonte, tenant, colecoes = orkmind_1.COLECOES_DO_ORK) {
-    return colecoes.flatMap(c => fonte.buscar({ collection: c, tags: { project: [tenant] } })
-        .filter(e => e.collection === c && (e.tags.project ?? []).includes(tenant)))
-        .sort((a, b) => a.collection.localeCompare(b.collection) || a.id.localeCompare(b.id));
+function conferirUniverso(entradas, tenant, lidoEm = Date.now()) {
+    const vistos = new Set();
+    for (const e of entradas) {
+        if (!(0, orkmind_1.pertenceAoUniverso)(e, tenant, lidoEm) || vistos.has(e.id))
+            throw new Error('memory.query.scope-violation');
+        vistos.add(e.id);
+    }
+}
+/**
+ * RM-038 (D4): o universo da busca e do indice, o domicilio unico. A fonte le uma vez (a ponte
+ * filtra o tenant na origem e aplica a governanca da biblioteca); aqui a fronteira e conferida de
+ * novo, a ordem fica estavel e a contagem por colecao sai pronta para o status e o index.
+ */
+function universoDaBusca(fonte, tenant) {
+    const lidoEm = Date.now();
+    const lido = fonte.universo(tenant);
+    conferirUniverso(lido.entradas, tenant, lidoEm);
+    const entradas = [...lido.entradas].sort((a, b) => a.collection.localeCompare(b.collection) || a.id.localeCompare(b.id));
+    const porColecao = Object.fromEntries(orkmind_1.COLECOES_DO_ORK.map(c => [c, 0]));
+    for (const e of entradas)
+        porColecao[e.collection] += 1;
+    return { tenant, lidoEm, entradas, porColecao, foraDaBusca: lido.foraDaBusca,
+        ...(lido.latenciaMs === undefined ? {} : { latenciaMs: lido.latenciaMs }) };
+}
+/** Codigo tipado de uma falha (`memory.query.window-saturated`), ou o padrao quando nao ha. */
+function codigoDaFalha(erro, padrao = 'memory.universo.indisponivel') {
+    return /^[a-z]+(?:\.[a-z-]+)+/.exec(erro instanceof Error ? erro.message : '')?.[0] ?? padrao;
 }
 /** Conteudo que nunca vai ao provider: padrao de segredo da policy ou URL com credencial. */
 function conteudoRecusado(conteudo) {
     return (0, policies_1.procurarSegredos)(conteudo).length > 0 || URL_COM_CREDENCIAL.test(conteudo);
 }
+/**
+ * RM-038: o indice embeda a entrada? Nao embeda texto vazio, acima do limite nem com padrao de
+ * segredo. Domicilio unico para o `indexar` e para o aviso de cobertura do status.
+ */
+function indexavel(e) {
+    return e.content.trim() !== '' && e.content.length <= orkmind_1.EMBED_MAX_CARACTERES && !conteudoRecusado(e.content);
+}
 function tokensEstimados(conteudo) {
     return Math.ceil(conteudo.length / exports.CARACTERES_POR_TOKEN);
 }
@@ -236,13 +272,20 @@ function espacoDoAlvo(config, alvo, env = process.env) {
  * que ja voltaram, porque cada vetor gravado e coerente por si.
  */
 function indexar(o) {
+    // RM-038 (D6): conferir de novo antes de qualquer coisa; nada de outro tenant vai ao embed, nem de
+    // um chamador que montou o universo a mao. Violacao falha alto, nunca vira descarte silencioso.
+    if (o.universo.tenant !== o.tenant)
+        throw new Error('memory.query.scope-violation');
+    conferirUniverso(o.universo.entradas, o.tenant, o.universo.lidoEm);
     const espaco = espacoDoAlvo(o.config, o.alvo, o.env);
-    const universo = o.universo.filter(e => (e.tags.project ?? []).includes(o.tenant));
+    const universo = o.universo.entradas;
     const foraDoLimite = universo.filter(e => e.content.length > orkmind_1.EMBED_MAX_CARACTERES);
     const recusados = universo.filter(e => e.content.length <= orkmind_1.EMBED_MAX_CARACTERES && conteudoRecusado(e.content));
-    const indexaveis = universo.filter(e => e.content.length <= orkmind_1.EMBED_MAX_CARACTERES && !conteudoRecusado(e.content) && e.content.trim());
+    const indexaveis = universo.filter(indexavel);
     const base = { alvo: o.alvo, modelo: null, dim: null, arquivo: null, dryRun: o.dryRun,
-        universo: universo.length, coerentes: 0, embedados: 0, reescritos: 0, removidos: 0, recusados: recusados.length,
+        universo: universo.length, porColecao: { ...o.universo.porColecao }, foraDaBusca: o.universo.foraDaBusca,
+        latenciaUniversoMs: o.universo.latenciaMs ?? null,
+        coerentes: 0, embedados: 0, reescritos: 0, removidos: 0, recusados: recusados.length,
         foraDoLimite: foraDoLimite.length, truncados: 0, tokensEstimados: 0, custoEstimadoUsd: 0, chamadasAoProvider: 0, motivo: null, detalhe: '' };
     if ('motivo' in espaco) {
         const tokens = indexaveis.reduce((t, e) => t + tokensEstimados(e.content), 0);
@@ -302,6 +345,40 @@ function indexar(o) {
         return { ...r, motivo, detalhe: `indexacao interrompida depois de ${r.embedados} vetor(es); os lotes concluidos ficaram gravados` };
     return r;
 }
+/**
+ * RM-038 (D7): o aviso de cobertura, o mesmo no status e na busca. Reindexar so e sugerido quando
+ * resolve; o que o indice nunca embeda (vazio, acima do limite, padrao de segredo) e dito a parte.
+ */
+function avisoDeCobertura(coerentes, entradas, alvo, onde = '') {
+    if (coerentes >= entradas.length)
+        return null;
+    const foraPorDesenho = entradas.filter(e => !indexavel(e)).length;
+    const base = `o indice cobre ${coerentes} de ${entradas.length} entrada(s) que a busca enxerga${onde}`;
+    if (coerentes < entradas.length - foraPorDesenho)
+        return `${base}: rode ork memory index${alvo === 'fallback' ? ' --modelo fallback' : ''}`;
+    return `${base}; ${foraPorDesenho} fica(m) fora do indice por desenho (vazia, acima de ${orkmind_1.EMBED_MAX_CARACTERES} caracteres ou com padrao de segredo)`;
+}
+/** 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';
+}
+/** 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 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}`] : []),
+    ].join('\n');
+}
 /** Vetores coerentes de um indice para o universo informado: a base da busca e da cobertura. */
 function vetoresCoerentes(indice, universo) {
     const saida = new Map();

package/dist/indice.js

@@ -63,7 +63,9 @@ function calcularIndice(eventos) {
     const parcelas = [];
     let valor = exports.INDICE_BASE;
     for (const insumo of exports.INSUMOS_DO_INDICE) {
-        const ocorrencias = eventos.filter((e) => e.tipo === insumo.evento).length;
+        // Ensaio de 03/10/2026 (RM-049): o `ork ship --dry-run` barrado grava `ship_blocked` com `dryRun: true`;
+        // ensaio nao e tropeco da entrega, como ja nao e pausa no board (fatia 2 do ensaio da 0.5.0, P2).
+        const ocorrencias = eventos.filter((e) => e.tipo === insumo.evento && e.dryRun !== true).length;
         if (ocorrencias === 0)
             continue;
         const bruto = insumo.peso * ocorrencias;

package/dist/init.js

@@ -46,6 +46,7 @@ exports.baseBranchDetectada = baseBranchDetectada;
 exports.verifyDetectado = verifyDetectado;
 exports.detectar = detectar;
 exports.manifestoYaml = manifestoYaml;
+exports.exigirRepositorioParaInit = exigirRepositorioParaInit;
 exports.init = init;
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
@@ -192,6 +193,8 @@ conduction:
 worktree:
   base_branch: "${d.baseBranch}"
   dir: ".claude/worktrees"
+  # true: o ork thread new cria a worktree e a branch da thread sem flag (--sem-worktree cria sem);
+  # false ou ausente: só com --worktree auto
   por_thread: true
 
 verify:
@@ -259,6 +262,20 @@ policies:
   push_direto_na_base: block
 `;
 }
+/**
+ * Ensaio de 03/10/2026 (RM-049): o `ork init` rodado por engano fora de um repositorio (no HOME, por
+ * exemplo) gravava manifesto, `AGENTS.md` e `.orkastery/` ali e saia 0; um repositorio criado depois
+ * dentro dessa pasta herdava o manifesto de fora, com outro nome e outra abbrev, e o doctor dizia PRONTO.
+ * A CLI recusa antes de gravar qualquer coisa. A funcao `init` segue aceitando qualquer pasta (demo e
+ * canarios montam o projeto por ela).
+ */
+function exigirRepositorioParaInit(dir) {
+    const r = (0, util_1.exec)('git', ['rev-parse', '--is-inside-work-tree'], dir);
+    if (r.ok && r.stdout.trim() === 'true')
+        return;
+    throw new Error(`init.fora-do-repositorio: ${path.resolve(dir)} não está num repositório git; nada foi criado. ` +
+        'Entre no repositório do projeto (ou crie um com git init e o primeiro commit) e rode ork init de novo.');
+}
 /** Gera o manifesto e o esqueleto de `.orkastery/`. Nao sobrescreve sem `force`. */
 function init(dirInicial, opcoes = {}) {
     const deteccao = detectar(dirInicial, opcoes.nome, opcoes.abbrev);

package/dist/integracoes-locais.js

@@ -16,4 +16,6 @@ exports.TESTES_DE_INTEGRACAO_LOCAL = new Set([
     'memory-publication-profile.test.js', 'native-fixture.test.js', 'orkmind-transport.test.js', 'verify-sandbox.test.js',
     // RM-037 (fatia 3): o worker do ork_git_commit e o sandbox do verify de verdade, como no mcp-git.test.js.
     'rm037-fatia3-hard-link-mcp-git.test.js', 'rm037-fatia3-lease-mcp-git.test.js',
+    // RM-038 (fatia de correcao): a ponte com o GovernedStore real da biblioteca instalada.
+    'rm038-universo-ponte.test.js',
 ]);

package/dist/intelligence-graph-cli.js

@@ -34,6 +34,9 @@ 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.descreverVersoes = descreverVersoes;
+exports.correcaoDosAnalisadores = correcaoDosAnalisadores;
+exports.checarAnalisadoresDoGrafo = checarAnalisadoresDoGrafo;
 exports.lerPedido = lerPedido;
 exports.executarGrafo = executarGrafo;
 /**
@@ -56,14 +59,62 @@ const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const intelligence_graph_contract_1 = require("./intelligence-graph-contract");
 const intelligence_graph_index_1 = require("./intelligence-graph-index");
+const intelligence_graph_parsers_1 = require("./intelligence-graph-parsers");
 const intelligence_graph_query_1 = require("./intelligence-graph-query");
 const intelligence_graph_repo_1 = require("./intelligence-graph-repo");
+const intelligence_graph_contexto_1 = require("./intelligence-graph-contexto");
 exports.STATUS_SCHEMA = 'ork.code-graph-index-status/v0';
+/** As versoes dos analisadores como o `ork grafo status` e o `ork doctor` as mostram. */
+function descreverVersoes(v) {
+    return Object.entries(v).map(([k, x]) => `${k} ${x}`).join(', ');
+}
+/** O prefixo das recusas dos analisadores (`intelligence-graph-parsers.ts`). */
+const RECUSA_DOS_ANALISADORES = 'grafo.parser.indisponivel';
+/**
+ * RM-031 (pacote do npm): o que fazer quando os analisadores nao carregam, dito pelo `ork doctor` e
+ * pelo `ork grafo status`. O micromark e so ESM e carrega por `require`, o que o Node so faz sem flag
+ * a partir de 20.19 e de 22.12. Nos outros casos o pacote falta ou esta fora da instalacao do `ork`,
+ * e a instalacao global do npm traz os analisadores, que sao dependencias do pacote. Mora aqui, fora
+ * 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)';
+    }
+    // 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)';
+}
+/**
+ * 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
+ * Node sem `require` de ESM. A falta e `warn`, com a correcao: o grafo nao e condicao do despacho de
+ * 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) {
+    const nome = 'analisadores do grafo';
+    try {
+        carregar();
+        return { nome, nivel: 'ok', detalhe: descreverVersoes(versoes()) };
+    }
+    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) };
+    }
+}
 /** O mesmo schema da amostra do KG2: as amostras auditadas continuam validas. */
 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 contexto <thread> [--json [--teto-bytes N]]',
     '     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]]',
@@ -83,6 +134,7 @@ const ESTADO_DO_INDICE = Object.freeze({
 const SUBCOMANDOS = Object.freeze({
     indexar: { posicionais: 0, bandeiras: ['verificar', 'forcar', 'json'], valores: [] },
     status: { posicionais: 0, bandeiras: ['json'], valores: [] },
+    contexto: { posicionais: 1, bandeiras: ['json'], valores: ['teto-bytes'] },
     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'] },
@@ -238,9 +290,11 @@ function status(ctx, p) {
     const doHead = chave ? estado.indices.find((i) => i.chave === chave) ?? null : null;
     // Sem analisadores nao ha chave: o indice do HEAD fica indisponivel, nunca "ausente" (indexar tambem nao roda).
     const indiceDoHeadEstado = erro ? 'indisponivel' : doHead ? (doHead.problema ? 'com-problema' : 'presente') : 'ausente';
+    // RM-031 (pacote do npm): a recusa dos analisadores vem com o que fazer, a mesma correcao do `ork doctor`.
+    const correcao = erro !== null && erro.startsWith(RECUSA_DOS_ANALISADORES) ? correcaoDosAnalisadores(erro, ctx.versao) : null;
     const r = {
         schema: exports.STATUS_SCHEMA, head: arvore.head, arvore: arvore.motivo === null ? 'limpa' : arvore.motivo, chave_do_head: chave,
-        indice_do_head: indiceDoHeadEstado, analisadores, erro,
+        indice_do_head: indiceDoHeadEstado, analisadores, erro, correcao,
         dir: estado.dir, bytes: estado.bytes, indices: estado.indices, sobras: estado.sobras,
     };
     if (p.bandeiras.has('json')) {
@@ -250,8 +304,11 @@ function status(ctx, p) {
     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)'
-            : r.indice_do_head === 'indisponivel' ? '(sem os analisadores nesta instalacao, nem a consulta nem o indexar rodam)' : `(${r.indice_do_head})`}`,
-        `  analisadores    ${erro ?? Object.entries(analisadores).map(([k, v]) => `${k} ${v}`).join(', ')}`,
+            : 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)})`,
     ];
     for (const i of estado.indices) {
@@ -388,6 +445,29 @@ function consultar(ctx, p) {
     ctx.escrever(respostaComTeto(perguntar, limite, teto));
     return 0;
 }
+function contexto(ctx, p) {
+    const teto = tetoDeBytes(p);
+    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 });
+    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);
+    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'));
+    }
+    return 0;
+}
 const sha256 = (b) => (0, node_crypto_1.createHash)('sha256').update(b).digest('hex');
 /**
  * Bytes da arvore, conferidos arquivo a arquivo contra o manifesto do indice: o trecho da amostra e
@@ -541,12 +621,12 @@ function limpar(ctx, p) {
     return 0;
 }
 /** 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 erroEmJson = (ctx, e, compacto, schema = intelligence_graph_query_1.CONSULTA_SCHEMA) => {
     const [codigo, ...detalhe] = String(e.message).split('\n')[0].split(': ');
     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,
+        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));
@@ -554,7 +634,8 @@ const erroEmJson = (ctx, e, compacto) => {
 };
 /** `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='));
+    const schema = argv[0] === 'contexto' ? intelligence_graph_contexto_1.CONTEXTO_SCHEMA : intelligence_graph_query_1.CONSULTA_SCHEMA;
+    const compacto = argv[0] === 'contexto' || argv.some((a) => a === '--teto-bytes' || a.startsWith('--teto-bytes='));
     let p;
     try {
         p = lerPedido(argv);
@@ -562,7 +643,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, compacto);
+            return erroEmJson(ctx, e, compacto, schema);
         throw e;
     }
     try {
@@ -574,11 +655,13 @@ function executarGrafo(argv, ctx) {
             return amostra(ctx, p);
         if (p.sub === 'limpar')
             return limpar(ctx, p);
+        if (p.sub === 'contexto')
+            return contexto(ctx, p);
         return consultar(ctx, p);
     }
     catch (e) {
         if (!p.bandeiras.has('json'))
             throw e;
-        return erroEmJson(ctx, e, compacto);
+        return erroEmJson(ctx, e, compacto, schema);
     }
 }

package/dist/intelligence-graph-contexto.js

@@ -0,0 +1,215 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONTEXTO_FORA_DO_INDICE = exports.CONTEXTO_POR_ALVO = exports.CONTEXTO_TETO_PADRAO = exports.CONTEXTO_SCHEMA = void 0;
+exports.sementesDaThread = sementesDaThread;
+exports.pacoteDeContexto = pacoteDeContexto;
+/** KG5 fatia 3: composicao pura do contexto da thread. Sem E/S, relogio ou inferencia. */
+const node_crypto_1 = require("node:crypto");
+const intelligence_graph_contract_1 = require("./intelligence-graph-contract");
+const intelligence_graph_query_1 = require("./intelligence-graph-query");
+exports.CONTEXTO_SCHEMA = 'ork.thread-graph-context/v2';
+exports.CONTEXTO_TETO_PADRAO = 32768;
+exports.CONTEXTO_POR_ALVO = 8;
+exports.CONTEXTO_FORA_DO_INDICE = 3;
+const hash = (texto) => (0, node_crypto_1.createHash)('sha256').update(texto).digest('hex');
+/** Caminho relativo do repositorio, nunca caminho de maquina, URL ou estado privado. */
+function caminhoPublico(bruto) {
+    const p = bruto.replace(/^\.\//, '');
+    if (!p || p.startsWith('/') || p.startsWith('~') || /[:\\\u0000-\u001f\u007f]/.test(p) || p.length > 500
+        || p.split('/').some((x) => !x || x === '..' || x === '.' || x === '.git' || x === '.orkastery'))
+        return null;
+    return p;
+}
+/** GOAL/PLAN citam caminhos relativos a raiz em codigo, links ou texto; nao executam instrucoes. */
+function caminhosCitados(texto, diretorios) {
+    const r = [];
+    const semCitacoes = texto.replace(/`([^`\n]+)`|\]\(([^)\n]+)\)/g, (_m, codigo, link) => {
+        const v = codigo ?? link ?? '';
+        if (!/^(?:[a-z]+:|\/)/i.test(v) && (v.includes('/') || /\.[a-z0-9]+(?:#.*|:\d+(?::\d+)?)?$/i.test(v)
+            || /^(?:Dockerfile|Makefile|LICENSE)$/.test(v)))
+            r.push(v.replace(/#.*$/, '').replace(/:\d+(?::\d+)?$/, ''));
+        return ' ';
+    });
+    // Em prosa, exigir diretorio ou extensao de fonte conhecida evita versoes, Node.js e dominios.
+    for (const m of semCitacoes.matchAll(/(?:^|[\s(\["'])((?:[\p{L}\p{N}_@.-]+\/)+[\p{L}\p{N}_@.-]+|[\p{L}\p{N}_@-]+\.(?:ts|tsx|js|jsx|mjs|cjs|mts|cts|json|md|markdown|yaml|yml|toml|py|rs|go|c|h|css|html))(?=\.(?:\s|$)|[:#\s),;\]"']|$)/gu))
+        if (!/^Node\.js\.?$/i.test(m[1]))
+            r.push(m[1].replace(/\.$/, ''));
+    return r.filter((bruto) => {
+        const p = caminhoPublico(bruto);
+        return p !== null && !/^Node\.js$/i.test(p) && (/\.(?:ts|tsx|js|jsx|mjs|cjs|mts|cts|json|md|markdown|yaml|yml|toml|py|rs|go|c|h|css|html)$/i.test(p)
+            || /(?:^|\/)(?:Dockerfile|Makefile|LICENSE)$/.test(p)
+            || (p.includes('/') && diretorios.has(p.split('/')[0])));
+    });
+}
+function sementesDaThread(entrada, caminhosDoRepositorio = []) {
+    const diretorios = new Set(caminhosDoRepositorio.filter((p) => p.includes('/')).map((p) => p.split('/')[0]));
+    const mapa = new Map();
+    const adicionar = (bruto, origem) => {
+        const p = caminhoPublico(bruto);
+        if (!p)
+            return;
+        const origens = mapa.get(p) ?? new Set();
+        origens.add(origem);
+        mapa.set(p, origens);
+    };
+    if (entrada.diffEstado !== 'ignorado-sem-worktree')
+        for (const p of entrada.diff)
+            adicionar(p, 'diff');
+    for (const tipo of ['goal', 'plan'])
+        for (const p of caminhosCitados(entrada[tipo] ?? '', diretorios))
+            adicionar(p, tipo);
+    for (const c of entrada.claims)
+        adicionar(c.arquivo, `claim:${c.id}`);
+    return [...mapa].sort(([a], [b]) => (0, intelligence_graph_contract_1.compararUtf8)(a, b))
+        .map(([arquivo, origens]) => ({ arquivo, origens: [...origens].sort(intelligence_graph_contract_1.compararUtf8) }));
+}
+/** O grafo recebido ja deve estar filtrado pela concessao de quem consulta. */
+function pacoteDeContexto(grafo, indice, entrada, tetoBytes = exports.CONTEXTO_TETO_PADRAO) {
+    if (!Number.isInteger(tetoBytes) || tetoBytes < 4096 || tetoBytes > 65536)
+        throw new intelligence_graph_query_1.ErroDeConsulta('grafo.contexto.teto-invalido', 'teto deve ser inteiro de 4096 a 65536 bytes');
+    const porId = new Map(grafo.nodes.map((n) => [n.node_id, n]));
+    const arquivos = new Set(grafo.nodes.filter((n) => n.kind === 'file').map((n) => n.locator.path));
+    const sementes = sementesDaThread(entrada, [...arquivos]).map((s) => ({ ...s, estado: arquivos.has(s.arquivo) ? 'indexado' : 'fora-do-indice' }));
+    const indexadas = sementes.filter((s) => s.estado === 'indexado'), ausentes = sementes.filter((s) => s.estado !== 'indexado');
+    const alvos = new Set(indexadas.map((s) => s.arquivo));
+    const diff = entrada.diffEstado === 'ignorado-sem-worktree' ? [] : [...new Set(entrada.diff)].sort(intelligence_graph_contract_1.compararUtf8);
+    // Distancia em arquivos, em ambos os sentidos, sem depender da ordem das arestas.
+    const adj = new Map();
+    for (const a of grafo.edges) {
+        const de = porId.get(a.from).locator.path, para = porId.get(a.to).locator.path;
+        if (de === para)
+            continue;
+        if (!adj.has(de))
+            adj.set(de, new Set());
+        if (!adj.has(para))
+            adj.set(para, new Set());
+        adj.get(de).add(para);
+        adj.get(para).add(de);
+    }
+    const dist = new Map(diff.filter((p) => arquivos.has(p)).map((p) => [p, 0]));
+    const fila = [...dist.keys()];
+    for (let i = 0; i < fila.length; i++)
+        for (const p of adj.get(fila[i]) ?? []) {
+            if (!dist.has(p)) {
+                dist.set(p, dist.get(fila[i]) + 1);
+                fila.push(p);
+            }
+        }
+    const extratores = [...indice.extratores].sort((a, b) => (0, intelligence_graph_contract_1.compararUtf8)((0, intelligence_graph_contract_1.canonico)(a), (0, intelligence_graph_contract_1.canonico)(b)));
+    const extratorIds = new Map(extratores.map((e, i) => [(0, intelligence_graph_contract_1.canonico)(e), i]));
+    const grupos = new Map();
+    let totalArestas = 0, estruturais = 0, evidenciasAuxiliares = 0;
+    for (const a of grafo.edges) {
+        const de = porId.get(a.from), para = porId.get(a.to);
+        if (!alvos.has(de.locator.path) && !alvos.has(para.locator.path))
+            continue;
+        totalArestas++;
+        if ((a.kind === 'declares' || a.kind === 'contains') && de.locator.path === para.locator.path && alvos.has(de.locator.path)) {
+            estruturais++;
+            continue;
+        }
+        const proprias = a.evidence.filter((e) => e.path === de.locator.path);
+        evidenciasAuxiliares += a.evidence.length - proprias.length;
+        // Sem evidencia no arquivo de origem, a aresta fica em omitidos.arestas.
+        if (!proprias.length)
+            continue;
+        const origem = `file ${de.locator.path}`, destino = (0, intelligence_graph_query_1.rotuloDoNo)(para);
+        const chave = (0, intelligence_graph_contract_1.canonico)([a.kind, destino, de.locator.path]);
+        const grupo = grupos.get(chave) ?? { kind: a.kind, origem, destino, alvo: para.node_id, quantidade: 0,
+            evidencias: new Map(), entreArquivos: de.locator.path !== para.locator.path,
+            distancia: Math.min(dist.get(de.locator.path) ?? Infinity, dist.get(para.locator.path) ?? Infinity) };
+        grupo.quantidade++;
+        for (const e of proprias) {
+            const x = extratorIds.get((0, intelligence_graph_contract_1.canonico)({ extractor_id: e.extractor_id, extractor_version: e.extractor_version }));
+            if (x === undefined)
+                throw new intelligence_graph_query_1.ErroDeConsulta('grafo.contexto.extrator-ausente', 'extrator da evidencia ausente no cabecalho');
+            const s = e.span;
+            const tupla = [x, e.extraction_method,
+                s.type === 'text' ? [s.line_start, s.line_end] : ['pdf', s.page, s.extracted_text_hash], [s.byte_start, s.byte_end]];
+            grupo.evidencias.set((0, intelligence_graph_contract_1.canonico)(tupla), tupla);
+        }
+        grupos.set(chave, grupo);
+    }
+    // Entre arquivos > perto do diff > tipo > rotulos; empates independem da ordem do indice.
+    const ordenados = [...grupos.values()].sort((a, b) => Number(b.entreArquivos) - Number(a.entreArquivos)
+        || (a.distancia === b.distancia ? 0 : a.distancia < b.distancia ? -1 : 1)
+        || (0, intelligence_graph_contract_1.compararUtf8)(a.kind, b.kind) || (0, intelligence_graph_contract_1.compararUtf8)(a.destino, b.destino) || (0, intelligence_graph_contract_1.compararUtf8)(a.origem, b.origem));
+    // Dentro da mesma prioridade, intercalar tipos impede calls de expulsar imports/references.
+    const rodadas = new Map();
+    const justos = ordenados.map((g) => {
+        const chave = JSON.stringify([g.alvo, g.entreArquivos, g.distancia, g.kind]);
+        const rodada = rodadas.get(chave) ?? 0;
+        rodadas.set(chave, rodada + 1);
+        return { g, rodada };
+    }).sort((a, b) => Number(b.g.entreArquivos) - Number(a.g.entreArquivos)
+        || (a.g.distancia === b.g.distancia ? 0 : a.g.distancia < b.g.distancia ? -1 : 1)
+        || a.rodada - b.rodada || (0, intelligence_graph_contract_1.compararUtf8)(a.g.kind, b.g.kind)
+        || (0, intelligence_graph_contract_1.compararUtf8)(a.g.destino, b.g.destino) || (0, intelligence_graph_contract_1.compararUtf8)(a.g.origem, b.g.origem)).map(({ g }) => g);
+    const normalizada = { ...entrada, diff, diffEstado: entrada.diffEstado ?? 'coletado-na-worktree',
+        claims: [...entrada.claims].sort((a, b) => (0, intelligence_graph_contract_1.compararUtf8)((0, intelligence_graph_contract_1.canonico)(a), (0, intelligence_graph_contract_1.canonico)(b))) };
+    const fixo = { schema: exports.CONTEXTO_SCHEMA, thread: entrada.thread, base: entrada.base, entrada_sha256: hash((0, intelligence_graph_contract_1.canonico)(normalizada)),
+        indice: { ...indice, extratores },
+        fontes: { goal: entrada.goal === null ? 'ausente' : hash(entrada.goal), plan: entrada.plan === null ? 'ausente' : hash(entrada.plan),
+            diff: normalizada.diffEstado },
+        consulta: { profundidade: 1, sentido: 'ambos', por_alvo: exports.CONTEXTO_POR_ALVO, fora_do_indice: exports.CONTEXTO_FORA_DO_INDICE },
+        total_sementes: sementes.length, sementes_fora_do_indice: ausentes.length, total_arestas: totalArestas,
+        total_ligacoes: ordenados.length, resumidas: { estruturais }, parcial: intelligence_graph_query_1.AVISO_DE_PARCIALIDADE };
+    const selecionadas = [], ligacoes = [];
+    const montar = () => {
+        const caminhos = new Set(selecionadas.filter((s) => s.estado === 'indexado').map((s) => s.arquivo));
+        const rotulos = new Set([...caminhos].map((p) => `file ${p}`));
+        for (const a of ligacoes) {
+            rotulos.add(a.origem);
+            rotulos.add(a.destino);
+            caminhos.add(porId.get(a.alvo).locator.path);
+            caminhos.add(a.origem.slice(5));
+        }
+        const refs = new Map([...rotulos].sort(intelligence_graph_contract_1.compararUtf8).map((r, i) => [r, `n${i + 1}`]));
+        const fontes = grafo.snapshot.source_manifest.filter((m) => caminhos.has(m.path)).sort((a, b) => (0, intelligence_graph_contract_1.compararUtf8)(a.path, b.path));
+        const omitidos = { sementes: sementes.length - selecionadas.length, ligacoes: ordenados.length - ligacoes.length,
+            arestas: totalArestas - estruturais - ligacoes.reduce((s, a) => s + a.quantidade, 0), evidencias_auxiliares: evidenciasAuxiliares };
+        const cortado = omitidos.sementes > 0 || omitidos.ligacoes > 0 || omitidos.arestas > 0 || evidenciasAuxiliares > 0;
+        const r = { ...fixo, sementes: selecionadas, nos: Object.fromEntries([...refs].map(([r, ref]) => [ref, r])),
+            arestas: ligacoes.map((a) => ({ kind: a.kind, from: refs.get(a.origem), to: refs.get(a.destino), quantidade: a.quantidade,
+                evidencias: [...a.evidencias].sort(([a], [b]) => (0, intelligence_graph_contract_1.compararUtf8)(a, b)).map(([, e]) => e) })),
+            truncado: cortado, omitidos, teto: { bytes: tetoBytes, cortado },
+            medida: { pacote_bytes: 0, leitura_crua_bytes: fontes.reduce((s, f) => s + f.size_bytes, 0),
+                arquivos: fontes.map((f) => ({ path: f.path, bytes: f.size_bytes })),
+                origem: 'source_manifest; tamanho dos arquivos, nao custo de descoberta', tokens: 'unavailable' } };
+        let texto = (0, intelligence_graph_contract_1.canonico)(r);
+        while (r.medida.pacote_bytes !== Buffer.byteLength(texto)) {
+            r.medida.pacote_bytes = Buffer.byteLength(texto);
+            texto = (0, intelligence_graph_contract_1.canonico)(r);
+        }
+        return texto;
+    };
+    let melhor = montar();
+    if (Buffer.byteLength(melhor) > tetoBytes)
+        throw new intelligence_graph_query_1.ErroDeConsulta('grafo.contexto.teto-excedido', 'cabecalho nao cabe no teto');
+    const tentarSemente = (s) => {
+        selecionadas.push(s);
+        const texto = montar();
+        if (Buffer.byteLength(texto) <= tetoBytes)
+            melhor = texto;
+        else
+            selecionadas.pop();
+    };
+    for (const s of indexadas)
+        tentarSemente(s);
+    const porAlvo = new Map();
+    for (const a of justos) {
+        if ((porAlvo.get(a.alvo) ?? 0) >= exports.CONTEXTO_POR_ALVO)
+            continue;
+        ligacoes.push(a);
+        const texto = montar();
+        if (Buffer.byteLength(texto) <= tetoBytes) {
+            melhor = texto;
+            porAlvo.set(a.alvo, (porAlvo.get(a.alvo) ?? 0) + 1);
+        }
+        else
+            ligacoes.pop(); // Um hub grande nao impede uma ligacao menor e relevante de entrar.
+    }
+    for (const s of ausentes.slice(0, exports.CONTEXTO_FORA_DO_INDICE))
+        tentarSemente(s);
+    return melhor;
+}

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