@orkastery/cli 0.6.0 → 0.6.2

package/dist/noctum-retomada-rede.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CARENCIA_DA_RETOMADA_MS = void 0;
+exports.retomadaNaRede = retomadaNaRede;
+const maquina_1 = require("./maquina");
+const noctum_arco_1 = require("./noctum-arco");
+const noctum_coordenacao_1 = require("./noctum-coordenacao");
+const noctum_envelope_1 = require("./noctum-envelope");
+/** O cancelamento exige duas carências de batida: uma partição de 15 min não transfere trabalho. */
+exports.CARENCIA_DA_RETOMADA_MS = 2 * noctum_coordenacao_1.BATIDA_VENCIDA_MS;
+const idadeDoSinal = (estado, maquina, quando) => {
+    const sinal = estado.sinais.get(maquina);
+    return sinal ? Date.parse(quando) - Date.parse(sinal) : Number.POSITIVE_INFINITY;
+};
+const canceladasDestaMaquina = (estado, maquina) => [...estado.ordens.values()].filter(o => o.maquina === maquina && o.estado === 'isolada' && !!o.cancelada)
+    .map(o => ({ ordem: o.ordem, trabalho: o.trabalho }));
+/**
+ * Executa no máximo uma mudança de coordenação por chamada. Releituras e corridas continuam sob as trocas atômicas da N3;
+ * uma recusa tipada vira lacuna do tique, nunca estado vazio.
+ */
+function retomadaNaRede(carregado, arco, opcoes = {}) {
+    const quando = opcoes.quando ?? new Date().toISOString();
+    const local = (0, noctum_arco_1.lerArco)(carregado.raiz, arco, quando);
+    if (!local?.conteudo || !(0, noctum_envelope_1.envelopeMultimaquina)(local.conteudo)) {
+        return { aplicavel: false, acoes: [], canceladasLocais: [], lacuna: null };
+    }
+    const eu = (0, maquina_1.nomeDaMaquina)(opcoes.maquina);
+    const acoes = [];
+    try {
+        let estado = (0, noctum_coordenacao_1.lerCoordenacao)(carregado, arco, { ...opcoes, quando });
+        const cessao = estado.autoridade ? estado.cessoes.get(estado.autoridade.geracao) : null;
+        if (estado.autoridade && estado.autoridade.maquina !== eu && cessao?.para === eu && local.situacao === 'vigente') {
+            (0, noctum_coordenacao_1.assumirAutoridade)(carregado, arco, { ...opcoes, quando });
+            acoes.push('autoridade-assumida-por-cessao');
+            estado = (0, noctum_coordenacao_1.lerCoordenacao)(carregado, arco, { ...opcoes, quando });
+        }
+        else if (estado.autoridade && estado.autoridade.maquina !== eu && local.situacao === 'vigente' &&
+            idadeDoSinal(estado, estado.autoridade.maquina, quando) > noctum_coordenacao_1.BATIDA_VENCIDA_MS) {
+            (0, noctum_coordenacao_1.assumirAutoridade)(carregado, arco, { ...opcoes, quando,
+                forcar: { motivo: 'noctum.retomada.autoridade-sem-sinal' } });
+            acoes.push('autoridade-tomada-sem-sinal');
+            estado = (0, noctum_coordenacao_1.lerCoordenacao)(carregado, arco, { ...opcoes, quando });
+        }
+        if (estado.autoridade?.maquina === eu && local.situacao === 'encerrado') {
+            const para = (estado.vigente.conteudo.maquinas ?? []).filter(m => m.nome !== eu)
+                .map(m => ({ nome: m.nome, em: estado.sinais.get(m.nome) ?? '' }))
+                .sort((a, b) => Date.parse(b.em || '1970-01-01') - Date.parse(a.em || '1970-01-01'))[0];
+            if (para && !estado.cessoes.has(estado.autoridade.geracao)) {
+                (0, noctum_coordenacao_1.cederAutoridade)(carregado, arco, para.nome, 'noctum.retomada.cessao-no-encerramento', { ...opcoes, quando });
+                acoes.push(`autoridade-cedida:${para.nome}`);
+                estado = (0, noctum_coordenacao_1.lerCoordenacao)(carregado, arco, { ...opcoes, quando });
+            }
+        }
+        else if (estado.autoridade?.maquina === eu && local.situacao === 'vigente') {
+            const presa = new Map((estado.vigente.conteudo.trabalhos ?? []).map(t => [t.id, t.maquina ?? null]));
+            const ordem = [...estado.ordens.values()].find(o => o.maquina !== eu && (0, noctum_coordenacao_1.ordemViva)(o) && !o.cancelada &&
+                presa.get(o.trabalho) !== o.maquina && idadeDoSinal(estado, o.maquina, quando) > exports.CARENCIA_DA_RETOMADA_MS);
+            if (ordem) {
+                (0, noctum_coordenacao_1.cancelarOrdem)(carregado, arco, ordem.ordem, 'noctum.retomada.maquina-sem-sinal', { ...opcoes, quando });
+                acoes.push(`ordem-cancelada:${ordem.ordem}`);
+                estado = (0, noctum_coordenacao_1.lerCoordenacao)(carregado, arco, { ...opcoes, quando });
+            }
+        }
+        return { aplicavel: true, acoes, canceladasLocais: canceladasDestaMaquina(estado, eu), lacuna: null };
+    }
+    catch (e) {
+        if (!(e instanceof noctum_envelope_1.RecusaDoArco))
+            throw e;
+        return { aplicavel: true, acoes, canceladasLocais: [], lacuna: { motivo: e.motivo, detalhe: e.message } };
+    }
+}

