@orkastery/cli 0.5.0 → 0.5.1

package/dist/intelligence-graph-index.js

@@ -33,13 +33,14 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.versoesDoParser = exports.EXCLUSOES_DA_ARVORE = exports.MODULOS_DO_EXTRATOR = exports.PRAZO_DE_SOBRA_MS = exports.NOME_DE_INDICE = exports.INDICE_SCHEMA = void 0;
+exports.versoesDoParser = exports.EXCLUSOES_DA_ARVORE = exports.MODULOS_DO_EXTRATOR = exports.PRAZO_DE_SOBRA_MS = exports.LIMITE_DE_ANCESTRAIS = exports.NOME_DE_INDICE = exports.INDICE_SCHEMA_ANTERIOR = exports.INDICE_SCHEMA = void 0;
 exports.impressaoDoExtrator = impressaoDoExtrator;
 exports.perfilDoIndice = perfilDoIndice;
 exports.chaveDoIndice = chaveDoIndice;
 exports.concessaoLocal = concessaoLocal;
 exports.pastaDoGrafo = pastaDoGrafo;
 exports.lerIndice = lerIndice;
+exports.escolherBase = escolherBase;
 exports.construirIndice = construirIndice;
 exports.indiceDoHead = indiceDoHead;
 exports.estadoDosIndices = estadoDosIndices;
@@ -61,6 +62,11 @@ exports.limparIndices = limparIndices;
  * publica, por pasta temporaria e `rename`; a leitura confere tamanho e digest dos bytes.
  *
  * O indice nao e autoridade de fato: e projecao descartavel do repositorio. Nada nele concede acesso.
+ *
+ * RM-031 KG4 (D1, D2, D5, D7): o indice guarda tambem as unidades por arquivo (`unidades.json`), e a
+ * construcao sem indice do HEAD parte do indice da revisao ancestral mais proxima com o mesmo perfil:
+ * reextrai so o que a mudanca alcanca e grava os mesmos bytes da extracao completa. Sem base que
+ * prove isso, extrai completo e diz por que.
  */
 const node_crypto_1 = require("node:crypto");
 const fs = __importStar(require("node:fs"));
@@ -69,9 +75,13 @@ const intelligence_graph_contract_1 = require("./intelligence-graph-contract");
 const intelligence_graph_extract_1 = require("./intelligence-graph-extract");
 const intelligence_graph_parsers_1 = require("./intelligence-graph-parsers");
 const intelligence_graph_repo_1 = require("./intelligence-graph-repo");
-exports.INDICE_SCHEMA = 'ork.code-graph-index/v0';
+/** KG4 (D2): a v1 tem as unidades por arquivo; a v0 (KG3) nao serve de base e o `limpar` a remove. */
+exports.INDICE_SCHEMA = 'ork.code-graph-index/v1';
+exports.INDICE_SCHEMA_ANTERIOR = 'ork.code-graph-index/v0';
 exports.NOME_DE_INDICE = /^idx-[a-f0-9]{64}$/;
-const ARQUIVOS = { manifesto: 'indice.json', grafo: 'grafo.json', relatorio: 'relatorio.json' };
+const ARQUIVOS = { manifesto: 'indice.json', grafo: 'grafo.json', relatorio: 'relatorio.json', unidades: 'unidades.json' };
+/** KG4 (D1): quantas revisoes, do HEAD para tras, a escolha da base percorre. */
+exports.LIMITE_DE_ANCESTRAIS = 512;
 /** Temporario e lixo de construcao interrompida so saem no `limpar` depois deste prazo. */
 exports.PRAZO_DE_SOBRA_MS = 60 * 60 * 1000;
 /** D3: os modulos compilados da extracao e do indice. Codigo corrigido sem troca de versao muda a chave. */
@@ -189,6 +199,31 @@ function lerPrivado(arquivo) {
         fs.closeSync(fd);
     }
 }
