@orkastery/cli 0.6.1 → 0.6.2

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;
+        }
+    }
+}

package/dist/mcp-verify.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ESPERA_DA_FILA_PESADA_MCP_MS = void 0;
+exports.diagnosticoDoVerifyMcp = diagnosticoDoVerifyMcp;
 exports.verificarMcp = verificarMcp;
 /** Operação estruturada: argumentos só identificam a thread; execução sempre confinada. */
 const fs = __importStar(require("node:fs"));
@@ -68,6 +69,14 @@ 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;
 }
+/** Parte pura do retorno MCP: permite provar o contrato mesmo quando o sandbox nao abre outro sandbox. */
+function diagnosticoDoVerifyMcp(r) {
+    return {
+        regressoes: r.regressoes.map(c => c.nome),
+        preExistentes: r.preExistentes.map(c => c.nome),
+        comparacoes: r.comparacoes,
+    };
+}
 /** Síncrono: prazo total/per-command, não cancelamento reativo do event loop. */
 function verificarMcp(raizEntrada, threadId, conducao = {}) {
     const deadline = Date.now() + PRAZO_TOTAL_MS;
@@ -167,7 +176,7 @@ function verificarMcp(raizEntrada, threadId, conducao = {}) {
             execucoes: execucoes.slice(0, LIMITE_RETORNO).map(c => ({ nome: c.nome, ok: c.ok, code: c.code,
                 executado: c.executado === true, resumo: c.resumo })),
             totalExecucoes: execucoes.length, omitidas: Math.max(0, execucoes.length - LIMITE_RETORNO),
-            regressoes: r.regressoes.map(c => c.nome), preExistentes: r.preExistentes.map(c => c.nome),
+            ...diagnosticoDoVerifyMcp(r),
             executor: 'codex-sandbox', prazoTotalMs: PRAZO_TOTAL_MS, limitePorComandoMs: COMANDO_MAX_MS,
         };
     }