package/dist/noctum-vigia.js

@@ -76,6 +76,7 @@ const maquina_1 = require("./maquina");
 const noctum_arco_1 = require("./noctum-arco");
 const noctum_envelope_1 = require("./noctum-envelope");
 const noctum_execucao_1 = require("./noctum-execucao");
+const noctum_maquinas_1 = require("./noctum-maquinas");
 const noctum_entrega_1 = require("./noctum-entrega");
 const noctum_reconciliacao_1 = require("./noctum-reconciliacao");
 const noctum_supervisao_1 = require("./noctum-supervisao");
@@ -85,6 +86,7 @@ const claude_bg_1 = require("./adapters/claude-bg");
 const runtime_profiles_1 = require("./runtime-profiles");
 const sessoes_contas_1 = require("./sessoes-contas");
 const noctum_sessoes_em_voo_1 = require("./noctum-sessoes-em-voo");
+const noctum_retomada_rede_1 = require("./noctum-retomada-rede");
 const thread_1 = require("./thread");
 const util_1 = require("./util");
 const ARQUIVO_DO_CONDUTOR = 'condutor.lock';
@@ -260,10 +262,24 @@ function passoConduzido(carregado, arco, quem, opcoes = {}) {
         (0, noctum_supervisao_1.gravarComEstado)(carregado, arco, (s) => s.parada ? [] : [{ tipo: 'parada', motivo: visao.parada.motivo, detalhe: visao.parada.detalhe }], quando);
         return { acao: 'parado', motivo: visao.parada.motivo, detalhe: visao.parada.detalhe };
     }
-    const r = (0, noctum_execucao_1.passoDoArco)(carregado, arco, { ...opcoes.passo, quando, maquina: opcoes.maquina ?? opcoes.passo?.maquina,
+    const opcoesDaN2 = { ...opcoes.passo, quando, maquina: opcoes.maquina ?? opcoes.passo?.maquina,
         ...(visao ? { perfis: () => visao.perfis } : {}),
         ...(conteudo && estado ? { alvos: (fase, runtime, modo) => (0, noctum_supervisao_1.alvosDaFase)(carregado, conteudo, estado, fase, runtime, modo) } : {}),
-        supervisao: decisoesDaSupervisao(sup, estado) });
+        supervisao: decisoesDaSupervisao(sup, estado) };
+    let r;
+    if (estado?.conteudo && (0, noctum_envelope_1.envelopeMultimaquina)(estado.conteudo)) {
+        const daMaquina = (0, noctum_maquinas_1.passoDaMaquina)(carregado, arco, { ...opcoes.coordenacao, quando, maquina: opcoesDaN2.maquina,
+            consultarSessoes: opcoesDaN2.consultarSessoes ?? opcoes.consultarRuntime, n2: opcoesDaN2 });
+        if (daMaquina.acao === 'aguardar') {
+            r = { acao: 'aguardar', ate: cadencia, motivo: daMaquina.motivo, fila: null, detalhe: daMaquina.detalhe, maquina: daMaquina.relatorio };
+        }
+        else {
+            r = { ...daMaquina.passo, ...(daMaquina.acao === 'passo' ? { maquina: daMaquina.relatorio } : {}) };
+        }
+    }
+    else {
+        r = (0, noctum_execucao_1.passoDoArco)(carregado, arco, opcoesDaN2);
+    }
     gravarEstadoDoPasso(carregado, arco, quem, r, quando);
     // N1 do CHECK 2: a baseline do trabalho que falhou sem ser espera isola o trabalho, com a causa: os outros seguem, e o
     // tique e o relatório dizem por quê.