+/** KG4: as mesmas regras de `lerPrivado` e o tamanho do manifesto, sem ler o conteudo (a consulta nao precisa das unidades). */
+function conferirPrivado(arquivo, bytes) {
+    let fd;
+    try {
+        fd = fs.openSync(arquivo, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
+    }
+    catch (e) {
+        const codigo = e.code;
+        if (codigo === 'ENOENT')
+            falha('grafo.indice.corrompido', `${path.basename(arquivo)} ausente`);
+        falha('grafo.indice.permissao-invalida', `${path.basename(arquivo)} (${codigo ?? 'erro'})`);
+    }
+    try {
+        const st = fs.fstatSync(fd);
+        const dono = uid();
+        if (!st.isFile() || st.nlink !== 1 || (dono !== null && st.uid !== dono) || (st.mode & 0o777) !== 0o600) {
+            falha('grafo.indice.permissao-invalida', path.basename(arquivo));
+        }
+        if (st.size !== bytes)
+            falha('grafo.indice.corrompido', `${path.basename(arquivo)} nao bate com o tamanho`);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
 function gravarPrivado(arquivo, texto) {
     const fd = fs.openSync(arquivo, fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_EXCL | fs.constants.O_NOFOLLOW, 0o600);
     try {
@@ -213,7 +248,11 @@ const HEX64 = /^[a-f0-9]{64}$/;
 function manifestoValido(m, chave) {
     const o = m;
     const inteiro = (n) => Number.isSafeInteger(n) && n >= 0;
+    if (o && typeof o === 'object' && o.schema === exports.INDICE_SCHEMA_ANTERIOR) {
+        falha('grafo.indice.formato-anterior', `${exports.INDICE_SCHEMA_ANTERIOR} (KG3), sem unidades; o ork grafo limpar o remove`);
+    }
     if (!o || typeof o !== 'object' || o.schema !== exports.INDICE_SCHEMA || o.chave !== chave || o.graph_schema !== intelligence_graph_contract_1.GRAFO_SCHEMA
+        || o.units_schema !== intelligence_graph_extract_1.UNIDADES_SCHEMA || !HEX64.test(o.units_digest) || !inteiro(o.units_bytes)
         || typeof o.revision !== 'string' || !/^(?:[a-f0-9]{40}|[a-f0-9]{64})$/.test(o.revision)
         || !HEX64.test(o.graph_digest) || !HEX64.test(o.report_digest) || !inteiro(o.graph_bytes) || !inteiro(o.report_bytes)
         || typeof o.snapshot_id !== 'string' || typeof o.repository_id !== 'string' || typeof o.tenant_id !== 'string'
@@ -259,7 +298,27 @@ function lerIndice(ctx, chave, opcoes = {}) {
         }
     }
     const relatorio = opcoes.relatorio ? JSON.parse(bytesDoRelatorio.toString('utf8')) : null;
-    return { dir, manifesto, grafo, relatorio };
+    // KG4: as unidades so sao lidas (e o digest conferido) por quem as usa; a consulta confere so o tamanho.
+    let unidades = null;
+    if (opcoes.unidades) {
+        let u;
+        try {
+            u = JSON.parse(conferido(ARQUIVOS.unidades, manifesto.units_bytes, manifesto.units_digest).toString('utf8'));
+        }
+        catch (e) {
+            if (e instanceof SyntaxError)
+                falha('grafo.indice.corrompido', 'unidades.json');
+            throw e;
+        }
+        if (!u || u.schema !== intelligence_graph_extract_1.UNIDADES_SCHEMA || u.snapshot_id !== manifesto.snapshot_id || u.graph_digest !== manifesto.graph_digest
+            || !Array.isArray(u.arquivos) || !Array.isArray(u.globais_ts)) {
+            falha('grafo.indice.corrompido', 'unidades.json fora do manifesto');
+        }
+        unidades = u;
+    }
+    else
+        conferirPrivado(path.join(dir, ARQUIVOS.unidades), manifesto.units_bytes);
+    return { dir, manifesto, grafo, relatorio, unidades };
 }
 /** Embaralhamento reproduzivel (LCG): a permutacao da verificacao nao depende de acaso. */
 function embaralhar(itens, semente) {
@@ -296,11 +355,88 @@ function removerPasta(grafoDir, nome) {
         fs.renameSync(alvo, lixo);
     fs.rmSync(lixo, { recursive: true, force: true });
 }
+/** O perfil que um manifesto guarda: tudo o que entra na chave, menos a revisao. */
+const perfilDoManifesto = (m) => ({
+    repository_id: m.repository_id, tenant_id: m.tenant_id, acl_refs: m.acl_refs, analisadores: m.analisadores, pacotes: m.pacotes, codigo: m.codigo,
+});
+const curta = (r) => r.slice(0, 12);
+/**
+ * KG4 (D1, D5): a base e o indice da revisao ancestral mais proxima do HEAD (nas `LIMITE_DE_ANCESTRAIS`
+ * do `git rev-list`) com o mesmo perfil. Sem ela, o motivo diz o que havia: indice ancestral de outro
+ * extrator, indice do mesmo extrator fora da linha do HEAD (historico reescrito ou outro ramo), indice
+ * de formato anterior, ou nenhum. Base que nao passa na leitura e trocada pela proxima, com o erro.
+ */
+function escolherBase(ctx, perfil, head, raiz) {
+    let dir;
+    try {
+        dir = pastaDoGrafo(ctx, false);
+    }
+    catch (e) {
+        if (e.message === 'grafo.indice.ausente')
+            return { base: null, motivo: 'nenhum indice guardado' };
+        throw e;
+    }
+    const posicao = new Map((0, intelligence_graph_repo_1.revisoesAncestrais)(raiz, exports.LIMITE_DE_ANCESTRAIS).map((r, i) => [r, i]));
+    const desejado = (0, intelligence_graph_contract_1.canonico)(perfil), identidade = (0, intelligence_graph_contract_1.canonico)([perfil.repository_id, perfil.tenant_id, perfil.acl_refs]);
+    const candidatos = [];
+    let outroExtrator = null, foraDaLinha = null, anterior = false;
+    for (const nome of fs.readdirSync(dir).sort(intelligence_graph_contract_1.compararUtf8)) {
+        if (!exports.NOME_DE_INDICE.test(nome))
+            continue;
+        let m;
+        try {
+            pastaPrivada(path.join(dir, nome), false);
+            m = manifestoValido(JSON.parse(lerPrivado(path.join(dir, nome, ARQUIVOS.manifesto)).toString('utf8')), nome);
+        }
+        catch (e) {
+            if (e.message.startsWith('grafo.indice.formato-anterior'))
+                anterior = true;
+            continue;
+        }
+        if (m.revision === head)
+            continue;
+        const p = perfilDoManifesto(m), i = posicao.get(m.revision);
+        if ((0, intelligence_graph_contract_1.canonico)(p) === desejado) {
+            if (i === undefined)
+                foraDaLinha ??= m.revision;
+            else
+                candidatos.push({ chave: nome, revision: m.revision, posicao: i });
+        }
+        else if (i !== undefined && (0, intelligence_graph_contract_1.canonico)([p.repository_id, p.tenant_id, p.acl_refs]) === identidade && (!outroExtrator || i < outroExtrator.posicao)) {
+            const campos = ['analisadores', 'pacotes', 'codigo'].filter((k) => (0, intelligence_graph_contract_1.canonico)(p[k]) !== (0, intelligence_graph_contract_1.canonico)(perfil[k]));
+            outroExtrator = { revision: m.revision, campos, posicao: i };
+        }
+    }
+    const erros = [];
+    for (const c of candidatos.sort((a, b) => a.posicao - b.posicao)) {
+        try {
+            const lido = lerIndice(ctx, c.chave, { grafo: false, unidades: true });
+            return { base: { revision: c.revision, chave: c.chave, unidades: lido.unidades }, motivo: null };
+        }
+        catch (e) {
+            erros.push(`${curta(c.revision)}: ${e.message}`);
+        }
+    }
+    if (erros.length)
+        return { base: null, motivo: `base ilegivel (${erros.join('; ')})` };
+    const motivos = [];
+    if (foraDaLinha) {
+        motivos.push(`nenhum indice de revisao ancestral nas ultimas ${exports.LIMITE_DE_ANCESTRAIS}; o de ${curta(foraDaLinha)} nao esta entre elas (historico reescrito, outro ramo ou revisao mais antiga)`);
+    }
+    if (outroExtrator)
+        motivos.push(`o extrator mudou desde o indice de ${curta(outroExtrator.revision)} (${outroExtrator.campos.join(', ')})`);
+    if (!motivos.length && anterior)
+        motivos.push(`so ha indice de formato anterior (${exports.INDICE_SCHEMA_ANTERIOR})`);
+    return { base: null, motivo: motivos.length ? motivos.join('; ') : 'nenhum indice de revisao ancestral com este extrator' };
+}
+const textoDasUnidades = (u) => JSON.stringify(u);
 /**
- * Constroi o indice do HEAD limpo, ou confirma o que ja existe. `--forcar` extrai de novo e so
- * troca os arquivos se o conteudo mudou; `--verificar` extrai de novo, prova o determinismo com a
- * ordem de leitura trocada e reprova se o guardado integro difere; indice que nao passa na leitura
- * e substituido.
+ * Constroi o indice do HEAD limpo, ou confirma o que ja existe. Sem o indice do HEAD, parte do indice
+ * ancestral com o mesmo perfil (KG4) e reextrai so o que a mudanca alcanca; sem base, ou se o
+ * incremental falha, extrai completo e diz por que. `--forcar` extrai completo e so troca os arquivos se
+ * o conteudo mudou; `--verificar` extrai completo, prova o determinismo com a ordem de leitura trocada,
+ * compara com o incremental quando ha base e reprova se o guardado integro difere; indice que nao passa
+ * na leitura e substituido. O incremental passa pelas mesmas validacoes da completa antes de publicar.
  */
 function construirIndice(ctx, opcoes = {}) {
     const inicio = process.hrtime.bigint();
@@ -308,10 +444,11 @@ function construirIndice(ctx, opcoes = {}) {
     const arvore = (0, intelligence_graph_repo_1.revisaoDaArvore)(ctx.raiz);
     if (arvore.motivo !== null || arvore.head === null)
         falha('grafo.indice.arvore-nao-limpa', arvore.motivo ?? 'sem-commit');
+    const head = arvore.head;
     const parser = opcoes.parser ?? (0, intelligence_graph_parsers_1.carregarAnalisadores)();
     const leitura = leituraDo(ctx, opcoes.leitura);
     const perfil = perfilDoIndice(arvore.raiz, (0, exports.versoesDoParser)(parser), leitura);
-    const chave = chaveDoIndice(arvore.head, perfil);
+    const chave = chaveDoIndice(head, perfil);
     const grafoDir = pastaDoGrafo(ctx, true);
     const final = path.join(grafoDir, chave);
     let motivo = null;
@@ -320,55 +457,96 @@ function construirIndice(ctx, opcoes = {}) {
         try {
             const atual = lerIndice(ctx, chave, { grafo: false });
             // `--verificar` nunca confia no guardado: extrai de novo e compara, como o `--forcar`.
-            if (!opcoes.forcar && !opcoes.verificar)
-                return { estado: 'existente', motivo: null, chave, dir: final, manifesto: atual.manifesto, determinismo: null, ms: ms() };
+            if (!opcoes.forcar && !opcoes.verificar) {
+                return {
+                    estado: 'existente', motivo: null, chave, dir: final, manifesto: atual.manifesto, determinismo: null, ms: ms(),
+                    modo: null, base: null, motivo_completo: null, reaproveitamento: null, incremental: null,
+                };
+            }
         }
         catch (e) {
             motivo = e.message;
         }
     }
     const entrada = (0, intelligence_graph_repo_1.lerRepositorio)(arvore.raiz, leitura);
-    if (entrada.revision !== arvore.head)
+    if (entrada.revision !== head)
         falha('grafo.indice.arvore-nao-limpa', entrada.revision_unavailable_reason ?? 'revisao-mudou');
     const fora = (entrada.excluidas ?? []).filter((e) => exports.EXCLUSOES_DA_ARVORE.has(e.motivo)).sort((a, b) => (0, intelligence_graph_contract_1.compararUtf8)(a.path, b.path));
     if (fora.length) {
         falha('grafo.indice.arvore-nao-limpa', `rastreado fora da leitura (${fora[0].motivo}: ${fora[0].path}${fora.length > 1 ? ` e mais ${fora.length - 1}` : ''})`);
     }
-    const r = (0, intelligence_graph_extract_1.extrairGrafo)(entrada, parser);
+    // KG4 (D1, D5, D7): a base, salvo com `--forcar`.
+    let base = null, motivoCompleto = 'pedido com --forcar';
+    if (!opcoes.forcar)
+        ({ base, motivo: motivoCompleto } = escolherBase(ctx, perfil, head, arvore.raiz));
+    let r = null, modo = 'completo';
+    if (base && !opcoes.verificar) {
+        try {
+            r = (0, intelligence_graph_extract_1.extrairGrafo)(entrada, parser, base.unidades);
+            modo = 'incremental';
+        }
+        catch (e) {
+            // O incremental nunca impede o indice: a completa decide, e o motivo fica dito.
+            motivoCompleto = `o incremental a partir de ${curta(base.revision)} falhou e a extracao foi completa (${e.message})`;
+            r = null;
+        }
+    }
+    if (!r)
+        r = (0, intelligence_graph_extract_1.extrairGrafo)(entrada, parser);
     const bytesDe = new Map(entrada.fontes.map((f) => [f.path, f.bytes]));
     const fornecidas = new Map(r.grafo.snapshot.source_manifest.map((m) => {
         const b = bytesDe.get(m.path);
         return [m.path, { tipo: (0, intelligence_graph_extract_1.decodificarUtf8)(b) === null ? 'binario' : 'texto', bytes: b }];
     }));
-    const conferencia = (0, intelligence_graph_contract_1.conferirFontes)(r.grafo, fornecidas);
+    // KG4 (D6): `r.grafo` e o retorno de `validarGrafo` dentro da extracao; validar de novo so repetiria.
+    const conferencia = (0, intelligence_graph_contract_1.conferirFontesDoGrafoValidado)(r.grafo, fornecidas);
     if (conferencia.estado !== 'verificada' || conferencia.evidenciasIndisponiveis > 0)
         falha('grafo.indice.fontes-nao-conferidas');
-    let determinismo = null;
+    const textoDoGrafo = (0, intelligence_graph_contract_1.canonico)(r.grafo), textoDoRelatorio = (0, intelligence_graph_contract_1.canonico)(r.relatorio), unidades = textoDasUnidades(r.unidades);
+    if (sha256(textoDoGrafo) !== r.digest)
+        falha('grafo.indice.digest-divergente');
+    let determinismo = null, incremental = null;
     if (opcoes.verificar) {
-        const relatorio = (0, intelligence_graph_contract_1.sha256DoCanonico)(r.relatorio);
+        const relatorio = sha256(textoDoRelatorio), dasUnidades = sha256(unidades);
         determinismo = [['ordem invertida', [...entrada.fontes].reverse()], ['ordem embaralhada', embaralhar(entrada.fontes, 2026)]]
             .map(([ordem, fontes]) => {
             const outra = (0, intelligence_graph_extract_1.extrairGrafo)({ ...entrada, fontes }, parser);
-            const doOutro = (0, intelligence_graph_contract_1.sha256DoCanonico)(outra.relatorio);
-            return { ordem, digest: outra.digest, relatorio: doOutro, igual: outra.digest === r.digest && doOutro === relatorio };
+            const doOutro = (0, intelligence_graph_contract_1.sha256DoCanonico)(outra.relatorio), unidadesDoOutro = sha256(textoDasUnidades(outra.unidades));
+            return {
+                ordem, digest: outra.digest, relatorio: doOutro, unidades: unidadesDoOutro,
+                igual: outra.digest === r.digest && doOutro === relatorio && unidadesDoOutro === dasUnidades,
+            };
         });
         const diferente = determinismo.find((d) => !d.igual);
         if (diferente)
             falha('grafo.indice.nao-deterministico', diferente.ordem);
+        if (base) {
+            // KG4 (D7): a prova no repositorio de quem usa: o incremental da base da os mesmos bytes da completa.
+            let inc;
+            try {
+                inc = (0, intelligence_graph_extract_1.extrairGrafo)(entrada, parser, base.unidades);
+            }
+            catch (e) {
+                falha('grafo.indice.incremental-divergente', `o incremental da base ${curta(base.revision)} falhou: ${e.message}`);
+            }
+            const igual = (0, intelligence_graph_contract_1.canonico)(inc.grafo) === textoDoGrafo && (0, intelligence_graph_contract_1.canonico)(inc.relatorio) === textoDoRelatorio && textoDasUnidades(inc.unidades) === unidades;
+            if (!igual)
+                falha('grafo.indice.incremental-divergente', `base ${curta(base.revision)}`);
+            incremental = { base: base.revision, igual, reaproveitamento: inc.reaproveitamento };
+        }
     }
-    const textoDoGrafo = (0, intelligence_graph_contract_1.canonico)(r.grafo), textoDoRelatorio = (0, intelligence_graph_contract_1.canonico)(r.relatorio);
-    if (sha256(textoDoGrafo) !== r.digest)
-        falha('grafo.indice.digest-divergente');
     const manifesto = {
-        schema: exports.INDICE_SCHEMA, chave, revision: arvore.head, ...perfil, graph_schema: intelligence_graph_contract_1.GRAFO_SCHEMA, snapshot_id: r.grafo.snapshot.snapshot_id,
+        schema: exports.INDICE_SCHEMA, chave, revision: head, ...perfil, graph_schema: intelligence_graph_contract_1.GRAFO_SCHEMA, snapshot_id: r.grafo.snapshot.snapshot_id,
         graph_digest: r.digest, graph_bytes: Buffer.byteLength(textoDoGrafo, 'utf8'),
         report_digest: sha256(textoDoRelatorio), report_bytes: Buffer.byteLength(textoDoRelatorio, 'utf8'),
         contagens: r.relatorio.contagens,
         conferencia: { fontes: conferencia.fontesVerificadas.length, evidencias: conferencia.evidenciasVerificadas },
+        units_schema: intelligence_graph_extract_1.UNIDADES_SCHEMA, units_digest: sha256(unidades), units_bytes: Buffer.byteLength(unidades, 'utf8'),
     };
     const conteudos = {
-        [ARQUIVOS.manifesto]: (0, intelligence_graph_contract_1.canonico)(manifesto), [ARQUIVOS.grafo]: textoDoGrafo, [ARQUIVOS.relatorio]: textoDoRelatorio,
+        [ARQUIVOS.manifesto]: (0, intelligence_graph_contract_1.canonico)(manifesto), [ARQUIVOS.grafo]: textoDoGrafo, [ARQUIVOS.relatorio]: textoDoRelatorio, [ARQUIVOS.unidades]: unidades,
     };
+    const daBase = modo === 'incremental' && base ? { revision: base.revision, chave: base.chave } : opcoes.verificar && base ? { revision: base.revision, chave: base.chave } : null;
     const tmp = path.join(grafoDir, `.tmp-${(0, node_crypto_1.randomUUID)()}`);
     pastaPrivada(tmp, true);
     try {
@@ -376,7 +554,10 @@ function construirIndice(ctx, opcoes = {}) {
             gravarPrivado(path.join(tmp, nome), texto);
         sincronizarPasta(tmp);
         opcoes.antesDePublicar?.();
-        const resultado = (estado) => ({ estado, motivo, chave, dir: final, manifesto, determinismo, ms: ms() });
+        const resultado = (estado) => ({
+            estado, motivo, chave, dir: final, manifesto, determinismo, ms: ms(), modo, base: daBase,
+            motivo_completo: modo === 'incremental' ? null : motivoCompleto, reaproveitamento: r?.reaproveitamento ?? null, incremental,
+        });
         if (!existia && fs.lstatSync(final, { throwIfNoEntry: false })) {
             // Corrida: outra construcao publicou a mesma chave durante esta. Vale a dela, se estiver integra.
             lerIndice(ctx, chave, { grafo: false });

package/dist/intelligence-graph-repo.js

@@ -37,6 +37,7 @@ exports.TENANT_PADRAO = void 0;
 exports.identidadeDaLeitura = identidadeDaLeitura;
 exports.revisaoDaArvore = revisaoDaArvore;
 exports.headsDasArvores = headsDasArvores;
+exports.revisoesAncestrais = revisoesAncestrais;
 exports.lerRepositorio = lerRepositorio;
 /**
  * RM-031 KG2 (D8): leitura do repositorio Git local para o extrator. E a unica borda de E/S do
@@ -118,6 +119,15 @@ function headsDasArvores(diretorio) {
     const saida = obrigatorio(diretorio, ['worktree', 'list', '--porcelain']).toString('utf8');
     return [...new Set(saida.split('\n').filter((l) => /^HEAD [0-9a-f]{40,64}$/.test(l)).map((l) => l.slice(5)))].sort();
 }
+/**
+ * RM-031 KG4 (D1): o HEAD e as revisoes ancestrais dele (`git rev-list`), da mais recente para a mais
+ * antiga, ate o limite. Sem commit, ou com o Git falhando, nao ha ancestral.
+ */
+function revisoesAncestrais(diretorio, limite) {
+    const raiz = obrigatorio(diretorio, ['rev-parse', '--show-toplevel']).toString('utf8').trim();
+    const r = git(raiz, ['rev-list', `--max-count=${Math.max(1, Math.floor(limite))}`, 'HEAD']);
+    return r.ok ? r.saida.toString('utf8').split('\n').filter((l) => /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/.test(l)) : [];
+}
 /** Le o repositorio que contem `diretorio` e devolve a entrada do extrator. */
 function lerRepositorio(diretorio, opcoes = {}) {
     const raiz = obrigatorio(diretorio, ['rev-parse', '--show-toplevel']).toString('utf8').trim();

package/dist/leases.js

@@ -78,6 +78,7 @@ exports.adquirirRegiao = adquirirRegiao;
 exports.tabelaDeLeases = tabelaDeLeases;
 exports.soltarDaThread = soltarDaThread;
 exports.soltarThreadFechada = soltarThreadFechada;
+exports.podarRegioesDeThreadsFechadas = podarRegioesDeThreadsFechadas;
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const manifest_1 = require("./manifest");
@@ -634,3 +635,18 @@ function podarThreadsFechadas(raiz, nome, quem) {
             soltarThreadFechada(raiz, thread, 'poda', quem);
     }
 }
+/**
+ * RM-037 (fatia 3, defeito 4): a mesma poda, para as conferencias previas do MCP. O `ork_git_commit`
+ * conferia `lerLease` antes do `adquirirRegiao` e recusava com `lease.busy` o lease que a ork-companybrai3
+ * (fechada) deixou, e soltar o lease de outra thread exigia o dono. Lease e fila de thread fechada sao
+ * orfaos: saem aqui, com registro no ledger dela. Lease de thread aberta, vencido ou nao, e o da propria
+ * thread seguem como estao, e a conferencia de quem chama decide. De melhor esforco, como no `adquirirRegiao`.
+ */
+function podarRegioesDeThreadsFechadas(raiz, nomes, quem) {
+    for (const nome of nomes) {
+        try {
+            podarThreadsFechadas(raiz, nome, quem);
+        }
+        catch { /* a conferencia de quem chama decide */ }
+    }
+}

package/dist/ledger.js

@@ -45,6 +45,7 @@ exports.caminhoLedger = caminhoLedger;
 exports.registrar = registrar;
 exports.threadPresente = threadPresente;
 exports.registrarSeExiste = registrarSeExiste;
+exports.ehEnsaio = ehEnsaio;
 exports.lerLedger = lerLedger;
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
@@ -236,6 +237,14 @@ function registrarSeExiste(dirThread, threadId, tipo, dados = {}) {
     }
     return evento;
 }
+/**
+ * Fatia 2 do ensaio da 0.5.0 (P2): o evento que um `--dry-run` grava (`dryRun: true`) e ensaio, nao
+ * estado. O ledger o guarda como rastro; board, escalonador, monitor (o pulse) e maestro o descartam.
+ * O ensaio do ship gravava `gate_blocked human.pending` e a thread aparecia pausada sem ninguem pedir.
+ */
+function ehEnsaio(e) {
+    return e.dryRun === true;
+}
 /** Le o ledger inteiro. Linha corrompida vira evento `ledger_corrupted` em vez de quebrar a leitura. */
 function lerLedger(dirThread) {
     const caminho = caminhoLedger(dirThread);

package/dist/licoes.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PISO_DA_PROPOSTA = exports.JANELA_DA_PROPOSTA_DIAS = void 0;
+exports.PISO_DA_PROPOSTA = exports.JANELA_DA_PROPOSTA_DIAS = exports.DICA_DO_MOTIVO = void 0;
 exports.lerLicoes = lerLicoes;
 exports.resumoDasLicoes = resumoDasLicoes;
 exports.textoDasLicoes = textoDasLicoes;
@@ -59,7 +59,7 @@ const estado_thread_1 = require("./estado-thread");
 const ledger_1 = require("./ledger");
 const policies_1 = require("./policies");
 /** O que evita cada bloqueio, na forma de comando. Sem dica, a licao so conta a recorrencia. */
-const DICA_DO_MOTIVO = {
+exports.DICA_DO_MOTIVO = {
     'claims.failed': 'rode o comando da claim antes de registra-la; claim sem prova local volta como GO-FIX',
     'verify.regression': 'grave a baseline antes do GO (`ork verify <thread> --baseline`) e rode os testes focados antes do CHECK',
     'verify.failed': 'grave a baseline antes do GO, para a falha ter com que ser comparada',
@@ -67,7 +67,8 @@ const DICA_DO_MOTIVO = {
     'runtime.unavailable': 'declare a ordem de fallback do bloco (`ork setup <modo> --bloco N --fallback runtime:modelo`)',
     'runtime.quota-exhausted': 'tenha um segundo perfil da conta (`ork accounts add`) ou fallback no bloco',
     'tree.blocked': 'sincronize a worktree com a base antes do SHIP (`ork worktree sync <thread>`)',
-    'ci.failed': 'rode a suite hermetica (`npm --prefix core run test:ci`) antes do push',
+    // Fatia 2 do ensaio da 0.5.0 (P6): o que o CI do projeto roda, e nao o script do Orkastery.
+    'ci.failed': 'rode antes do push o que o CI do projeto roda (`ci.command` do manifesto ou, sem ele, os comandos de `verify`)',
     'artifact.missing': 'grave o artefato da fase exatamente no caminho que o prompt pede',
 };
 const DICA_DA_CLASSE = {
@@ -116,7 +117,7 @@ function recorrencias(licoes) {
     const classes = new Map();
     for (const l of licoes) {
         for (const m of l.motivos) {
-            const r = motivos.get(m) ?? { chave: `motivo:${m}`, tipo: 'motivo', nome: m, threads: [], vezes: 0, dica: DICA_DO_MOTIVO[m] ?? null };
+            const r = motivos.get(m) ?? { chave: `motivo:${m}`, tipo: 'motivo', nome: m, threads: [], vezes: 0, dica: exports.DICA_DO_MOTIVO[m] ?? null };
             r.threads.push(l.thread);
             motivos.set(m, r);
         }

package/dist/liveness.js

@@ -120,7 +120,8 @@ function detectarFasesOrfas(carregado, opcoes = {}) {
         const t = (0, thread_1.lerThread)(carregado.raiz, id), dir = (0, thread_1.dirThread)(carregado.raiz, id);
         if (t.status !== 'aberta')
             continue;
-        const eventos = (0, ledger_1.lerLedger)(dir), di = eventos.map(e => e.tipo).lastIndexOf('phase_dispatch');
+        // Fatia 2 do ensaio da 0.5.0 (P2; CHECK, rodada 1, A1): o gate do `ship --dry-run` nao e gate em aberto.
+        const eventos = (0, ledger_1.lerLedger)(dir).filter(e => !(0, ledger_1.ehEnsaio)(e)), di = eventos.map(e => e.tipo).lastIndexOf('phase_dispatch');
         if (di < 0)
             continue;
         const d = eventos[di], inicio = Date.parse(d.ts), fase = d.fase;

package/dist/maestro-runtime.js

@@ -47,6 +47,7 @@ const hitl_sessions_1 = require("./hitl-sessions");
 const thread_1 = require("./thread");
 const hitl_gates_1 = require("./hitl-gates");
 const ocupacao_1 = require("./ocupacao");
+const ledger_1 = require("./ledger");
 const horario_1 = require("./horario");
 const conducao_1 = require("./conducao");
 const conducao_texto_1 = require("./conducao-texto");
@@ -95,6 +96,8 @@ function operationalSources(reader, threads, native = [], now = new Date().toISO
             events = raw.split('\n').filter(Boolean).map(line => JSON.parse(line));
             if (events.some(e => typeof e.tipo !== 'string' || e.thread !== t.id))
                 throw Error('invalid');
+            // Fatia 2 do ensaio da 0.5.0 (P2): o ensaio (`dryRun: true`) nao vira bloqueio nem entrega incompleta.
+            events = events.filter(e => !(0, ledger_1.ehEnsaio)(e));
         }
         catch {
             for (const name of names.filter(n => !['leases', 'retries'].includes(n)))

package/dist/manifest.js

@@ -165,6 +165,28 @@ function booleano(v, padrao) {
 function mapa(v) {
     return v && typeof v === 'object' && !Array.isArray(v) ? v : {};
 }
+/**
+ * RM-031 KG5 (D2): `grafo.mcp` so liga com o booleano `true`. Ausente vale `false`; texto que parece
+ * booleano, outro tipo ou `grafo` que nao e mapa tambem valem `false`, com aviso: ligar expoe as tools
+ * do grafo, e na duvida fica desligado. Chave desconhecida em `grafo` so avisa.
+ */
+function lerGrafo(v, avisos) {
+    const mostrar = (x) => JSON.stringify(x).slice(0, 80);
+    if (v === undefined || v === null)
+        return { mcp: false };
+    if (typeof v !== 'object' || Array.isArray(v)) {
+        avisos.push(`grafo deve ser um mapa com mcp: true ou false; vale mcp: false (${mostrar(v)} nao reconhecido)`);
+        return { mcp: false };
+    }
+    for (const chave of Object.keys(v))
+        if (chave !== 'mcp')
+            avisos.push(`grafo.${chave} desconhecida; o bloco grafo so tem mcp`);
+    const mcp = v.mcp;
+    if (mcp === undefined || mcp === null || typeof mcp === 'boolean')
+        return { mcp: mcp === true };
+    avisos.push(`grafo.mcp deve ser true ou false; vale false (${mostrar(mcp)} nao reconhecido)`);
+    return { mcp: false };
+}
 /** Mesmo contrato na leitura do YAML e nos consumidores de manifesto em memoria. */
 function validarOptInPlaybook(valor) {
     if (valor === undefined)
@@ -534,6 +556,8 @@ function carregarManifesto(dirInicial = diretorioDoProjeto()) {
             compartilhada: booleano(fabrica.compartilhada, false),
             remoto: texto(fabrica.remoto, 'origin'),
         },
+        // RM-031 KG5 (D2): expor as tools do grafo no MCP e opt-in do dono.
+        grafo: lerGrafo(dados.grafo, avisos),
         policies: Object.fromEntries(Object.entries(mapa(dados.policies)).map(([k, v]) => [k, texto(v, '')])),
     };
     return { caminho: achado.caminho, raiz, legado: achado.legado, bytes, manifesto, erros, avisos };

package/dist/mcp-artifacts.js

@@ -157,6 +157,8 @@ function comEscrita(raiz, id, executar) {
             }
         }
         const nome = `path:.orkastery/threads/${id}`;
+        // RM-037 (fatia 3, defeito 4): lease e fila de thread fechada sao orfaos e saem antes da conferencia.
+        (0, leases_1.podarRegioesDeThreadsFechadas)(raiz, [nome], id);
         if ((0, leases_1.lerLease)(raiz, nome) || (0, leases_1.leasesColidentes)(raiz, nome).length)
             throw Error('lease.busy: estado canonico ocupado');
         const r = (0, leases_1.adquirirRegiao)(raiz, nome, { thread: id, motivo: 'MCP documento ou claim', ttlMs: 30000, retomarVencido: false });