@orkastery/cli 0.2.0 → 0.3.0

package/dist/mcp-server.js

@@ -0,0 +1,469 @@
+"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.criarServidorMcp = criarServidorMcp;
+exports.servirMcp = servirMcp;
+/** Transporte MCP de projeto. O cliente nativo e a configuracao de startup sao confiaveis;
+ * argumentos de ferramentas nunca escolhem raiz, shell ou resposta humana. */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const zod_to_json_schema_1 = require("zod-to-json-schema");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const zod_1 = require("zod");
+const util_1 = require("./util");
+const runtime_ambiente_1 = require("./runtime-ambiente");
+const manifest_1 = require("./manifest");
+const horario_1 = require("./horario");
+const thread_1 = require("./thread");
+const ledger_1 = require("./ledger");
+const phase_1 = require("./phase");
+const leases_1 = require("./leases");
+const hitl_gates_1 = require("./hitl-gates");
+const hitl_contract_1 = require("./hitl-contract");
+const hitl_presentation_1 = require("./hitl-presentation");
+const hitl_sessions_1 = require("./hitl-sessions");
+const hitl_local_1 = require("./hitl-local");
+const mcp_artifacts_1 = require("./mcp-artifacts");
+const mcp_git_1 = require("./mcp-git");
+const preflight_1 = require("./preflight");
+const modos_1 = require("./modos");
+const versao_1 = require("./versao");
+const mcp_verify_1 = require("./mcp-verify");
+const conducao_1 = require("./conducao");
+const conducao_texto_1 = require("./conducao-texto");
+const mcp_ship_1 = require("./mcp-ship");
+const company_brain_mcp_1 = require("./company-brain-mcp");
+const claude_bg_1 = require("./adapters/claude-bg");
+const session_watcher_claude_1 = require("./session-watcher-claude");
+const runtime_profiles_1 = require("./runtime-profiles");
+const mcp_maestro_1 = require("./mcp-maestro");
+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();
+/**
+ * O modo de conducao no canal MCP: quem decide e o NUCLEO, o host so transporta.
+ *
+ * Com `z.enum(ORDEM_DOS_MODOS)` o canal devolvia a MESMA frase para um modo aposentado e
+ * para um typo ("Invalid enum value. Expected 'classic' | ... received 'look'"): em
+ * ingles, sem motivo tipado e sem dizer por qual modo trocar. O GOAL da I-43 pediu
+ * recusa tipada em QUALQUER canal, e quem sabe separar `modo.aposentado` de
+ * `modo.desconhecido` e `exigirModoVivo`, no nucleo. O `describe` mantem os modos vivos
+ * visiveis na descoberta da ferramenta, derivados da mesma lista.
+ */
+const modoDeConducao = zod_1.z.string().trim().min(1).max(40)
+    .describe(`modo de conducao vivo: ${modos_1.ORDEM_DOS_MODOS.join(', ')}`)
+    .superRefine((bruto, ctx) => {
+    try {
+        (0, modos_1.exigirModoVivo)(bruto);
+    }
+    catch (e) {
+        ctx.addIssue({ code: zod_1.z.ZodIssueCode.custom, message: e.message });
+    }
+})
+    .transform((bruto) => (0, modos_1.exigirModoVivo)(bruto));
+const nova = zod_1.z.object({ nome: zod_1.z.string().trim().min(1).max(200),
+    modo: modoDeConducao.optional() }).strict();
+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();
+// 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) }] });
+/** Factory publica para compor transporte nativo ou testes; nao executa ferramentas no startup. */
+function criarServidorMcp(opcoes) {
+    if (!path.isAbsolute(opcoes.projeto))
+        throw Error('mcp.project.invalid: raiz absoluta obrigatoria');
+    if (!['claude-code', 'codex'].includes(opcoes.host))
+        throw Error('mcp.host.invalid');
+    if (opcoes.permissoesFilho !== undefined && !['interactive', 'worktree'].includes(opcoes.permissoesFilho))
+        throw Error('mcp.child-permissions.invalid');
+    if (opcoes.threadId !== undefined)
+        identidade.parse(opcoes.threadId);
+    if (opcoes.dispatchId !== undefined && (opcoes.threadId === undefined || !/^[a-f0-9-]{36}$/.test(opcoes.dispatchId)))
+        throw Error('mcp.dispatch.invalid: identidade de despacho exige thread vinculada');
+    // I-36 (D6): o canal do MCP e o host ja validado da conexao; a identidade so reentra (D4).
+    const conducao = { canal: opcoes.host, identidade: opcoes.dispatchId ?? null };
+    const raiz = fs.realpathSync(opcoes.projeto);
+    if (fs.realpathSync((0, manifest_1.exigirManifesto)(raiz).raiz) !== raiz)
+        throw Error('mcp.project.invalid: informe a raiz do manifesto');
+    // I-35: o dono é o do projeto servido, não o do cwd de quem iniciou o servidor.
+    (0, horario_1.registrarFonteDoFuso)(() => (0, horario_1.fusoDoManifesto)((0, manifest_1.carregarManifesto)(raiz)));
+    const fixacao = fs.statSync(raiz);
+    let perfilShip, erroShip = 'mcp.ship.unavailable: perfil de transporte indisponivel';
+    try {
+        perfilShip = (0, mcp_ship_1.criarPerfilShipMcp)(raiz, opcoes.transporteShip ?? 'github-ssh');
+    }
+    catch (e) {
+        const m = e.message;
+        if (m.startsWith('mcp.'))
+            erroShip = m;
+    }
+    const carregar = () => {
+        const atual = fs.statSync(raiz);
+        if (atual.dev !== fixacao.dev || atual.ino !== fixacao.ino || fs.realpathSync(raiz) !== raiz)
+            throw Error('mcp.project.changed');
+        const estado = path.join(raiz, '.orkastery');
+        if (fs.existsSync(estado)) {
+            const real = fs.realpathSync(estado);
+            if (!real.startsWith(raiz + path.sep))
+                throw Error('mcp.scope.violation: estado fora do projeto');
+        }
+        const c = (0, manifest_1.exigirManifesto)(raiz);
+        if (fs.realpathSync(c.raiz) !== raiz)
+            throw Error('mcp.project.changed');
+        return c;
+    };
+    const confinado = (file) => {
+        const real = fs.realpathSync(file);
+        if (real !== raiz && !real.startsWith(raiz + path.sep))
+            throw Error('mcp.scope.violation');
+        return real;
+    };
+    const thread = (id) => {
+        if (opcoes.threadId !== undefined && id !== opcoes.threadId)
+            throw Error('mcp.thread.scope: sessao vinculada a outra thread');
+        identidade.parse(id);
+        carregar();
+        confinado((0, thread_1.dirThread)(raiz, id));
+        (0, mcp_artifacts_1.validarArquivosEstadoMcp)(raiz, id);
+        const t = (0, thread_1.lerThread)(raiz, id);
+        if (t.id !== id)
+            throw Error('mcp.thread.identity');
+        if (t.worktree)
+            confinado(t.worktree);
+        return t;
+    };
+    if (opcoes.threadId)
+        thread(opcoes.threadId);
+    const pendencias = (id) => {
+        const t = thread(id), eventos = (0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, id)), contexto = (0, hitl_gates_1.contextoHitl)(raiz, id);
+        const pedidos = [(0, hitl_presentation_1.pedidoHitlAberto)(raiz, id, t.faseAtual, null),
+            ...t.sessoes.filter(s => s.fase === t.faseAtual).map(s => (0, hitl_presentation_1.pedidoHitlAberto)(raiz, id, t.faseAtual, s.sessionId))];
+        // FX6: a oferta acompanha o pedido REAL. A conexao viva e ESTA: o host desta sessao MCP,
+        // e so ele. Nenhum outro canal mcp-local sai `disponivel` daqui por suposicao.
+        return pedidos.filter(p => p && eventos.some(e => e.tipo === 'hitl_requested' && e.contexto === contexto &&
+            e.pedido?.id === p.id)).map(p => ({ pedido: p, estado: (0, hitl_contract_1.estadoDoPedido)(p),
+            canais: (0, hitl_presentation_1.ofertaDoPedido)(p, [opcoes.host]), prazoLocal: (0, hitl_presentation_1.prazoLocalDoPedido)(p) }));
+    };
+    const fases = (id) => {
+        thread(id);
+        const eventos = (0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, id)).filter(e => ['phase_dispatch', 'phase_dispatch_verified', 'phase_result',
+            'phase_dispatch_failed', 'session_watcher_started', 'gate_blocked'].includes(e.tipo));
+        return { limite: 20, omitidos: Math.max(0, eventos.length - 20), eventos: eventos.slice(-20).map(e => ({
+                tipo: e.tipo, ts: e.ts, fase: e.fase, sessionId: e.sessionId, runtime: e.runtime, model: e.model, effort: e.effort,
+                classificacao: e.classificacao, motivo: e.motivo, encontrada: e.encontrada, controlador: e.controlador
+            })) };
+    };
+    const observar = (id) => {
+        const t = thread(id), eventos = (0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, id));
+        // I-34 (D8): a conclusão vem do phase_result do watcher ou, sem ele, da mesma tabela D2
+        // aplicada a esta leitura única (sem cursor, só classificações imediatas). Nada é gravado.
+        const turnoClaude = (s, nativo, perfil, erroClaude) => {
+            const despachoEm = s.despachadaEm;
+            if (typeof despachoEm !== 'string' || !Number.isFinite(Date.parse(despachoEm)))
+                return { estado: 'nao-confirmado', conclusaoDeFase: 'nao-inferida' };
+            const sessao = { sessionId: s.sessionId, fase: s.fase, despachadaEm: despachoEm };
+            const stop = (0, session_watcher_claude_1.stopCorrelacionado)(eventos.filter(e => e.thread === id), sessao);
+            const turno = { estado: stop ? 'encerrado' : 'nao-confirmado',
+                ...(stop ? { evidencia: { tipo: stop.tipo, ts: stop.ts, sessionId: stop.sessionId, fase: stop.fase,
+                        runtime: stop.runtime, despachoEm: stop.despachoEm, sensorEventId: stop.sensorEventId } } : {}) };
+            const nome = (c, m) => c === 'fase_concluida' ? 'fase_concluida' : `gate_blocked:${String(m)}`;
+            const registrada = eventos.filter(e => e.tipo === 'phase_result' && e.runtime === 'claude-bg' && e.sessionId === s.sessionId &&
+                e.despachoEm === despachoEm && e.origem === 'sessions.watch').at(-1);
+            if (registrada)
+                return { ...turno, conclusaoDeFase: nome(registrada.classificacao, registrada.motivo), registrada: true,
+                    conclusao: { sensorResultId: registrada.sensorResultId, ts: registrada.ts, estadoNativo: registrada.estadoNativo, fonte: registrada.fonte } };
+            const cursor = { schema: 'ork.session-cursor-claude/v1', sessionId: s.sessionId, despachoEm };
+            // D12: mesma prova do lado do `ork` que o watcher exige, só lida quando o turno terminou.
+            const fonte = (0, session_watcher_claude_1.fonteRegistrada)(eventos, sessao);
+            const prova = () => (0, session_watcher_claude_1.provaDoOrk)(raiz, id, sessao, eventos, { artefato: fonte?.artefato, cwd: fonte?.cwd ?? path.resolve(t.worktree ?? raiz), head: fonte?.head });
+            // I-33 (D11b): a leitura declara o mesmo motivo mais especifico que o watcher gravaria.
+            const { c } = (0, session_watcher_claude_1.comFalhaDeConta)((0, session_watcher_claude_1.classificarSessaoClaude)({ sessao, eventos, consulta: { ok: erroClaude === '', registros: [], detalhe: erroClaude, consultadoEm: '' },
+                registro: nativo, cursor, agoraMs: Date.now(), limiteMs: Infinity, pausaAoFim: (0, thread_1.pausaNaThread)(t, s.fase),
+                prova, processo: session_watcher_claude_1.processoNativo }), () => (0, session_watcher_claude_1.falhaDeContaDaTranscricao)(perfil, fonte?.cwd ?? path.resolve(t.worktree ?? raiz), s.sessionId));
+            // D15 (6) e D17: sem Stop correlacionado e sem resultado registrado, a sessão encerrada pelo
+            // condutor não ganha na leitura um gate que o ledger não tem, mas a leitura declara o que o
+            // watcher grava para o mesmo estado. Com Stop, `stopped` segue a mesma regra do watcher.
+            if (nativo?.state === 'stopped' && !stop && c.terminal)
+                return { ...turno, conclusaoDeFase: 'encerrada-pelo-condutor', registrada: false,
+                    classificacaoDoWatcher: nome(c.classificacao, c.motivo),
+                    conclusao: { fonte: 'sessão encerrada pelo condutor (stopped) sem phase_result registrado', estadoNativo: 'stopped', regraDoWatcher: c.fonte } };
+            return c.terminal ? { ...turno, conclusaoDeFase: nome(c.classificacao, c.motivo), registrada: false,
+                conclusao: { fonte: c.fonte, estadoNativo: nativo?.state } } : { ...turno, conclusaoDeFase: 'nao-inferida' };
+        };
+        // I-33 (D4): uma consulta por conta. Cada sessao claude-bg e observada com o env do perfil
+        // gravado no seu registro; perfil invalido nao cai para o env do processo.
+        const porConta = new Map();
+        const consultarConta = (perfil) => {
+            const chave = perfil ? `${perfil.id}|${perfil.configDir}` : '(processo)';
+            const pronta = porConta.get(chave);
+            if (pronta)
+                return pronta;
+            let claude = null, erroClaude = '';
+            const r = (0, util_1.exec)('claude', ['agents', '--json', '--all', '--cwd', raiz], raiz, 10000, perfil ? (0, claude_bg_1.ambienteDoPerfil)(perfil) : (0, runtime_ambiente_1.ambienteDeAssinatura)());
+            try {
+                if (!r.ok || Buffer.byteLength(r.stdout) > 1024 * 1024)
+                    throw Error('consulta Claude falhou ou excedeu limite');
+                const schema = zod_1.z.array(zod_1.z.object({ sessionId: zod_1.z.string().uuid(), cwd: zod_1.z.string().refine(path.isAbsolute),
+                    state: zod_1.z.string().optional(), status: zod_1.z.string().optional(), waitingFor: zod_1.z.string().max(1000).nullable().optional() }).passthrough()).max(10000);
+                const registros = schema.parse(JSON.parse(r.stdout));
+                if (new Set(registros.map(s => s.sessionId)).size !== registros.length)
+                    throw Error('sessao Claude duplicada');
+                const estadoComparavel = (v) => ['working', 'running', 'busy'].includes(v) ? 'working' : v;
+                claude = registros.map(s => ({ sessionId: s.sessionId, cwd: s.cwd, estado: s.state ?? s.status ?? '', state: s.state, status: s.status,
+                    divergenciaEstado: s.state !== undefined && s.status !== undefined && estadoComparavel(s.state) !== estadoComparavel(s.status), ...(s.waitingFor ? { waitingFor: s.waitingFor } : {}),
+                    ...(Number.isSafeInteger(s.pid) && s.pid > 0 ? { pid: s.pid } : {}) }));
+            }
+            catch {
+                erroClaude = 'observacao nativa indisponivel: consulta Claude escopada falhou ou retornou formato invalido';
+            }
+            const resultado = { claude, erroClaude };
+            porConta.set(chave, resultado);
+            return resultado;
+        };
+        const nativas = t.sessoes.map(s => {
+            if (s.runtime === 'claude-bg') {
+                let perfil;
+                try {
+                    perfil = (0, runtime_profiles_1.perfilDoRegistro)(eventos, { sessionId: s.sessionId, despachadaEm: s.despachadaEm });
+                }
+                catch {
+                    return { sessionId: s.sessionId, runtime: s.runtime, disponivel: false,
+                        detalhe: 'observacao nativa indisponivel: perfil registrado da sessao invalido' };
+                }
+                const { claude, erroClaude } = consultarConta(perfil);
+                const sessao = claude?.find(x => x.sessionId === s.sessionId && x.cwd === path.resolve(t.worktree ?? raiz));
+                const nativo = sessao ? { sessionId: sessao.sessionId, cwd: sessao.cwd, state: sessao.state, status: sessao.status, pid: sessao.pid } : null;
+                return { sessionId: s.sessionId, runtime: s.runtime, disponivel: !!sessao, turno: turnoClaude(s, nativo, perfil, erroClaude),
+                    ...(perfil ? { perfil: perfil.id } : {}),
+                    ...(sessao ? { sessao } : { detalhe: erroClaude || 'observacao nativa indisponivel: UUID/cwd da fase nao encontrado na consulta escopada' }) };
+            }
+            if (s.runtime !== 'codex')
+                return { sessionId: s.sessionId, runtime: s.runtime, disponivel: false,
+                    detalhe: 'observacao nativa indisponivel: runtime nao suportado' };
+            try {
+                const consulta = (0, hitl_sessions_1.controleNativo)(s.runtime, raiz, id, s.sessionId).consultar();
+                const sessao = consulta.sessoes.find(x => x.sessionId === s.sessionId && x.cwd === path.resolve(t.worktree ?? raiz));
+                return { sessionId: s.sessionId, runtime: s.runtime, disponivel: consulta.ok && !!sessao,
+                    ...(sessao ? { sessao } : { detalhe: 'observacao nativa indisponivel: sessao nao confirmada pelo controller vinculado' }) };
+            }
+            catch (e) {
+                return { sessionId: s.sessionId, runtime: s.runtime, disponivel: false, detalhe: e.message };
+            }
+        });
+        return { thread: t, phases: fases(id), pendencias: pendencias(id), nativas };
+    };
+    const livre = (id) => {
+        const nomes = ['main-tree', ...(id ? ['worktree-write:' + id] : [])];
+        for (const nome of nomes) {
+            const conflitos = (0, leases_1.leasesColidentes)(raiz, nome, id);
+            if (conflitos.length)
+                throw Error('lease.busy: ' + conflitos.map(l => l.nome + ' (' + l.thread + ')').join(', '));
+        }
+    };
+    const server = new index_js_1.Server({ name: 'orkastery', version: versao_1.VERSAO_DO_ORK }, { capabilities: { tools: {} }, instructions: 'Opere somente este projeto pelas ferramentas do nucleo. Decisoes humanas usam ork_request_decision e o dialogo do host; argumentos de ferramenta nunca sao respostas.' });
+    const ferramentas = new Map();
+    function registrarTool(nome, config, executar) {
+        if (opcoes.threadId && ['ork_thread_new', 'ork_phase_run', 'ork_request_decision', 'ork_preflight'].includes(nome))
+            return;
+        const schema = converterSchema(config.inputSchema, { $refStrategy: 'none' });
+        ferramentas.set(nome, { tool: { name: nome, description: config.description, annotations: config.annotations,
+                inputSchema: schema },
+            executar: async (raw, extra) => executar(config.inputSchema.parse(raw), extra) });
+    }
+    server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => ({ tools: [...ferramentas.values()].map(f => f.tool) }));
+    server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request, extra) => {
+        try {
+            const f = ferramentas.get(request.params.name);
+            if (!f)
+                throw Error('mcp.tool.unknown');
+            return await f.executar(request.params.arguments ?? {}, extra);
+        }
+        catch (e) {
+            return { ...resposta({ erro: e.message }), isError: true };
+        }
+    });
+    const ingresso = (0, hitl_local_1.criarIngressoLocal)(raiz, { host: opcoes.host, connectionId: (0, node_crypto_1.randomUUID)() }, async (pedido, signal) => {
+        carregar();
+        thread(pedido.thread);
+        // D12: pergunta nativa que aceita texto NAO vira menu. Um menu sobre pergunta aberta
+        // muda a pergunta, e a resposta que chega a sessao deixa de ser a do humano.
+        // I-41: a recusa de quem nao tem dialogo mora no contrato, e por isso ela vem primeiro.
+        // Depois dela sempre ha resposta aceita; ler `maxCaracteres` de um default inventaria um
+        // limite para um formulario que nunca chega a ser montado.
+        const apresentacao = (0, hitl_presentation_1.apresentarDecisao)(pedido);
+        const aceita = (0, hitl_contract_1.respostaAceitaDoPedido)(pedido);
+        const livre = aceita.tipo === 'texto';
+        const limite = Math.min(4096, Math.max(1, aceita.maxCaracteres));
+        const r = await server.elicitInput({ mode: 'form',
+            message: apresentacao.mensagem,
+            requestedSchema: { type: 'object', properties: { opcao: livre
+                        ? { type: 'string', title: 'Sua resposta', maxLength: limite }
+                        : { type: 'string', title: 'Sua decisão', oneOf: apresentacao.escolhas } },
+                required: ['opcao'] } }, { signal, timeout: 300000 });
+        if (r.action !== 'accept')
+            return { action: r.action };
+        const parsed = zod_1.z.object({ opcao: zod_1.z.string().min(1).max(limite) }).strict().parse(r.content);
+        return { action: 'accept', content: parsed };
+    });
+    server.onclose = () => ingresso.fechar();
+    (0, company_brain_mcp_1.registerBrainTools)(registrarTool, carregar, thread, opcoes.brainWrites ?? []);
+    (0, mcp_maestro_1.registerMaestro)(registrarTool, { root: raiz, threadId: opcoes.threadId, load: carregar, checkThread: thread, tools: () => [...ferramentas.keys()] });
+    registrarTool('ork_preflight', { description: 'Preflight contextual por modo e bloco, sem inventário global/modelos. Não autoriza despacho nem comprova entrega.',
+        inputSchema: zod_1.z.object({ modo: modoDeConducao }).strict(), annotations: { readOnlyHint: true } }, async ({ modo }) => {
+        carregar();
+        return resposta((0, preflight_1.preflight)(raiz, modo, opcoes.nomesProviderHerdados));
+    });
+    registrarTool('ork_git_status', { description: 'Consulta HEADs locais atuais da worktree e branch de destino fixadas. Nao consulta a rede nem reserva os HEADs; commit e SHIP revalidam seus valores.',
+        inputSchema: daThread, annotations: { readOnlyHint: true } }, async ({ threadId }) => {
+        thread(threadId);
+        return resposta((0, mcp_git_1.estadoGitMcp)(raiz, threadId));
+    });
+    registrarTool('ork_ship', { description: 'Entrega pela API oficial: verifica em sandbox, mergeia e prova push no unico origin fixado no startup. Exige HEADs fonte/destino e respeita gates; interrupcao exige reconciliacao.',
+        inputSchema: daThread.extend({ expectedSource: zod_1.z.string().regex(/^[a-f0-9]{40}$/), expectedDestination: zod_1.z.string().regex(/^[a-f0-9]{40}$/) }).strict(),
+        annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: true } }, async (args, extra) => {
+        thread(args.threadId);
+        livre(args.threadId);
+        if (!perfilShip)
+            throw Error(erroShip);
+        const r = await (0, mcp_ship_1.shipMcp)(perfilShip, args, extra.signal);
+        return { ...resposta(r), ...(r.ok ? {} : { isError: true }) };
+    });
+    registrarTool('ork_verify', { description: 'Reexecuta claims e verificadores do manifesto na worktree, em sandbox e com prazo total de tres minutos. Registra resultado real; falhas bloqueiam a verificacao.',
+        inputSchema: daThread, annotations: { readOnlyHint: false, destructiveHint: false } }, async ({ threadId }) => {
+        thread(threadId);
+        livre(threadId);
+        try {
+            const r = (0, mcp_verify_1.verificarMcp)(raiz, threadId, conducao);
+            return { ...resposta(r), ...(r.ok ? {} : { isError: true }) };
+        }
+        catch (e) {
+            // I-36 (T18): a mesma recusa tipada do CLI, com o mesmo texto, sem reescrever nada no host.
+            if (e instanceof conducao_1.ErroDeConducao)
+                return { ...resposta(e.recusa), isError: true };
+            throw e;
+        }
+    });
+    registrarTool('ork_git_commit', { description: 'Commita somente paths com claims e HEAD esperado na worktree da thread. Recusa hooks/filtros ativos; preserva configuracao. Commit local nao e SHIP.',
+        inputSchema: daThread.extend({ expectedHead: zod_1.z.string().regex(/^[a-f0-9]{40}$/),
+            paths: zod_1.z.array(zod_1.z.string().min(1).max(512)).min(1).max(32), mensagem: zod_1.z.string().trim().min(1).max(2048) }).strict(),
+        annotations: { readOnlyHint: false, destructiveHint: false } }, async (args, extra) => {
+        thread(args.threadId);
+        livre(args.threadId);
+        const r = await (0, mcp_git_1.commitMcp)(raiz, args, extra.signal);
+        return { ...resposta(r), ...(r.ok ? {} : { isError: true }) };
+    });
+    const documento = daThread.extend({ tipo: zod_1.z.enum(['goal', 'plan', 'check']) }).strict();
+    registrarTool('ork_artifact_read', { description: 'Le documento GOAL, PLAN ou CHECK da thread, com hash para revisao; nao le caminhos arbitrarios.',
+        inputSchema: documento, annotations: { readOnlyHint: true } }, async ({ threadId, tipo }) => {
+        thread(threadId);
+        return resposta((0, mcp_artifacts_1.lerArtefatoMcp)(raiz, threadId, tipo));
+    });
+    registrarTool('ork_artifact_write', { description: 'Grava documento do agente no bloco atual com hash esperado (null para criar). Nao registra recibo oficial nem aprova gate.',
+        inputSchema: documento.extend({ conteudo: zod_1.z.string().max(131072), expectedSha256: zod_1.z.string().regex(/^[a-f0-9]{64}$/).nullable() }).strict(),
+        annotations: { readOnlyHint: false, destructiveHint: false } }, async ({ threadId, tipo, conteudo, expectedSha256 }) => {
+        thread(threadId);
+        livre(threadId);
+        return resposta((0, mcp_artifacts_1.escreverArtefatoMcp)(raiz, threadId, tipo, conteudo, expectedSha256));
+    });
+    registrarTool('ork_claims_list', { description: 'Lista alegacoes e seu estado de verificacao registrado pelo nucleo.',
+        inputSchema: daThread, annotations: { readOnlyHint: true } }, async ({ threadId }) => {
+        thread(threadId);
+        return resposta((0, mcp_artifacts_1.listarClaimsMcp)(raiz, threadId));
+    });
+    registrarTool('ork_claim_add', { description: 'Registra alegacao prospectiva e comandos como dados. Nao executa comandos nem declara a alegacao verificada.',
+        inputSchema: daThread.extend({ arquivo: zod_1.z.string().min(1).max(500), alegacao: zod_1.z.string().min(1).max(8192),
+            verificar: zod_1.z.array(zod_1.z.string().min(1).max(8192)).max(20) }).strict(), annotations: { readOnlyHint: false, destructiveHint: false } }, async ({ threadId, ...entrada }) => { thread(threadId); livre(threadId); return resposta((0, mcp_artifacts_1.adicionarClaimMcp)(raiz, threadId, entrada)); });
+    registrarTool('ork_thread_status', { description: 'Estado canonico de uma thread deste projeto; pausas previstas nao sao pedidos abertos.',
+        inputSchema: daThread, annotations: { readOnlyHint: true } }, async ({ threadId }) => {
+        const t = thread(threadId);
+        const c = (0, conducao_1.conducaoDaThread)(raiz, threadId);
+        return resposta({ thread: t, conducao: c, linhaDeConducao: c ? (0, conducao_texto_1.linhaDeConducao)(c) : null, resumo: (0, thread_1.resumoDaThread)(t, c) });
+    });
+    registrarTool('ork_phase_list', { description: 'Despachos e resultados registrados da thread, sem despachar ou consultar outros projetos.',
+        inputSchema: daThread, annotations: { readOnlyHint: true } }, async ({ threadId }) => {
+        thread(threadId);
+        return resposta({ threadId, phases: fases(threadId) });
+    });
+    registrarTool('ork_hitl_pending', { description: 'Pedidos HITL atuais da thread, incluindo prazo; nao aprova nem abre pedido.',
+        inputSchema: daThread, annotations: { readOnlyHint: true } }, async ({ threadId }) => resposta({ threadId, pendencias: pendencias(threadId) }));
+    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));
+    });
+    registrarTool('ork_thread_new', { description: 'Cria uma thread para a demanda autorizada, com worktree isolada; modo validado pelo nucleo. Nao inicia modelo.',
+        inputSchema: nova, annotations: { readOnlyHint: false, destructiveHint: false } }, async ({ nome, modo }) => {
+        const c = carregar();
+        livre();
+        const destino = path.resolve(raiz, c.manifesto.worktree.dir);
+        if (!destino.startsWith(raiz + path.sep))
+            throw Error('mcp.scope.violation: worktree.dir fora do projeto');
+        // Validar ancestrais existentes antes de o nucleo criar o diretorio.
+        let existente = destino;
+        while (!fs.existsSync(existente))
+            existente = path.dirname(existente);
+        confinado(existente);
+        return resposta((0, thread_1.novaThread)(c, { nome, modo: modo ?? c.manifesto.conduction.default_mode, criarWorktree: true }));
+    });
+    registrarTool('ork_phase_run', { description: 'Despacha fase autorizada pelo nucleo, preservando policies, estado e runtime/modelo. dryRun nao inicia modelo, mas pode registrar prompt/eventos.',
+        inputSchema: fase, annotations: { readOnlyHint: false, destructiveHint: false } }, async (args) => {
+        const t = thread(args.threadId);
+        livre(t.id);
+        const { threadId, fase: f, ...op } = args;
+        return resposta((0, phase_1.rodarFase)(carregar(), threadId, { ...op, fase: (0, thread_1.exigirFase)(t, f), canal: conducao.canal }));
+    });
+    registrarTool('ork_gate_request', { description: 'Abre pedido de gate somente quando pausa ou escalacao tipada esta comprovada no nucleo; nao aprova.',
+        inputSchema: daThread.extend({ motivo: zod_1.z.enum(['human.pending', 'policy.violation', 'cost.violation',
+                'retry.max_tentativas', 'hitl.credencial', 'runtime.unavailable']).optional() }).strict(),
+        annotations: { readOnlyHint: false, destructiveHint: false } }, async ({ threadId, motivo }) => {
+        thread(threadId);
+        livre(threadId);
+        return resposta((0, hitl_gates_1.abrirPedidoGate)(raiz, threadId, motivo));
+    });
+    registrarTool('ork_request_decision', { description: 'Apresenta pedido existente ao dono por dialogo nativo. Somente IDs; nunca forneca resposta nos argumentos.',
+        inputSchema: daDecisao, annotations: { readOnlyHint: false, destructiveHint: false } }, async ({ threadId, pedidoId }, extra) => {
+        thread(threadId);
+        return resposta(await ingresso.solicitar(threadId, pedidoId, extra.signal));
+    });
+    return server;
+}
+async function servirMcp(opcoes) {
+    const server = criarServidorMcp(opcoes);
+    await server.connect(new stdio_js_1.StdioServerTransport());
+}