@orkastery/cli 0.5.0 → 0.5.1

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,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.
@@ -223,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);
@@ -349,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');
@@ -362,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

@@ -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

@@ -77,6 +77,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();
@@ -296,6 +297,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)
@@ -540,6 +545,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');

package/dist/network-roadmap.js

@@ -70,6 +70,7 @@ const path = __importStar(require("node:path"));
 const branch_de_estado_1 = require("./branch-de-estado");
 const docs_1 = require("./docs");
 const fabrica_estado_1 = require("./fabrica-estado");
+Object.defineProperty(exports, "LIMIAR_SEM_BATIDA_MS", { enumerable: true, get: function () { return fabrica_estado_1.LIMIAR_SEM_BATIDA_MS; } });
 const forja_1 = require("./forja");
 const horario_1 = require("./horario");
 const estado_thread_1 = require("./estado-thread");
@@ -85,8 +86,6 @@ const yaml_1 = require("./yaml");
 exports.CONTRATO_PANORAMA_DA_REDE = 'ork.network-roadmap/v1';
 /** O registro de projetos da RM-052, lido como ela o grava. */
 exports.CONTRATO_REGISTRO_DE_PROJETOS = 'ork.projetos/v1';
-/** Maquina sem retrato novo ha mais disto esta sem batida: o mesmo limiar da rede (RM-053, `SEM_BATIDA_MS`). */
-exports.LIMIAR_SEM_BATIDA_MS = 3 * 60 * 60 * 1000;
 /** A recusa de projeto sai com o mesmo codigo da RM-052. */
 exports.SAIDA_DO_PEDIDO = 4;
 /** A recusa do `--projeto`, com os mesmos codigos da RM-052: o nucleo nunca chuta. */
@@ -423,7 +422,7 @@ function maquinasDoPanorama(retratos, local, ctx, lacunas) {
         if (local && m.maquina === local.maquina)
             continue;
         const idadeMs = Math.max(0, agora - Date.parse(m.publicadoEm));
-        const semBatida = idadeMs > exports.LIMIAR_SEM_BATIDA_MS;
+        const semBatida = idadeMs > fabrica_estado_1.LIMIAR_SEM_BATIDA_MS;
         if (semBatida) {
             lacunas.push(lacuna('maquina.sem-batida', 'fabrica', m.maquina, `${m.maquina} sem retrato novo há ${(0, horario_1.duracaoCurta)(Math.floor(idadeMs / 60000))} (último em ${(0, horario_1.formatarDataHora)(m.publicadoEm, { fuso: ctx.fuso })}): ` +
                 'as threads dela podem ter andado', `confira a ${m.maquina}: ela publica ao criar thread, despachar fase, entregar e a cada batida do pulse`));
@@ -834,7 +833,7 @@ function montarPanoramaDaRede(opcoes = {}) {
     }
     const projetos = alvos.map((p) => lerProjeto(p, ctx));
     return { contrato: exports.CONTRATO_PANORAMA_DA_REDE, consultadoEm: quando, maquina: ctx.maquina, pedido: opcoes.pedido ?? null,
-        limiarSemBatidaMin: exports.LIMIAR_SEM_BATIDA_MS / 60000, fuso: projetos[0]?.projeto.fuso ?? ctx.fuso, projetos, naoConsultado, lacunas };
+        limiarSemBatidaMin: fabrica_estado_1.LIMIAR_SEM_BATIDA_MS / 60000, fuso: projetos[0]?.projeto.fuso ?? ctx.fuso, projetos, naoConsultado, lacunas };
 }
 // ---------------------------------------------------------------------------
 // O texto.
