@orkastery/cli 0.6.4 → 0.6.5

package/dist/manifest.js

@@ -257,6 +257,197 @@ function lerCheck(v, erros, avisos) {
 }
 /** Nome de lane: o que vira `test:<lane>` no ledger. */
 const NOME_DE_LANE = /^[a-z0-9][a-z0-9-]{0,31}$/;
+/** RM-081 F1: o relatorio e sempre um caminho POSIX relativo, nunca uma busca ou um caminho da maquina. */
+function caminhoJUnit(chave, v, erros) {
+    if (typeof v !== 'string' || !v.trim()) {
+        erros.push(`${chave} precisa ser um caminho relativo, em texto`);
+        return undefined;
+    }
+    const bruto = v.trim();
+    const normal = path.posix.normalize(bruto);
+    if (bruto.includes('\\') || bruto.includes('\0') || path.posix.isAbsolute(bruto) || path.win32.isAbsolute(bruto)
+        || normal === '.' || normal === '..' || normal.startsWith('../')) {
+        erros.push(`${chave}: ${exibir(v)} precisa ser um caminho relativo dentro da worktree`);
+        return undefined;
+    }
+    return normal;
+}
+/** RM-081 F3: o runner recebe a lista somente no marcador fechado, uma vez. */
+function filtroDoComando(chave, v, erros) {
+    if (v === undefined || v === null)
+        return undefined;
+    if (typeof v !== 'string' || !v.trim()) {
+        erros.push(`${chave} precisa ser um comando em texto com o marcador {testes}`);
+        return undefined;
+    }
+    const filtro = v.trim();
+    const marcadores = filtro.match(/\{testes\}/g)?.length ?? 0;
+    if (marcadores !== 1) {
+        erros.push(`${chave} precisa ter o marcador {testes} exatamente uma vez`);
+        return undefined;
+    }
+    return filtro;
+}
+/** RM-081 F5: caminho ou glob POSIX relativo, sem sair da worktree nem alcançar estado do nucleo. */
+function caminhoDaSelecao(chave, v, erros) {
+    if (typeof v !== 'string' || !v.trim()) {
+        erros.push(`${chave} precisa ser um caminho ou glob relativo, em texto`);
+        return undefined;
+    }
+    const bruto = v.trim().replace(/\/+$/, '');
+    const normal = path.posix.normalize(bruto);
+    if (!bruto || bruto.includes('\\') || bruto.includes('\0') || path.posix.isAbsolute(bruto)
+        || path.win32.isAbsolute(bruto) || normal === '.' || normal === '..' || normal.startsWith('../')
+        || /^(\.orkastery|\.git)(\/|$)/.test(normal)) {
+        erros.push(`${chave}: ${exibir(v)} precisa ficar dentro da worktree, fora de .orkastery e .git`);
+        return undefined;
+    }
+    return normal;
+}
+/** RM-081 F5: o manifesto declara o mecanismo e a superficie que o runner sabe relacionar. */
+function selecaoDoComando(chave, v, erros) {
+    if (v === undefined || v === null)
+        return undefined;
+    if (typeof v !== 'object' || Array.isArray(v)) {
+        erros.push(`${chave} precisa ser um mapa com comando, mapeia e configuracao opcional`);
+        return undefined;
+    }
+    for (const nome of Object.keys(v)) {
+        if (!['comando', 'mapeia', 'configuracao'].includes(nome)) {
+            erros.push(`${chave}.${nome} desconhecida; use somente comando, mapeia e configuracao`);
+        }
+    }
+    const comando = typeof v.comando === 'string' ? v.comando.trim() : '';
+    const bases = comando.match(/\{base\}/g)?.length ?? 0;
+    const arquivos = comando.match(/\{arquivos\}/g)?.length ?? 0;
+    if (!comando || bases + arquivos !== 1) {
+        erros.push(`${chave}.comando precisa ter exatamente um marcador {base} ou {arquivos}`);
+    }
+    const lista = (nome) => {
+        const valor = v[nome];
+        if (valor === undefined || valor === null)
+            return [];
+        const itens = Array.isArray(valor) ? valor : [valor];
+        return itens.flatMap((item, indice) => {
+            const lido = caminhoDaSelecao(`${chave}.${nome}[${indice}]`, item, erros);
+            return lido ? [lido] : [];
+        });
+    };
+    const mapeia = lista('mapeia');
+    const configuracao = lista('configuracao');
+    return comando && bases + arquivos === 1
+        ? { comando, mapeia, ...(configuracao.length ? { configuracao } : {}) }
+        : undefined;
+}
+/** RM-081 F2: uma unica estrategia, fechada e validada antes de qualquer teste rodar. */
+function relogioDoComando(chave, v, erros) {
+    if (v === undefined || v === null)
+        return undefined;
+    if (typeof v !== 'object' || Array.isArray(v)) {
+        erros.push(`${chave} precisa ser um mapa com exatamente uma de nome, marcador ou tag`);
+        return undefined;
+    }
+    const conhecidas = ['nome', 'marcador', 'tag'];
+    for (const nome of Object.keys(v)) {
+        if (!conhecidas.includes(nome))
+            erros.push(`${chave}.${nome} desconhecida; use somente nome, marcador ou tag`);
+    }
+    const presentes = conhecidas.filter((nome) => v[nome] !== undefined && v[nome] !== null);
+    if (presentes.length !== 1) {
+        erros.push(`${chave} precisa declarar exatamente uma de nome, marcador ou tag`);
+        return undefined;
+    }
+    const estrategia = presentes[0];
+    if (estrategia === 'nome') {
+        const valores = Array.isArray(v.nome) ? v.nome : [v.nome];
+        const padroes = valores.flatMap((item) => typeof item === 'string' && item.trim() ? [item.trim()] : []);
+        if (padroes.length !== valores.length || padroes.length === 0 || padroes.length > 20) {
+            erros.push(`${chave}.nome precisa ter de 1 a 20 expressoes regulares em texto`);
+            return undefined;
+        }
+        for (const padrao of padroes) {
+            try {
+                void new RegExp(padrao);
+            }
+            catch {
+                erros.push(`${chave}.nome contem expressao regular invalida: ${exibir(padrao)}`);
+                return undefined;
+            }
+        }
+        return { nome: padroes };
+    }
+    const valor = v[estrategia];
+    if (typeof valor !== 'string' || !valor.trim()) {
+        erros.push(`${chave}.${estrategia} precisa ser texto nao vazio`);
+        return undefined;
+    }
+    return estrategia === 'marcador' ? { marcador: valor.trim() } : { tag: valor.trim() };
+}
+/** RM-081 F4: recursos da lane sao nomes locais a rodada, unicos e de uma linha. */
+function recursosDoComando(chave, v, erros) {
+    if (v === undefined)
+        return undefined;
+    if (!Array.isArray(v) || v.length === 0) {
+        erros.push(`${chave} precisa ser uma lista nao vazia de textos`);
+        return undefined;
+    }
+    const lidos = [];
+    let valido = true;
+    for (const recurso of v) {
+        if (typeof recurso !== 'string' || !recurso.trim() || recurso.trim().length > 80 || /[\r\n]/.test(recurso)) {
+            erros.push(`${chave}: ${exibir(recurso)} precisa ser texto de uma linha, de 1 a 80 caracteres`);
+            valido = false;
+        }
+        else if (lidos.includes(recurso.trim())) {
+            erros.push(`${chave}: ${exibir(recurso.trim())} esta repetido`);
+            valido = false;
+        }
+        else
+            lidos.push(recurso.trim());
+    }
+    return valido ? lidos : undefined;
+}
+/** Texto continua sendo o contrato legado; o objeto exige comando e aceita os opt-ins da superficie. */
+function lerComando(chave, v, erros, aceitaSelecao = false, aceitaRecursos = false) {
+    if (v === undefined || v === null)
+        return {};
+    if (typeof v === 'string')
+        return { comando: v };
+    if (typeof v !== 'object' || Array.isArray(v)) {
+        erros.push(`${chave} precisa ser o comando em texto ou um mapa com comando (recebido ${exibir(v)})`);
+        return {};
+    }
+    const conhecidas = ['comando', 'junit', 'filtro', 'relogio', ...(aceitaSelecao ? ['selecao'] : []),
+        ...(aceitaRecursos ? ['recursos'] : [])];
+    for (const nome of Object.keys(v)) {
+        if (!conhecidas.includes(nome)) {
+            erros.push(`${chave}.${nome} desconhecida; use somente ${conhecidas.join(', ')}`);
+        }
+    }
+    const comando = typeof v.comando === 'string' && v.comando.trim() ? v.comando.trim() : undefined;
+    if (!comando)
+        erros.push(`${chave}.comando precisa ser texto nao vazio`);
+    const junit = v.junit === undefined ? undefined : caminhoJUnit(`${chave}.junit`, v.junit, erros);
+    const dispensaJUnit = aceitaRecursos && v.recursos !== undefined && v.recursos !== null;
+    if (v.junit === undefined) {
+        const dependencias = ['filtro', 'relogio']
+            .filter((dependencia) => v[dependencia] !== undefined && v[dependencia] !== null);
+        for (const dependencia of dependencias) {
+            if (v[dependencia] !== undefined && v[dependencia] !== null) {
+                erros.push(`${chave}.junit precisa ser declarado porque ${chave}.${dependencia} depende do relatorio JUnit`);
+            }
+        }
+        if (!dependencias.length && !dispensaJUnit) {
+            erros.push(`${chave}.junit precisa ser declarado no objeto de comando`);
+        }
+    }
+    const filtro = filtroDoComando(`${chave}.filtro`, v.filtro, erros);
+    const relogio = relogioDoComando(`${chave}.relogio`, v.relogio, erros);
+    const selecao = aceitaSelecao ? selecaoDoComando(`${chave}.selecao`, v.selecao, erros) : undefined;
+    const recursos = aceitaRecursos ? recursosDoComando(`${chave}.recursos`, v.recursos, erros) : undefined;
+    return { ...(comando ? { comando } : {}), ...(junit ? { junit } : {}), ...(filtro ? { filtro } : {}),
+        ...(relogio ? { relogio } : {}), ...(selecao ? { selecao } : {}), ...(recursos ? { recursos } : {}) };
+}
 /**
  * RM-072 (D3): o bloco `check.agile`. Cada chave liga uma peca do Agile; tipo errado e erro do manifesto, porque uma
  * peca mal escrita que sumisse em silencio mudaria o que o CHECK roda. `produto` so aceita caminho relativo dentro da
@@ -302,16 +493,42 @@ function lerAgile(v, erros, avisos) {
         }
         else {
             const lanes = {};
-            for (const [lane, comando] of Object.entries(v.test)) {
+            const junit = {};
+            const filtro = {};
+            const relogio = {};
+            const selecao = {};
+            const recursos = {};
+            for (const [lane, valor] of Object.entries(v.test)) {
                 if (!NOME_DE_LANE.test(lane))
                     erros.push(`check.agile.test.${lane}: nome de lane aceita [a-z0-9-], ate 32 caracteres`);
-                else if (typeof comando !== 'string' || !comando.trim())
-                    erros.push(`check.agile.test.${lane} precisa ser o comando, em texto`);
-                else
-                    lanes[lane] = comando.trim();
+                else {
+                    const lido = lerComando(`check.agile.test.${lane}`, valor, erros, true, true);
+                    if (lido.comando)
+                        lanes[lane] = lido.comando.trim();
+                    if (lido.junit)
+                        junit[lane] = lido.junit;
+                    if (lido.filtro)
+                        filtro[lane] = lido.filtro;
+                    if (lido.relogio)
+                        relogio[lane] = lido.relogio;
+                    if (lido.selecao)
+                        selecao[lane] = lido.selecao;
+                    if (lido.recursos)
+                        recursos[lane] = lido.recursos;
+                }
             }
             if (Object.keys(lanes).length)
                 agile.test = lanes;
+            if (Object.keys(junit).length)
+                agile.junit = junit;
+            if (Object.keys(filtro).length)
+                agile.filtro = filtro;
+            if (Object.keys(relogio).length)
+                agile.relogio = relogio;
+            if (Object.keys(selecao).length)
+                agile.selecao = selecao;
+            if (Object.keys(recursos).length)
+                agile.recursos = recursos;
         }
     }
     if (v.apos_a_varredura !== undefined && v.apos_a_varredura !== null) {
@@ -666,6 +883,14 @@ function carregarManifesto(dirInicial = diretorioDoProjeto()) {
             '(esperado nome de branch do git, sem "-" no começo e sem "..")');
     }
     const verify = mapa(dados.verify);
+    const comandosVerify = Object.fromEntries(['build', 'test', 'typecheck', 'security_scan']
+        .map((nome) => [nome, lerComando(`verify.${nome}`, verify[nome], erros)]));
+    const junitVerify = Object.fromEntries(Object.entries(comandosVerify)
+        .flatMap(([nome, lido]) => lido.junit ? [[nome, lido.junit]] : []));
+    const filtroVerify = Object.fromEntries(Object.entries(comandosVerify)
+        .flatMap(([nome, lido]) => lido.filtro ? [[nome, lido.filtro]] : []));
+    const relogioVerify = Object.fromEntries(Object.entries(comandosVerify)
+        .flatMap(([nome, lido]) => lido.relogio ? [[nome, lido.relogio]] : []));
     const ci = mapa(dados.ci);
     const concurrency = mapa(dados.concurrency);
     const handoff = mapa(dados.handoff);
@@ -879,15 +1104,14 @@ function carregarManifesto(dirInicial = diretorioDoProjeto()) {
             ...dependenciasDaWorktree(worktree.dependencias, erros),
         },
         verify: {
-            build: verify.build === null || verify.build === undefined ? undefined : texto(verify.build, ''),
-            test: verify.test === null || verify.test === undefined ? undefined : texto(verify.test, ''),
+            build: comandosVerify.build.comando,
+            test: comandosVerify.test.comando,
             ...prazosDoVerify(verify, erros),
-            typecheck: verify.typecheck === null || verify.typecheck === undefined
-                ? undefined
-                : texto(verify.typecheck, ''),
-            security_scan: verify.security_scan === null || verify.security_scan === undefined
-                ? undefined
-                : texto(verify.security_scan, ''),
+            typecheck: comandosVerify.typecheck.comando,
+            security_scan: comandosVerify.security_scan.comando,
+            ...(Object.keys(junitVerify).length ? { junit: junitVerify } : {}),
+            ...(Object.keys(filtroVerify).length ? { filtro: filtroVerify } : {}),
+            ...(Object.keys(relogioVerify).length ? { relogio: relogioVerify } : {}),
             // I-54 (RM-037, D10): o preparo unico da rodada de verify, quando declarado.
             ...(typeof verify.preparo === 'string' && verify.preparo.trim() ? { preparo: verify.preparo.trim() } : {}),
         },

package/dist/retry.js

@@ -117,6 +117,8 @@ const postura_local_1 = require("./postura-local");
 const locale_1 = require("./locale");
 const locale_retry_1 = require("./locale-retry");
 const retomada_checkpoint_1 = require("./retomada-checkpoint");
+const codex_task_complete_1 = require("./codex-task-complete");
+const session_events_1 = require("./session-events");
 /** RM-061 (F2b, D3): `porque` e `correcao` de cada motivo tem a fonte no catalogo pt-BR; o `--json` nao muda. */
 const TEXTOS_DA_POLITICA = locale_retry_1.RETRY_PT_BR.politica;
 /**
@@ -385,6 +387,31 @@ function blocoPausa(thread, fase) {
 function estadoTerminalDeRetry(estado) {
     return ['completed', 'failed', 'stopped', 'cancelled', 'interrupted', 'terminated'].includes(estado.trim().toLowerCase());
 }
+/** Prova estreita: somente o rollout fixado da sessão Codex que originou o gate da fase. */
+function faseJaTerminouPorTaskComplete(raiz, thread, fase, evento) {
+    const candidata = [...thread.sessoes].reverse().find(s => s.runtime === 'codex' && s.fase === fase &&
+        typeof s.despachadaEm === 'string' && (typeof evento?.sessionId !== 'string' || s.sessionId === evento.sessionId) &&
+        (typeof evento?.despachoEm !== 'string' || s.despachadaEm === evento.despachoEm));
+    if (!candidata)
+        return false;
+    try {
+        const prova = (0, codex_task_complete_1.taskCompleteFixadoDaSessao)(raiz, thread, (0, session_events_1.exigirSessaoDespachada)(candidata, candidata.sessionId), (0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, thread.id)));
+        // task_complete encerra o turno, mas pode carregar uma falha estruturada de runtime.
+        // Só o resultado que concluiu a fase impede nova tentativa; cota/auth/modelo mantêm
+        // a política tipada de recuperação já existente.
+        return prova?.terminal.classificacao === 'fase_concluida';
+    }
+    catch {
+        return false;
+    }
+}
+function planoProtegidoPorTaskComplete(thread, fase, limite, effort) {
+    return { thread: thread.id, modo: thread.modo, fase, motivo: null,
+        detalhe: 'rollout autenticado da sessão despachada já contém task_complete', politica: null,
+        acao: 'sem-retry', tentativas: 0, limite, effort, effortAnterior: effort, automatica: false,
+        bloqueio: 'gate.sem-reprovacao',
+        razao: 'rollout autenticado já contém task_complete; a fase terminou e não será redespachada' };
+}
 /**
  * Calcula o plano de retry SEM executar nada.
  *
@@ -417,6 +444,8 @@ function planejarRetry(carregado, threadId, opcoes = {}) {
         };
     }
     const fase = opcoes.fase ?? (evento ? faseDoEvento(evento, thread) : thread.faseAtual);
+    if (faseJaTerminouPorTaskComplete(raiz, thread, fase, evento))
+        return planoProtegidoPorTaskComplete(thread, fase, limite, effortBase);
     const politica = politicaDoMotivo(motivo);
     const tentativas = tentativasFeitas(raiz, threadId, fase, motivo);
     const detalhe = evento && typeof evento.detalhe === 'string' ? evento.detalhe : '';
@@ -1429,6 +1458,12 @@ function executarRetry(carregado, threadId, opcoes = {}) {
         }
     }
     const thread = (0, thread_1.lerThread)(raiz, threadId);
+    // D4: reconfirma imediatamente antes do primeiro efeito do retry; o plano anterior pode ter
+    // sido calculado enquanto o runtime ainda anexava o terminal ao rollout.
+    if (plano.motivo !== null && plano.fase &&
+        faseJaTerminouPorTaskComplete(raiz, thread, plano.fase, ultimaReprovacao(raiz, threadId))) {
+        plano = planoProtegidoPorTaskComplete(thread, plano.fase, plano.limite, plano.effortAnterior);
+    }
     const dir = (0, thread_1.dirThread)(raiz, threadId);
     const vazio = {
         plano,

package/dist/session-watcher-claude.js

@@ -70,6 +70,7 @@ const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const node_crypto_1 = require("node:crypto");
 const claude_bg_1 = require("./adapters/claude-bg");
+const codex_events_1 = require("./adapters/codex-events");
 const ratelimit_1 = require("./ratelimit");
 const runtime_profiles_1 = require("./runtime-profiles");
 const codex_runner_1 = require("./adapters/codex-runner");
@@ -181,27 +182,19 @@ function classificarSessaoClaude(e) {
     const bloqueio = (fonte, motivo = 'runtime.unavailable', conclusaoNativa = false) => ({ terminal: true, classificacao: 'gate_blocked', motivo, fonte, conclusaoNativa, stop });
     // D12: o `done` classifica o texto final do agente; a fase só conclui com a prova do `ork`.
     const concluir = (sinal, conclusaoNativa) => {
+        // RM-075: indisponibilidade da tela não fabrica espera humana. Só uma pergunta
+        // efetivamente lida pode produzir human.pending.
+        const perguntaReal = e.perguntaReal?.() ?? false;
+        if (perguntaReal)
+            return { ...bloqueio(`${sinal}; a mensagem final pergunta ao humano`, 'human.pending', conclusaoNativa),
+                perguntaReal, dependeDoStop: true, diagnostico: 'a mensagem final pede uma resposta humana' };
         const prova = e.prova();
         const c = !prova.ok
             ? { ...bloqueio(`${sinal}; sem prova do ork: ${prova.fonte}`, prova.motivo ?? 'human.pending', conclusaoNativa),
                 diagnostico: `sem prova do ork: ${prova.fonte}` }
             : e.pausaAoFim ? bloqueio(`${sinal}; ${prova.fonte}; pausa prevista ao fim do bloco`, 'human.pending', conclusaoNativa)
                 : { terminal: true, classificacao: 'fase_concluida', motivo: null, fonte: `${sinal}; ${prova.fonte}`, conclusaoNativa, stop };
-        return { ...c, dependeDoStop: true };
-    };
-    // RM-037 (defeitosdeco D-1): turno encerrado pelo Stop e sessão viva em `blocked` é o Claude Code
-    // dizendo que o texto final pediu resposta. Nunca conclui direto, e a pausa humana abre sempre
-    // (`human.pending`): GO-FIX (R6 do CHECK), sem a prova o motivo também é o humano, porque um
-    // `artifact.missing` automático abriria correção sobre uma sessão viva que espera resposta.
-    const esperaHumana = () => {
-        const sinal = 'Stop correlacionado e sessão viva à espera humana (blocked)';
-        const prova = e.prova();
-        const c = !prova.ok
-            ? { ...bloqueio(`${sinal}; sem prova do ork: ${prova.fonte}; o humano decide`, 'human.pending'),
-                diagnostico: `a sessão espera resposta humana (blocked) e a fase ainda não tem a prova do ork: ${prova.fonte}` }
-            : { ...bloqueio(`${sinal}; ${prova.fonte}; o humano decide`, 'human.pending'),
-                diagnostico: 'a fase tem a prova do ork e a sessão espera resposta humana (blocked): o humano decide' };
-        return { ...c, dependeDoStop: true };
+        return { ...c, perguntaReal, dependeDoStop: true };
     };
     const venceu = (desde) => agora - desde >= e.limiteMs;
     // Sem prova para concluir nem para bloquear: `runtime.unavailable` reexecutaria o mesmo prompt
@@ -276,7 +269,7 @@ function classificarSessaoClaude(e) {
                 cursor.bloqueadoDesde ??= agora;
                 if (agora - cursor.bloqueadoDesde < exports.INTERVALO_WATCH_CLAUDE_MS)
                     return espera('turno encerrado pelo Stop com a sessão à espera humana (blocked); aguardando a segunda observação');
-                return esperaHumana();
+                return concluir('Stop correlacionado e sessão blocked sem pergunta de permissão pendente', false);
             }
             delete cursor.bloqueadoDesde;
             // RM-037 (defeito 4 de 19 e 20/10/2026): turno encerrado pelo Stop e a sessão ociosa no prompt (`status: idle`). O
@@ -570,18 +563,18 @@ function commitConferido(cwd, sha, headNoDespacho) {
  */
 function provaDoOrk(raiz, threadId, sessao, eventos, fonte) {
     const intervalo = eventosDoIntervalo(eventos, sessao);
-    const falta = (texto, extra = {}) => ({ ok: false, fonte: texto, motivo: sessao.fase === 'PLAN' ? 'artifact.missing' : 'human.pending', ...extra });
+    const falta = (texto, extra = {}) => ({ ok: false, fonte: texto, ...extra });
     const saida = saidaDoArtefato(raiz, threadId, sessao, fonte, eventos);
     if (saida) {
         if (!saida.produzido)
-            return falta(`${saida.arquivo} não foi gravado no intervalo do despacho`);
+            return falta(`${saida.arquivo} não foi gravado no intervalo do despacho`, { motivo: 'artifact.missing' });
         if (sessao.fase !== 'CHECK')
             return { ok: true, fonte: `${saida.arquivo} gravado no intervalo do despacho` };
         const v = intervalo.filter(e => e.tipo === 'verify_run' && typeof e.commit === 'string').at(-1);
         const verify = v ? { eventId: String(v.eventId), commit: String(v.commit), ts: v.ts } : null;
         const veredito = saida.texto === null ? null : vereditoDoParecer(saida.texto);
         if (!veredito)
-            return falta(`${saida.arquivo} gravado sem exatamente um veredito legível`, { veredito: null, verify });
+            return falta(`${saida.arquivo} gravado sem exatamente um veredito legível`, { motivo: 'artifact.missing', veredito: null, verify });
         return { ok: true, fonte: `${saida.arquivo} gravado com veredito ${veredito}`, veredito, verify };
     }
     if (sessao.fase === 'GO') {
@@ -589,9 +582,22 @@ function provaDoOrk(raiz, threadId, sessao, eventos, fonte) {
         const registrados = [...new Set(intervalo.filter(e => (e.tipo === 'mcp_git_committed' ||
                 (e.tipo === 'commit' && e.sessionId === sessao.sessionId)) &&
                 typeof e.commit === 'string' && SHA_COMMIT.test(e.commit)).map(e => String(e.commit)))].slice(-20);
-        if (!registrados.length)
-            return falta('nenhum commit registrado pelo núcleo no intervalo do despacho', { commits: [] });
         const cwd = fonte?.cwd, headNoDespacho = fonte?.head;
+        if (!registrados.length) {
+            if (!cwd || typeof headNoDespacho !== 'string')
+                return falta('HEAD da worktree no despacho não registrado; GO sem mudança não conferível', { commits: [] });
+            if ((0, procedencia_1.cwdLocalOuNulo)(raiz, threadId, cwd, 'ledger') === null)
+                return falta('cwd do despacho fora das worktrees registradas; GO sem mudança não conferível', { commits: [] });
+            if (headDaWorktree(cwd) !== headNoDespacho)
+                return falta('HEAD da worktree mudou sem commit registrado pelo núcleo', { commits: [], worktreeLimpa: false });
+            const status = (0, util_1.exec)('git', ['status', '--porcelain'], cwd, 30000);
+            if (!status.ok)
+                return falta('git status da worktree do despacho falhou', { commits: [], worktreeLimpa: false });
+            if (status.stdout.trim() !== '')
+                return falta('worktree com alterações não commitadas', { commits: [], worktreeLimpa: false });
+            return { ok: true, fonte: 'GO sem mudança: nenhum commit, HEAD igual ao despacho e worktree limpa',
+                commits: [], worktreeLimpa: true, resultado: 'go.sem-mudanca' };
+        }
         if (!cwd || typeof headNoDespacho !== 'string')
             return falta('HEAD da worktree no despacho não registrado; commit não conferível', { commits: [], recusados: registrados });
         // RM-047 (P2): o git da prova só roda na worktree registrada; o cwd vem do ledger.
@@ -733,9 +739,17 @@ function observarClaudeSobLock(ctx) {
     // e ao fecho.
     let erroLido;
     const erroDaTranscricao = () => erroLido !== undefined ? erroLido : (erroLido = ultimoErroDeApi(perfil, fonte.cwd, sessao.sessionId));
+    let perguntaLida;
+    const perguntaReal = () => {
+        if (perguntaLida !== undefined)
+            return perguntaLida;
+        const tela = (ctx.tela ?? (() => (0, claude_bg_1.logsDaSessao)(registro?.id ?? sessao.sessionId.slice(0, 8), 60, (0, claude_bg_1.ambienteDoPerfil)(perfil))))();
+        perguntaLida = tela.ok && (0, codex_events_1.mensagemFinalPedeHumano)(tela.texto);
+        return perguntaLida;
+    };
     const { c, falha } = comFalhaDeConta(classificarSessaoClaude({ sessao, eventos, consulta, registro, cursor, agoraMs: ctx.agoraMs,
         limiteMs: ctx.limiteMs, pausaAoFim: (0, thread_1.pausaNaThread)(thread, sessao.fase),
-        prova: () => prova ??= provaDoOrk(raiz, thread.id, sessao, eventos, fonte), processo: processoNativo }), () => falhaDoErro(erroDaTranscricao(), ctx.agoraMs));
+        prova: () => prova ??= provaDoOrk(raiz, thread.id, sessao, eventos, fonte), processo: processoNativo, perguntaReal }), () => falhaDoErro(erroDaTranscricao(), ctx.agoraMs));
     (0, codex_runner_1.gravarAtomico)(arquivoCursor, cursor);
     // GO-FIX 3 (achado 1): cursor gravado numa thread que sumiu durante a consulta é desfeito aqui;
     // as pastas criadas pela observação, pelo `session-watcher`.
@@ -787,6 +801,8 @@ function observarClaudeSobLock(ctx) {
             evidencia: { fonte: 'claude agents --json --all', consultadoEm: consulta.consultadoEm, registro: evidenciaDoRegistro(registro) },
             ...(artefato ? { artefato: { arquivo: artefato.arquivo, sha256Base: artefato.sha256Base, sha256Atual: artefato.sha256 } } : {}),
             ...(prova ? { provaOrk: prova } : {}),
+            ...(prova?.resultado ? { resultado: prova.resultado } : {}),
+            ...(c.perguntaReal !== undefined ? { perguntaReal: c.perguntaReal } : {}),
             conclusaoNativa: c.conclusaoNativa, conclusaoNativaAusente: c.conclusaoNativa ? null : c.fonte,
             ...(perfil ? { perfil } : {}),
             ...(falha ? { falhaDeConta: { motivo: falha.motivo, resetEm: falha.resetEm, fonte: falha.fonte, trecho: falha.trecho } } : {}),

package/dist/session-watcher-grok.js

@@ -144,8 +144,14 @@ function classificarSessaoGrok(e) {
     const bloqueio = (motivo, fonte, extra = {}) => ({ terminal: true, classificacao: 'gate_blocked', motivo, fonte, conclusaoNativa: false, diagnostico: fonte, ...extra });
     const interrupcao = (codigo, sinal, fonte) => bloqueio('human.pending', fonte, { interrupcao: { codigo, sinal, stopReason: estado.fim?.stopReason ?? null },
         retomar: true, diagnostico: `${fonte}; ${RETOMADA}` });
+    const porNegacao = () => {
+        const comando = estado.negacaoTerminal.comando;
+        return bloqueio('policy.violation', `comando de terminal negado pela política fechada: ${comando}`, { comandoNegado: comando, diagnostico: `a sessão terminou imediatamente depois de negar o comando: ${comando}` });
+    };
     const pelaFim = (comRecibo) => {
         const fim = estado.fim;
+        if (estado.negacaoTerminal)
+            return porNegacao();
         if (fim.stopReason === grok_events_1.STOP_CANCELADO)
             return interrupcao(recibo?.exitCode ?? null, recibo?.signal ?? null, 'end com stopReason cancelled');
         if (fim.stopReason !== grok_events_1.STOP_FIM_NORMAL) {
@@ -180,6 +186,8 @@ function classificarSessaoGrok(e) {
     }
     if (recibo.erro)
         return bloqueio('runtime.unavailable', `o supervisor não iniciou o grok (${recibo.erro})`);
+    if (estado.negacaoTerminal && valido)
+        return porNegacao();
     if (recibo.exitCode === 130 || recibo.exitCode === 143 || recibo.signal === 'SIGINT' || recibo.signal === 'SIGTERM') {
         return interrupcao(recibo.exitCode, recibo.signal, `processo interrompido (${recibo.signal ?? `saida ${recibo.exitCode}`}) no recibo do supervisor`);
     }
@@ -406,6 +414,8 @@ function observarGrokSobLock(ctx) {
             ...(c.erroDoRuntime ? { erroDoRuntime: c.erroDoRuntime } : {}),
             ...(c.falhaDeConta ? { falhaDeConta: { motivo: c.falhaDeConta.motivo, resetEm: c.falhaDeConta.resetEm,
                     fonte: c.falhaDeConta.fonte, trecho: c.falhaDeConta.trecho } } : {}),
+            ...(c.comandoNegado ? { comandoNegado: c.comandoNegado,
+                evidencia: `comando negado pela lista fechada do Grok: ${c.comandoNegado}` } : {}),
             // D18 da I-34: o diagnóstico vai ao pedido HITL e, como `detalhe` do `gate_blocked`, ao monitor e ao pulse.
             diagnostico: c.diagnostico, ...(detalhe ? { detalhe } : {}),
             observadoEm: new Date(agoraMs).toISOString(), gate: 'phase.dispatch', origem: 'sessions.watch',