@orkastery/cli 0.6.1 → 0.6.3

package/dist/locale-verify.js

@@ -82,6 +82,14 @@ exports.VERIFY_PT_BR = {
     semVeredito: (nomes) => `Sem veredito por tempo (nao e reprovacao: prazo estourado ou relogio sob steal): ${nomes}`,
     // Classificacao e veredito
     classificacao: (regressoes, preExistentes, semBaseline) => `Classificacao: ${regressoes} regressao(oes), ${preExistentes} pre-existente(s), ${semBaseline} falha(s) sem baseline`,
+    comparacaoPorTeste: (comando, regressoes, preExistentes, corrigidos) => `Comparacao teste a teste (${comando}): ${regressoes} regressao(oes), ${preExistentes} pre-existente(s), ` +
+        `${corrigidos} corrigido(s)`,
+    testeRegressao: (nome) => `    regressao      ${nome}`,
+    testePreExistente: (nome) => `    pre-existente  ${nome}`,
+    testeCorrigido: (nome) => `    corrigido      ${nome}`,
+    comparacaoPorComando: (comando, classificacao, motivo) => `Comparacao somente por comando (${comando}): ${classificacao}; ${motivo === 'baseline-sem-nomes'
+        ? 'a baseline nao guardou nomes de testes' : 'a rodada atual nao informou nomes de testes'}. ` +
+        'Nenhuma contagem de regressoes por teste foi calculada.',
     regressao: (nome, comando) => `  regressao      ${nome}: ${comando}`,
     preExistente: (nome, comando) => `  pre-existente  ${nome}: ${comando}`,
     falhaSemBaseline: (nome, comando) => `  sem baseline   ${nome}: ${comando}`,
@@ -171,6 +179,13 @@ exports.VERIFY_EN = {
     falhou: (code) => `FAILED (exit ${code})`,
     semVeredito: (nomes) => `No verdict for lack of time (not a failure: deadline exceeded or clock under steal): ${nomes}`,
     classificacao: (regressoes, preExistentes, semBaseline) => `Classification: ${regressoes} regression(s), ${preExistentes} pre-existing, ${semBaseline} failure(s) without a baseline`,
+    comparacaoPorTeste: (comando, regressoes, preExistentes, corrigidos) => `Test-by-test comparison (${comando}): ${regressoes} regression(s), ${preExistentes} pre-existing, ${corrigidos} fixed`,
+    testeRegressao: (nome) => `    regression     ${nome}`,
+    testePreExistente: (nome) => `    pre-existing   ${nome}`,
+    testeCorrigido: (nome) => `    fixed          ${nome}`,
+    comparacaoPorComando: (comando, classificacao, motivo) => `Command-only comparison (${comando}): ${classificacao === 'regressao' ? 'regression' : classificacao === 'pre-existente'
+        ? 'pre-existing' : 'fixed'}; ${motivo === 'baseline-sem-nomes' ? 'the baseline did not store test names'
+        : 'the current run did not report test names'}. No per-test regression count was calculated.`,
     regressao: (nome, comando) => `  regression     ${nome}: ${comando}`,
     preExistente: (nome, comando) => `  pre-existing   ${nome}: ${comando}`,
     falhaSemBaseline: (nome, comando) => `  no baseline    ${nome}: ${comando}`,

package/dist/locale.js

@@ -108,22 +108,25 @@ const locale_operacao_restante_1 = require("./locale-operacao-restante");
 const locale_conducao_1 = require("./locale-conducao");
 const locale_grafo_1 = require("./locale-grafo");
 const locale_audit_1 = require("./locale-audit");
+const locale_preflight_1 = require("./locale-preflight");
+const locale_maestro_1 = require("./locale-maestro");
 exports.LOCALE_PADRAO = 'pt-BR';
 /**
  * Comandos cujo texto ja sai pelo catalogo, por `comando` ou por `comando subcomando`; `comando ?` e o
  * subcomando desconhecido (o erro de uso e do proprio comando). Os demais seguem em pt-BR. Ficam de
- * fora por decisao (D2 da F2a): `doctor --modo`, `thread new --from-finding`, `onboarding sync` e
- * `experiencia uninstall`. A F2b (G3) acrescenta `verify` (com `--baseline`),
+ * fora por decisao (D2 da F2a): `thread new --from-finding`. A F3e acrescenta `doctor --modo`,
+ * `onboarding sync` e `experiencia uninstall`. A F2b (G3) acrescenta `verify` (com `--baseline`),
  * `ship`, `ship registrar-pr`, `retry plan`, `retry run`, `master` (o indice), `master aceitar-omissao` e
  * `master pedir`, `pulse` (sem `responder` nem `cadencia`) e `roadmap status`. A F3a (D5) acrescenta `docs init`, e a
  * F3b (D1), o resto da lista do dono; a F3c completa `decisao registrar` e `network roadmap`. O conhecimento escrito
  * (RM-026 K7, fatia 2) nasce coberto: `conhecimento listar|mostrar|colecoes|verificar` e o uso errado dele.
  */
 exports.COMANDOS_COM_LOCALE = ['doctor', 'init', 'onboarding show', 'onboarding set', 'onboarding reset',
-    'onboarding ?', 'experiencia show', 'experiencia ?', 'thread new', 'thread status', 'thread ?',
+    'onboarding sync', 'onboarding ?', 'experiencia show', 'experiencia uninstall', 'experiencia ?', 'thread new', 'thread status', 'thread ?',
     'phase list', 'phase run', 'phase ?', 'verify', 'ship', 'ship registrar-pr', 'retry plan', 'retry run',
     'retry policy', 'retry parse', 'retry list', 'retry resume', 'retry cancel', 'retry ?',
-    'master', 'master <thread>', 'master aceitar-omissao', 'master pedir', 'master classes', 'master batch',
+    'master', 'master <thread>', 'master aceitar-omissao', 'master pedir', 'master audit', 'master digest', 'master migrar',
+    'master classes', 'master ratificar', 'master batch', 'master propor',
     'pulse', 'roadmap status', 'docs init',
     // F3b (D1): o resto do CLI, na ordem do pedido.
     'thread list', 'thread close', 'thread entrega', 'worktree ensure', 'worktree sync', 'worktree audit', 'worktree release', 'worktree ?',
@@ -151,7 +154,7 @@ exports.COMANDOS_COM_LOCALE = ['doctor', 'init', 'onboarding show', 'onboarding
     'orquestracao status', 'orquestracao ?', 'monitor', 'licoes', 'demo',
     'fabrica list', 'fabrica publicar', 'fabrica entrar', 'fabrica sair', 'fabrica batida', 'fabrica ?', 'eval',
     'memory status', 'memory inventory', 'memory migrate', 'memory sync', 'memory search', 'memory index', 'memory ?',
-    'mcp install', 'conducao status', 'conducao assumir', 'conducao atualizar', 'conducao autorizar',
+    'mcp install', 'mcp serve', 'mcp ?', 'brain', 'activation', 'conducao status', 'conducao assumir', 'conducao atualizar', 'conducao autorizar',
     'conducao autorizacao', 'conducao batida', 'conducao sentinela', 'conducao ?', 'grafo',
     'audit packs', 'audit pack', 'audit lint', 'audit run', 'audit list', 'audit show', 'audit prompt',
     'audit ingest', 'audit finding', 'audit achado', 'audit verify', 'audit report', 'audit relatorio',
@@ -226,8 +229,6 @@ function chaveDoMaster(bruto, opcoes) {
 function cobreLocale(posicionais, opcoes) {
     if (opcoes.json !== undefined)
         return false;
-    if (posicionais[0] === 'doctor' && opcoes.modo !== undefined)
-        return false;
     return exports.COMANDOS_COM_LOCALE.includes(chaveDoLocale(posicionais, opcoes));
 }
 /** `en_US.UTF-8`, `en-GB`, `en` viram `en`; `pt_BR.UTF-8`, `pt` viram pt-BR; o resto, undefined. */
@@ -293,7 +294,14 @@ const PT_BR = {
         subcomandoDesconhecido: (comando, sub) => `subcomando desconhecido: ${comando} ${sub}`,
         /** `exigirManifesto` fora de um projeto: o primeiro erro de quem chega (D14). */
         manifestoNaoEncontrado: (nome, dir) => `manifesto ${nome} nao encontrado a partir de ${dir}. Rode: ork init`,
+        receiptVerifiersUso: 'uso: ork receipt-verifiers --json',
+        activationUso: 'uso: ork activation plan|status|enable|disable',
+        masterDigestUso: 'uso: ork master digest <enviar|preview|responder>',
+        masterRatificarUso: 'resposta deve ser ratificar <thread> <assinatura> <classe>',
+        masterSelecaoUso: 'seleção deve ser thread:assinatura',
     },
+    preflight: locale_preflight_1.PREFLIGHT_PT_BR,
+    maestro: locale_maestro_1.MAESTRO_PT_BR,
     horario: {
         brasilia: 'horário de Brasília',
         legendaBrasilia: 'Horários de Brasília.',
@@ -307,6 +315,7 @@ const PT_BR = {
     },
     doctor: {
         titulo: 'ork doctor: o que vale nesta maquina agora',
+        modoUso: (modos) => `uso: ork doctor --modo ${modos}`,
         correcao: 'correcao',
         bloqueado: (falhas, avisos) => `Veredito: BLOQUEADO (${falhas} fail, ${avisos} warn). Corrija os itens acima antes de despachar fase.`,
         pronto: (avisos) => `Veredito: PRONTO (${avisos} warn). Despacho de fase liberado por \`ork phase run\`.`,
@@ -731,7 +740,14 @@ const EN = {
         erro: (mensagem) => `error: ${mensagem}`,
         subcomandoDesconhecido: (comando, sub) => sub === undefined ? `missing subcommand: ${comando}` : `unknown subcommand: ${comando} ${sub}`,
         manifestoNaoEncontrado: (nome, dir) => `\`${nome}\` not found in ${dir} or any parent directory; run \`ork init\` first.`,
+        receiptVerifiersUso: 'usage: ork receipt-verifiers --json',
+        activationUso: 'usage: ork activation plan|status|enable|disable',
+        masterDigestUso: 'usage: ork master digest <enviar|preview|responder>',
+        masterRatificarUso: 'the response must be ratificar <thread> <signature> <class>',
+        masterSelecaoUso: 'the selection must be thread:signature',
     },
+    preflight: locale_preflight_1.PREFLIGHT_EN,
+    maestro: locale_maestro_1.MAESTRO_EN,
     horario: {
         brasilia: 'Brasília time',
         legendaBrasilia: 'Times in Brasília time.',
@@ -744,6 +760,7 @@ const EN = {
     },
     doctor: {
         titulo: 'ork doctor: what holds on this machine now',
+        modoUso: (modes) => `usage: ork doctor --modo ${modes}`,
         correcao: 'fix',
         bloqueado: (falhas, avisos) => `Verdict: BLOCKED (${falhas} fail, ${avisos} warn). Fix the items above before dispatching a phase.`,
         pronto: (avisos) => `Verdict: READY (${avisos} warn). Phase dispatch allowed through \`ork phase run\`.`,

package/dist/maestro-cli.js

@@ -10,6 +10,7 @@ const maestro_sources_1 = require("./maestro-sources");
 const maestro_actions_1 = require("./maestro-actions");
 const maestro_runtime_1 = require("./maestro-runtime");
 const horario_1 = require("./horario");
+const locale_maestro_1 = require("./locale-maestro");
 function readMaestro(context, options) {
     const observations = options.native && options.threadId ? (0, maestro_runtime_1.nativeForThread)(context.root, options.threadId) : [];
     return (0, maestro_snapshot_1.maestroSnapshot)(context, { ...options, collect: ctx => {
@@ -31,31 +32,25 @@ function readMaestro(context, options) {
             return sources;
         } });
 }
-/** RM-052: de onde veio o projeto do panorama, na lingua do dono. */
-const ORIGEM_DO_PANORAMA = Object.freeze({
-    installation: 'fixado na instalação', cwd: 'pelo diretório atual', worktree: 'pela worktree da thread',
-    selection: 'pedido explicitamente (--projeto ou ORK_PROJETO)',
-});
-function maestroText(snapshot) {
+function maestroText(snapshot, textos = locale_maestro_1.MAESTRO_PT_BR) {
     const p = snapshot.project;
-    return [`${p.name} · panorama Maestro`,
+    return [textos.titulo(p.name),
         // I-35: o snapshot guarda ISO; o texto ao dono diz quando consultou, no fuso dele.
-        `• Consulta: ${(0, horario_1.formatarDataHoraRotulada)(snapshot.observedAt, { agora: snapshot.observedAt })}`,
+        textos.consulta((0, horario_1.formatarDataHoraRotulada)(snapshot.observedAt, { agora: snapshot.observedAt })),
         // RM-052: qual cópia foi lida e o que o panorama não lê, antes de qualquer seção.
-        `• Projeto consultado: ${p.name}${p.root ? ` · ${p.root}` : ''}${p.remote === undefined ? '' : ` · ${p.remote ?? 'sem remoto'}`} · ${ORIGEM_DO_PANORAMA[p.origin]}`,
-        ...(snapshot.notConsulted?.length ? [`• Não lido: ${snapshot.notConsulted.join(' · ')}`] : []),
+        textos.projeto(p.name, p.root ?? '', p.remote === null ? textos.semRemoto : p.remote, textos.origem[p.origin]),
+        ...(snapshot.notConsulted?.length ? [textos.naoLido(snapshot.notConsulted.join(' · '))] : []),
         ...maestro_contract_1.SECTION_NAMES.map(name => {
             const s = snapshot.sections[name];
-            return `• ${name}: ${s.state} · ${s.coverage.returned}/${s.coverage.total ?? '?'}${s.coverage.omitted ? ' · mais itens disponíveis' : ''}`;
+            return textos.secao(name, s.state, s.coverage.returned, s.coverage.total, !!s.coverage.omitted);
         }),
-        ...snapshot.sections.threads.items.slice(0, 8).map(t => `  ${t.title}: ${t.facts.phase} · ${t.status}`),
-        `• Recomendo: ${snapshot.conflicts.length ? 'reler as fontes em conflito' : snapshot.gaps.length ? 'conferir as lacunas antes de agir' : 'escolher uma thread para ver o detalhe'}.`,
-        'Use ork maestro --json para cobertura e ações; --thread ID consulta o detalhe nativo.',
+        ...snapshot.sections.threads.items.slice(0, 8).map(t => textos.thread(t.title, String(t.facts.phase), t.status)),
+        textos.recomendacao(snapshot.conflicts.length, snapshot.gaps.length), textos.final,
     ].join('\n');
 }
-function runMaestroCli(argv, cwd = process.cwd(), trusted = {}, io = { out: (v) => console.log(v), err: (v) => console.error(v) }) {
+function runMaestroCli(argv, cwd = process.cwd(), trusted = {}, io = { out: (v) => console.log(v), err: (v) => console.error(v) }, textos = locale_maestro_1.MAESTRO_PT_BR) {
     if (argv.length === 1 && argv[0] === '--help') {
-        io.out('ork maestro [--json] [--thread ID] [--section NOME --offset N]\nConsulta sem criar ou despachar trabalho. Na conversa, diga: orkastery maestro.');
+        io.out(textos.help);
         return 0;
     }
     try {
@@ -94,7 +89,7 @@ function runMaestroCli(argv, cwd = process.cwd(), trusted = {}, io = { out: (v)
         const context = (0, maestro_discovery_1.discoverMaestro)({ cwd, ...trusted });
         const snapshot = readMaestro(context, { threadId, offsets: section ? { [section]: offset } : undefined, native: true,
             host: { tools: ['ork_thread_status', 'ork_observe', 'ork_git_status'], child: false } });
-        io.out(json ? JSON.stringify(snapshot) : maestroText(snapshot));
+        io.out(json ? JSON.stringify(snapshot) : maestroText(snapshot, textos));
         return 0;
     }
     catch (e) {

package/dist/mcp-install.js

@@ -55,7 +55,8 @@ const IMPRESSAO_SSH = /^SHA256:[A-Za-z0-9+/]{43}$/;
 exports.TOOLS_DONO_CODEX = ['ork_thread_new', 'ork_phase_run', 'ork_request_decision'];
 // RM-037 (rm037defeito, defeito 1): a decisao autonoma da sessao entra com as outras mutacoes do filho;
 // sem o grant, o codex com approval_policy never recusaria a chamada.
-exports.TOOLS_FILHO_CODEX = ['ork_artifact_write', 'ork_claim_add', 'ork_decision_record', 'ork_git_commit', 'ork_verify', 'ork_ship'];
+exports.TOOLS_FILHO_CODEX = ['ork_artifact_write', 'ork_claim_add', 'ork_decision_record', 'ork_request_conduction',
+    'ork_git_commit', 'ork_verify', 'ork_verify_status', 'ork_ship'];
 // Brain mutation tools are deliberately excluded from the existing opt-in bundle.
 // A native integration must request exact startup grants plus scoped activation.
 var company_brain_mcp_1 = require("./company-brain-mcp");

package/dist/mcp-server.js

@@ -70,9 +70,7 @@ const preflight_1 = require("./preflight");
 const modos_1 = require("./modos");
 const mcp_noctum_1 = require("./mcp-noctum");
 const versao_1 = require("./versao");
-const mcp_verify_1 = require("./mcp-verify");
 const conducao_1 = require("./conducao");
-const fila_pesada_1 = require("./fila-pesada");
 const decisao_autonoma_1 = require("./decisao-autonoma");
 const conducao_texto_1 = require("./conducao-texto");
 const mcp_ship_1 = require("./mcp-ship");
@@ -87,6 +85,7 @@ const mcp_experiencia_1 = require("./mcp-experiencia");
 const mcp_grafo_1 = require("./mcp-grafo");
 const mcp_conhecimento_1 = require("./mcp-conhecimento");
 const locale_1 = require("./locale");
+const pedido_conducao_1 = require("./pedido-conducao");
 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();
@@ -456,23 +455,20 @@ function criarServidorMcp(opcoes) {
         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.',
+    registrarTool('ork_verify', { description: 'Inicia uma rodada assíncrona do verify canônico no processo do servidor, vinculada à thread e ao despacho. Devolve imediatamente o UUID; repetir enquanto viva reutiliza a rodada.',
         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 };
-            // RM-058 N2 (A6 do CHECK): a fila pesada que nao deu a vez no prazo responde como a conducao.
-            if (e instanceof fila_pesada_1.ErroDaFilaPesada)
-                return { ...resposta(e.recusa), isError: true };
-            throw e;
-        }
+        const { iniciarVerifyMcp } = await Promise.resolve().then(() => __importStar(require('./mcp-verify-async')));
+        const r = iniciarVerifyMcp(raiz, threadId, { host: opcoes.host, despacho: opcoes.dispatchId ?? null });
+        return { ...resposta(r), ...(r.estado === 'falhou' ? { isError: true } : {}) };
+    });
+    registrarTool('ork_verify_status', { description: 'Consulta uma rodada assíncrona do verify por UUID: na fila, rodando com a lane atual, concluída com o veredito completo do CLI ou falha tipada. Não inicia nem duplica rodada.',
+        inputSchema: daThread.extend({ rodadaId: zod_1.z.string().uuid() }).strict(), annotations: { readOnlyHint: true, destructiveHint: false } }, async ({ threadId, rodadaId }) => {
+        thread(threadId);
+        const { consultarVerifyMcp } = await Promise.resolve().then(() => __importStar(require('./mcp-verify-async')));
+        const r = consultarVerifyMcp(raiz, threadId, rodadaId);
+        const reprovou = r.estado === 'falhou' || (r.estado === 'concluido' && r.veredito?.ok === false);
+        return { ...resposta(r), ...(reprovou ? { isError: true } : {}) };
     });
     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}$/),
@@ -649,6 +645,13 @@ function criarServidorMcp(opcoes) {
         });
     if (opcoes.threadId && opcoes.dispatchId) {
         const despacho = opcoes.dispatchId;
+        registrarTool('ork_request_conduction', { description: 'Registra um pedido tipado desta sessao para a conducao, com comando ork exato. Nao executa o comando, nao aprova gate e nao responde pelo dono.',
+            inputSchema: daThread.extend({ motivo: zod_1.z.enum(pedido_conducao_1.MOTIVOS_DE_PEDIDO_A_CONDUCAO), detalhe: zod_1.z.string().trim().min(1).max(2000),
+                comando: zod_1.z.string().trim().min(1).max(1000) }).strict(),
+            annotations: { readOnlyHint: false, destructiveHint: false } }, async ({ threadId, motivo, detalhe, comando }) => {
+            thread(threadId);
+            return resposta((0, pedido_conducao_1.registrarPedidoAConducao)(raiz, threadId, { despacho, motivo, detalhe, comando, host: opcoes.host }));
+        });
         registrarTool('ork_session_inbox', { description: 'Lado receptor do Mensageiro de Sessoes na sessao de fase deste despacho: confere e reserva uma vez a resposta do dono que chegou de outra sessao (conferir, com o prazo ate) e, depois de ela entrar na fila, grava o recibo (confirmar). A sessao sai do despacho deste servidor, nunca de argumento. Nao responde nem aprova pedido.',
             inputSchema: daThread.extend({ operacao: zod_1.z.enum(['conferir', 'confirmar']), texto: zod_1.z.string().max(entrega_por_mod_1.LIMITE_DA_MENSAGEM),
                 envioId: zod_1.z.string().uuid().optional(), ate: zod_1.z.string().max(40).optional() }).strict(),

package/dist/mcp-verify-async.js

@@ -0,0 +1,353 @@
+"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.CONTRATO_VERIFY_MCP = void 0;
+exports.iniciarVerifyMcp = iniciarVerifyMcp;
+exports.consultarVerifyMcp = consultarVerifyMcp;
+exports.executarVerifyMcpWorker = executarVerifyMcpWorker;
+/**
+ * Verify assíncrono do MCP: o transporte inicia uma rodada curta e um worker do próprio servidor
+ * executa o mesmo `verificar` do CLI. O estado fica no domínio canônico da thread; o modelo nunca
+ * escolhe raiz, comando, PID ou lease.
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const node_child_process_1 = require("node:child_process");
+const hitl_gates_1 = require("./hitl-gates");
+const manifest_1 = require("./manifest");
+const mcp_artifacts_1 = require("./mcp-artifacts");
+const leases_1 = require("./leases");
+const thread_1 = require("./thread");
+const verify_1 = require("./verify");
+const conducao_1 = require("./conducao");
+const fila_pesada_1 = require("./fila-pesada");
+const mcp_verify_1 = require("./mcp-verify");
+const verify_2 = require("./verify");
+const claims_1 = require("./claims");
+const locale_1 = require("./locale");
+exports.CONTRATO_VERIFY_MCP = 'ork.verify-mcp/v1';
+const ESTADOS_VIVOS = new Set(['na-fila', 'rodando']);
+const UUID = /^[a-f0-9]{8}-[a-f0-9]{4}-[1-5][a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}$/i;
+const LIMITE_ESTADO = 16 * 1024 * 1024;
+function agora(dep) { return (dep?.agora?.() ?? new Date()).toISOString(); }
+function falhaDaExecucao(e) {
+    if (e instanceof fila_pesada_1.ErroDaFilaPesada)
+        return { motivo: e.recusa.motivo, detalhe: e.message, recusa: e.recusa };
+    if (e instanceof conducao_1.ErroDeConducao)
+        return { motivo: e.recusa.motivo, detalhe: e.message, recusa: e.recusa };
+    return { motivo: 'verify.worker-failed', detalhe: e.message };
+}
+function inicioDoProcesso(pid) {
+    try {
+        const stat = fs.readFileSync(`/proc/${pid}/stat`, 'utf8');
+        return stat.slice(stat.lastIndexOf(')') + 2).split(' ')[19] ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+function processoVivo(processo) {
+    try {
+        process.kill(processo.pid, 0);
+    }
+    catch {
+        return false;
+    }
+    return processo.inicio === null || inicioDoProcesso(processo.pid) === processo.inicio;
+}
+function mesmoLease(a, b) {
+    return !!a && a.nome === b.nome && a.thread === b.thread && a.pid === b.pid &&
+        a.adquiridoEm === b.adquiridoEm && a.expiraEm === b.expiraEm && a.motivo === b.motivo;
+}
+function diretorioDasRodadas(raiz, threadId, criar) {
+    (0, mcp_artifacts_1.validarArquivosEstadoMcp)(raiz, threadId);
+    const threadDir = fs.realpathSync((0, thread_1.dirThread)(raiz, threadId));
+    const estadoReal = fs.realpathSync(path.join(raiz, '.orkastery'));
+    if (!threadDir.startsWith(estadoReal + path.sep))
+        throw Error('mcp.verify.async.scope');
+    const dir = path.join(threadDir, 'verify-mcp');
+    const st = fs.lstatSync(dir, { throwIfNoEntry: false });
+    if (!st) {
+        if (!criar)
+            throw Error('mcp.verify.round.not-found');
+        fs.mkdirSync(dir, { mode: 0o700 });
+    }
+    const atual = fs.lstatSync(dir);
+    if (!atual.isDirectory() || atual.isSymbolicLink() || fs.realpathSync(dir) !== dir ||
+        (process.getuid && atual.uid !== process.getuid()))
+        throw Error('mcp.verify.async.scope');
+    return dir;
+}
+function lerArquivoSeguro(file, ausente) {
+    let fd;
+    try {
+        fd = fs.openSync(file, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW | fs.constants.O_NONBLOCK);
+    }
+    catch (e) {
+        if (ausente && e.code === 'ENOENT')
+            return null;
+        throw e;
+    }
+    try {
+        const st = fs.fstatSync(fd);
+        if (!st.isFile() || st.nlink !== 1 || st.size > LIMITE_ESTADO || (process.getuid && st.uid !== process.getuid()))
+            throw Error('mcp.verify.async.unsafe');
+        const bytes = fs.readFileSync(fd);
+        if (bytes.length > LIMITE_ESTADO)
+            throw Error('mcp.verify.async.too-large');
+        return bytes;
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+function validarEstado(v, threadId, rodadaId) {
+    const e = v;
+    if (!e || e.contrato !== exports.CONTRATO_VERIFY_MCP || e.threadId !== threadId || e.rodadaId !== rodadaId ||
+        !UUID.test(rodadaId) || !['na-fila', 'rodando', 'concluido', 'falhou'].includes(String(e.estado)) ||
+        typeof e.criadaEm !== 'string' || typeof e.atualizadaEm !== 'string' ||
+        !e.lease || e.lease.thread !== threadId || typeof e.host !== 'string')
+        throw Error('mcp.verify.async.invalid');
+    return e;
+}
+function lerEstado(dir, threadId, rodadaId) {
+    if (!UUID.test(rodadaId))
+        throw Error('mcp.verify.round.invalid');
+    const bytes = lerArquivoSeguro(path.join(dir, `${rodadaId}.json`), false);
+    try {
+        return validarEstado(JSON.parse(bytes.toString('utf8')), threadId, rodadaId);
+    }
+    catch (e) {
+        if (e.message.startsWith('mcp.'))
+            throw e;
+        throw Error('mcp.verify.async.invalid');
+    }
+}
+function gravarAtomico(dir, nome, valor) {
+    const destino = path.join(dir, nome);
+    const temp = path.join(dir, `.${nome}.${process.pid}.${(0, node_crypto_1.randomUUID)()}.tmp`);
+    const bytes = JSON.stringify(valor) + '\n';
+    if (Buffer.byteLength(bytes) > LIMITE_ESTADO)
+        throw Error('mcp.verify.async.too-large');
+    try {
+        fs.writeFileSync(temp, bytes, { flag: 'wx', mode: 0o600 });
+        fs.renameSync(temp, destino);
+    }
+    finally {
+        fs.rmSync(temp, { force: true });
+    }
+}
+function gravarEstado(dir, estado) {
+    gravarAtomico(dir, `${estado.rodadaId}.json`, estado);
+}
+function lerAtiva(dir, threadId) {
+    const bytes = lerArquivoSeguro(path.join(dir, 'active.json'), true);
+    if (!bytes)
+        return null;
+    let id;
+    try {
+        id = JSON.parse(bytes.toString('utf8')).rodadaId;
+    }
+    catch {
+        throw Error('mcp.verify.async.invalid');
+    }
+    if (typeof id !== 'string' || !UUID.test(id))
+        throw Error('mcp.verify.async.invalid');
+    return lerEstado(dir, threadId, id);
+}
+function publico(estado, reutilizada) {
+    const { host: _host, processo: _processo, lease: _lease, ...visivel } = estado;
+    return { ...visivel, ...(reutilizada === undefined ? {} : { reutilizada }) };
+}
+function vivo(estado, dep) {
+    return !!estado.processo && (dep?.processoVivo ?? processoVivo)(estado.processo);
+}
+function liberarLeaseExata(raiz, estado) {
+    if (mesmoLease((0, leases_1.lerLease)(raiz, estado.lease.nome), estado.lease))
+        (0, leases_1.liberar)(raiz, estado.lease.nome, estado.threadId);
+}
+function falhaDeProcesso(estado, instante) {
+    return { ...estado, estado: 'falhou', lane: null, atualizadaEm: instante,
+        falha: { motivo: 'verify.processo-morto', detalhe: 'o worker terminou sem gravar um veredito completo' } };
+}
+function prazoDaLease(raiz, threadId) {
+    const carregado = (0, manifest_1.exigirManifesto)(raiz);
+    const claims = (0, claims_1.lerClaims)(raiz, threadId).filter((c) => c.estado !== 'retirada');
+    const quantidade = claims.reduce((n, c) => n + c.verificar.length, 0) + (0, verify_2.comandosDoManifesto)(carregado.manifesto).length + 2;
+    const prazos = [carregado.manifesto.verify.timeout_ms ?? 600_000,
+        ...Object.values(carregado.manifesto.verify.timeout_ms_por_comando ?? {}).filter((n) => typeof n === 'number')];
+    return mcp_verify_1.ESPERA_DA_FILA_PESADA_MCP_MS + Math.max(conducao_1.PRAZO_DE_SESSAO_PADRAO_MS, (0, conducao_1.prazoDaVerificacao)(Math.max(...prazos), quantidade));
+}
+function lancarWorker(pedido) {
+    const child = (0, node_child_process_1.spawn)(process.execPath, [pedido.worker, pedido.raiz, pedido.threadId, pedido.rodadaId], {
+        cwd: pedido.raiz, detached: true, stdio: 'ignore', env: process.env,
+    });
+    if (!child.pid)
+        throw Error('mcp.verify.worker.spawn');
+    child.unref();
+    let inicio = null;
+    for (let i = 0; i < 20 && inicio === null; i++) {
+        inicio = inicioDoProcesso(child.pid);
+        if (inicio === null)
+            Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 5);
+    }
+    return { pid: child.pid, inicio };
+}
+function iniciarVerifyMcp(raiz, threadId, vinculo, dep = {}) {
+    const carregado = (0, manifest_1.exigirManifesto)(raiz);
+    if (fs.realpathSync(carregado.raiz) !== fs.realpathSync(raiz))
+        throw Error('mcp.verify.project');
+    (0, mcp_artifacts_1.validarArquivosEstadoMcp)(raiz, threadId);
+    const thread = (0, thread_1.lerThread)(raiz, threadId);
+    if (thread.status === 'fechada' || !thread.worktree)
+        throw Error('mcp.verify.thread');
+    return (0, hitl_gates_1.comLockHitl)(raiz, threadId, () => {
+        const dir = diretorioDasRodadas(raiz, threadId, true);
+        const ativa = lerAtiva(dir, threadId);
+        if (ativa && ESTADOS_VIVOS.has(ativa.estado) && vivo(ativa, dep))
+            return publico(ativa, true);
+        if (ativa) {
+            const reconciliada = ESTADOS_VIVOS.has(ativa.estado) ? falhaDeProcesso(ativa, agora(dep)) : ativa;
+            if (reconciliada !== ativa)
+                gravarEstado(dir, reconciliada);
+            liberarLeaseExata(raiz, reconciliada);
+        }
+        const nomeLease = `worktree-write:${threadId}`;
+        (0, leases_1.podarRegioesDeThreadsFechadas)(raiz, [nomeLease, 'main-tree'], threadId);
+        if ((0, leases_1.lerLease)(raiz, nomeLease) || (0, leases_1.leasesColidentes)(raiz, nomeLease).length || (0, leases_1.leasesColidentes)(raiz, 'main-tree').length)
+            throw Error('lease.busy: verify assíncrono exige a worktree livre');
+        const rodadaId = (0, node_crypto_1.randomUUID)();
+        const instante = agora(dep);
+        const regiao = (0, leases_1.adquirirRegiao)(raiz, nomeLease, { thread: threadId, motivo: `MCP VERIFY ASYNC ${rodadaId}`,
+            ttlMs: prazoDaLease(raiz, threadId), retomarVencido: false });
+        if (!regiao.ok || !regiao.lease)
+            throw Error('lease.busy: verify assíncrono não adquiriu a worktree');
+        let estado = { contrato: exports.CONTRATO_VERIFY_MCP, rodadaId, threadId, despacho: vinculo.despacho,
+            host: vinculo.host, estado: 'na-fila', lane: null, criadaEm: instante, atualizadaEm: instante,
+            processo: null, lease: regiao.lease };
+        gravarEstado(dir, estado);
+        gravarAtomico(dir, 'active.json', { contrato: exports.CONTRATO_VERIFY_MCP, rodadaId });
+        try {
+            const worker = path.resolve(__dirname, 'mcp-verify-worker.js');
+            const processo = (dep.lancar ?? lancarWorker)({ worker, raiz: fs.realpathSync(raiz), threadId, rodadaId });
+            estado = { ...estado, processo, atualizadaEm: agora(dep) };
+            gravarEstado(dir, estado);
+            return publico(estado, false);
+        }
+        catch (e) {
+            estado = { ...estado, estado: 'falhou', atualizadaEm: agora(dep),
+                falha: { motivo: 'verify.worker-failed', detalhe: e.message } };
+            gravarEstado(dir, estado);
+            liberarLeaseExata(raiz, estado);
+            return publico(estado, false);
+        }
+    });
+}
+function consultarVerifyMcp(raiz, threadId, rodadaId, dep = {}) {
+    (0, thread_1.lerThread)(raiz, threadId);
+    (0, mcp_artifacts_1.validarArquivosEstadoMcp)(raiz, threadId);
+    const estado = lerEstado(diretorioDasRodadas(raiz, threadId, false), threadId, rodadaId);
+    return publico(ESTADOS_VIVOS.has(estado.estado) && !vivo(estado, dep) ? falhaDeProcesso(estado, agora(dep)) : estado);
+}
+function atualizarRodada(raiz, threadId, rodadaId, mudar) {
+    return (0, hitl_gates_1.comLockHitl)(raiz, threadId, () => {
+        const dir = diretorioDasRodadas(raiz, threadId, false);
+        const atual = lerEstado(dir, threadId, rodadaId);
+        const proximo = mudar(atual);
+        gravarEstado(dir, proximo);
+        return proximo;
+    });
+}
+/** Entrada do processo destacado; exportada para o teste hermético executar a mesma rodada sem transporte. */
+function executarVerifyMcpWorker(raiz, threadId, rodadaId) {
+    const dir = diretorioDasRodadas(raiz, threadId, false);
+    let inicial = lerEstado(dir, threadId, rodadaId);
+    const inicioAtual = inicioDoProcesso(process.pid);
+    if (!inicial.processo || inicial.processo.pid !== process.pid ||
+        (inicial.processo.inicio !== null && inicial.processo.inicio !== inicioAtual))
+        throw Error('mcp.verify.worker.identity');
+    if (!mesmoLease((0, leases_1.lerLease)(raiz, inicial.lease.nome), inicial.lease))
+        throw Error('mcp.verify.worker.lease');
+    const atualizar = (mudanca) => {
+        inicial = atualizarRodada(raiz, threadId, rodadaId, (atual) => {
+            if (!mesmoLease((0, leases_1.lerLease)(raiz, atual.lease.nome), atual.lease))
+                return { ...atual, estado: 'falhou', lane: null, atualizadaEm: new Date().toISOString(),
+                    falha: { motivo: 'verify.lease-perdida', detalhe: 'a lease da worktree mudou durante a rodada' } };
+            return { ...atual, ...mudanca, atualizadaEm: new Date().toISOString() };
+        });
+        if (inicial.estado === 'falhou')
+            throw Error(inicial.falha?.motivo ?? 'verify.worker-failed');
+    };
+    // RM-064: o estado terminal só é gravado depois de a lease voltar. Quem lê `concluido` ou `falhou`
+    // pode contar com a worktree livre; a ordem inversa deixava a recusa visível com a lease ainda presa.
+    let terminal = null;
+    try {
+        atualizar({ estado: 'na-fila', lane: 'fila-pesada' });
+        const carregado = (0, manifest_1.exigirManifesto)(raiz);
+        const resultado = (0, locale_1.comLocale)('pt-BR', () => (0, verify_1.verificar)(carregado, threadId, {
+            operacao: 'mcp.verify',
+            conducao: { canal: inicial.host, identidade: inicial.despacho,
+                filaPesada: { esperarMs: mcp_verify_1.ESPERA_DA_FILA_PESADA_MCP_MS, aoEsperar: (ocupantes) => atualizar({ estado: 'na-fila',
+                        lane: 'fila-pesada', ocupantes: ocupantes.map((o) => ({ operacao: o.operacao, thread: o.thread })) }) } },
+            progresso: (lane) => atualizar({ estado: 'rodando', lane, ocupantes: undefined }),
+        }));
+        const locale = (0, locale_1.resolverLocale)(carregado.manifesto.owner?.language).locale;
+        const veredito = { ok: resultado.ok, commit: resultado.commit, motivos: resultado.motivos,
+            check: resultado.check, texto: (0, locale_1.comLocale)(locale, () => (0, verify_1.textoDoVerify)(resultado)), resultado };
+        terminal = { estado: 'concluido', lane: null, veredito, falha: undefined, ocupantes: undefined };
+    }
+    catch (e) {
+        terminal = { estado: 'falhou', lane: null, falha: falhaDaExecucao(e), ocupantes: undefined };
+    }
+    finally {
+        const atual = lerEstado(dir, threadId, rodadaId);
+        const leaseNossa = mesmoLease((0, leases_1.lerLease)(raiz, atual.lease.nome), atual.lease);
+        liberarLeaseExata(raiz, atual);
+        if (atual.estado === 'falhou')
+            terminal = null; // a falha já gravada (lease perdida, por exemplo) prevalece
+        else if (!leaseNossa)
+            terminal = { estado: 'falhou', lane: null, ocupantes: undefined,
+                falha: { motivo: 'verify.lease-perdida', detalhe: 'a lease da worktree mudou durante a rodada' } };
+        if (terminal) {
+            const fim = terminal;
+            try {
+                inicial = atualizarRodada(raiz, threadId, rodadaId, (a) => ({ ...a, ...fim, atualizadaEm: new Date().toISOString() }));
+            }
+            catch { /* a leitura abaixo projeta morte/falha; nunca inventa verde */ }
+        }
+    }
+    return consultarVerifyMcp(raiz, threadId, rodadaId);
+}

package/dist/mcp-verify-worker.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/** Processo destacado do verify MCP. Toda autoridade vem do estado criado pelo servidor. */
+const mcp_verify_async_1 = require("./mcp-verify-async");
+if (require.main === module) {
+    const [raiz, threadId, rodadaId, ...resto] = process.argv.slice(2);
+    if (!raiz || !threadId || !rodadaId || resto.length)
+        process.exitCode = 2;
+    else {
+        try {
+            (0, mcp_verify_async_1.executarVerifyMcpWorker)(raiz, threadId, rodadaId);
+        }
+        catch {
+            process.exitCode = 1;
+        }
+    }
+}