@orkastery/cli 0.6.3 → 0.6.5

package/dist/security-scan/incremental.js

@@ -0,0 +1,289 @@
+"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.lerCacheIncremental = void 0;
+exports.resolverRegrasSemgrep = resolverRegrasSemgrep;
+exports.consultarCacheIncremental = consultarCacheIncremental;
+exports.gravarCacheIncremental = gravarCacheIncremental;
+/** Cache de resultado normalizado do Agile, por conteúdo e fora do repositório. */
+const crypto = __importStar(require("node:crypto"));
+const node_child_process_1 = require("node:child_process");
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const run_1 = require("./run");
+const CONTRATO = 'ork.security-scan.incremental/v1';
+const LOCKFILES = new Set(['package-lock.json', 'npm-shrinkwrap.json', 'pnpm-lock.yaml', 'yarn.lock', 'poetry.lock',
+    'Pipfile.lock', 'go.mod', 'go.sum']);
+const sha256 = (valor) => crypto.createHash('sha256').update(valor).digest('hex');
+const SCRIPT_DO_REGISTRO = String.raw `
+# ORK_SEMGREP_RESOLVE_V1
+import sys, urllib.request
+pedido = urllib.request.Request(sys.argv[1], headers={"Accept": "application/json", "User-Agent": "orkastery-security-scan"})
+with urllib.request.urlopen(pedido, timeout=20) as resposta:
+    if resposta.status != 200:
+        raise RuntimeError("HTTP " + str(resposta.status))
+    sys.stdout.buffer.write(resposta.read())
+`;
+/** O mesmo endpoint público para o qual o resolvedor do Semgrep mapeia um id do registro. */
+function urlDoRegistro(referencia) {
+    if (/^[prs]\/[A-Za-z0-9._/-]+$/.test(referencia))
+        return `https://semgrep.dev/c/${referencia}`;
+    if (/^https:\/\//.test(referencia))
+        return referencia;
+    return null;
+}
+function baixarDoRegistro(ferramenta, url) {
+    const uid = process.getuid?.() ?? 65534;
+    const gid = process.getgid?.() ?? 65534;
+    const nome = `ork-security-scan-semgrep-registry-${process.pid}-${crypto.randomBytes(4).toString('hex')}`;
+    const r = (0, node_child_process_1.spawnSync)('docker', ['run', '--rm', '--name', nome, '--user', `${uid === 0 ? 65534 : uid}:${uid === 0 ? 65534 : gid}`,
+        '--network', 'default', '--entrypoint', 'python3', ferramenta.image, '-c', SCRIPT_DO_REGISTRO, url], { encoding: 'utf8', timeout: 30_000, maxBuffer: 64 * 1024 * 1024, killSignal: 'SIGKILL' });
+    if (r.error || r.status !== 0)
+        (0, node_child_process_1.spawnSync)('docker', ['rm', '-f', nome], { stdio: 'ignore', timeout: 10_000 });
+    return !r.error && r.status === 0 && r.stdout.trim() ? r.stdout : null;
+}
+/** O conteúdo que o próprio Semgrep extrai da resposta do registro (`rules` direto ou envelope `rule_config`). */
+function conteudoResolvido(resposta) {
+    try {
+        const json = JSON.parse(resposta);
+        const regras = Object.prototype.hasOwnProperty.call(json, 'rules') ? json : json.rule_config;
+        return typeof regras === 'string' ? regras : JSON.stringify(regras);
+    }
+    catch {
+        return resposta;
+    }
+}
+const MARCAS_ENTRE_ARQUIVOS = ['join', 'interfile', 'crossfile', 'multifile'];
+const MARCA_NA_LINHA = /(?:^|[\s{,])(?:mode\s*:\s*)?(?:join|inter[-_ ]?file|cross[-_ ]?file|multi[-_ ]?file)(?:\s*:|\s*$)/i;
+const CHAVE_DA_LINHA = /^(\s*)(-\s+)?([A-Za-z_][\w-]*)\s*:(?:\s+(.*))?$/;
+const normalizar = (chave) => chave.toLowerCase().replace(/[-_]/g, '');
+/**
+ * Se a marca cruza arquivos de fato. `join` cruza em qualquer motor. `interfile` em `options` só cruza no motor Pro do
+ * Semgrep; em `metadata` é rótulo do registro, que o motor ignora. Em qualquer outro lugar, cruza (conservador).
+ */
+function marcaCruzaArquivos(marca, pai, pro) {
+    if (marca === 'join')
+        return true;
+    if (pai === 'metadata')
+        return false;
+    if (pai === 'options')
+        return pro;
+    return true;
+}
+/**
+ * O registro responde em YAML. Toda linha com marca cruza arquivos, menos a chave da própria marca, em bloco e com valor
+ * booleano, cujo pai pela indentação a torna inócua no motor da rodada. Linha de texto que parece chave nunca relaxa nada.
+ */
+function marcaNoYaml(conteudo, pro) {
+    const pais = [];
+    for (const linha of conteudo.split(/\r?\n/)) {
+        const m = CHAVE_DA_LINHA.exec(linha);
+        const coluna = m ? m[1].length + (m[2]?.length ?? 0) : 0;
+        if (m)
+            while (pais.length && pais[pais.length - 1].coluna >= coluna)
+                pais.pop();
+        if (MARCA_NA_LINHA.test(linha)) {
+            const chave = m ? normalizar(m[3]) : null;
+            const booleano = !!m && /^(?:true|false|yes|no|on|off)?\s*(?:#.*)?$/i.test(m[4] ?? '');
+            if (!chave || !MARCAS_ENTRE_ARQUIVOS.includes(chave) || !booleano
+                || marcaCruzaArquivos(chave, pais[pais.length - 1]?.chave ?? null, pro))
+                return true;
+        }
+        if (m)
+            pais.push({ coluna, chave: normalizar(m[3]) });
+    }
+    return false;
+}
+function regraEntreArquivos(conteudo, pro) {
+    let valor;
+    try {
+        valor = JSON.parse(conteudo);
+    }
+    catch {
+        return marcaNoYaml(conteudo, pro);
+    }
+    if (typeof valor === 'string')
+        return marcaNoYaml(valor, pro);
+    const visitar = (atual, pai) => {
+        if (Array.isArray(atual))
+            return atual.some((item) => visitar(item, pai));
+        if (!atual || typeof atual !== 'object')
+            return false;
+        return Object.entries(atual).some(([chave, filho]) => {
+            const normal = normalizar(chave);
+            if (normal === 'mode' && typeof filho === 'string' && /^(join|interfile|crossfile|multifile)$/i.test(filho))
+                return true;
+            if (MARCAS_ENTRE_ARQUIVOS.includes(normal) && filho !== false && filho !== null
+                && marcaCruzaArquivos(normal, pai, pro))
+                return true;
+            return visitar(filho, normal);
+        });
+    };
+    return visitar(valor, null);
+}
+/** O Semgrep da rodada usa o motor Pro, o único que cruza arquivos nas regras `interfile`: `--pro*`, `semgrep ci` ou token. */
+function motorPro(ferramenta, unidades) {
+    const stacks = new Set(unidades.map((u) => u.stack).filter((s) => !!s));
+    const todos = [ferramenta.args, ...[...stacks].map((s) => ferramenta.argsByStack?.[s] ?? [])];
+    return todos.some((args) => args.some((a) => a.startsWith('--pro')) || args.includes('ci'))
+        || Object.keys(ferramenta.env ?? {}).some((k) => /^SEMGREP_APP_TOKEN$/i.test(k));
+}
+function referenciasDasRegras(ferramenta, unidades) {
+    const stacks = new Set(unidades.map((u) => u.stack).filter((s) => !!s));
+    const referencias = new Set();
+    for (const stack of stacks) {
+        const args = ferramenta.argsByStack?.[stack] ?? [];
+        for (let i = 0; i < args.length - 1; i++)
+            if (args[i] === '--config' || args[i] === '-f')
+                referencias.add(args[++i]);
+    }
+    return [...referencias].sort();
+}
+function resolverRegrasSemgrep(ferramenta, unidades, baixar = baixarDoRegistro) {
+    const referencias = referenciasDasRegras(ferramenta, unidades);
+    if (referencias.length === 0)
+        return { reutilizavel: false, hash: null, motivo: 'regras-sem-referencia', referencias };
+    const resolvidas = [];
+    const pro = motorPro(ferramenta, unidades);
+    for (const referencia of referencias) {
+        const url = urlDoRegistro(referencia);
+        if (!url)
+            return { reutilizavel: false, hash: null, motivo: 'referencia-de-regra-nao-resolvivel', referencias };
+        const resposta = baixar(ferramenta, url);
+        if (!resposta)
+            return { reutilizavel: false, hash: null, motivo: 'registro-indisponivel', referencias };
+        const conteudo = conteudoResolvido(resposta);
+        if (regraEntreArquivos(conteudo, pro))
+            return { reutilizavel: false, hash: null, motivo: 'regra-entre-arquivos', referencias };
+        resolvidas.push([referencia, conteudo]);
+    }
+    return { reutilizavel: true, hash: sha256(JSON.stringify(resolvidas)), referencias };
+}
+/** Só habilita o que tem garantia explícita: Semgrep por arquivo e dependências por lockfile. */
+function escopoDaFerramenta(t, trabalho) {
+    if (t.name === 'semgrep') {
+        // A API direta antecede o trabalhador e continua útil para conferir o retrato por arquivo isoladamente. No caminho
+        // real do Agile, `incremental: true` torna obrigatória a identidade das regras resolvidas: ausência, registro
+        // indisponível ou regra entre arquivos nunca cai nesta compatibilidade.
+        if (trabalho.incremental !== true)
+            return 'arquivo';
+        return trabalho.regrasSemgrep?.reutilizavel && trabalho.regrasSemgrep.hash ? 'arquivo' : null;
+    }
+    if (t.category === 'dependency')
+        return 'lockfile';
+    return null;
+}
+function arquivos(root, escopo) {
+    const saida = {};
+    const visitar = (dir) => {
+        let nomes;
+        try {
+            nomes = fs.readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+        }
+        catch {
+            return;
+        }
+        for (const nome of nomes) {
+            if (nome.name === '.git')
+                continue;
+            const absoluto = path.join(dir, nome.name);
+            if (nome.isDirectory()) {
+                visitar(absoluto);
+                continue;
+            }
+            if (!nome.isFile())
+                continue;
+            const relativo = path.relative(root, absoluto).split(path.sep).join('/');
+            const lockfile = LOCKFILES.has(nome.name) || /^requirements(?:\.[^.]+)?\.txt$/.test(nome.name);
+            if (escopo === 'lockfile' && !lockfile)
+                continue;
+            try {
+                saida[relativo] = sha256(fs.readFileSync(absoluto));
+            }
+            catch { /* arquivo mudou durante a leitura: nao entra */ }
+        }
+    };
+    visitar(root);
+    return saida;
+}
+function identidade(trabalho, ferramenta) {
+    return sha256(JSON.stringify({ ferramenta, unidades: trabalho.units, configuracao: trabalho.config, base: trabalho.ctx.base,
+        regrasSemgrep: trabalho.regrasSemgrep?.hash ?? null }));
+}
+function localDaEntrada(chave) {
+    return path.join((0, run_1.cacheRoot)(), 'incremental', `${chave}.json`);
+}
+function consultarCacheIncremental(trabalho, ferramenta) {
+    const escopo = escopoDaFerramenta(ferramenta, trabalho);
+    if (!escopo)
+        return { escopo: null, atual: null, anterior: null, alterados: [], reutilizado: null };
+    const retrato = { escopo, arquivos: arquivos(trabalho.ctx.headTree, escopo) };
+    if (escopo === 'lockfile' && Object.keys(retrato.arquivos).length === 0) {
+        return { escopo, atual: retrato, anterior: null, alterados: [], reutilizado: null };
+    }
+    const chave = identidade(trabalho, ferramenta);
+    try {
+        const entrada = JSON.parse(fs.readFileSync(localDaEntrada(chave), 'utf8'));
+        if (entrada.contrato !== CONTRATO || entrada.chave !== chave || entrada.resultado?.run?.state !== 'ran') {
+            return { escopo, atual: retrato, anterior: null, alterados: [], reutilizado: null };
+        }
+        const nomes = new Set([...Object.keys(entrada.retrato.arquivos), ...Object.keys(retrato.arquivos)]);
+        const alterados = [...nomes].filter((nome) => entrada.retrato.arquivos[nome] !== retrato.arquivos[nome]).sort();
+        return { escopo, atual: retrato, anterior: entrada.resultado, alterados,
+            reutilizado: alterados.length === 0 ? entrada.resultado : null };
+    }
+    catch {
+        return { escopo, atual: retrato, anterior: null, alterados: [], reutilizado: null };
+    }
+}
+const lerCacheIncremental = (trabalho, ferramenta) => consultarCacheIncremental(trabalho, ferramenta).reutilizado;
+exports.lerCacheIncremental = lerCacheIncremental;
+function gravarCacheIncremental(trabalho, ferramenta, resultado) {
+    const escopo = escopoDaFerramenta(ferramenta, trabalho);
+    if (!escopo || resultado.run.state !== 'ran')
+        return;
+    const retrato = { escopo, arquivos: arquivos(trabalho.ctx.headTree, escopo) };
+    if (escopo === 'lockfile' && Object.keys(retrato.arquivos).length === 0)
+        return;
+    const chave = identidade(trabalho, ferramenta), arquivo = localDaEntrada(chave);
+    try {
+        fs.mkdirSync(path.dirname(arquivo), { recursive: true, mode: 0o700 });
+        const temporario = `${arquivo}.${process.pid}.tmp`;
+        const entrada = { contrato: CONTRATO, chave, retrato, resultado };
+        fs.writeFileSync(temporario, JSON.stringify(entrada), { mode: 0o600 });
+        fs.renameSync(temporario, arquivo);
+    }
+    catch { /* cache ausente custa CPU, mas nunca muda o veredito */ }
+}

package/dist/security-scan/trabalhador.js

@@ -41,9 +41,11 @@ exports.comCacheNoHost = comCacheNoHost;
  * `runScanAgil`, um trabalhador por ferramenta, ao mesmo tempo.
  */
 const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
 const executor_1 = require("./executor");
 const guard_1 = require("./guard");
 const run_1 = require("./run");
+const incremental_1 = require("./incremental");
 /**
  * S6 do CHECK: o binario nativo usa o cache por usuario que o Docker monta (o caminho do host no lugar do caminho do
  * container), e nao o `/tmp` compartilhado do catalogo, onde outro usuario da maquina deixaria um banco do Trivy.
@@ -51,10 +53,49 @@ const run_1 = require("./run");
 function comCacheNoHost(t) {
     if (!t.cacheMounts?.length)
         return t;
-    let args = t.args;
-    for (const m of t.cacheMounts)
-        args = args.map((a) => a.split(m.container).join(m.host));
-    return { ...t, args };
+    const trocar = (args) => {
+        let resposta = args;
+        for (const m of t.cacheMounts ?? [])
+            resposta = resposta.map((a) => a.split(m.container).join(m.host));
+        return resposta;
+    };
+    return { ...t, args: trocar(t.args), ...(t.argsByStack
+            ? { argsByStack: Object.fromEntries(Object.entries(t.argsByStack).map(([stack, args]) => [stack, trocar(args ?? [])])) }
+            : {}) };
+}
+/** Semgrep é a garantia por arquivo: roda apenas conteúdo mudado e conserva os achados dos demais arquivos. */
+function semgrepIncremental(trabalho, ferramenta, consulta, executar) {
+    if (ferramenta.name !== 'semgrep' || !consulta.anterior || consulta.escopo !== 'arquivo' || !ferramenta.argsByStack)
+        return null;
+    if (new Set(trabalho.units.map((u) => u.stack)).size !== trabalho.units.length)
+        return null;
+    const existentes = consulta.alterados.filter((arquivo) => {
+        try {
+            return fs.statSync(path.join(trabalho.ctx.headTree, arquivo)).isFile();
+        }
+        catch {
+            return false;
+        }
+    });
+    const argsByStack = {};
+    const unidades = trabalho.units.filter((unidade) => {
+        const prefixo = unidade.dir === '.' ? '' : `${unidade.dir.replace(/\\/g, '/')}/`;
+        const alvos = existentes.filter((arquivo) => !prefixo || arquivo.startsWith(prefixo));
+        const base = unidade.stack ? ferramenta.argsByStack?.[unidade.stack] : undefined;
+        if (!base?.length || alvos.length === 0 || !unidade.stack)
+            return false;
+        argsByStack[unidade.stack] = [...base.slice(0, -1), ...alvos.map((arquivo) => `{src}/${arquivo}`)];
+        return true;
+    });
+    const mudaram = new Set(consulta.alterados);
+    const preservados = consulta.anterior.head.filter((achado) => !mudaram.has(achado.file));
+    if (unidades.length === 0)
+        return { ...consulta.anterior, head: preservados };
+    const parcial = executar({ ...ferramenta, argsByStack }, unidades, true);
+    if (parcial.run.state !== 'ran')
+        return parcial;
+    const novos = parcial.head.filter((achado) => mudaram.has(achado.file));
+    return { ...parcial, head: [...preservados, ...novos], base: consulta.anterior.base };
 }
 if (require.main === module) {
     const trabalho = JSON.parse(fs.readFileSync(process.argv[2], 'utf8'));
@@ -65,7 +106,14 @@ if (require.main === module) {
         // chooseExecutor escolher o nativo); sem ele, o Docker, como no Classic.
         const sonda = (0, executor_1.defaultProbe)();
         const probe = trabalho.nativoPrimeiro ? { ...sonda, dockerCli: () => false, dockerDaemon: () => false } : sonda;
-        const r = (0, run_1.scanTool)(trabalho.nativoPrimeiro ? comCacheNoHost(trabalho.tool) : trabalho.tool, trabalho.units, trabalho.config, { ...resto, deadline: deadline ?? Infinity, probe, guard, images: new Map() });
+        const ferramenta = trabalho.nativoPrimeiro ? comCacheNoHost(trabalho.tool) : trabalho.tool;
+        const executar = (tool, units, somenteHead = false) => (0, run_1.scanTool)(tool, units, trabalho.config, { ...resto, ...(somenteHead ? { base: resto.head, baseTree: resto.headTree, rangeCommits: 0 } : {}),
+            deadline: deadline ?? Infinity, probe, guard, images: new Map() });
+        const consulta = trabalho.incremental ? (0, incremental_1.consultarCacheIncremental)(trabalho, ferramenta) : null;
+        const r = consulta?.reutilizado ?? (consulta ? semgrepIncremental(trabalho, ferramenta, consulta, executar) : null)
+            ?? executar(ferramenta, trabalho.units);
+        if (trabalho.incremental && !consulta?.reutilizado)
+            (0, incremental_1.gravarCacheIncremental)(trabalho, ferramenta, r);
         process.stdout.write(JSON.stringify(r));
     }
     finally {

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',