@@ -893,7 +892,8 @@ function textoDoPanoramaDaRede(p) {
         // Cada projeto no fuso do dono dele (achado 5 da rodada 2): a legenda do bloco diz quando difere.
         const fuso = x.projeto.fuso;
         linhas.push('', '────────', '');
-        linhas.push(x.roadmap ? (0, roadmap_status_1.textoDoStatusDoRoadmap)(x.roadmap, fuso)
+        // Fatia 2 do ensaio (P7): o fuso ja sai no fim do panorama (e no bloco, quando difere): sem a legenda do status.
+        linhas.push(x.roadmap ? (0, roadmap_status_1.textoDoStatusDoRoadmap)(x.roadmap, fuso, { legenda: false })
             : `Roadmap do ${x.projeto.nome}: não lido (${x.lacunas.map((l) => l.tipo).filter((t) => t !== 'projeto.sem-clone').join(', ') || 'sem fonte'}).`);
         linhas.push('', 'Threads por máquina', ...linhasDasMaquinas(x, fuso));
         linhas.push('', 'Reservas', ...linhasDasReservas(x, fuso));

package/dist/ocupacao.js

@@ -91,9 +91,11 @@ function ultimaAtividadeEm(eventos) {
  * despacho e a sessao roda ate o fim do bloco. O impedimento de verify tambem nao: a sessao corrige e
  * verifica de novo. Somente leitura.
  */
-function sessaoLivreDaVaga(eventos, desde, agora, staleMin, 
+function sessaoLivreDaVaga(doLedger, desde, agora, staleMin, 
 /** A-3 do CHECK 4: o bloqueio no runtime e por sessao; o de outra sessao (a sucedida) nao libera esta. */
 sessionId) {
+    // Fatia 2 do ensaio da 0.5.0 (P2): evento de `--dry-run` nao e atividade nem parada.
+    const eventos = doLedger.filter((e) => !(0, ledger_1.ehEnsaio)(e));
     const ultima = ultimaAtividadeEm(eventos);
     if (ultima !== null && minutos(ultima, agora) >= staleMin)
         return 'stale';
@@ -196,7 +198,9 @@ function minutos(desdeEm, ateEm) {
  *      anterior terminada ou o runtime nao consultado), e entra por FIFO quando
  *      houver vaga -- e ai conta contra o limite, como sempre contou.
  */
-function avaliarOcupacao(thread, eventos, opcoes) {
+function avaliarOcupacao(thread, doLedger, opcoes) {
+    // Fatia 2 do ensaio da 0.5.0 (P2): o ensaio do ship (`dryRun: true`) nao pausa a thread no board.
+    const eventos = doLedger.filter((e) => !(0, ledger_1.ehEnsaio)(e));
     const sessionId = ultimaSessao(thread, eventos);
     const sessaoEstado = opcoes.estados === null || sessionId === null
         ? null

package/dist/onboarding.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ETAPAS_ONBOARDING = exports.PAUTA_ONBOARDING = exports.CONTRATO_ONBOARDING = void 0;
+exports.ETAPAS_ONBOARDING = exports.PAUTA_ONBOARDING = exports.ONDE_FICAM_OS_SEGREDOS = exports.CONTRATO_ONBOARDING = void 0;
 exports.caminhoOnboarding = caminhoOnboarding;
 exports.validarConteudo = validarConteudo;
 exports.jsonCanonico = jsonCanonico;
@@ -54,10 +54,15 @@ const horario_1 = require("./horario");
 const experiencia_1 = require("./experiencia");
 const yaml_1 = require("./yaml");
 exports.CONTRATO_ONBOARDING = 'ork.onboarding/v1';
+/**
+ * Fatia 2 do ensaio da 0.5.0 (P5): onde ficam os segredos, para quem usa o Hermes e para quem nao
+ * usa. Perguntas, erro e ajuda leem daqui; as docs e os hosts repetem a frase, conferida por teste.
+ */
+exports.ONDE_FICAM_OS_SEGREDOS = 'no ambiente do processo ou no cofre do host (no Hermes, ~/.hermes/.env)';
 exports.PAUTA_ONBOARDING = [
     { etapa: 'maestro', pergunta: `Quem conduz o projeto, quais são seus objetivos e preferências, e em qual fuso horário o Orkastery deve mostrar horários? Informe o fuso como nome IANA, ex.: {"fuso":"${horario_1.FUSO_DE_BRASILIA}"}; ele orienta ${horario_1.CHAVE_DO_FUSO} no manifesto, sem editá-lo. Preferências em {"owner":{...}} gravam owner no manifesto.` },
-    { etapa: 'credenciais', pergunta: 'Quais provedores públicos e nomes de variáveis em env serão usados? Segredos somente em ~/.hermes/.env; nunca informe valores.' },
-    { etapa: 'bancos', pergunta: 'Quais bancos públicos e nomes de variáveis em env configuram as conexões? Nunca informe DSN ou senha; valores somente em ~/.hermes/.env.' },
+    { etapa: 'credenciais', pergunta: `Quais provedores públicos e nomes de variáveis em env serão usados? Segredos ficam ${exports.ONDE_FICAM_OS_SEGREDOS}; nunca informe valores.` },
+    { etapa: 'bancos', pergunta: `Quais bancos públicos e nomes de variáveis em env configuram as conexões? Nunca informe DSN ou senha; valores ficam ${exports.ONDE_FICAM_OS_SEGREDOS}.` },
     { etapa: 'memoria', pergunta: 'Deseja OrkMind? Informe {"modo":"orkmind"} ou {"modo":"files"}; a escolha orienta memory.mode no manifesto, sem editá-lo.' },
     { etapa: 'produtos', pergunta: 'Quais produtos e repositórios públicos pertencem ao projeto?' },
     { etapa: 'topologia', pergunta: 'Como se distribuem ambientes e serviços? Informe identificadores públicos.' },
@@ -74,7 +79,7 @@ function objeto(v) {
         [Object.prototype, null].includes(Object.getPrototypeOf(v));
 }
 /** Recusa antes de persistir. Diagnósticos nunca incluem a entrada recebida. */
-function invalido() { throw new Error('onboarding.input.invalid: use JSON público e referências de variáveis; segredos somente em ~/.hermes/.env'); }
+function invalido() { throw new Error(`onboarding.input.invalid: use JSON público e referências de variáveis; segredos ficam ${exports.ONDE_FICAM_OS_SEGREDOS}`); }
 function textoSeguro(v) {
     return !(0, policies_1.procurarSegredos)(v).length &&
         !/[a-z][a-z0-9+.-]*:\/\/[^\s/]*@/i.test(v) &&

package/dist/orquestracao.js

@@ -388,7 +388,8 @@ function montarMonitor(carregado, opcoes = {}) {
     const linhas = [];
     for (const item of itens) {
         const { thread } = item;
-        const eventos = (0, ledger_1.lerLedger)((0, thread_1.dirThread)(item.raiz, thread.id));
+        // Fatia 2 do ensaio da 0.5.0 (P2): o evento de `--dry-run` nao abre parada no monitor nem no pulse.
+        const eventos = (0, ledger_1.lerLedger)((0, thread_1.dirThread)(item.raiz, thread.id)).filter((e) => !(0, ledger_1.ehEnsaio)(e));
         const pausas = pausasAbertas(thread, eventos, estados, quando);
         const impedimentos = impedimentosAbertos(item, eventos, item.raiz, quando);
         // O limite de paralelismo da maquina tambem trava, e o escalonador ja o calculou.