@@ -285,7 +301,7 @@ function passoConduzido(carregado, arco, quem, opcoes = {}) {
     try {
         const entrega = (opcoes.entregar ?? noctum_entrega_1.passoDaEntrega)(carregado, arco, { maquina: opcoes.maquina ?? opcoes.passo?.maquina,
             lerReservas: opcoes.passo?.lerReservas, consultarSessoes: opcoes.passo?.consultarSessoes, ...(visao ? { perfis: () => visao.perfis } : {}),
-            ...opcoes.entrega, quando });
+            remoto: opcoes.coordenacao?.remoto, redeDaCoordenacao: opcoes.coordenacao?.rede, ...opcoes.entrega, quando });
         return { ...r, entrega };
     }
     catch (e) {
@@ -379,6 +395,7 @@ function vigiarArco(carregado, arco, opcoes = {}) {
         opcoes.depoisDeIniciar?.();
         const lacunas = [];
         const contagem = { reservas: 0, retomadas: 0, isolados: 0, contas: 0 };
+        let passoTerminal = null;
         if (sup.interrupcoesSeguidas >= parametros.interrupcoesQueParam && !sup.parada) {
             sup = (0, noctum_supervisao_1.gravarComEstado)(carregado, arco, (s) => s.parada ? [] : [{ tipo: 'parada', motivo: 'supervisor-falhou',
                     detalhe: `${s.interrupcoesSeguidas} tiques do vigia interrompidos em série (o limite é ${parametros.interrupcoesQueParam})` }], quando);
@@ -386,9 +403,22 @@ function vigiarArco(carregado, arco, opcoes = {}) {
         const estado = (0, noctum_arco_1.lerArco)(raiz, arco, quando);
         const conteudo = v2(estado);
         if (conteudo) {
+            const retomada = (0, noctum_retomada_rede_1.retomadaNaRede)(carregado, arco, { ...opcoes.coordenacao, quando,
+                maquina: opcoes.maquina ?? opcoes.passo?.maquina });
+            if (retomada.lacuna)
+                lacunas.push(`retomada na rede: ${retomada.lacuna.motivo}: ${retomada.lacuna.detalhe}`);
+            if (estado.conteudo && (0, noctum_envelope_1.envelopeMultimaquina)(estado.conteudo) && estado.situacao !== 'vigente' && estado.situacao !== 'agendado') {
+                const daMaquina = (0, noctum_maquinas_1.passoDaMaquina)(carregado, arco, { ...opcoes.coordenacao, quando,
+                    maquina: opcoes.maquina ?? opcoes.passo?.maquina, consultarSessoes: opcoes.passo?.consultarSessoes ?? opcoes.consultarRuntime,
+                    n2: opcoes.passo });
+                passoTerminal = daMaquina.acao === 'aguardar'
+                    ? { acao: 'aguardar', ate: new Date(Date.parse(quando) + parametros.cadenciaMs).toISOString(), motivo: daMaquina.motivo,
+                        fila: null, detalhe: daMaquina.detalhe, maquina: daMaquina.relatorio }
+                    : { ...daMaquina.passo, ...(daMaquina.acao === 'passo' ? { maquina: daMaquina.relatorio } : {}) };
+            }
             const store = (opcoes.lerStore ?? storePadrao(raiz))();
             aplicarContas(carregado, arco, conteudo, store, quando, contagem);
-            reconciliarSobATravaDeDespacho(carregado, arco, conteudo, parametros, quando, opcoes, lacunas, contagem);
+            reconciliarSobATravaDeDespacho(carregado, arco, conteudo, parametros, quando, opcoes, lacunas, contagem, retomada.canceladasLocais);
             for (const d of (0, noctum_reconciliacao_1.decidirPedidos)(raiz, arco, (0, noctum_arco_1.lerArco)(raiz, arco, quando))) {
                 (0, retry_1.cancelarPedido)(carregado, d.pedido, d.motivo);
                 (0, noctum_supervisao_1.gravarNaSupervisao)(carregado, arco, [{ tipo: 'pedido_tratado', pedido: d.pedido, thread: d.thread, acao: 'cancelado', motivo: d.motivo.slice(0, 200) }], quando);
@@ -407,7 +437,7 @@ function vigiarArco(carregado, arco, opcoes = {}) {
         sup = (0, noctum_supervisao_1.lerSupervisao)(raiz, arco);
         // D5: com a trava do condutor livre, este tique conduz: a geração do vigia, com a prova, e um passo.
         let condutor = 'sem-passo';
-        let passo = null;
+        let passo = passoTerminal;
         const vigente = (0, noctum_arco_1.lerArco)(raiz, arco, quando).situacao === 'vigente';
         if (!sup.parada && vigente && conteudo) {
             const fdCondutor = (0, fila_pesada_1.tentarTravaExclusiva)(path.join(dir, ARQUIVO_DO_CONDUTOR));
@@ -459,7 +489,7 @@ function vigiarArco(carregado, arco, opcoes = {}) {
  * com o instante da leitura; as reservas pendentes são decididas sobre o arco relido sob a trava (A3); e, com o arco
  * vigente e sem parada (A5), as sessões e as recusas repetidas. Com a trava ocupada, tudo fica para o tique seguinte.
  */
-function reconciliarSobATravaDeDespacho(carregado, arco, conteudo, parametros, quando, opcoes, lacunas, contagem) {
+function reconciliarSobATravaDeDespacho(carregado, arco, conteudo, parametros, quando, opcoes, lacunas, contagem, ordensCanceladas = []) {
     const { raiz } = carregado;
     const noctum = path.join((0, estado_thread_1.raizDoEstado)(raiz), '.orkastery', 'noctum');
     const fd = (0, fila_pesada_1.tentarTravaExclusiva)(path.join(noctum, 'despacho.lock'));
@@ -497,7 +527,7 @@ function reconciliarSobATravaDeDespacho(carregado, arco, conteudo, parametros, q
         }
         if (estado.situacao !== 'vigente' || sup.parada)
             return;
-        aplicarSessoes(carregado, arco, conteudo, leitura, quando, opcoes, lacunas, contagem, consultar);
+        aplicarSessoes(carregado, arco, conteudo, leitura, quando, opcoes, lacunas, contagem, consultar, ordensCanceladas);
         // B4 do CHECK: o trabalho que o núcleo recusa seguidas vezes pelo mesmo tipo de motivo (a árvore, a policy, o erro
         // antes de lançar) não volta a noite toda: no teto, e com a série durando ao menos uma cadência, é isolado. O soluço
         // mais curto que a cadência (a conferência de login inconclusiva da A14, que o núcleo refaz a cada despacho) não isola.
@@ -528,7 +558,7 @@ function aplicarContas(carregado, arco, conteudo, store, quando, contagem) {
  * listagem nova; sem confirmação, a parada fica no log como não confirmada e nada é autorizado (no teto das tentativas, o
  * trabalho é isolado). Confirmada, ou já morta, a sessão vira `sessao_morta` no ledger da thread e a retomada é autorizada.
  */
-function aplicarSessoes(carregado, arco, conteudo, leitura, quando, opcoes, lacunas, contagem, consultar) {
+function aplicarSessoes(carregado, arco, conteudo, leitura, quando, opcoes, lacunas, contagem, consultar, ordensCanceladas = []) {
     const { raiz } = carregado;
     const sup = (0, noctum_supervisao_1.lerSupervisao)(raiz, arco);
     const parametros = sup.parametros;
@@ -547,7 +577,17 @@ function aplicarSessoes(carregado, arco, conteudo, leitura, quando, opcoes, lacu
             registrarMorte(raiz, p.thread, p, prova);
         return confirmada ? prova : null;
     };
-    for (const d of (0, noctum_reconciliacao_1.decidirSessoes)(raiz, arco, conteudo, (0, noctum_arco_1.lerArco)(raiz, arco, quando), sup, leitura, quando)) {
+    const cancelados = new Set(ordensCanceladas.map(o => o.trabalho));
+    for (const s of (0, noctum_sessoes_em_voo_1.sessoesEmVooDoArco)(raiz, (0, noctum_arco_1.lerArco)(raiz, arco, quando)).filter(s => cancelados.has(s.trabalho))) {
+        if (!s.sessionId || !s.thread) {
+            lacunas.push(`trabalho ${s.trabalho}: a ordem foi cancelada, mas a sessão em voo não está identificada`);
+            continue;
+        }
+        const prova = pararEConferir({ sessionId: s.sessionId, runtime: s.runtime, perfil: s.conta, thread: s.thread }, 'ordem-cancelada', s.trabalho);
+        if (!prova)
+            lacunas.push(`${s.thread}: a parada da sessão ${s.sessionId} da ordem cancelada não foi confirmada pelo runtime`);
+    }
+    for (const d of (0, noctum_reconciliacao_1.decidirSessoes)(raiz, arco, conteudo, (0, noctum_arco_1.lerArco)(raiz, arco, quando), sup, leitura, quando, cancelados)) {
         if (d.acao === 'aguardar') {
             lacunas.push(`${d.thread}: ${d.detalhe}`);
             continue;

package/dist/parado-no-condutor.js

@@ -102,6 +102,7 @@ const session_watcher_claude_1 = require("./session-watcher-claude");
 const thread_1 = require("./thread");
 const util_1 = require("./util");
 const worktree_1 = require("./worktree");
+const merge_da_entrega_1 = require("./merge-da-entrega");
 exports.CONTRATO_PRS = 'ork.prs-abertos/v1';
 /** D4: duas batidas do pulse. Abaixo disto o condutor pode estar agindo. */
 exports.LIMIAR_PARADO_NO_CONDUTOR_MIN = 30;
@@ -783,20 +784,19 @@ function refsLocais(raiz, remoto) {
     }
     return mapa;
 }
-/** Os merges `ship(<thread>)` da base numa leitura so, do mais novo para o mais velho (fica o mais novo). */
-function mergesNaBase(raiz, baseRef) {
+/** Os merges das entregas da base numa leitura so, do mais novo para o mais velho (fica o mais novo). */
+function mergesNaBase(raiz, baseRef, base, threads) {
     const mapa = new Map();
     if (!baseRef)
         return mapa;
-    // Regex basica do git: o `(` e literal. A ref vem qualificada do `for-each-ref`.
-    const r = git(raiz, ['log', baseRef, '--first-parent', '--format=%H%x09%cI%x09%s', '--grep=^ship(']);
-    if (!r.ok)
-        return mapa;
-    for (const linha of r.stdout.split('\n')) {
-        const [sha, em, assunto] = linha.split('\t');
-        const m = /^ship\(([A-Za-z0-9._-]+)\)/.exec(assunto ?? '');
-        if (m && sha && SHA.test(sha) && !mapa.has(m[1]))
-            mapa.set(m[1], { sha, em: instante(em) });
+    const reconhecidos = (0, merge_da_entrega_1.mergesDasEntregasNaBase)(raiz, baseRef, base, threads.map((t) => ({
+        thread: t.id,
+        branch: (0, merge_da_entrega_1.branchRegistradaDaEntrega)(raiz, t.id) ?? (0, worktree_1.branchDaWorktree)(t),
+    })));
+    for (const t of threads) {
+        const merge = reconhecidos.get(t.id)?.[0];
+        if (merge)
+            mapa.set(t.id, { sha: merge.mergeSha, em: merge.em });
     }
     return mapa;
 }
@@ -857,7 +857,6 @@ function entregasDoProjeto(carregado, opcoes) {
     const refs = refsLocais(raiz, remoto);
     // A copia do remoto vem primeiro: a base local desta maquina pode estar parada (o merge e pelo GitHub).
     const baseRef = [`refs/remotes/${remoto}/${baseBranch}`, `refs/heads/${baseBranch}`].find((r) => refs.has(r)) ?? null;
-    const merges = mergesNaBase(raiz, baseRef);
     const sessoes = opcoes.sessoes ?? [];
     const threads = [];
     for (const id of (0, thread_1.listarIds)(raiz)) {
@@ -866,6 +865,7 @@ function entregasDoProjeto(carregado, opcoes) {
         }
         catch { /* thread ilegivel fica de fora */ }
     }
+    const merges = mergesNaBase(raiz, baseRef, baseBranch, threads);
     const fatos = threads.filter((t) => t.status !== 'fechada').map((t) => {
         let eventos = [];
         try {
@@ -1007,11 +1007,10 @@ function entregasDoProjeto(carregado, opcoes) {
                 desde = f.merge.em ?? fimEm;
                 peloGit = true;
                 passo = `registrar a entrega do merge ${f.merge.sha.slice(0, 7)} (ork ship registrar-pr ${t.id})`;
-                evidencia.push(`git log: merge ship(${t.id}) ${f.merge.sha.slice(0, 7)} na base, sem ship_done no ledger`);
+                evidencia.push(`git log: merge da entrega de ${t.id} ${f.merge.sha.slice(0, 7)} na base, sem ship_done no ledger`);
             }
             else if (!aberto && daBranch.mesclado && !f.entregueNaPonta && (daBranch.mesclado.mescladoEm ?? fimEm)) {
-                // N4 do CHECK (rodada 2): PR mesclado sem o assunto ship(<thread>); o `registrar-pr` nao o acha sozinho. Com o
-                // merge ship(<thread>) ainda sem registro na base (squash), o `registrar-pr` acha.
+                // N4 do CHECK (rodada 2): PR mesclado sem assunto ou branch reconhecivel; o `registrar-pr` nao o acha sozinho.
                 caso = 'sem-registro';
                 desde = daBranch.mesclado.mescladoEm ?? fimEm;
                 passo = f.merge && !f.mergeRegistrado ? `registrar a entrega do merge ${f.merge.sha.slice(0, 7)} (ork ship registrar-pr ${t.id})`

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/phase.js

@@ -73,6 +73,7 @@ const board_1 = require("./board");
 const verify_1 = require("./verify");
 const session_watcher_1 = require("./session-watcher");
 const session_watcher_claude_1 = require("./session-watcher-claude");
+const session_watcher_grok_1 = require("./session-watcher-grok");
 const manifest_1 = require("./manifest");
 const mcp_grafo_1 = require("./mcp-grafo");
 const runtimes_1 = require("./runtimes");
@@ -84,6 +85,7 @@ const ratelimit_1 = require("./ratelimit");
 const impedimento_1 = require("./impedimento");
 const claude_bg_1 = require("./adapters/claude-bg");
 const codex_1 = require("./adapters/codex");
+const grok_1 = require("./adapters/grok");
 const memoria_1 = require("./memoria");
 const prompts_1 = require("./prompts");
 const slug_1 = require("./slug");
@@ -183,8 +185,9 @@ function perfilParaDespacho(carregado, thread, fase, runtime, opcoes) {
         const escolha = escolherPerfil(raiz, runtime, { perfil: opcoes.perfil, excluir, politica, carga });
         if (escolha.erro || !escolha.perfil || opcoes.dryRun)
             return escolha;
+        // RM-067 (F3): o grok nao tem conferencia de login sem ler a credencial; o despacho prova o login (semConferencia).
         const auth = runtime === 'claude-bg' ? (0, claude_bg_1.conferirAuth)(escolha.perfil) : runtime === 'codex' ? (0, codex_1.conferirAuth)(escolha.perfil)
-            : { ok: false, detalhe: `runtime ${runtime} sem conferencia de login` };
+            : runtime === 'grok' ? (0, grok_1.conferirAuth)(escolha.perfil) : { ok: false, detalhe: `runtime ${runtime} sem conferencia de login` };
         if (auth.ok)
             return escolha;
         let motivo, razao;
@@ -477,6 +480,7 @@ function dadosDoDespacho(ctx, comando) {
         ...(ctx.identidade ? { identidade: ctx.identidade } : {}),
         // I-33 (D4): so identidade e diretorio do perfil; o store guarda o resto e nada e segredo.
         ...(ctx.perfil ? { perfil: ctx.perfil } : {}),
+        ...(ctx.perfilPedido ? { perfilPedido: ctx.perfilPedido } : {}),
         comando: comandoMascarado(comando, ctx.promptSha256),
     };
 }
@@ -554,7 +558,7 @@ sensores) {
     vincularConducaoDaSessao(ctx, sessionId);
     // I-51 (RM-047): as outras maquinas veem a fase nova; so com a fabrica compartilhada.
     (0, fabrica_publicar_1.publicarEmSegundoPlano)(ctx.raiz);
-    if (ctx.runtime === 'codex' || ctx.runtime === 'claude-bg')
+    if (ctx.runtime === 'codex' || ctx.runtime === 'claude-bg' || ctx.runtime === 'grok')
         registrarObservacao(ctx, sessao, dir, controlador, sensores);
     return sessao;
 }
@@ -590,9 +594,14 @@ function registrarObservacao(ctx, sessao, dir, controlador, sensores) {
         // I-34: claude-bg observa pela fonte nativa; no PLAN o registro guarda o sha de base do artefato.
         // I-33 (N1): o GO codex registra o HEAD do despacho, como a fonte claude-bg; ele revela commit pelo shell no checkpoint.
         const head = ctx.runtime === 'codex' && ctx.fase === 'GO' ? { head: ctx.headNoDespacho ?? null } : {};
-        const fonte = ctx.runtime === 'claude-bg' ? (0, session_watcher_claude_1.fonteClaudeDoDespacho)(ctx.raiz, ctx.thread.id, ctx.fase, ctx.cwd)
-            : sensores?.logPath ? { logPath: sensores.logPath, processoPath: sensores.processoPath, reciboPath: sensores.reciboPath, ...head }
-                : controlador ? { controlador, cwd: ctx.cwd, ...head } : null;
+        // RM-067 (F2, D8): o grok observa o stream e os recibos do supervisor; o HEAD do GO vem de antes do despacho.
+        // RM-067 (F3): a pasta da sessao mora na casa do perfil do despacho; sem perfil, na do processo.
+        const fonte = ctx.runtime === 'grok' ? (sensores?.logPath && sensores.processoPath && sensores.reciboPath
+            ? (0, session_watcher_grok_1.fonteGrokDoDespacho)(ctx.raiz, ctx.thread.id, ctx.fase, ctx.cwd, { logPath: sensores.logPath, processoPath: sensores.processoPath, reciboPath: sensores.reciboPath }, ctx.perfil ? (0, runtime_profiles_1.diretorioDoPerfil)(ctx.perfil) : (0, grok_1.casaDoGrok)(), { head: ctx.headNoDespacho, ...(ctx.artefatoNoDespacho !== undefined ? { artefato: ctx.artefatoNoDespacho } : {}) })
+            : null)
+            : ctx.runtime === 'claude-bg' ? (0, session_watcher_claude_1.fonteClaudeDoDespacho)(ctx.raiz, ctx.thread.id, ctx.fase, ctx.cwd)
+                : sensores?.logPath ? { logPath: sensores.logPath, processoPath: sensores.processoPath, reciboPath: sensores.reciboPath, ...head }
+                    : controlador ? { controlador, cwd: ctx.cwd, ...head } : null;
         if (!fonte)
             return;
         (0, session_watcher_1.prepararFonteWatcher)(ctx.raiz, sessao.sessionId, fonte);
@@ -904,6 +913,9 @@ tomadaPrevia) {
             }
         }
         const cwd = (0, procedencia_1.diretorioDaThread)(raiz, thread);
+        // O pedido explicito precisa sobreviver mesmo quando o despacho para antes de escolher ou abrir a conta.
+        // `perfil` continua sendo o destino efetivo; misturar os dois quebraria a rotacao por falha da propria conta.
+        const perfilPedido = opcoes.perfil !== undefined ? { id: opcoes.perfil, runtime } : undefined;
         // RM-063 (F3): o prompt vai ao disco e ao ledger, com o sha256, ANTES do contexto do runtime e do adaptador. No
         // incidente de 12/10/2026 a fase morreu no despacho e o `ork retry run` saiu com "nao ha despacho falho registrado
         // em GO com prompt gravado"; daqui em diante, toda tentativa deixa o prompt que o retry redespacha sem pedir o texto.
@@ -911,7 +923,8 @@ tomadaPrevia) {
         const promptNoLedger = { promptPath: path.relative(raiz, promptPath), promptSha256: sha };
         if (!opcoes.dryRun) {
             (0, ledger_1.registrar)(dir, thread.id, ledger_1.TIPOS_DE_EVENTO.promptGravado, { fase, slug, modo: thread.modo, runtime, model, effort, cwd,
-                ...promptNoLedger, origem: 'phase.run', canal, ...(opcoes.correlacao ? { correlacao: opcoes.correlacao } : {}), identidade });
+                ...promptNoLedger, origem: 'phase.run', canal, ...(opcoes.correlacao ? { correlacao: opcoes.correlacao } : {}), identidade,
+                ...(perfilPedido ? { perfilPedido } : {}) });
         }
         const correcaoDoRetry = `ork retry run ${thread.id} redespacha o mesmo prompt (sha256 ${sha.slice(0, 12)})`;
         let contextoRuntime;
@@ -921,7 +934,8 @@ tomadaPrevia) {
         catch (e) {
             const erro = `runtime.unavailable: ${e.message}`;
             (0, gates_1.registrarGateBloqueado)(dir, thread.id, { gate: 'phase.dispatch', motivo: 'runtime.unavailable',
-                modo: thread.modo, detalhe: erro, fase, slug, ...(opcoes.dryRun ? {} : { ...promptNoLedger, correcao: correcaoDoRetry }) });
+                modo: thread.modo, detalhe: erro, fase, slug, ...(opcoes.dryRun ? {} : { ...promptNoLedger, correcao: correcaoDoRetry }),
+                ...(perfilPedido ? { perfilPedido } : {}) });
             return { thread, slug, promptPath, promptSha256: sha, comando: [], sessionId: null,
                 verificada: false, pausaAoFim: (0, thread_1.pausaNaThread)(thread, fase), dryRun: opcoes.dryRun === true,
                 runtime, model, effort, bloqueado: true, motivo: 'runtime.unavailable', violacoes, erro };
@@ -940,16 +954,20 @@ tomadaPrevia) {
         }
         if (escolha.erro) {
             const motivo = escolha.motivo ?? 'runtime.unavailable';
-            const erro = `${motivo}: ${escolha.erro}`;
+            const erro = perfilPedido
+                ? (0, locale_1.textoDoCatalogo)((m) => m.retry.perfilPedidoRecusado(perfilPedido.id, perfilPedido.runtime, motivo, escolha.erro))
+                : `${motivo}: ${escolha.erro}`;
             if (!opcoes.dryRun) {
                 const semPerfil = { identidade, raiz, thread, fase, slug, promptPath, promptSha256: sha, runtime, cwd, model, effort,
-                    origem: 'phase.run', canal, correlacao: opcoes.correlacao ?? null };
+                    origem: 'phase.run', canal, correlacao: opcoes.correlacao ?? null, ...(perfilPedido ? { perfilPedido } : {}) };
                 (0, ledger_1.registrar)(dir, thread.id, ledger_1.TIPOS_DE_EVENTO.despachoFalhou, { ...dadosDoDespacho(semPerfil, []), erro });
                 (0, gates_1.registrarGateBloqueado)(dir, thread.id, { gate: 'phase.dispatch', motivo, modo: thread.modo, detalhe: erro,
-                    correcao: motivo === 'cost.violation'
-                        ? 'refaca o login do perfil pela assinatura (claude auth login --claudeai ou codex login com ChatGPT) e rode ork accounts check; perfil de provider pago nunca despacha'
-                        : 'ork accounts list mostra o estado de cada perfil; ork retry run segue pela ordem de fallback ou pela fila',
-                    fase, slug, runtime, origem: 'phase.run' });
+                    correcao: perfilPedido
+                        ? (0, locale_1.textoDoCatalogo)((m) => m.retry.correcaoDoPerfilPedido(perfilPedido.id, perfilPedido.runtime, motivo, thread.id))
+                        : motivo === 'cost.violation'
+                            ? 'refaca o login do perfil pela assinatura (claude auth login --claudeai ou codex login com ChatGPT) e rode ork accounts check; perfil de provider pago nunca despacha'
+                            : 'ork accounts list mostra o estado de cada perfil; ork retry run segue pela ordem de fallback ou pela fila',
+                    fase, slug, runtime, origem: 'phase.run', ...promptNoLedger, ...(perfilPedido ? { perfilPedido } : {}) });
             }
             return { thread, slug, promptPath, promptSha256: sha, comando: [], sessionId: null,
                 verificada: false, pausaAoFim: (0, thread_1.pausaNaThread)(thread, fase), dryRun: opcoes.dryRun === true,
@@ -986,8 +1004,10 @@ tomadaPrevia) {
         const claimsSchema = fase === 'GO' && runtime === 'codex'
             ? schemaDeClaimsDoPacote()
             : undefined;
-        // I-33 (N1): lido antes de a sessao existir; depois dela, um commit rapido ja estaria no HEAD.
-        const headNoDespacho = fase === 'GO' && runtime === 'codex' && !opcoes.dryRun ? (0, session_watcher_claude_1.headDaWorktree)(cwd) : undefined;
+        // I-33 (N1): lido antes de a sessao existir; depois dela, um commit rapido ja estaria no HEAD. RM-067: o grok tambem.
+        const headNoDespacho = fase === 'GO' && (runtime === 'codex' || runtime === 'grok') && !opcoes.dryRun ? (0, session_watcher_claude_1.headDaWorktree)(cwd) : undefined;
+        // RM-067 (D8): a base do artefato do grok tambem sai antes do despacho, que espera a pasta da sessao.
+        const artefatoNoDespacho = runtime === 'grok' && !opcoes.dryRun ? (0, session_watcher_grok_1.baseDoArtefato)(raiz, thread.id, fase) : undefined;
         const pedidoAoRuntime = {
             prompt,
             nome: slug,
@@ -1028,7 +1048,9 @@ tomadaPrevia) {
             effort,
             origem: 'phase.run',
             ...(perfil ? { perfil } : {}),
+            ...(perfilPedido ? { perfilPedido } : {}),
             ...(headNoDespacho !== undefined ? { headNoDespacho } : {}),
+            ...(artefatoNoDespacho !== undefined ? { artefatoNoDespacho } : {}),
         };
         let resultado;
         try {
@@ -1042,6 +1064,7 @@ tomadaPrevia) {
                 (0, ledger_1.registrar)(dir, thread.id, ledger_1.TIPOS_DE_EVENTO.despachoFalhou, { ...dadosDoDespacho(ctx, []), erro });
                 (0, gates_1.registrarGateBloqueado)(dir, thread.id, { gate: 'phase.dispatch', motivo: 'runtime.unavailable', modo: thread.modo,
                     detalhe: erro, correcao: correcaoDoRetry, fase, slug, runtime, origem: 'phase.run', ...promptNoLedger,
+                    ...(perfilPedido ? { perfilPedido } : {}),
                     evidencia: 'excecao real do runtime adapter no despacho, nao relato do agente' });
             }
             throw e;
@@ -1091,6 +1114,7 @@ tomadaPrevia) {
                 (0, gates_1.registrarGateBloqueado)(dir, thread.id, { gate: 'phase.dispatch', motivo: falha.motivo, modo: thread.modo, detalhe: erro,
                     correcao: 'ork retry run rotaciona para o proximo perfil, para o runtime de fallback ou para a fila', fase, slug,
                     runtime, origem: 'phase.run', falhaDeConta: falha, ...(perfil ? { perfil } : {}),
+                    ...(perfilPedido ? { perfilPedido } : {}),
                     evidencia: 'saida real do runtime adapter no despacho, nao relato do agente' });
                 return { thread, slug, promptPath, promptSha256: sha, comando: resultado.comando, controlador: resultado.controlador,
                     sessionId: null, verificada: false, pausaAoFim, dryRun: false, runtime, model, effort, bloqueado: false,
@@ -1122,6 +1146,9 @@ tomadaPrevia) {
                     detalhe: erro,
                     // RM-058 N4 (D17 da ork-rm058n4): o pedido do despacho do arco é do vigia do arco, e o `ork retry resume` não o retoma.
                     ...(opcoes.correlacao ? { correlacao: opcoes.correlacao } : {}),
+                    // RM-067 (GO-FIX 1, A1): o pedido do grok volta pelo grok, com o modelo dele; o dos outros runtimes segue como antes.
+                    ...(runtime === 'grok' ? { runtime } : {}),
+                    ...(perfilPedido ? { runtime, perfil: perfilPedido.id, perfilPedido } : {}),
                 });
                 (0, ledger_1.registrar)(dir, thread.id, ledger_1.TIPOS_DE_EVENTO.rateLimitEnfileirado, {
                     fase,
@@ -1167,6 +1194,7 @@ tomadaPrevia) {
             // a registrava: o `ork retry plan` nao a via e a fase ficava parada sem ninguem saber.
             (0, gates_1.registrarGateBloqueado)(dir, thread.id, { gate: 'phase.dispatch', motivo: 'runtime.unavailable', modo: thread.modo,
                 detalhe: erro, correcao: correcaoDoRetry, fase, slug, runtime, origem: 'phase.run', ...promptNoLedger, ...daSessao,
+                ...(perfilPedido ? { perfilPedido } : {}),
                 evidencia: 'saida real do runtime adapter no despacho, nao relato do agente' });
             return {
                 thread,

package/dist/postura-local.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.POSTURAS_QUE_AFROUXAM = exports.ARQUIVO_POSTURA_LOCAL = exports.CONTRATO_POSTURA_LOCAL = void 0;
+exports.RUNTIMES_COM_POSTURA = exports.POSTURAS_QUE_AFROUXAM = exports.ARQUIVO_POSTURA_LOCAL = exports.CONTRATO_POSTURA_LOCAL = void 0;
 exports.pastaPrivadaDaPostura = pastaPrivadaDaPostura;
 exports.caminhoDaPosturaLocal = caminhoDaPosturaLocal;
 exports.posturaAfrouxada = posturaAfrouxada;
@@ -154,13 +154,17 @@ function lerPosturaLocal(raiz) {
         return { postura: null, motivo: 'a confirmação local é de outro checkout' };
     return { postura: o, motivo: null };
 }
+/**
+ * Os runtimes que recebem a postura de sandbox do manifesto: o Codex e, desde a F4 da RM-067, o `grok`, em que a postura
+ * mais frouxa vira o perfil `off` (sem sandbox). O `claude-bg` não recebe a postura.
+ */
+exports.RUNTIMES_COM_POSTURA = ['codex', 'grok'];
 /**
  * A recusa do despacho: `null` quando a postura do manifesto vale nesta máquina (não afrouxa, ou
  * foi confirmada localmente com o mesmo valor); senão o erro tipado com o comando que confirma.
- * Só o Codex recebe a postura de sandbox do manifesto.
  */
 function recusaDePostura(raiz, manifesto, runtime) {
-    if (runtime !== 'codex')
+    if (!exports.RUNTIMES_COM_POSTURA.includes(runtime))
         return null;
     const postura = posturaAfrouxada(manifesto);
     if (!postura)