@orkastery/cli 0.4.3 → 0.5.1

package/dist/mcp-experiencia.js

@@ -0,0 +1,164 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.consultaExperienciaSchema = void 0;
+exports.apresentarConsulta = apresentarConsulta;
+exports.consultarPainel = consultarPainel;
+exports.criarLeitorExperiencia = criarLeitorExperiencia;
+exports.registrarConsultasExperiencia = registrarConsultasExperiencia;
+/** Consultas do projeto fixado. Nunca reserva item, publica máquina ou executa push. */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const node_crypto_1 = require("node:crypto");
+const zod_1 = require("zod");
+const roadmap_reservas_1 = require("./roadmap-reservas");
+const fabrica_estado_1 = require("./fabrica-estado");
+const mcp_ship_1 = require("./mcp-ship");
+const mcp_git_1 = require("./mcp-git");
+exports.consultaExperienciaSchema = zod_1.z.object({}).strict();
+function apresentarConsulta(painel) {
+    const estado = painel.atualizado ? 'atualizado' : painel.ponta ? 'desatualizado' : 'indisponivel';
+    return { estado, dados: estado === 'indisponivel' ? null : painel,
+        motivo: estado === 'atualizado' ? null : 'mcp.experiencia.remoto.indisponivel' };
+}
+const indisponivel = () => ({ estado: 'indisponivel', dados: null, motivo: 'mcp.experiencia.consulta.indisponivel' });
+/** Chamada somente depois de validar a fixação do worker. */
+function consultarPainel(raiz, tipo) {
+    try {
+        return apresentarConsulta(tipo === 'reservas' ? (0, roadmap_reservas_1.listarReservas)(raiz, { remoto: 'origin' })
+            : (0, fabrica_estado_1.lerFabrica)(raiz, { remoto: 'origin', timeoutMs: 15000 }));
+    }
+    catch {
+        return indisponivel();
+    }
+}
+/** Usa as mesmas guardas de transporte do núcleo; não cria autorização de SHIP. */
+function assinatura(raiz, transporte) {
+    (0, mcp_ship_1.criarPerfilShipMcp)(raiz, transporte);
+    const g = path.join(raiz, '.git');
+    (0, mcp_git_1.perfilGitMcp)(raiz, g, g, 'consulta-experiencia', []);
+    const st = fs.statSync(raiz);
+    return (0, node_crypto_1.createHash)('sha256').update(JSON.stringify([st.dev, st.ino, fs.realpathSync(raiz),
+        (0, mcp_git_1.gitPassivoMcp)(raiz, ['remote', 'get-url', '--all', 'origin']),
+        (0, mcp_git_1.gitPassivoMcp)(raiz, ['config', '--null', '--list'])])).digest('hex');
+}
+const PRAZO_DA_CONSULTA_MS = 90000;
+/**
+ * O worker herda somente ambiente permitido; nunca modifica env do servidor. Roda assíncrono para
+ * o servidor MCP seguir atendendo as outras tools durante a consulta remota, e em grupo próprio:
+ * prazo ou cancelamento da chamada matam o worker e o git que ele abriu.
+ */
+function criarLeitorExperiencia(raiz, transporte, prazoMs = PRAZO_DA_CONSULTA_MS) {
+    let fixacao = null;
+    try {
+        fixacao = assinatura(raiz, transporte);
+    }
+    catch { /* ferramenta continua descoberta, com lacuna explícita */ }
+    return (tipo, signal) => new Promise(resolve => {
+        if (!fixacao || signal?.aborted) {
+            resolve(indisponivel());
+            return;
+        }
+        const grupo = process.platform !== 'win32';
+        const filho = (0, node_child_process_1.spawn)(process.execPath, [__filename, '--consulta-experiencia'], {
+            cwd: raiz, env: { ...(0, mcp_git_1.ambienteGitMcp)(), SSH_AUTH_SOCK: process.env.SSH_AUTH_SOCK },
+            stdio: ['pipe', 'pipe', 'ignore'], detached: grupo,
+        });
+        let saida = '', terminado = false;
+        const concluir = (r) => {
+            if (terminado)
+                return;
+            terminado = true;
+            clearTimeout(prazo);
+            signal?.removeEventListener('abort', abortar);
+            resolve(r);
+        };
+        const abortar = () => {
+            if (terminado)
+                return;
+            filho.stdout?.destroy();
+            try {
+                if (filho.pid)
+                    process.kill(grupo ? -filho.pid : filho.pid, 'SIGKILL');
+            }
+            catch { /* já terminou */ }
+            concluir(indisponivel());
+        };
+        const prazo = setTimeout(abortar, prazoMs);
+        signal?.addEventListener('abort', abortar, { once: true });
+        filho.stdout.setEncoding('utf8');
+        filho.stdout.on('data', (parte) => { saida += parte; if (saida.length > 1024 * 1024)
+            abortar(); });
+        filho.stdin.on('error', () => undefined);
+        filho.on('error', () => concluir(indisponivel()));
+        filho.on('close', (codigo, sinal) => {
+            if (codigo !== 0 || sinal) {
+                concluir(indisponivel());
+                return;
+            }
+            try {
+                concluir(JSON.parse(saida));
+            }
+            catch {
+                concluir(indisponivel());
+            }
+        });
+        filho.stdin.end(JSON.stringify({ raiz, transporte, fixacao, tipo }));
+    });
+}
+function registrarConsultasExperiencia(registrar, opcoes) {
+    const ler = criarLeitorExperiencia(opcoes.raiz, opcoes.transporte);
+    for (const [nome, tipo] of [['ork_roadmap_reservas', 'reservas'], ['ork_fabrica', 'fabrica']]) {
+        registrar(nome, { description: 'Consulta de ' + tipo + ' do projeto e origin fixados; distingue remoto atualizado, cópia desatualizada e indisponibilidade. Não reserva nem publica.',
+            inputSchema: exports.consultaExperienciaSchema, annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: true } }, async (_args, extra) => {
+            opcoes.carregar();
+            return { content: [{ type: 'text', text: JSON.stringify(await ler(tipo, extra.signal)) }] };
+        });
+    }
+}
+if (require.main === module && process.argv[2] === '--consulta-experiencia') {
+    try {
+        const p = zod_1.z.object({ raiz: zod_1.z.string(), transporte: zod_1.z.enum(['github-ssh', 'bare-local']),
+            fixacao: zod_1.z.string().regex(/^[a-f0-9]{64}$/), tipo: zod_1.z.enum(['reservas', 'fabrica']) }).strict()
+            .parse(JSON.parse(fs.readFileSync(0, 'utf8')));
+        if (assinatura(p.raiz, p.transporte) !== p.fixacao)
+            throw Error('scope.changed');
+        process.stdout.write(JSON.stringify(consultarPainel(p.raiz, p.tipo)));
+    }
+    catch {
+        process.stdout.write(JSON.stringify(indisponivel()));
+    }
+}

