@orkastery/cli 0.6.3 → 0.6.5

package/adapters/openclaw/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "orkastery",
   "name": "Orkastery",
   "description": "Conducao de looping threads em 6 fases pelo nucleo `ork`, exposta ao OpenClaw como tools `ork_*`. Zero regra de negocio no host: cada tool e uma chamada de CLI. Toda tool de projeto aceita projeto (nome do projeto pedido); o cwd do gateway nunca escolhe o projeto. O status do roadmap vem de ork_network_roadmap; as maquinas da pessoa, de ork_network_status (sem projeto).",
-  "version": "0.6.3",
+  "version": "0.6.5",
   "configSchema": {
     "type": "object",
     "properties": {},

package/adapters/openclaw/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orkastery/openclaw-plugin",
-  "version": "0.6.3",
+  "version": "0.6.5",
   "description": "Plugin Orkastery para OpenClaw: 32 tools ork_* que traduzem intencao em chamada de CLI do nucleo `ork`. Zero regra de negocio no host.",
   "type": "module",
   "private": true,

package/dist/adapters/codex-controller-sensor.js

@@ -34,6 +34,8 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CONTRATO_FIXACAO = exports.LIMITE_METADADO_BYTES = void 0;
+exports.lerFonteControllerFixada = lerFonteControllerFixada;
+exports.consumirRolloutControllerFixado = consumirRolloutControllerFixado;
 exports.registrarFonteController = registrarFonteController;
 exports.lerSnapshotController = lerSnapshotController;
 /** D1/D2: leitor validado da fonte do controller. Sem RPC, resposta, sinal ou resume. */
@@ -222,7 +224,7 @@ function conferirSessionMeta(fd, tamanho, sessionId, cwd) {
  * Não há atomicidade contra troca entre lstat e open: a garantia é a reconferência do
  * descritor aberto e do vínculo com a fonte fixada, com recusa quando a prova não se sustenta.
  */
-function conferirFonteDeRollout(rollout, uid, sessionId, cwd, fixado) {
+function comRolloutConferido(rollout, uid, sessionId, cwd, fixado, consumir) {
     if (typeof rollout !== 'string' || !rollout || !path.isAbsolute(rollout))
         recusar('rollout do controller não confirmado');
     const file = rollout;
@@ -252,12 +254,15 @@ function conferirFonteDeRollout(rollout, uid, sessionId, cwd, fixado) {
         if (fixado && (st.ino !== fixado.ino || st.dev !== fixado.dev))
             recusar('rollout do controller rotacionado sem vínculo provado com a fonte fixada');
         conferirSessionMeta(fd, st.size, sessionId, cwd);
-        return { file, ino: st.ino, dev: st.dev };
+        return { fonte: { file, ino: st.ino, dev: st.dev }, valor: consumir(fd, st.size) };
     }
     finally {
         fs.closeSync(fd);
     }
 }
+function conferirFonteDeRollout(rollout, uid, sessionId, cwd, fixado) {
+    return comRolloutConferido(rollout, uid, sessionId, cwd, fixado, () => undefined).fonte;
+}
 /**
  * Fixacao privada da fonte: escrita uma unica vez, antes de qualquer efeito de observacao,
  * e reconferida em cada poll e em cada restart do observador. Sem redescoberta de processo.
@@ -303,6 +308,20 @@ function lerFonteFixada(file, esperado, uid) {
         cwd: esperado.cwd, sessionId: esperado.sessionId, rollout: f.rollout, rolloutIno: f.rolloutIno,
         rolloutDev: f.rolloutDev, criadoEm: f.criadoEm, processoController: controlador, processoRuntime: runtime, uid };
 }
+/** Leitura pura da fixação do watcher: não descobre fonte, não grava pin e reconfere o rollout. */
+function lerFonteControllerFixada(file, esperado) {
+    const uid = esperado.uid ?? uidAtual();
+    const fonte = lerFonteFixada(file, esperado, uid);
+    if (!fonte)
+        return null;
+    conferirDiretorioDaFonte(fonte.dir, esperado.dirSessoes, uid);
+    conferirFonteDeRollout(fonte.rollout, uid, fonte.sessionId, fonte.cwd, { file: fonte.rollout, ino: fonte.rolloutIno, dev: fonte.rolloutDev });
+    return fonte;
+}
+/** Consome bytes do descritor autenticado do rollout já fixado, sem reabrir pathname não conferido. */
+function consumirRolloutControllerFixado(fonte, consumir) {
+    return comRolloutConferido(fonte.rollout, fonte.uid, fonte.sessionId, fonte.cwd, { file: fonte.rollout, ino: fonte.rolloutIno, dev: fonte.rolloutDev }, consumir).valor;
+}
 /**
  * Espera humana so suspende o prazo com o tuple nativo completo: thread, turno, `requestId`
  * inclusive o numero `0`, item e hash iguais aos da pergunta projetada.

package/dist/adapters/codex-events.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ParserCodex = exports.LIMITE_RESPOSTA_CODEX = exports.LIMITE_LINHA_CODEX = void 0;
 exports.falhaDeContaDoErroCodex = falhaDeContaDoErroCodex;
 exports.classificarMensagem = classificarMensagem;
+exports.mensagemFinalPedeHumano = mensagemFinalPedeHumano;
 /** D4/D5: stream e rollout são observações de turno, nunca aprovação de CHECK. */
 const gates_1 = require("../gates");
 const claude_bg_1 = require("./claude-bg");
@@ -59,13 +60,21 @@ function classificarMensagem(texto) {
     const estado = /(?:^|\n)\s*(?:motivo|gate_blocked|bloquead[oa](?:\s+por)?|blocked(?:\s+by)?)\s*[:=]?\s*`?([a-z]+[._][a-z_.-]+)`?/i.exec(final);
     if (estado)
         return motivo(estado[1]) ?? falha();
-    const pergunta = final.replace(/`[^`]*`/g, '').trim();
+    return mensagemFinalPedeHumano(final) ? humano() : sucesso();
+}
+/**
+ * RM-075: a mensagem final pede uma resposta do humano? A regra é compartilhada pelos
+ * rollouts Codex e pela tela final do claude-bg, para `human.pending` não nascer apenas
+ * do estado nativo `blocked`.
+ */
+function mensagemFinalPedeHumano(texto) {
+    if (typeof texto !== 'string')
+        return false;
+    const pergunta = texto.replace(/`[^`]*`/g, '').trim();
     if (/(?:preciso|aguardo|aguardando|waiting for|need)\s+(?:da?\s+)?(?:sua|your|confirmação|resposta|autorização|approval|confirmation)/i.test(pergunta))
-        return humano();
-    if (/\?\s*$/.test(pergunta) &&
-        /(?:\b(?:você|voce|you|confirma|confirme|deseja|prefere|autoriza|posso|can you|could you|should I)\b|(?:qual|which|what)\s+(?:é\s+o\s+|is\s+the\s+)?(?:diretório|diretorio|caminho|arquivo|opção|opcao|directory|path|file|option))/i.test(pergunta))
-        return humano();
-    return sucesso();
+        return true;
+    return /\?\s*$/.test(pergunta) &&
+        /(?:\b(?:você|voce|you|confirma|confirme|deseja|prefere|autoriza|posso|can you|could you|should I)\b|(?:qual|which|what)\s+(?:é\s+o\s+|is\s+the\s+)?(?:diretório|diretorio|caminho|arquivo|opção|opcao|directory|path|file|option))/i.test(pergunta);
 }
 function tokens(v, fonte, escopo) {
     if (!v || typeof v !== 'object')

package/dist/adapters/grok-events.js

@@ -64,6 +64,19 @@ exports.LIMITE_LINHA_GROK = 1024 * 1024;
 exports.LIMITE_ERRO_GROK = 300;
 const STOP = /^[a-z][a-z0-9_]{0,39}$/;
 const ID = /^[A-Za-z0-9][A-Za-z0-9_.:-]{0,127}$/;
+/** A saída estrutural do Bash que o runtime usa quando `dontAsk` nega antes de executar. */
+function negacaoDaPolitica(e) {
+    const saida = e.rawOutput;
+    if (saida && typeof saida === 'object' && !Array.isArray(saida)) {
+        const o = saida;
+        if (o.type === 'PermissionDenied' || o.code === 'permission_denied' || o.outcome === 'blocked-by-permissions')
+            return true;
+        if (typeof o.exit_code === 'number')
+            return false;
+        return typeof o.output_for_prompt === 'string' && /Denied by permission policy|tool permission denied for/i.test(o.output_for_prompt);
+    }
+    return typeof saida === 'string' && /Denied by permission policy|tool permission denied for/i.test(saida);
+}
 /**
  * D7: um texto do runtime pronto para o ledger, sem corte: os segredos que o núcleo já conhece, a chave da xAI
  * (`xai-...`) e sem controle. GO-FIX 1 (A4): quem corta, corta depois de redigir, para nenhum segredo perder o prefixo.
@@ -106,7 +119,13 @@ class ParserGrok {
         if (estado && estado.sessaoEsperada !== sessaoEsperada)
             throw new Error('estado do parser do grok de outra sessão');
         this.estado = estado ? structuredClone(estado)
-            : { sessaoEsperada, fim: null, erro: null, invalido: false, sessaoDivergente: false, eventos: 0 };
+            : { sessaoEsperada, fim: null, erro: null, invalido: false, sessaoDivergente: false, eventos: 0,
+                comandosTerminal: {}, negacaoTerminal: null };
+        // Cursor gravado antes da F5a continua legível.
+        if (!this.estado.comandosTerminal || typeof this.estado.comandosTerminal !== 'object')
+            this.estado.comandosTerminal = {};
+        if (this.estado.negacaoTerminal === undefined)
+            this.estado.negacaoTerminal = null;
     }
     /** Lê as linhas completas do bloco; o resto fica pendente para o próximo. */
     push(chunk) {
@@ -158,12 +177,34 @@ class ParserGrok {
         }
         this.eventosValidos++;
         this.estado.eventos++;
+        if (e.type === 'tool_call') {
+            this.estado.negacaoTerminal = null;
+            const entrada = e.rawInput;
+            if (typeof e.toolCallId === 'string' && ID.test(e.toolCallId) && (e.toolName === 'bash' || e.toolName === 'run_terminal_cmd') &&
+                entrada && typeof entrada === 'object' && !Array.isArray(entrada) && typeof entrada.command === 'string') {
+                const comando = redigirErroGrok(entrada.command);
+                if (comando)
+                    this.estado.comandosTerminal[e.toolCallId] = comando;
+            }
+            return;
+        }
+        if (e.type === 'tool_call_update') {
+            const id = typeof e.toolCallId === 'string' && ID.test(e.toolCallId) ? e.toolCallId : null;
+            const comando = id ? this.estado.comandosTerminal[id] : undefined;
+            this.estado.negacaoTerminal = comando && negacaoDaPolitica(e) ? { comando } : null;
+            if (id && e.status === 'completed')
+                delete this.estado.comandosTerminal[id];
+            return;
+        }
         if (e.type === 'error') {
+            this.estado.negacaoTerminal = null;
             this.estado.erro = { mensagem: redigirErroGrok(e.message) || 'erro do grok sem mensagem' };
             return;
         }
-        if (e.type !== 'end')
+        if (e.type !== 'end') {
+            this.estado.negacaoTerminal = null;
             return;
+        }
         const sessionId = typeof e.sessionId === 'string' && ID.test(e.sessionId) ? e.sessionId : null;
         if (sessionId !== this.estado.sessaoEsperada)
             this.estado.sessaoDivergente = true;

package/dist/adapters/grok.js

@@ -33,7 +33,8 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.IGNORADOS_DA_CONFIG_DO_FILHO = exports.MARCA_DA_CONFIG_DO_FILHO = exports.ESPERA_PADRAO_MS = exports.ESFORCO_DO_GROK = exports.PERFIL_DE_SANDBOX_PADRAO = exports.PERFIL_DE_SANDBOX_DO_GROK = exports.AMBIENTE_SEM_MCP_DE_OUTROS_CLIENTES = exports.ENVS_REMOVIDAS_DO_DESPACHO = exports.FONTE_VERIFICACAO = exports.NOME_ADAPTER = void 0;
+exports.IGNORADOS_DA_CONFIG_DO_FILHO = exports.MARCA_DA_CONFIG_DO_FILHO = exports.ESPERA_PADRAO_MS = exports.ESFORCO_DO_GROK = exports.COMANDOS_TERMINAL_DO_GROK = exports.PERFIL_DE_SANDBOX_PADRAO = exports.PERFIL_DE_SANDBOX_DO_GROK = exports.AMBIENTE_SEM_MCP_DE_OUTROS_CLIENTES = exports.ENVS_REMOVIDAS_DO_DESPACHO = exports.FONTE_VERIFICACAO = exports.NOME_ADAPTER = void 0;
+exports.regrasDosComandosDoGrok = regrasDosComandosDoGrok;
 exports.esforcoDoGrok = esforcoDoGrok;
 exports.ferramentasDoGrok = ferramentasDoGrok;
 exports.ferramentasServidasAoGrok = ferramentasServidasAoGrok;
@@ -112,6 +113,24 @@ exports.PERFIL_DE_SANDBOX_DO_GROK = Object.freeze({
     'danger-full-access': 'off',
 });
 exports.PERFIL_DE_SANDBOX_PADRAO = 'workspace';
+/**
+ * RM-067 (F5a, D3): a lista fechada dos comandos de terminal do ciclo da fase. O motivo mora com o comando para uma
+ * inclusão futura nunca virar só mais um curinga sem justificativa. As regras do MCP continuam em `ferramentasDoGrok`.
+ */
+exports.COMANDOS_TERMINAL_DO_GROK = Object.freeze([
+    { comando: 'git', motivo: 'inspecionar e registrar o estado da worktree pelos fluxos autorizados da fase' },
+    { comando: 'node', motivo: 'executar o CLI compilado e os scripts de prova do projeto' },
+    { comando: 'npm', motivo: 'instalar, compilar e testar o pacote pelo manifesto' },
+    { comando: 'ork', motivo: 'consultar e operar o ciclo da fase quando o transporte nativo estiver disponível' },
+    { comando: 'grep', motivo: 'localizar texto e produzir evidência reproduzível' },
+    { comando: 'find', motivo: 'descobrir arquivos dentro do sandbox da worktree' },
+    { comando: 'ls', motivo: 'inspecionar diretórios dentro do sandbox da worktree' },
+    { comando: 'cat', motivo: 'ler arquivos de texto dentro do sandbox da worktree' },
+]);
+/** A forma oficial do guia 22: a regra exata cobre o comando nu, e a regra com espaço cobre seus argumentos. */
+function regrasDosComandosDoGrok() {
+    return exports.COMANDOS_TERMINAL_DO_GROK.flatMap(({ comando }) => [`Bash(${comando})`, `Bash(${comando} *)`]);
+}
 /**
  * RM-067 (F4, E6): o esforço do Orkastery nos níveis canônicos do `grok` (`none`, `minimal`, `low`, `medium`, `high`,
  * `xhigh`, `max`, no guia headless). O `eco` vira `minimal`, para a escada de esforço (`eco` antes de `low`) seguir com
@@ -245,7 +264,10 @@ function comandoDoDespacho(pedido, ferramentas) {
         args.push('-m', pedido.model);
     if (pedido.effort?.trim())
         args.push('--effort', esforcoDoGrok(pedido.effort));
-    args.push('--sandbox', perfilDeSandbox(pedido.sandbox, pedido.colaboracao), '--no-auto-update');
+    // RM-067 (F5a, D3): no headless, o que não casar com uma regra é negado e devolvido ao modelo, sem abrir diálogo.
+    args.push('--permission-mode', 'dontAsk', '--sandbox', perfilDeSandbox(pedido.sandbox, pedido.colaboracao), '--no-auto-update');
+    for (const regra of regrasDosComandosDoGrok())
+        args.push('--allow', regra);
     // RM-067 (F4b, G2): com o MCP do ork, uma regra por ferramenta liberada, no fim, para o despacho sem contexto ficar igual
     // e a retomada (que guarda o que vem depois do `-s`) levar as mesmas regras.
     for (const ferramenta of ferramentas)
@@ -253,8 +275,9 @@ function comandoDoDespacho(pedido, ferramentas) {
     return ['grok', ...args];
 }
 /**
- * D2: a linha de comando exata do despacho (usada também pelo `--dry-run`). O prompt fica no argumento 2, que o ledger
- * mascara. Nunca `--yolo`, `--always-approve` nem `--permission-mode`.
+ * D2 e F5a: a linha de comando exata do despacho (usada também pelo `--dry-run`). O prompt fica no argumento 2, que o
+ * ledger mascara. Todo despacho headless usa `--permission-mode dontAsk` com as regras fechadas de D3; nunca `--yolo`,
+ * `--always-approve` nem `--permission-mode bypassPermissions`.
  *
  * RM-067 (F4, E8): `--trust` confia a pasta do `--cwd`, a worktree da thread, que é o checkout do próprio projeto. O guia
  * de regras de projeto do `grok` diz que o `AGENTS.md` só carrega na partida com a pasta confiada (`--trust` ou a
@@ -263,7 +286,7 @@ function comandoDoDespacho(pedido, ferramentas) {
  * `grok` lê; não aprova ferramenta nenhuma.
  *
  * RM-067 (F4b, G2): num projeto preparado, o comando leva no fim um `--allow MCPTool(orkastery__<ferramenta>)` por
- * ferramenta do MCP do `ork` que o caso libera (`ferramentasDoGrok`), e nenhuma outra regra.
+ * ferramenta do MCP do `ork` que o caso libera (`ferramentasDoGrok`), além das regras fechadas de terminal da F5a.
  */
 function montarComando(pedido) {
     return comandoDoDespacho(pedido, ferramentasDoDespacho(pedido, contextoDoDespacho(pedido)));

package/dist/agendador-cpu.js

@@ -1,7 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.JANELA_DA_SONDA_MS = exports.LIMIAR_STEAL_DO_AGENDADOR_PCT = exports.RESERVA_DO_GRUPO = exports.ENV_CPUS_DOCKER = exports.ENV_SINAL_DA_RESERVA = exports.ENV_CPUS_DA_LANE_APOS_RESERVA = exports.ENV_CPUS_DA_LANE = void 0;
+exports.AMOSTRAS_DA_SONDA = exports.JANELA_DA_SONDA_MS = exports.LIMIAR_STEAL_DO_AGENDADOR_PCT = exports.MINIMO_ESTRUTURAL_DO_GRUPO = exports.RESERVA_DO_GRUPO = exports.ENV_CONTAINERS_DA_LANE = exports.ENV_CPUS_DOCKER = exports.ENV_SINAL_DA_RESERVA = exports.ENV_CPUS_DA_LANE_APOS_RESERVA = exports.ENV_CPUS_DA_LANE_APOS_VARREDURA = exports.ENV_WORKERS = exports.ENV_CPUS_DA_LANE = void 0;
+exports.registrarContainerDaLane = registrarContainerDaLane;
+exports.workersDaReserva = workersDaReserva;
 exports.cargaDoProcLoadavg = cargaDoProcLoadavg;
+exports.mediana = mediana;
+exports.resumirMedicaoCpuDoGrupo = resumirMedicaoCpuDoGrupo;
 exports.medirCpuDoGrupo = medirCpuDoGrupo;
 exports.planejarCpuDoGrupo = planejarCpuDoGrupo;
 exports.paredeClassicaSimulada = paredeClassicaSimulada;
@@ -10,19 +14,43 @@ exports.paredeAgileSimulada = paredeAgileSimulada;
  * RM-074: o plano de CPU do grupo do Agile Check.
  *
  * A lane hermetica deixa duas CPUs para a varredura e para a integracao. Cada conteiner recebe uma cota dessa fatia,
- * em vez de enxergar a maquina inteira. Antes de lancar os comandos, o auxiliar do verify mede `/proc/loadavg` e uma
- * janela de `/proc/stat`; sob carga ou steal, as pecas voltam a ordem do Classic e usam uma CPU a menos que a maquina.
+ * em vez de enxergar a maquina inteira. Antes de lancar os comandos, o auxiliar do verify mede `/proc/loadavg` e
+ * varias janelas curtas de `/proc/stat`. A mediana ignora um pico isolado. Steal acima do limiar reduz a capacidade do
+ * plano em degraus; a ordem do Classic, com a paralelizacao do Classic, so volta quando nao cabem as tres CPUs
+ * estruturais do grupo paralelo ou quando a carga ocupa quase a maquina inteira.
  */
 const node_fs_1 = require("node:fs");
 const steal_1 = require("./steal");
 exports.ENV_CPUS_DA_LANE = 'ORK_CHECK_CPUS_DA_LANE';
+/** RM-081 F4: contrato publico com a quantidade inteira de workers disponivel ao runner. */
+exports.ENV_WORKERS = 'ORK_WORKERS';
+exports.ENV_CPUS_DA_LANE_APOS_VARREDURA = 'ORK_CHECK_CPUS_DA_LANE_APOS_VARREDURA';
 exports.ENV_CPUS_DA_LANE_APOS_RESERVA = 'ORK_CHECK_CPUS_DA_LANE_APOS_RESERVA';
 exports.ENV_SINAL_DA_RESERVA = 'ORK_CHECK_RESERVA_DEVOLVIDA';
 exports.ENV_CPUS_DOCKER = 'ORK_CHECK_CPUS_DOCKER';
+/** Registro privado da rodada: quem sobe um container na lane anota o nome para a sonda de CPU. */
+exports.ENV_CONTAINERS_DA_LANE = 'ORK_CHECK_CONTAINERS_DA_LANE';
 exports.RESERVA_DO_GRUPO = 2;
+exports.MINIMO_ESTRUTURAL_DO_GRUPO = exports.RESERVA_DO_GRUPO + 1;
+/** Abaixo dele o steal nao desconta capacidade (como na M7); acima, a M8 desconta a fracao medida, sem corte tudo ou nada. */
 exports.LIMIAR_STEAL_DO_AGENDADOR_PCT = 10;
 exports.JANELA_DA_SONDA_MS = 250;
-const cpusValidas = (cpus) => Math.max(1, Math.floor(Number.isFinite(cpus) ? cpus : 1));
+exports.AMOSTRAS_DA_SONDA = 5;
+/** Registra o container antes do `docker run`; falha de evidencia nunca impede a ferramenta de rodar. */
+function registrarContainerDaLane(nome, ambiente = process.env) {
+    const arquivo = ambiente[exports.ENV_CONTAINERS_DA_LANE];
+    if (!arquivo || !nome)
+        return;
+    try {
+        (0, node_fs_1.appendFileSync)(arquivo, JSON.stringify({ nome, em: new Date().toISOString() }) + '\n', { mode: 0o600 });
+    }
+    catch { /* a medicao fica incompleta e o agendador conserva a reserva */ }
+}
+/** Reserva publicada para runners: entrada invalida, fracionaria ou zero nunca produz menos de um worker. */
+function workersDaReserva(cpus) {
+    return Math.max(1, Math.floor(Number.isFinite(cpus) ? cpus : 1));
+}
+const cpusValidas = workersDaReserva;
 /** A carga de um minuto de `/proc/loadavg`; entrada invalida ou ausencia nao inventam saturacao. */
 function cargaDoProcLoadavg(conteudo) {
     if (!conteudo)
@@ -38,44 +66,93 @@ function lerProc(arquivo) {
         return null;
     }
 }
+/** Mediana das amostras validas; quantidade par usa o ponto medio. */
+function mediana(amostras) {
+    const validas = amostras.filter((x) => Number.isFinite(x) && x >= 0).sort((a, b) => a - b);
+    if (validas.length === 0)
+        return null;
+    const meio = Math.floor(validas.length / 2);
+    return validas.length % 2 ? validas[meio] : (validas[meio - 1] + validas[meio]) / 2;
+}
+/** Fecha as amostras da sonda nas duas medianas que alimentam o plano. */
+function resumirMedicaoCpuDoGrupo(amostrasCarga1, amostrasStealPct) {
+    const cargas = amostrasCarga1.filter((x) => Number.isFinite(x) && x >= 0);
+    const steals = amostrasStealPct.filter((x) => Number.isFinite(x) && x >= 0);
+    return { carga1: mediana(cargas), stealPct: mediana(steals), amostrasCarga1: cargas, amostrasStealPct: steals };
+}
 /**
- * Mede a maquina dentro do proprio grupo, antes de qualquer comando: a carga nas duas pontas e o steal da janela.
- * A leitura maior da carga impede uma subida durante a sonda de desaparecer na media de um minuto.
+ * Mede a maquina dentro do proprio grupo, antes de qualquer comando. A janela total continua curta, mas e dividida em
+ * amostras de carga e steal; a mediana deixa um unico pico registrado sem entregar a decisao a ele.
  */
 async function medirCpuDoGrupo(janelaMs = exports.JANELA_DA_SONDA_MS) {
-    const statInicial = (0, steal_1.amostraDoProcStat)(lerProc('/proc/stat'));
-    const cargaInicial = cargaDoProcLoadavg(lerProc('/proc/loadavg'));
-    await new Promise((resolve) => setTimeout(resolve, janelaMs));
-    const cargaFinal = cargaDoProcLoadavg(lerProc('/proc/loadavg'));
-    const cargas = [cargaInicial, cargaFinal].filter((x) => x !== null);
-    return {
-        carga1: cargas.length ? Math.max(...cargas) : null,
-        stealPct: (0, steal_1.stealDaJanela)(statInicial, (0, steal_1.amostraDoProcStat)(lerProc('/proc/stat'))),
-    };
+    const cargas = [];
+    const steals = [];
+    let statAnterior = (0, steal_1.amostraDoProcStat)(lerProc('/proc/stat'));
+    const intervaloMs = janelaMs / exports.AMOSTRAS_DA_SONDA;
+    for (let i = 0; i < exports.AMOSTRAS_DA_SONDA; i++) {
+        await new Promise((resolve) => setTimeout(resolve, intervaloMs));
+        const carga = cargaDoProcLoadavg(lerProc('/proc/loadavg'));
+        if (carga !== null)
+            cargas.push(carga);
+        const statAtual = (0, steal_1.amostraDoProcStat)(lerProc('/proc/stat'));
+        const steal = (0, steal_1.stealDaJanela)(statAnterior, statAtual);
+        if (steal !== null)
+            steals.push(steal);
+        statAnterior = statAtual;
+    }
+    return resumirMedicaoCpuDoGrupo(cargas, steals);
 }
 /** O plano unico que alimenta concorrencia das lanes, varredura e `docker run --cpus`. */
 function planejarCpuDoGrupo(cpusInformadas, medicao) {
     const cpus = cpusValidas(cpusInformadas);
+    const steal = Math.min(100, Math.max(0, medicao.stealPct ?? 0));
+    // So o steal desconta capacidade. A carga de um minuto do /proc/loadavg inclui o build do proprio verify e a rodada
+    // anterior; descontada, tiraria CPUs de maquina quieta. A carga segue a regra anterior: ordem do Classic perto da
+    // maquina inteira ocupada.
+    const descontoDeSteal = steal >= exports.LIMIAR_STEAL_DO_AGENDADOR_PCT ? steal / 100 : 0;
+    const capacidadeEfetiva = Math.max(1, Math.min(cpus, Math.round(cpus * (1 - descontoDeSteal))));
     const classic = Math.max(1, cpus - 1);
     const motivos = [];
-    if (cpus < 3)
+    if (cpus < exports.MINIMO_ESTRUTURAL_DO_GRUPO)
         motivos.push(`${cpus} CPU(s), sem duas CPUs livres para o grupo paralelo`);
+    else if (capacidadeEfetiva < exports.MINIMO_ESTRUTURAL_DO_GRUPO) {
+        motivos.push(`capacidade efetiva ${capacidadeEfetiva}/${cpus} CPU(s), abaixo do minimo estrutural ${exports.MINIMO_ESTRUTURAL_DO_GRUPO}`);
+    }
     if (medicao.carga1 !== null && medicao.carga1 >= classic)
         motivos.push(`carga ${medicao.carga1} em /proc/loadavg (limiar ${classic})`);
-    if (medicao.stealPct !== null && medicao.stealPct >= exports.LIMIAR_STEAL_DO_AGENDADOR_PCT) {
-        motivos.push(`steal ${medicao.stealPct}% em /proc/stat (limiar ${exports.LIMIAR_STEAL_DO_AGENDADOR_PCT}%)`);
-    }
     const saturado = motivos.length > 0;
-    const fatia = saturado ? classic : Math.min(exports.RESERVA_DO_GRUPO, cpus - 1);
+    const estado = saturado ? 'fallback' : capacidadeEfetiva < cpus ? 'degradado' : 'agile';
+    const fatia = saturado ? classic : Math.min(exports.RESERVA_DO_GRUPO, capacidadeEfetiva - 1);
     const ferramentas = Math.max(1, Math.floor(fatia));
+    const medida = medicao.cpusIntegracao;
+    const medidaCompativel = medicao.fonteCpusIntegracao === 'medida' && Number.isFinite(medida) && medida >= 0;
+    const cpusIntegracao = saturado ? ferramentas : medidaCompativel
+        ? Math.max(1, Math.min(capacidadeEfetiva - 1, Math.ceil(medida)))
+        : ferramentas;
+    const integracaoEmParalelo = !saturado && medidaCompativel && capacidadeEfetiva - fatia - cpusIntegracao >= 1;
+    const amostras = (xs, resumo) => `[${(xs?.length ? xs : resumo === null ? [] : [resumo]).join(', ')}]`;
+    const evidencia = `carga em /proc/loadavg: amostras ${amostras(medicao.amostrasCarga1, medicao.carga1)}, mediana ` +
+        `${medicao.carga1 ?? 'indisponivel'}; steal em /proc/stat: amostras ${amostras(medicao.amostrasStealPct, medicao.stealPct)}, ` +
+        `mediana ${medicao.stealPct === null ? 'indisponivel' : `${medicao.stealPct}%`}`;
+    const motivo = saturado
+        ? `${motivos.join('; ')}; ${evidencia}`
+        : `capacidade ${capacidadeEfetiva}/${cpus} CPU(s)${estado === 'degradado' ? ' depois do desconto do steal' : ' inteira'}; ${evidencia}; ` +
+            `${fatia} CPU(s) reservadas a varredura; ` +
+            (integracaoEmParalelo ? `integracao medida cabe em paralelo com ${cpusIntegracao} CPU(s)` : 'integracao permanece encadeada');
     return {
         cpus,
         ordem: saturado ? 'classic' : 'paralela',
+        estado,
+        capacidadeEfetiva,
         saturado,
-        motivo: motivos.join('; ') || `carga e steal abaixo dos limiares; ${fatia} CPU(s) reservadas ao grupo`,
-        cpusHermetica: saturado ? classic : Math.max(1, cpus - fatia),
-        cpusHermeticaAposReserva: saturado ? classic : cpus,
-        cpusIntegracao: ferramentas,
+        motivo,
+        cpusHermetica: saturado ? classic : Math.max(1, capacidadeEfetiva - fatia - (integracaoEmParalelo ? cpusIntegracao : 0)),
+        cpusHermeticaAposVarredura: saturado ? classic : Math.max(1, capacidadeEfetiva - cpusIntegracao),
+        cpusHermeticaAposReserva: saturado ? classic : capacidadeEfetiva,
+        cpusIntegracao,
+        fonteCpusIntegracao: saturado ? 'classic' : medidaCompativel
+            ? 'medida' : 'conservadora',
+        integracaoEmParalelo,
         cpusDaFatia: fatia,
         ferramentasDaVarredura: ferramentas,
         cpusPorContainer: Math.max(0.01, Math.floor((fatia / ferramentas) * 100) / 100),
@@ -91,10 +168,23 @@ function paredeAgileSimulada(plano, trabalho) {
         return trabalho.hermetica / plano.cpusHermetica + trabalho.varredura / plano.cpusDaFatia
             + trabalho.integracao / plano.cpusIntegracao;
     }
-    const paredeDaReserva = trabalho.varredura / plano.cpusDaFatia + trabalho.integracao / plano.cpusIntegracao;
-    const feitoAntesDaDevolucao = Math.min(trabalho.hermetica, paredeDaReserva * plano.cpusHermetica);
-    const paredeDaHermetica = feitoAntesDaDevolucao === trabalho.hermetica
-        ? trabalho.hermetica / plano.cpusHermetica
-        : paredeDaReserva + (trabalho.hermetica - feitoAntesDaDevolucao) / plano.cpusHermeticaAposReserva;
-    return Math.max(paredeDaHermetica, paredeDaReserva);
+    const paredeVarredura = trabalho.varredura / plano.cpusDaFatia;
+    const paredeIntegracao = trabalho.integracao / plano.cpusIntegracao;
+    if (plano.integracaoEmParalelo) {
+        let instante = 0, restante = trabalho.hermetica, capacidade = plano.cpusHermetica;
+        for (const evento of [{ em: paredeVarredura, libera: plano.cpusDaFatia },
+            { em: paredeIntegracao, libera: plano.cpusIntegracao }].sort((a, b) => a.em - b.em)) {
+            restante = Math.max(0, restante - (evento.em - instante) * capacidade);
+            instante = evento.em;
+            capacidade += evento.libera;
+        }
+        return Math.max(paredeVarredura, paredeIntegracao, instante + restante / capacidade);
+    }
+    const feitoNaVarredura = Math.min(trabalho.hermetica, paredeVarredura * plano.cpusHermetica);
+    const restanteAposVarredura = trabalho.hermetica - feitoNaVarredura;
+    const feitoNaIntegracao = Math.min(restanteAposVarredura, paredeIntegracao * plano.cpusHermeticaAposVarredura);
+    const restanteFinal = restanteAposVarredura - feitoNaIntegracao;
+    const paredeDaHermetica = (feitoNaVarredura ? paredeVarredura : 0)
+        + (feitoNaIntegracao ? paredeIntegracao : 0) + restanteFinal / plano.cpusHermeticaAposReserva;
+    return Math.max(paredeDaHermetica, paredeVarredura + paredeIntegracao);
 }

package/dist/cenarios-sensores.js

@@ -47,10 +47,10 @@ const estado_thread_1 = require("./estado-thread");
 const catalogo_1 = require("./catalogo");
 const linha = (e) => JSON.stringify(e) + '\n';
 function esperar(teste) {
-    const limite = Date.now() + 5000;
+    const limite = Date.now() + 15000;
     while (!teste()) {
         if (Date.now() >= limite)
-            throw new Error('subprocesso do cenário não terminou em 5000 ms');
+            throw new Error('subprocesso do cenário não terminou no prazo de transporte');
         Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 10);
     }
 }
@@ -71,7 +71,8 @@ exports.CENARIO_SENSORES = {
             const hook = path.join(catalogo, 'adapters/claude-code/hooks/ork-sensor.js');
             const cli = (0, catalogo_1.cliDoCatalogo)(catalogo);
             const start = Date.now();
-            const h = (0, node_child_process_1.spawnSync)(process.execPath, [hook], { cwd: wt, encoding: 'utf8', timeout: 5000,
+            // O teto de transporte absorve a fila do Classic; a fixture continua exigindo a latência funcional abaixo de 5 s.
+            const h = (0, node_child_process_1.spawnSync)(process.execPath, [hook], { cwd: wt, encoding: 'utf8', timeout: 15000,
                 input: JSON.stringify({ cwd: wt, session_id: 'fixture-claude', hook_event_name: 'PermissionRequest', tool_use_id: 'fixture-tool' }),
                 env: { ...process.env, ORK_SENSOR_CLI: cli } });
             if (h.status !== 0 || h.stderr || h.stdout)
@@ -98,7 +99,7 @@ exports.CENARIO_SENSORES = {
             }
             // A identidade vem de um processo realmente executado e encerrado, sem recibo.
             const runner = require.resolve('./adapters/codex-runner');
-            const morto = (0, node_child_process_1.spawnSync)(process.execPath, ['-e', `console.log(JSON.stringify(require(process.argv[1]).identidadeProcesso(process.pid)))`, runner], { cwd: wt, encoding: 'utf8', timeout: 5000 });
+            const morto = (0, node_child_process_1.spawnSync)(process.execPath, ['-e', `console.log(JSON.stringify(require(process.argv[1]).identidadeProcesso(process.pid)))`, runner], { cwd: wt, encoding: 'utf8', timeout: 15000 });
             if (morto.status !== 0)
                 throw new Error('processo de morte do cenário indisponível');
             const filho = JSON.parse(morto.stdout);