package/dist/pedido-conducao.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MOTIVOS_DE_PEDIDO_A_CONDUCAO = void 0;
+exports.registrarPedidoAConducao = registrarPedidoAConducao;
+/**
+ * Pedido estreito da sessao de fase para a conducao. A sessao nao executa o comando,
+ * nao aprova gate e nao assume o dono: ela apenas registra por que parou e o passo exato.
+ */
+const gates_1 = require("./gates");
+const ledger_1 = require("./ledger");
+const thread_1 = require("./thread");
+exports.MOTIVOS_DE_PEDIDO_A_CONDUCAO = [
+    'concurrency.lease-indeterminado',
+    'conducao.acao-necessaria',
+];
+function comandoSeguro(comando) {
+    return comando.length <= 1000 && /^ork [^\s]/u.test(comando) && !/[\p{Cc}\p{Cf};|&<>`$\\()]/u.test(comando) &&
+        !/\s{2,}/.test(comando) && comando.trim() === comando;
+}
+/** Registra uma vez, sempre correlacionado ao despacho que originou o servidor MCP filho. */
+function registrarPedidoAConducao(raiz, threadId, entrada) {
+    if (!exports.MOTIVOS_DE_PEDIDO_A_CONDUCAO.includes(entrada.motivo))
+        throw Error('conducao.request.reason.invalid');
+    if (!comandoSeguro(entrada.comando)) {
+        throw Error('conducao.request.command.invalid: informe um comando ork de uma linha, sem operadores de shell');
+    }
+    const thread = (0, thread_1.lerThread)(raiz, threadId), dir = (0, thread_1.dirThread)(raiz, threadId), eventos = (0, ledger_1.lerLedger)(dir);
+    const despacho = eventos.filter(e => e.tipo === 'phase_dispatch' &&
+        e.identidade?.dispatchId === entrada.despacho).at(-1);
+    if (!despacho || despacho.thread !== threadId || typeof despacho.sessionId !== 'string' || typeof despacho.fase !== 'string') {
+        throw Error('conducao.request.dispatch.invalid: o servidor nao corresponde a um despacho provado desta thread');
+    }
+    const sessao = thread.sessoes.find(s => s.sessionId === despacho.sessionId && s.fase === despacho.fase);
+    if (!sessao)
+        throw Error('conducao.request.session.invalid: o despacho nao esta vinculado a sessao ativa da thread');
+    const existente = eventos.filter(e => e.tipo === 'gate_blocked' && e.origem === 'mcp.request_conduction' &&
+        e.despacho === entrada.despacho && e.motivo === entrada.motivo && e.comando === entrada.comando).at(-1);
+    if (existente)
+        return { ok: true, criado: false, eventId: existente.eventId, motivo: entrada.motivo,
+            comando: entrada.comando, fase: despacho.fase, sessionId: despacho.sessionId, despacho: entrada.despacho };
+    const evento = (0, gates_1.registrarGateBloqueado)(dir, threadId, {
+        gate: 'phase.dispatch', motivo: entrada.motivo, modo: thread.modo,
+        detalhe: entrada.detalhe, correcao: entrada.comando,
+        evidencia: `despacho ${entrada.despacho} da sessao ${despacho.sessionId}`,
+        fase: despacho.fase, sessionId: despacho.sessionId, despachoEm: sessao.despachadaEm,
+        despacho: entrada.despacho, comando: entrada.comando, origem: 'mcp.request_conduction',
+        pedidoConducao: { contrato: 'ork.pedido-conducao/v1', host: entrada.host, estado: 'aberto' },
+    });
+    return { ok: true, criado: true, eventId: evento.eventId, motivo: entrada.motivo,
+        comando: entrada.comando, fase: despacho.fase, sessionId: despacho.sessionId, despacho: entrada.despacho };
+}

package/dist/preflight.js

@@ -126,49 +126,46 @@ function sondasDeAmbiente(raiz, umask = umaskDoProcesso()) {
  * com login conferido pelo proprio CLI. A sonda nao marca o store: quem marca e o despacho.
  */
 function checkDeContas(raiz, runtime, auth = authPadrao) {
+    const m = (0, locale_1.msg)().preflight;
     let perfis;
     try {
         perfis = (0, runtime_profiles_1.perfisDoRuntime)((0, runtime_profiles_1.lerPerfisComContas)(raiz), runtime).filter(p => p.estado !== 'desativado');
     }
     catch (e) {
-        return { nome: 'contas', nivel: 'fail', detalhe: `store de perfis invalido: ${e.message}` };
+        return { nome: 'contas', nivel: 'fail', detalhe: m.storeInvalido(e.message) };
     }
     if (!perfis.length)
-        return { nome: 'contas', nivel: 'ok', detalhe: `${runtime} sem perfil configurado: despacho pelo ambiente do processo` };
+        return { nome: 'contas', nivel: 'ok', detalhe: m.semPerfil(runtime) };
     const estados = perfis.map(p => {
         const a = auth((0, runtime_profiles_1.perfilDeDespacho)(p));
         return { id: p.id, pronto: a.ok && (0, runtime_profiles_1.perfilDisponivel)(p),
-            texto: !a.ok ? `${a.pago ? 'provider pago, nunca despacha' : a.transitorio ? 'conferencia de login inconclusiva' : 'sem login'} (${a.detalhe})` : (0, runtime_profiles_1.perfilDisponivel)(p) ? 'pronto' : `${p.estado}${p.esgotadoAte ? ` ate ${p.esgotadoAte}` : ''}` };
+            texto: !a.ok ? `${a.pago ? m.estadoConta.providerPago : a.transitorio ? m.estadoConta.loginInconclusivo : m.estadoConta.semLogin} (${a.detalhe})`
+                : (0, runtime_profiles_1.perfilDisponivel)(p) ? m.estadoConta.pronto : m.estadoConta.esgotadoAte(p.estado, p.esgotadoAte ?? '') };
     });
     const prontos = estados.filter(e => e.pronto).length;
     return { nome: 'contas', nivel: prontos === 0 ? 'fail' : prontos < estados.length ? 'warn' : 'ok',
-        detalhe: `${runtime}: ${estados.map(e => `${e.id} ${e.texto}`).join('; ')}`,
-        ...(prontos < estados.length ? { correcao: 'ork accounts check marca os perfis; ork accounts add refaz o login pelo proprio CLI' } : {}) };
+        detalhe: m.contas(runtime, estados.map(e => `${e.id} ${e.texto}`).join('; ')),
+        ...(prontos < estados.length ? { correcao: m.contasCorrecao } : {}) };
 }
-const limites = [
-    'Sonda contextual local: não inventaria sessões, não inicia modelo e não autoriza despacho.',
-    'Aceitação do modelo, instalação do adaptador/MCP, contexto da thread, gates e policies do pedido são revalidados no despacho; com perfis, o login de cada conta é conferido aqui e de novo no despacho.',
-    'Trio sem override; um override posterior exige resolver e verificar novamente o despacho.',
-    'VERIFY/SHIP MCP exigem executor Codex isolado próprio e transporte SHIP válido; a sonda de despacho não comprova entrega.',
-];
 function preflight(raiz, modo, nomesHerdados = (0, runtime_ambiente_1.nomesDeProviderAtivos)(), sensores = sensoresPadrao) {
+    const t = (0, locale_1.msg)().preflight;
     // I-43: a matriz tem os cinco (para LER thread antiga); quem entra aqui e ESCRITA.
     if (!modos_1.ORDEM_DOS_MODOS.includes(modo))
         throw Error('preflight.mode.invalid');
     const checks = [];
-    checks.push({ nome: 'node', nivel: Number(process.versions.node.split('.')[0]) >= 20 ? 'ok' : 'fail', detalhe: 'Node 20 ou superior necessário' });
+    checks.push({ nome: 'node', nivel: Number(process.versions.node.split('.')[0]) >= 20 ? 'ok' : 'fail', detalhe: t.node });
     const git = !!(0, util_1.noPath)('git');
-    checks.push({ nome: 'git', nivel: git ? 'ok' : 'fail', detalhe: git ? 'Git disponível' : 'Git ausente' });
+    checks.push({ nome: 'git', nivel: git ? 'ok' : 'fail', detalhe: git ? t.gitOk : t.gitAusente });
     const repo = git ? (0, util_1.exec)('git', ['rev-parse', '--is-inside-work-tree'], raiz, 10000) : null;
-    checks.push({ nome: 'repositorio', nivel: repo?.ok && repo.stdout.trim() === 'true' ? 'ok' : 'fail', detalhe: 'Repositório Git local necessário' });
+    checks.push({ nome: 'repositorio', nivel: repo?.ok && repo.stdout.trim() === 'true' ? 'ok' : 'fail', detalhe: t.repo });
     checks.push(...sondasDeAmbiente(raiz));
     const carregado = (0, manifest_1.carregarManifesto)(raiz);
     const blocos = [];
-    checks.push({ nome: 'manifesto', nivel: !carregado || carregado.erros.length ? 'fail' : 'ok', detalhe: !carregado ? 'Manifesto ausente' : carregado.erros.length ? 'Manifesto inválido; corrija antes do despacho' : 'Manifesto válido' });
+    checks.push({ nome: 'manifesto', nivel: !carregado || carregado.erros.length ? 'fail' : 'ok', detalhe: !carregado ? t.manifestoAusente : carregado.erros.length ? t.manifestoInvalido : t.manifestoValido });
     if (carregado && !carregado.erros.length) {
         const m = carregado.manifesto;
-        checks.push({ nome: 'modo', nivel: m.conduction.allowed_modes.includes(modo) ? 'ok' : 'fail', detalhe: `Modo solicitado: ${modo}` });
-        checks.push({ nome: 'abbrev', nivel: (0, slug_1.validarAbbrev)(m.project.abbrev).ok ? 'ok' : 'fail', detalhe: 'Identidade curta do projeto validada' });
+        checks.push({ nome: 'modo', nivel: m.conduction.allowed_modes.includes(modo) ? 'ok' : 'fail', detalhe: t.modo(modo) });
+        checks.push({ nome: 'abbrev', nivel: (0, slug_1.validarAbbrev)(m.project.abbrev).ok ? 'ok' : 'fail', detalhe: t.abbrev });
         const setup = (0, setup_1.lerSetup)(carregado.raiz), observados = new Map(), contas = new Map();
         let sandbox;
         for (const [i, bloco] of modos_1.MODOS[modo].blocos.entries()) {
@@ -177,11 +174,11 @@ function preflight(raiz, modo, nomesHerdados = (0, runtime_ambiente_1.nomesDePro
             try {
                 trio = (0, phase_1.resolverDespacho)(m, {}, (0, setup_1.configDoBloco)(setup, modo, bloco.fases[0]));
                 (0, runtimes_1.resolverRuntime)(trio.runtime);
-                locais.push({ nome: 'trio', nivel: 'ok', detalhe: 'Runtime/modelo/esforço resolvidos pelo mesmo contrato do despacho; aceitação nativa não comprovada' });
+                locais.push({ nome: 'trio', nivel: 'ok', detalhe: t.trio });
                 if (!observados.has(trio.runtime))
                     observados.set(trio.runtime, sensores.runtime(trio.runtime));
                 const presente = observados.get(trio.runtime);
-                locais.push({ nome: 'runtime', nivel: presente ? 'ok' : 'fail', detalhe: presente ? `${trio.runtime} disponível` : `${trio.runtime} ausente` });
+                locais.push({ nome: 'runtime', nivel: presente ? 'ok' : 'fail', detalhe: presente ? t.runtimeOk(trio.runtime) : t.runtimeAusente(trio.runtime) });
                 if (presente) {
                     if (!contas.has(trio.runtime))
                         contas.set(trio.runtime, checkDeContas(carregado.raiz, trio.runtime, sensores.auth ?? authPadrao));
@@ -189,14 +186,15 @@ function preflight(raiz, modo, nomesHerdados = (0, runtime_ambiente_1.nomesDePro
                 }
                 if (trio.runtime === 'codex' && presente) {
                     sandbox ??= sensores.sandboxCodex();
-                    locais.push({ nome: 'sandbox de despacho', nivel: sandbox ? 'ok' : m.runtime.sandbox === 'danger-full-access' ? 'warn' : 'fail', detalhe: sandbox ? 'Sonda Codex sem modelo executou' : 'Sonda Codex falhou; não altere o sandbox para contornar a falha' });
+                    locais.push({ nome: 'sandbox de despacho', nivel: sandbox ? 'ok' : m.runtime.sandbox === 'danger-full-access' ? 'warn' : 'fail', detalhe: sandbox ? t.sandboxOk : t.sandboxFalhou });
                 }
                 const ativos = nomesHerdados.filter(n => runtime_ambiente_1.ENVS_DE_PROVIDER_PAGO.includes(n));
                 const relevantes = ativos.filter(n => trio.runtime === 'claude-bg' ? /^(ANTHROPIC_|CLAUDE_CODE_USE_)/.test(n) : /^(OPENAI_|OPENROUTER_)/.test(n));
-                locais.push({ nome: 'provider', nivel: m.runtime.provider_policy === 'subscription-only' && relevantes.length ? 'fail' : ativos.length ? 'warn' : 'ok', detalhe: relevantes.length ? `Nomes de provider incompatíveis com assinatura: ${relevantes.join(', ')}` : ativos.length ? 'Há nomes de provider alheios ao runtime; não usar credenciais pagas' : 'Nenhum nome de provider pago ativo' });
+                locais.push({ nome: 'provider', nivel: m.runtime.provider_policy === 'subscription-only' && relevantes.length ? 'fail' : ativos.length ? 'warn' : 'ok',
+                    detalhe: relevantes.length ? t.providerIncompativel(relevantes.join(', ')) : ativos.length ? t.providerAlheio : t.providerNenhum });
             }
             catch {
-                locais.push({ nome: 'trio', nivel: 'fail', detalhe: 'Setup/trio ou sonda inválidos; complete o modelo e confira o runtime no setup canônico' });
+                locais.push({ nome: 'trio', nivel: 'fail', detalhe: t.trioInvalido });
             }
             blocos.push({ numero: i + 1, fases: [...bloco.fases], trio, checks: locais, pronto: locais.every(c => c.nivel !== 'fail') });
         }
@@ -205,16 +203,17 @@ function preflight(raiz, modo, nomesHerdados = (0, runtime_ambiente_1.nomesDePro
     return { modo, scope: 'dispatch-local', checks, blocos,
         prontoPrimeiroBloco: basePronta && !!blocos[0]?.pronto,
         prontoTodosBlocos: basePronta && blocos.length > 0 && blocos.every(b => b.pronto),
-        entrega: { verificada: false, dependencias: ['executor Codex isolado', 'transporte SHIP instalado', 'gates e HEADs correntes'] }, limites: [...limites] };
+        entrega: { verificada: false, dependencias: ['executor Codex isolado', 'transporte SHIP instalado', 'gates e HEADs correntes'] }, limites: [...t.limites] };
 }
 function textoPreflight(r) {
     // I-35: o Check guarda o ISO (dado de maquina); quem imprime para o dono localiza.
     let localizou = false;
     const local = (t) => { const l = (0, horario_1.localizarTexto)(t); if (l !== t)
         localizou = true; return l; };
-    const linhas = ['ork doctor contextual: ' + r.modo, ...r.checks.map(c => `${c.nivel}: ${c.nome}: ${local(c.detalhe)}`),
-        ...r.blocos.flatMap(b => [`bloco ${b.numero} ${b.fases.join('→')}: ${b.trio ? `${b.trio.runtime}/${b.trio.model}/${b.trio.effort}` : 'trio pendente'}`, ...b.checks.map(c => `  ${c.nivel}: ${c.nome}: ${local(c.detalhe)}`)]),
-        `Primeiro bloco: ${r.prontoPrimeiroBloco ? 'sonda pronta' : 'bloqueado'}; todos os blocos: ${r.prontoTodosBlocos ? 'sonda pronta' : 'dependências pendentes'}`, ...r.limites];
+    const m = (0, locale_1.msg)().preflight, nome = (v) => m.nomes[v] ?? v;
+    const linhas = [m.titulo(r.modo), ...r.checks.map(c => m.check(c.nivel, nome(c.nome), local(c.detalhe))),
+        ...r.blocos.flatMap(b => [m.bloco(b.numero, b.fases.join('→'), b.trio ? `${b.trio.runtime}/${b.trio.model}/${b.trio.effort}` : null),
+            ...b.checks.map(c => m.checkDoBloco(c.nivel, nome(c.nome), local(c.detalhe)))]), m.resumo(r.prontoPrimeiroBloco, r.prontoTodosBlocos), ...r.limites];
     // O fuso sai uma vez por mensagem, depois dos limites.
     if (localizou)
         linhas.push((0, horario_1.legendaDoFuso)());

package/dist/prompts.js

@@ -292,7 +292,7 @@ function lintTemplate(t, contrato) {
  */
 exports.TEMPLATE_FASE_PADRAO = `---
 id: fase-padrao
-versao: 4
+versao: 5
 descricao: Prompt canonico de uma fase do ciclo GOAL..MASTER, com nomenclatura, modo de conducao, contexto da thread, memoria injetada e regras de evidencia.
 fases: [GOAL, PLAN, GO, CHECK, SHIP, MASTER]
 variaveis: [fase, thread, bloco, nome, ciclo_canonico, tag, blocos, pausas, linha_variante, regra_de_pausa, invariantes, slug, projeto_nome, projeto_abbrev, base_branch, base_commit, diretorio, trabalho, pedido, fecho_go, memoria_injetada, regras_de_evidencia]
@@ -307,6 +307,7 @@ Quando disponiveis, use ork_artifact_read/write para objetivo, plano e parecer,
 Decisao que voce tomar sem perguntar ao dono vai ao ledger por \`ork decisao registrar <thread>\` (no MCP, \`ork_decision_record\`, pois o sandbox do codex nao grava o ledger), com o que foi decidido, o porque, como mudar, o custo de reverter agora e depois, o criterio escrito, quem decidiu e a evidencia; e assim que ela chega ao dono no resumo, em vez de sumir na conversa.
 Artefato de autoria do agente nao e recibo oficial; cadastrar claim nao significa verifica-la.
 Para registrar produto, prefira ork_git_commit com HEAD atual e paths com claims; use ork_verify para verificacao real e ork_ship com HEADs fonte/destino conferidos para entrega. Commit local nao e SHIP; retorno incomplete exige reconciliar estado e remoto antes de repetir. Permissao para consultar nao concede essas operacoes: respeite a autorizacao nativa e os gates.
+Quando o MCP expuser \`ork_verify_status\`, chame \`ork_verify\` uma vez, guarde o \`rodadaId\` e consulte a mesma rodada a cada 30–60 s. Enquanto ela estiver na fila ou rodando, retenha apenas estado e lane atuais no contexto; nao repita o pedido nem copie payloads intermediarios. So avance com o veredito terminal verde; falha tipada ou veredito vermelho bloqueia o ciclo.
 Decisao do dono deve ser apresentada pela sessao condutora ao host; a sessao filha nao responde nem assume a identidade do dono.
 Preserve o perfil filho configurado: \`interactive\` concede consultas; \`worktree\` exige opt-in da instalacao e autoriza ferramentas exatas na WT validada, sem aprovar gates ou assumir o dono. Nao mude configuracao para contornar bloqueio.
 Consulte \`ork_git_status\` para HEADs reais e estado Git; use \`ork_git_commit\`, \`ork_verify\` e \`ork_ship\` pelos contratos do nucleo, sem Bash Git nem inventar SHAs. Use \`source.head\` como \`expectedHead\` do commit; consulte novamente apos commit e use \`source.head\`/\`destination.head\` como \`expectedSource\`/\`expectedDestination\` do SHIP. Base historica nao substitui a consulta atual. As regras Edit/deny sao permissoes nativas de ferramentas, nao sandbox de processos.
@@ -351,7 +352,7 @@ Falha de autenticação permanece impedimento; não troque provider, sandbox ou
 /** English counterpart of the canonical phase prompt. The pt-BR template above remains the source contract. */
 exports.TEMPLATE_FASE_PADRAO_EN = `---
 id: fase-padrao.en
-versao: 4
+versao: 5
 descricao: Canonical prompt for a GOAL..MASTER cycle phase, with naming, conduction mode, thread context, injected memory, and evidence rules.
 fases: [GOAL, PLAN, GO, CHECK, SHIP, MASTER]
 variaveis: [fase, thread, bloco, nome, ciclo_canonico, tag, blocos, pausas, linha_variante, regra_de_pausa, invariantes, slug, projeto_nome, projeto_abbrev, base_branch, base_commit, diretorio, trabalho, pedido, fecho_go, memoria_injetada, regras_de_evidencia]
@@ -366,6 +367,7 @@ When available, use ork_artifact_read/write for the goal, plan, and review, and
 Record every decision you make without asking the owner in the ledger with \`ork decisao registrar <thread>\` (or \`ork_decision_record\` in MCP because the Codex sandbox cannot write the ledger), including what was decided, why, how to change it, reversal cost now and later, the written criterion, who decided, and the evidence. This is how it reaches the owner in the summary instead of disappearing in the conversation.
 An agent-authored artifact is not an official receipt; registering a claim does not verify it.
 To record product changes, prefer ork_git_commit with the current HEAD and paths with claims; use ork_verify for real verification and ork_ship with checked source/destination HEADs for delivery. A local commit is not SHIP; an incomplete result requires reconciling state and remote before retrying. Permission to query does not grant those operations: respect native authorization and gates.
+When MCP exposes \`ork_verify_status\`, call \`ork_verify\` once, keep its \`rodadaId\`, and query that same round every 30–60 seconds. While queued or running, retain only the current state and lane in context; do not repeat the request or copy intermediate payloads. Continue only after a terminal green verdict; a typed failure or red verdict blocks the cycle.
 The conducting session presents an owner decision to the host; a child session neither answers nor assumes the owner's identity.
 Preserve the configured child profile: \`interactive\` grants queries; \`worktree\` requires installation opt-in and authorizes exact tools in the validated worktree, without approving gates or assuming the owner. Do not change configuration to bypass a block.
 Query \`ork_git_status\` for real HEADs and Git state; use \`ork_git_commit\`, \`ork_verify\`, and \`ork_ship\` through the core contracts, without Bash Git or invented SHAs. Use \`source.head\` as the commit \`expectedHead\`; query again after the commit and use \`source.head\`/\`destination.head\` as SHIP \`expectedSource\`/\`expectedDestination\`. A historical base does not replace the current query. Edit/deny rules are native tool permissions, not process sandbox rules.

package/dist/pulse.js

@@ -157,7 +157,8 @@ function comporPulse(carregado, entrada) {
             if (p.motivo === 'human.pending' && p.fonte === 'ledger' && entregas?.doCondutor.gates.has(`${l.thread}|${p.fase}`))
                 continue;
             if (ehRegistro(l.thread)) {
-                if (p.fonte === 'escalonador' || ['lease.busy', 'conducao.em-andamento', 'concurrency.limite', 'vaga.stale', 'runtime.silencio'].includes(p.motivo))
+                if (p.fonte === 'escalonador' || ['lease.busy', 'conducao.em-andamento', 'concurrency.limite', 'vaga.stale',
+                    'runtime.silencio', 'concurrency.lease-indeterminado', 'conducao.acao-necessaria'].includes(p.motivo))
                     continue;
                 const sessoes = radar.sessoes.filter(s => s.thread?.id === l.thread && s.thread.fase === p.fase);
                 // Escalada explícita de ledger não é apagada pela conclusão de uma sessão.
@@ -213,7 +214,8 @@ function comporPulse(carregado, entrada) {
                 }
             }
             // I-45: vaga parada e sinal do escalonador (`ork board reap` devolve a vaga), nao pergunta ao dono.
-            const esperaAutomatica = ['lease.busy', 'conducao.em-andamento', 'concurrency.limite', 'runtime.rate-limited', 'vaga.stale'].includes(p.motivo);
+            const esperaAutomatica = ['lease.busy', 'conducao.em-andamento', 'concurrency.limite', 'runtime.rate-limited', 'vaga.stale',
+                'concurrency.lease-indeterminado', 'conducao.acao-necessaria'].includes(p.motivo);
             (esperaAutomatica ? automaticas : humanos).push(item);
         }
     // RM-063 (F5): o MASTER por omissao da varredura nao vira item do dono (I-45: a entrega sem nota fica na faixa