package/dist/mcp-git.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HOOKS_ESTRITOS = exports.HOOKS_DO_COMMIT = exports.HOOKS_INERTES_DO_COMMIT = void 0;
+exports.comoOGitSaiu = comoOGitSaiu;
 exports.estadoGitMcp = estadoGitMcp;
 exports.commitMcp = commitMcp;
 exports.perfilGitMcp = perfil;
@@ -115,11 +116,25 @@ function ambiente(env = process.env) {
     return { HOME: env.HOME, USER: env.USER, LOGNAME: env.LOGNAME,
         XDG_CONFIG_HOME: env.XDG_CONFIG_HOME, PATH: '/usr/bin:/bin', LANG: 'C.UTF-8', TMPDIR: '/tmp' };
 }
+/**
+ * Fatia 2 do ensaio da 0.5.0 (P8): como o git saiu, sem o stderr, que pode citar caminho e conteudo.
+ * O sinal vem antes do erro (CHECK, rodada 1, S4): prazo estourado e saida acima do limite matam o git
+ * que ja executou; so o erro sem sinal (ENOENT, EACCES) e git que nem rodou.
+ */
+function comoOGitSaiu(r) {
+    const codigo = r.error ? r.error.code ?? 'erro' : '';
+    if (r.signal)
+        return `interrompido por ${r.signal}${codigo ? ` (${codigo})` : ''}`;
+    if (r.error)
+        return `nao executou (${codigo})`;
+    return `saiu ${r.status}`;
+}
 function git(wt, args, input) {
     const r = (0, node_child_process_1.spawnSync)(GIT, ['--no-pager', '--literal-pathspecs', ...args], { cwd: wt, env: ambiente(),
         encoding: 'utf8', input, timeout: 10000, killSignal: 'SIGKILL', maxBuffer: LIMITE });
+    // O subcomando e sempre o primeiro argumento interno, nunca entrada do cliente.
     if (r.status !== 0 || r.signal || r.error)
-        falha('command.failed');
+        falha(`command.failed: git ${args[0]} ${comoOGitSaiu(r)}`);
     return r.stdout;
 }
 /** Lista positiva de configuração passiva. Não é blacklist de shell. */
