@orkastery/cli 0.5.0 → 0.5.3

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. */
@@ -155,25 +170,64 @@ 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');
-        const st = fs.lstatSync(f);
-        if (st.isSymbolicLink() || (!st.isDirectory() && (!st.isFile() || st.nlink !== 1)))
-            falha('metadata.unsafe');
+        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, { throwIfNoEntry: false });
+        if (!st)
+            return; // Uma retomada pode remover a fila ou o candidato depois da enumeracao.
+        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');
-        if (st.isDirectory())
-            for (const n of fs.readdirSync(f))
+            falha(`metadata.unsafe: ${rotulo(f)} fora de ${path.basename(root)}`);
+        if (st.isDirectory()) {
+            let entradas;
+            try {
+                entradas = fs.readdirSync(f, { encoding: 'buffer' });
+            }
+            catch (e) {
+                if (e.code === 'ENOENT')
+                    return;
+                throw e;
+            }
+            for (const bytes of entradas) {
+                const n = bytes.toString('utf8');
+                // Perda de bytes nao e ENOENT transitorio: o nome decodificado pode nem apontar para esta entrada.
+                if (!Buffer.from(n, 'utf8').equals(bytes))
+                    falha(`metadata.unsafe: nome fora de UTF-8 em ${rotulo(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.
@@ -223,9 +277,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);
@@ -349,6 +403,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');
@@ -362,7 +418,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,93 @@
+"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 cinco 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 mcp_grafo_1 = require("./mcp-grafo");
+const CONSULTAS = Object.freeze({ vizinhos: 1, chamadores: 1, importadores: 1, caminho: 2, contexto: 1 });
+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,
+        contextoDaThread: (id) => (0, mcp_grafo_1.lerEntradaDaThread)(carregado.raiz, id), 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,279 @@
+"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.lerEntradaDaThread = lerEntradaDaThread;
+exports.argvDaTool = argvDaTool;
+exports.consultarPeloWorker = consultarPeloWorker;
+exports.registrarConsultasDoGrafo = registrarConsultasDoGrafo;
+/**
+ * RM-031 KG5: a consulta do grafo de codigo pelas fases, pelo MCP do projeto.
+ *
+ * Cinco 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); contexto usa ork.thread-graph-context/v2. A recusa 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");
+const mcp_artifacts_1 = require("./mcp-artifacts");
+const thread_1 = require("./thread");
+const estado_thread_1 = require("./estado-thread");
+exports.TOOLS_DO_GRAFO = ['ork_grafo_vizinhos', 'ork_grafo_chamadores', 'ork_grafo_importadores', 'ork_grafo_caminho', 'ork_grafo_contexto'];
+/** 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)],
+    },
+    {
+        nome: 'ork_grafo_contexto',
+        descricao: 'Pacote deterministico da thread: diff da worktree contra base (ignorado sem worktree), GOAL, PLAN e claims; fan-in agregado e evidencias compactas. '
+            + 'JSON ork.thread-graph-context/v2 limitado em bytes, refs locais, prioridade entre arquivos e por proximidade ao diff. Sem indice do HEAD, recusa com ork grafo indexar.',
+        schema: zod_1.z.object({ threadId, tetoBytes }).strict(),
+        argv: (a) => ['contexto', a.threadId, ...opcoes(a)],
+    },
+];
+/** Leitura compartilhada por CLI e worker, fora da familia do grafo. Nunca escreve estado. */
+function lerEntradaDaThread(raiz, id) {
+    if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,79}$/.test(id))
+        throw Error('grafo.contexto.thread-invalida: id invalido');
+    const projeto = fs.realpathSync((0, estado_thread_1.raizDoEstado)(raiz));
+    (0, mcp_artifacts_1.validarArquivosEstadoMcp)(projeto, id);
+    const t = (0, thread_1.lerThread)(projeto, id);
+    const cwd = fs.realpathSync(t.worktree ?? projeto);
+    if (cwd !== projeto && !cwd.startsWith(projeto + path.sep))
+        throw Error('grafo.contexto.escopo: worktree fora do projeto');
+    if (fs.realpathSync((0, estado_thread_1.raizDoEstado)(cwd)) !== projeto)
+        throw Error('grafo.contexto.escopo: worktree de outro repositorio');
+    // Em uma WT, consultar outra thread daria um pacote de outra arvore silenciosamente.
+    const origem = fs.realpathSync(raiz);
+    if (origem !== projeto && origem !== cwd)
+        throw Error('grafo.contexto.escopo: thread de outra worktree');
+    if (!/^(?:[a-f0-9]{40}|[a-f0-9]{64})$/.test(t.base.commit))
+        throw Error('grafo.contexto.base-invalida: thread sem commit base');
+    const git = (args) => {
+        const r = (0, node_child_process_1.spawnSync)('git', ['-c', 'core.fsmonitor=false', ...args], {
+            cwd, env: { ...(0, mcp_git_1.ambienteGitMcp)(), GIT_OPTIONAL_LOCKS: '0' }, encoding: 'utf8', timeout: 10000, maxBuffer: 8 * 1024 * 1024,
+        });
+        if (r.error || r.status !== 0)
+            throw Error('grafo.contexto.git-falhou: nao foi possivel ler HEAD/base/diff da thread');
+        return r.stdout;
+    };
+    const head = git(['rev-parse', '--verify', 'HEAD']).trim();
+    const diff = !t.worktree || cwd === projeto ? [] : git(['diff', '--no-ext-diff', '--no-textconv', '--no-renames', '--name-only', '-z', t.base.commit, '--']).split('\0').filter(Boolean);
+    const goal = (0, mcp_artifacts_1.lerArtefatoMcp)(projeto, id, 'goal').conteudo;
+    const plan = (0, mcp_artifacts_1.lerArtefatoMcp)(projeto, id, 'plan').conteudo;
+    const claims = (0, mcp_artifacts_1.listarClaimsMcp)(projeto, id).filter((c) => c.estado !== 'retirada').map(({ id, arquivo }) => ({ id, arquivo }));
+    if (head !== git(['rev-parse', '--verify', 'HEAD']).trim())
+        throw Error('grafo.contexto.revisao-mudou: HEAD mudou durante a leitura; repita');
+    return { raiz: cwd, head, entrada: { thread: id, base: t.base.commit, diff, diffEstado: !t.worktree || cwd === projeto ? 'ignorado-sem-worktree' : 'coletado-na-worktree', goal, plan, claims } };
+}
+/** 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 cinco 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

@@ -200,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))

package/dist/mcp-server.js

@@ -58,6 +58,7 @@ const hitl_contract_1 = require("./hitl-contract");
 const hitl_presentation_1 = require("./hitl-presentation");
 const roadmap_status_1 = require("./roadmap-status");
 const network_roadmap_1 = require("./network-roadmap");
+const rede_status_1 = require("./rede-status");
 const hitl_sessions_1 = require("./hitl-sessions");
 const hitl_local_1 = require("./hitl-local");
 const mcp_artifacts_1 = require("./mcp-artifacts");
@@ -77,6 +78,7 @@ const runtime_profiles_1 = require("./runtime-profiles");
 const mcp_maestro_1 = require("./mcp-maestro");
 const projeto_alvo_1 = require("./projeto-alvo");
 const mcp_experiencia_1 = require("./mcp-experiencia");
+const mcp_grafo_1 = require("./mcp-grafo");
 const identidade = zod_1.z.string().min(1).max(80).regex(/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/);
 const daThread = zod_1.z.object({ threadId: identidade }).strict();
 const daDecisao = daThread.extend({ pedidoId: identidade }).strict();
@@ -106,7 +108,9 @@ const nova = zod_1.z.object({ nome: zod_1.z.string().trim().min(1).max(200),
 const fase = daThread.extend({ fase: zod_1.z.enum(['GOAL', 'PLAN', 'GO', 'CHECK', 'SHIP', 'MASTER']),
     prompt: zod_1.z.string().min(1).max(65536), runtime: zod_1.z.enum(['claude-bg', 'codex']).optional(),
     model: zod_1.z.string().trim().min(1).max(200).optional(),
-    effort: zod_1.z.enum(['low', 'medium', 'high', 'xhigh', 'max']).optional(), dryRun: zod_1.z.boolean().optional() }).strict();
+    effort: zod_1.z.enum(['low', 'medium', 'high', 'xhigh', 'max']).optional(),
+    // RM-056 (D1): o perfil pedido, validado contra o store pelo mesmo caminho do CLI.
+    perfil: zod_1.z.string().trim().regex(/^[a-z0-9][a-z0-9._-]{0,62}$/i).optional(), dryRun: zod_1.z.boolean().optional() }).strict();
 // Limite de tipos do conversor externo: validacao continua no schema Zod strict.
 const converterSchema = zod_to_json_schema_1.zodToJsonSchema;
 const resposta = (valor) => ({ content: [{ type: 'text', text: JSON.stringify(valor) }] });
@@ -296,6 +300,10 @@ function criarServidorMcp(opcoes) {
     };
     const livre = (id) => {
         const nomes = ['main-tree', ...(id ? ['worktree-write:' + id] : [])];
+        // RM-037 (fatia 3, GO-FIX 2, achado 1 do CHECK): esta e a primeira conferencia de toda tool de escrita.
+        // Lease e fila de thread fechada sao orfaos e saem aqui, com registro no ledger dela; sem isso o
+        // main-tree de um SHIP que caiu antes do fechamento travava verify, commit, ship e artefato pelo MCP.
+        (0, leases_1.podarRegioesDeThreadsFechadas)(raiz, nomes, id ?? '');
         for (const nome of nomes) {
             const conflitos = (0, leases_1.leasesColidentes)(raiz, nome, id);
             if (conflitos.length)
@@ -497,6 +505,16 @@ function criarServidorMcp(opcoes) {
         const panorama = (0, network_roadmap_1.montarPanoramaDaRede)({ fixado: raiz });
         return resposta({ texto: (0, network_roadmap_1.textoDoPanoramaDaRede)(panorama), panorama });
     });
+    /**
+     * RM-054 (fatia 3): as maquinas da pessoa (RM-053, `ork.rede-status/v1`), com a fonte, a batida e as
+     * lacunas. O retrato de cada maquina fica so com o projeto servido (D5 da RM-052).
+     */
+    registrarTool('ork_network_status', { description: 'Status da Orkastery Network, somente leitura: as maquinas da pessoa (casa privada na forja), com a batida de cada uma, a forja e o login, os runtimes e hosts com versao e o projeto servido em cada uma, mais a fonte e as lacunas. Transporte o texto como vem. Lacuna e "Nao consultado" sao o que nao foi lido: nunca conclua "nenhuma maquina" nem "rede vazia" a partir deles. Nao le roadmap nem threads: para isso, ork_network_roadmap.',
+        inputSchema: zod_1.z.object({}).strict(), annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: true } }, async () => {
+        carregar();
+        const status = (0, network_roadmap_1.redeDoProjetoFixado)(raiz);
+        return resposta({ texto: (0, rede_status_1.textoDaRede)(status), status: JSON.parse((0, rede_status_1.jsonDaRede)(status)) });
+    });
     registrarTool('ork_observe', { description: 'Observa uma vez o progresso canonico e pedidos da thread. Nao cria monitor ou despacho.',
         inputSchema: daThread, annotations: { readOnlyHint: true } }, async ({ threadId }) => {
         return resposta(observar(threadId));
@@ -540,6 +558,10 @@ function criarServidorMcp(opcoes) {
         thread(threadId);
         return resposta(await ingresso.solicitar(threadId, pedidoId, extra.signal));
     });
+    // RM-031 KG5 (D2): as tools do grafo so existem com a flag do manifesto da raiz no startup; sem ela, nada muda.
+    // CHECK rodada 1 (S8): o startup le so o manifesto, como antes; as conferencias de estado ficam na chamada.
+    if ((0, mcp_grafo_1.grafoLigado)((0, manifest_1.exigirManifesto)(raiz).manifesto))
+        (0, mcp_grafo_1.registrarConsultasDoGrafo)(registrarTool, { raiz, carregar, thread });
     return server;
 }
 async function servirMcp(opcoes) {

package/dist/mcp-ship.js

@@ -324,6 +324,8 @@ function executar(f, p) {
     if (comandos.length > 512 || comandos.reduce((n, s) => n + Buffer.byteLength(s), 0) > LIMITE)
         erro('verify.limit');
     const nome = `worktree-write:${t.id}`, nomes = [nome, `path:.orkastery/threads/${t.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, [...nomes, 'main-tree'], t.id);
     for (const n of [...nomes, 'main-tree'])
         if (fs.lstatSync((0, leases_1.caminhoLease)(raiz, n), { throwIfNoEntry: false }) || (0, leases_1.leasesColidentes)(raiz, n).length)
             erro('lease.busy');

package/dist/mcp-verify.js

@@ -97,7 +97,9 @@ function verificarMcp(raizEntrada, threadId, conducao = {}) {
     const stFila = fs.lstatSync((0, leases_1.caminhoFila)(raiz), { throwIfNoEntry: false });
     if (stFila && (!stFila.isFile() || stFila.nlink !== 1))
         throw Error('mcp.verify.queue.unsafe');
-    // Não herda nem remove lease existente, inclusive própria, expirada ou corrompida.
+    // RM-037 (fatia 3, defeito 4): lease e fila de thread fechada são órfãos e saem antes da conferência.
+    (0, leases_1.podarRegioesDeThreadsFechadas)(raiz, [...nomes, 'main-tree'], threadId);
+    // Não herda nem remove lease existente de thread aberta, inclusive própria, expirada ou corrompida.
     if (nomes.some(nome => fs.lstatSync((0, leases_1.caminhoLease)(raiz, nome), { throwIfNoEntry: false }) ||
         (0, leases_1.leasesColidentes)(raiz, nome).length) || (0, leases_1.leasesColidentes)(raiz, 'main-tree').length) {
         throw Error('lease.busy: verificação exige leases próprias livres');