@@ -131,6 +146,10 @@ function configPassiva(chave, valor, credenciaisInertes = false) {
         return valor.length <= 8192 && !valor.includes('\0');
     if (['user.name', 'user.email'].includes(chave))
         return !!valor.trim() && valor.length <= 512 && !/[\x00-\x1f]/.test(valor);
+    // RM-051: só afrouxa a checagem de dono, e o Git só a lê no sistema ou no global; o repositório
+    // continua conferido chave a chave aqui. A imagem do runner hospedado do GitHub grava `safe.directory=*`.
+    if (chave === 'safe.directory')
+        return valor.length <= 4096 && !/[\x00-\x1f\x7f]/.test(valor);
     // RM-037 (defeitosdeco D-3): a seção do próprio produto (por exemplo `orkastery.cortefeito`, lida
     // pela trava do corte no pre-push). O Git nunca lê essa seção, então ela não executa nada.
     if (/^orkastery\.[a-z0-9-]+$/.test(chave))
@@ -151,25 +170,47 @@ function configPassiva(chave, valor, credenciaisInertes = false) {
         return valor.length <= 2048 && !/[\x00-\x1f]/.test(valor);
     return false;
 }
-/** Metadados graváveis pelo Git/API não podem redirecionar escrita para fora. */
-function arvoreMetadados(root, alvo) {
+/**
+ * Metadados graváveis pelo Git/API não podem redirecionar escrita para fora.
+ *
+ * RM-037 (fatia 3, defeito 5): no armazém de objetos (`objects/`), arquivo regular com mais de um vínculo
+ * passa. O git nunca abre arquivo de lá para escrita: cria um temporário e renomeia, e objeto que já existe
+ * só tem o horário renovado. O vínculo não redireciona escrita, e um clone local liga os objetos por hard
+ * link (7.621 em 29/09): um clone qualquer travava o `ork_git_status` e o `ork_git_commit` de todas as
+ * threads. Fora de `objects/` (refs, logs, índice), segue um vínculo só, e a recusa diz o caminho e a receita.
+ */
+function arvoreMetadados(root, alvo, opcoes = {}) {
     if (!fs.lstatSync(alvo, { throwIfNoEntry: false }))
         return;
+    // O caminho da recusa e relativo a raiz do repositorio, onde a receita roda; com caractere fora do
+    // conjunto seguro (ref com `+` ou espaco, por exemplo), vai entre aspas simples para a receita copiar certo.
+    const rotulo = (f) => {
+        const r = path.relative(opcoes.relativoA ?? path.dirname(root), f).replace(/[\x00-\x1f\x7f]/g, '?').slice(0, 200);
+        return /^[A-Za-z0-9._/-]+$/.test(r) ? r : `'${r.replace(/'/g, "'\\''")}'`;
+    };
     let vistos = 0;
     const visitar = (f, profundidade) => {
-        if (++vistos > 8192 || profundidade > 32)
-            falha('metadata.unsupported');
+        if (++vistos > 8192)
+            falha(`metadata.unsupported: mais de 8192 entradas em ${rotulo(alvo)}` + (opcoes.armazemDeObjetos
+                ? '; empacote os objetos soltos sem perda com git repack -d (git count-objects -v mostra quantos)' : ''));
+        if (profundidade > 32)
+            falha(`metadata.unsupported: mais de 32 niveis em ${rotulo(alvo)}`);
         const st = fs.lstatSync(f);
-        if (st.isSymbolicLink() || (!st.isDirectory() && (!st.isFile() || st.nlink !== 1)))
-            falha('metadata.unsafe');
+        if (st.isSymbolicLink())
+            falha(`metadata.unsafe: link simbolico em ${rotulo(f)}`);
+        if (!st.isDirectory() && !st.isFile())
+            falha(`metadata.unsafe: ${rotulo(f)} nao e arquivo regular nem pasta`);
+        if (st.isFile() && st.nlink !== 1 && !opcoes.armazemDeObjetos)
+            falha(`metadata.unsafe: hard link em ${rotulo(f)} (${st.nlink} vinculos); ` +
+                `tire o vinculo sem perder conteudo: cp -p ${rotulo(f)} ${rotulo(f + '.tmp')} && mv ${rotulo(f + '.tmp')} ${rotulo(f)}`);
         if (f !== root && !dentro(root, f))
-            falha('metadata.unsafe');
+            falha(`metadata.unsafe: ${rotulo(f)} fora de ${path.basename(root)}`);
         if (st.isDirectory())
             for (const n of fs.readdirSync(f))
                 visitar(path.join(f, n), profundidade + 1);
     };
     if (fs.realpathSync(alvo) !== alvo)
-        falha('metadata.unsafe');
+        falha(`metadata.unsafe: ${rotulo(alvo)} passa por link simbolico`);
     visitar(alvo, 0);
 }
 /** Cobre também refresh do índice e checkout/diff internos da API de estado.
@@ -219,9 +260,9 @@ function perfil(wt, comum, gitdir, id, selecionados, hooksDaOperacao = exports.H
     fisico(path.dirname(comum), comum);
     fisico(comum, gitdir);
     for (const nome of ['objects', 'refs', 'logs', 'info'])
-        arvoreMetadados(comum, path.join(comum, nome));
+        arvoreMetadados(comum, path.join(comum, nome), { armazemDeObjetos: nome === 'objects' });
     for (const nome of ['index', 'logs', 'refs'])
-        arvoreMetadados(gitdir, path.join(gitdir, nome));
+        arvoreMetadados(gitdir, path.join(gitdir, nome), { relativoA: path.dirname(comum) });
     const estado = path.join(path.dirname(comum), '.orkastery');
     for (const nome of ['leases', 'state-backups']) {
         const f = path.join(estado, nome);
@@ -345,6 +386,8 @@ function executar(raiz, p) {
         if (git(wt, ['diff', '--cached', '--name-only', '-z']).length)
             falha('index.not-empty');
         const regioes = [`worktree-write:${t.id}`, ...p.paths.map(f => 'path:' + f)];
+        // RM-037 (fatia 3, defeito 4): lease e fila de thread fechada sao orfaos e saem antes da conferencia.
+        (0, leases_1.podarRegioesDeThreadsFechadas)(raiz, regioes, t.id);
         for (const nome of regioes) {
             if ((0, leases_1.lerLease)(raiz, nome) || (0, leases_1.leasesColidentes)(raiz, nome).length)
                 falha('lease.busy');
@@ -358,7 +401,16 @@ function executar(raiz, p) {
             falha('index.not-empty');
         (0, estado_thread_1.comEstadoParaGit)(raiz, t.id, wt, () => {
             conferir();
-            git(wt, ['add', '--', ...p.paths]);
+            // Fatia 2 do ensaio da 0.5.0 (P8): caminho rastreado entra por `git add -u`, que nao consulta regra de
+            // ignore; o `git add` dele, sob regra local (`fontes/` casando `marketplaces/fontes/`), indexava e saia 1.
+            // Caminho novo segue pelo `git add`, que continua recusando o ignorado, e vai antes: recusado, os
+            // rastreados nem chegam ao indice.
+            const rastreados = new Set(git(wt, ['ls-files', '-z', '--', ...p.paths]).split('\0').filter(Boolean));
+            const antigos = p.paths.filter(f => rastreados.has(f)), novos = p.paths.filter(f => !rastreados.has(f));
+            if (novos.length)
+                git(wt, ['add', '--', ...novos]);
+            if (antigos.length)
+                git(wt, ['add', '-u', '--', ...antigos]);
             const staged = git(wt, ['diff', '--cached', '--name-only', '-z']).split('\0').filter(Boolean).sort();
             if (!staged.length || staged.some(f => !p.paths.includes(f)))
                 falha('index.selection');

package/dist/mcp-grafo-worker.js

@@ -0,0 +1,91 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rodarConsulta = rodarConsulta;
+/**
+ * RM-031 KG5 (D3, D8): o worker da consulta do grafo pelo MCP.
+ *
+ * Roda num processo filho, aberto pelo `mcp-grafo.ts` com o ambiente minimo do MCP. Le `{raiz, argv}`
+ * do stdin, confere que o cwd e a raiz, aceita so as quatro consultas no argv que as tools montam (com
+ * `--json` e `--teto-bytes`), carrega o manifesto da raiz (a worktree da thread) e chama o
+ * `executarGrafo` com o argv que a CLI receberia: a resposta e a do `ork grafo`, byte a byte. O `main` do
+ * `ork` nao roda aqui, entao nada do argv vira `--projeto`, `--version` ou `--help`.
+ *
+ * E a segunda porta da familia do grafo, so pelo CLI dela (a fronteira confere). Saida 0 e resposta,
+ * 1 e recusa tipada da consulta (JSON no stdout), 2 e entrada recusada pelo proprio worker (stderr).
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const zod_1 = require("zod");
+const intelligence_graph_cli_1 = require("./intelligence-graph-cli");
+const manifest_1 = require("./manifest");
+const estado_thread_1 = require("./estado-thread");
+const CONSULTAS = Object.freeze({ vizinhos: 1, chamadores: 1, importadores: 1, caminho: 2 });
+const OPCAO = /^--(profundidade|sentido|tipo|limite|teto-bytes)=[a-z0-9_,]{1,120}$/;
+const PEDIDO = zod_1.z.object({
+    raiz: zod_1.z.string().min(1).max(4096).refine((p) => path.isAbsolute(p), 'raiz absoluta'),
+    argv: zod_1.z.array(zod_1.z.string().min(1).max(2048)).min(4).max(12),
+}).strict();
+/** Confere o pedido e roda a consulta; erro de entrada e lancado, com o prefixo `grafo.mcp.worker`. */
+function rodarConsulta(entrada, cwd, escrever) {
+    const lido = PEDIDO.safeParse(entrada);
+    if (!lido.success)
+        throw Error('grafo.mcp.worker: pedido fora do schema');
+    const { raiz, argv } = lido.data;
+    if (fs.realpathSync(cwd) !== fs.realpathSync(raiz))
+        throw Error('grafo.mcp.worker: o cwd nao e a raiz pedida');
+    const [sub, ...resto] = argv;
+    if (!Object.prototype.hasOwnProperty.call(CONSULTAS, sub))
+        throw Error(`grafo.mcp.worker: so as consultas ${Object.keys(CONSULTAS).join(', ')}`);
+    const posicionais = resto.slice(0, CONSULTAS[sub]), opcoes = resto.slice(CONSULTAS[sub]);
+    if (posicionais.length !== CONSULTAS[sub] || posicionais.some((p) => p.startsWith('--')))
+        throw Error('grafo.mcp.worker: no ausente ou com -- no inicio');
+    if (!opcoes.includes('--json') || !opcoes.some((o) => o.startsWith('--teto-bytes='))
+        || opcoes.some((o) => o !== '--json' && !OPCAO.test(o)))
+        throw Error('grafo.mcp.worker: opcoes fora das que a tool monta');
+    const carregado = (0, manifest_1.exigirManifesto)(raiz);
+    if (fs.realpathSync(carregado.raiz) !== fs.realpathSync(raiz))
+        throw Error('grafo.mcp.worker: o manifesto nao e o da raiz pedida');
+    return (0, intelligence_graph_cli_1.executarGrafo)(argv, { raiz: carregado.raiz, estado: (0, estado_thread_1.raizDoEstado)(carregado.raiz), repositorio: carregado.manifesto.project.name, escrever });
+}
+if (require.main === module) {
+    try {
+        process.exitCode = rodarConsulta(JSON.parse(fs.readFileSync(0, 'utf8')), process.cwd(), (texto) => { process.stdout.write(texto); });
+    }
+    catch (e) {
+        process.stderr.write(`${e.message.split('\n')[0]}\n`);
+        process.exitCode = 2;
+    }
+}

package/dist/mcp-grafo.js

@@ -0,0 +1,233 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LIMITE_MAXIMO_DO_MCP = exports.PROFUNDIDADE_MAXIMA_DO_MCP = exports.TIPOS_DE_ARESTA_DO_MCP = exports.PRAZO_DA_CONSULTA_MS = exports.TETO_MAXIMO = exports.TETO_MINIMO = exports.TETO_PADRAO = exports.TOOLS_DO_GRAFO = void 0;
+exports.grafoLigado = grafoLigado;
+exports.argvDaTool = argvDaTool;
+exports.consultarPeloWorker = consultarPeloWorker;
+exports.registrarConsultasDoGrafo = registrarConsultasDoGrafo;
+/**
+ * RM-031 KG5: a consulta do grafo de codigo pelas fases, pelo MCP do projeto.
+ *
+ * Quatro tools de leitura com o contrato do `ork grafo` (D6): cada uma roda, na worktree da thread, o
+ * argv que a CLI receberia (`<consulta> ... --json --teto-bytes N`) e devolve o que ela escreve, sem
+ * transformar: a resposta e JSON `ork.code-graph-query/v0` com a evidencia de cada aresta e no maximo
+ * `tetoBytes` bytes (D4); a recusa da consulta sai compacta e nao passa pelo teto.
+ *
+ * Desligadas por padrao (D2): so existem com `grafo.mcp: true` no manifesto da raiz, lido no startup, e
+ * cada chamada confere a flag de novo. A consulta roda num worker (D3), um processo filho por chamada,
+ * com o ambiente minimo do MCP, grupo proprio, prazo, cancelamento e teto do stdout: o servidor nao
+ * carrega o grafo nem o compilador. Este modulo nao importa a familia do grafo; o worker importa, so
+ * pelo CLI dela (D8). Erro de transporte (flag, thread, worker) vem como `{erro}`, como nas outras tools;
+ * erro da consulta vem como o JSON da CLI, com `isError`.
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const zod_1 = require("zod");
+const mcp_git_1 = require("./mcp-git");
+exports.TOOLS_DO_GRAFO = ['ork_grafo_vizinhos', 'ork_grafo_chamadores', 'ork_grafo_importadores', 'ork_grafo_caminho'];
+/** D4: o teto das respostas, em bytes do JSON. */
+exports.TETO_PADRAO = 32768;
+exports.TETO_MINIMO = 4096;
+exports.TETO_MAXIMO = 65536;
+/** D3: prazo de uma consulta de ponta a ponta (a CLI leva cerca de 1 s neste repositorio). */
+exports.PRAZO_DA_CONSULTA_MS = 60000;
+/** A resposta cabe no teto; o que passa disso, em bytes, e erro de outra ordem, e o worker morre. */
+const TETO_DO_STDOUT = 1024 * 1024;
+/**
+ * O vocabulario e os limites da consulta do KG3, repetidos aqui porque este modulo nao importa a
+ * familia do grafo (D8); o teste confere que sao os mesmos do contrato v1 e da consulta.
+ */
+exports.TIPOS_DE_ARESTA_DO_MCP = ['contains', 'declares', 'imports', 'calls', 'references', 'derived_from'];
+exports.PROFUNDIDADE_MAXIMA_DO_MCP = 5;
+exports.LIMITE_MAXIMO_DO_MCP = 10_000;
+/** D2: so o booleano `true` do manifesto da raiz liga as tools. */
+function grafoLigado(manifesto) {
+    return manifesto.grafo?.mcp === true;
+}
+const threadId = zod_1.z.string().min(1).max(80).regex(/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/);
+/** D6: o parser do `ork grafo` trata `--` como opcao, entao o no nao comeca assim, como na CLI. */
+const no = (descricao) => zod_1.z.string().min(1).max(2048)
+    .refine((v) => !v.startsWith('--') && !v.includes('\u0000'), { message: 'grafo.uso: o no nao comeca com -- nem tem NUL' })
+    .describe(descricao);
+const DESCRICAO_DO_NO = 'arquivo, caminho#fragmento, tipo:caminho#fragmento ou nome solto';
+const profundidade = zod_1.z.number().int().min(1).max(exports.PROFUNDIDADE_MAXIMA_DO_MCP).optional()
+    .describe('saltos (padrao 1)');
+const limite = zod_1.z.number().int().min(1).max(exports.LIMITE_MAXIMO_DO_MCP).optional()
+    .describe('maximo de arestas, as mais perto primeiro (padrao 500)');
+const sentido = zod_1.z.enum(['entrada', 'saida', 'ambos']).optional().describe('sentido das arestas');
+const tipos = zod_1.z.array(zod_1.z.enum(exports.TIPOS_DE_ARESTA_DO_MCP)).min(1).max(exports.TIPOS_DE_ARESTA_DO_MCP.length).optional()
+    .describe('tipos de aresta (padrao: todos)');
+const tetoBytes = zod_1.z.number().int().min(exports.TETO_MINIMO).max(exports.TETO_MAXIMO).optional()
+    .describe(`teto da resposta em bytes (padrao ${exports.TETO_PADRAO}); acima, saem as arestas mais longe`);
+const COMUM = 'Leitura do grafo do HEAD da worktree da thread (o do ork grafo): so o que o extrator prova. '
+    + 'Resposta JSON ork.code-graph-query/v0 de ate tetoBytes; sem indice do HEAD, recusa com a correcao ork grafo indexar.';
+/** As opcoes da CLI, na ordem dela, com `=`: o valor nunca vira outro argumento. */
+function opcoes(a) {
+    const r = [];
+    if (a.profundidade !== undefined)
+        r.push(`--profundidade=${a.profundidade}`);
+    if (a.sentido !== undefined)
+        r.push(`--sentido=${a.sentido}`);
+    if (a.tipos !== undefined)
+        r.push(`--tipo=${a.tipos.join(',')}`);
+    if (a.limite !== undefined)
+        r.push(`--limite=${a.limite}`);
+    r.push('--json', `--teto-bytes=${a.tetoBytes ?? exports.TETO_PADRAO}`);
+    return r;
+}
+const DEFINICOES = [
+    {
+        nome: 'ork_grafo_vizinhos',
+        descricao: `Vizinhanca de um no: arestas a ate N saltos, cada uma com extrator, metodo e evidencia (arquivo, linhas, bytes). ${COMUM}`,
+        schema: zod_1.z.object({ threadId, alvo: no(DESCRICAO_DO_NO), profundidade, sentido, tipos, limite, tetoBytes }).strict(),
+        argv: (a) => ['vizinhos', a.alvo, ...opcoes(a)],
+    },
+    {
+        nome: 'ork_grafo_chamadores',
+        descricao: `Quem chama o simbolo: arestas calls que chegam, com a evidencia. ${COMUM}`,
+        schema: zod_1.z.object({ threadId, alvo: no('simbolo (caminho#simbolo ou nome solto)'), profundidade, limite, tetoBytes }).strict(),
+        argv: (a) => ['chamadores', a.alvo, ...opcoes(a)],
+    },
+    {
+        nome: 'ork_grafo_importadores',
+        descricao: `Quem importa o arquivo ou o simbolo: arestas imports que chegam, com a evidencia. ${COMUM}`,
+        schema: zod_1.z.object({ threadId, alvo: no('arquivo ou simbolo'), profundidade, limite, tetoBytes }).strict(),
+        argv: (a) => ['importadores', a.alvo, ...opcoes(a)],
+    },
+    {
+        nome: 'ork_grafo_caminho',
+        descricao: `Menor caminho entre dois nos, cada passo com a evidencia; caminho que nao cabe no teto recusa. ${COMUM}`,
+        schema: zod_1.z.object({ threadId, de: no(`origem: ${DESCRICAO_DO_NO}`), para: no('destino, na mesma forma'), sentido, tipos, tetoBytes }).strict(),
+        argv: (a) => ['caminho', a.de, a.para, ...opcoes(a)],
+    },
+];
+/** D9: o argv que a tool monta para os argumentos dados; a medida offline usa o mesmo. */
+function argvDaTool(nome, args) {
+    const d = DEFINICOES.find((x) => x.nome === nome);
+    if (!d)
+        throw Error(`grafo.mcp.tool-desconhecida: ${nome}`);
+    return d.argv(args);
+}
+/**
+ * D3: roda a consulta num processo filho, em grupo proprio, com o ambiente minimo do MCP. Prazo,
+ * cancelamento e stdout acima do teto matam o grupo; a promessa sempre resolve.
+ */
+function consultarPeloWorker(raiz, argv, opcoesDoWorker = {}) {
+    return new Promise((resolve) => {
+        if (opcoesDoWorker.signal?.aborted) {
+            resolve({ codigo: null, saida: '', erro: '', interrompido: 'cancelada', pid: null });
+            return;
+        }
+        const grupo = process.platform !== 'win32';
+        const filho = (0, node_child_process_1.spawn)(process.execPath, [path.join(__dirname, 'mcp-grafo-worker.js')], {
+            cwd: raiz, env: (0, mcp_git_1.ambienteGitMcp)(), stdio: ['pipe', 'pipe', 'pipe'], detached: grupo,
+        });
+        let saida = '', erro = '', bytes = 0, terminado = false;
+        const concluir = (r) => {
+            if (terminado)
+                return;
+            terminado = true;
+            clearTimeout(prazo);
+            opcoesDoWorker.signal?.removeEventListener('abort', cancelar);
+            resolve(r);
+        };
+        const interromper = (motivo) => {
+            if (terminado)
+                return;
+            filho.stdout?.destroy();
+            filho.stderr?.destroy();
+            try {
+                if (filho.pid)
+                    process.kill(grupo ? -filho.pid : filho.pid, 'SIGKILL');
+            }
+            catch { /* ja terminou */ }
+            concluir({ codigo: null, saida: '', erro, interrompido: motivo, pid: filho.pid ?? null });
+        };
+        const cancelar = () => interromper('cancelada');
+        const prazoMs = opcoesDoWorker.prazoMs ?? exports.PRAZO_DA_CONSULTA_MS;
+        const prazo = setTimeout(() => interromper(`prazo de ${prazoMs} ms`), prazoMs);
+        opcoesDoWorker.signal?.addEventListener('abort', cancelar, { once: true });
+        filho.stdout.setEncoding('utf8');
+        filho.stdout.on('data', (parte) => {
+            saida += parte;
+            bytes += Buffer.byteLength(parte);
+            if (bytes > TETO_DO_STDOUT)
+                interromper('saida acima do teto do worker');
+        });
+        filho.stderr.setEncoding('utf8');
+        filho.stderr.on('data', (parte) => { if (erro.length < 4096)
+            erro += parte; });
+        filho.stdin.on('error', () => undefined);
+        filho.on('error', (e) => concluir({ codigo: null, saida: '', erro: e.message, interrompido: null, pid: filho.pid ?? null }));
+        filho.on('close', (codigo, sinal) => concluir({ codigo: sinal ? null : codigo, saida, erro, interrompido: null, pid: filho.pid ?? null }));
+        filho.stdin.end(JSON.stringify({ raiz, argv }));
+        try {
+            if (filho.pid)
+                opcoesDoWorker.aoIniciar?.(filho.pid);
+        }
+        catch { /* gancho de quem testa: nao muda o resultado da consulta */ }
+    });
+}
+const texto = (t, isError = false) => ({ content: [{ type: 'text', text: t }], ...(isError ? { isError: true } : {}) });
+/**
+ * As quatro tools, chamadas pelo servidor so com a flag ligada no startup. `carregar` e `thread` sao os
+ * do servidor: o projeto fixado e a thread conferida (escopo da sessao filha e worktree confinada).
+ */
+function registrarConsultasDoGrafo(registrar, contexto) {
+    // CHECK rodada 2 (N4): o confinamento compara caminhos reais, tambem quando quem registra passa outra forma da raiz.
+    const raiz = fs.realpathSync(contexto.raiz);
+    for (const d of DEFINICOES) {
+        registrar(d.nome, { description: d.descricao, inputSchema: d.schema, annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false } }, async (args, extra) => {
+            if (!grafoLigado(contexto.carregar().manifesto)) {
+                throw Error('grafo.mcp.desligado: a consulta do grafo pelo MCP esta desligada no manifesto (grafo.mcp); ligar e decisao do dono e vale para as sessoes abertas depois');
+            }
+            const t = contexto.thread(args.threadId);
+            // CHECK rodada 1 (S6): o caminho real que o worker recebe fica dentro do projeto, conferido aqui de novo.
+            const cwd = fs.realpathSync(t.worktree ?? raiz);
+            if (cwd !== raiz && !cwd.startsWith(raiz + path.sep))
+                throw Error('mcp.scope.violation: worktree fora do projeto');
+            const r = await consultarPeloWorker(cwd, d.argv(args), { signal: extra.signal, prazoMs: contexto.prazoMs });
+            if (r.interrompido)
+                throw Error(`grafo.mcp.indisponivel: consulta interrompida (${r.interrompido})`);
+            if (r.codigo === 0 && Buffer.byteLength(r.saida) <= (args.tetoBytes ?? exports.TETO_PADRAO))
+                return texto(r.saida);
+            if (r.codigo === 1 && r.saida.startsWith('{'))
+                return texto(r.saida, true);
+            throw Error(`grafo.mcp.indisponivel: o worker saiu com ${r.codigo ?? 'sinal'}${r.erro ? `: ${r.erro.split('\n')[0].slice(0, 300)}` : ''}`);
+        });
+    }
+}

package/dist/mcp-install.js

@@ -47,7 +47,9 @@ const node_util_1 = require("node:util");
 const smol_toml_1 = require("smol-toml");
 const manifest_1 = require("./manifest");
 exports.TOOLS_DONO_CODEX = ['ork_thread_new', 'ork_phase_run', 'ork_request_decision'];
-exports.TOOLS_FILHO_CODEX = ['ork_artifact_write', 'ork_claim_add', 'ork_git_commit', 'ork_verify', 'ork_ship'];
+// RM-037 (rm037defeito, defeito 1): a decisao autonoma da sessao entra com as outras mutacoes do filho;
+// sem o grant, o codex com approval_policy never recusaria a chamada.
+exports.TOOLS_FILHO_CODEX = ['ork_artifact_write', 'ork_claim_add', 'ork_decision_record', 'ork_git_commit', 'ork_verify', 'ork_ship'];
 // Brain mutation tools are deliberately excluded from the existing opt-in bundle.
 // A native integration must request exact startup grants plus scoped activation.
 var company_brain_mcp_1 = require("./company-brain-mcp");
@@ -198,8 +200,9 @@ function migrarEnvVarsCodex(bruto, entrada) {
     return bruto.slice(0, corpoFim) + (corpo.endsWith('\n') ? '' : '\n') + `env_vars = ${valor}\n` + bruto.slice(corpoFim);
 }
 function instalarMcp(opcoes) {
+    // Ensaio da 0.5.0: os READMEs dos plugins mandavam `--project .`, recusado sem dizer como acertar.
     if (!path.isAbsolute(opcoes.projeto))
-        throw Error('mcp.install.project.invalid: raiz absoluta obrigatoria');
+        throw Error('mcp.install.project.invalid: raiz absoluta obrigatoria; na raiz do projeto, use --project "$PWD"');
     if (!['claude-code', 'codex'].includes(opcoes.host))
         throw Error('mcp.install.host.invalid');
     if (opcoes.transporteShip !== undefined && !['github-ssh', 'bare-local'].includes(opcoes.transporteShip))