@orkastery/cli 0.6.4 → 0.6.6

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.4",
+  "version": "0.6.6",
   "configSchema": {
     "type": "object",
     "properties": {},

package/adapters/openclaw/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orkastery/openclaw-plugin",
-  "version": "0.6.4",
+  "version": "0.6.6",
   "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,8 +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_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_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;
@@ -11,12 +14,16 @@ 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';
@@ -24,8 +31,11 @@ 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;
+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];
@@ -36,7 +46,11 @@ function registrarContainerDaLane(nome, ambiente = process.env) {
     }
     catch { /* a medicao fica incompleta e o agendador conserva a reserva */ }
 }
-const cpusValidas = (cpus) => Math.max(1, Math.floor(Number.isFinite(cpus) ? cpus : 1));
+/** 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)
@@ -52,49 +66,89 @@ 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 cpusIntegracao = saturado ? ferramentas : Math.max(1, Math.min(ferramentas, Number.isFinite(medida) && medida > 0 ? Math.ceil(medida) : ferramentas));
-    const medidaCompativel = medicao.fonteCpusIntegracao === 'medida' && medida !== null && medida !== undefined;
-    const integracaoEmParalelo = !saturado && medidaCompativel && cpus - fatia - cpusIntegracao >= 1;
+    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 a varredura; ` +
-            (integracaoEmParalelo ? `integracao medida cabe em paralelo com ${cpusIntegracao} CPU(s)` : 'integracao permanece encadeada'),
-        cpusHermetica: saturado ? classic : Math.max(1, cpus - fatia - (integracaoEmParalelo ? cpusIntegracao : 0)),
-        cpusHermeticaAposVarredura: saturado ? classic : Math.max(1, cpus - cpusIntegracao),
-        cpusHermeticaAposReserva: saturado ? classic : cpus,
+        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',

package/dist/check-agil.js

@@ -388,6 +388,15 @@ function caiuDeVerdade(r) {
     return !r.ok && r.executado !== false && (r.causa === undefined || r.causa === 'exit') && Number.isInteger(r.code)
         && r.code >= 1 && r.code <= MAIOR_CODIGO_DA_LANE && !(r.relogioSobSteal?.length);
 }
+/** O agregado so afirma contagens quando todas as lanes trouxeram JUnit valido. */
+function junitDasLanes(lanes) {
+    if (!lanes.length || lanes.some((l) => l.resultado.junit?.estado !== 'lido'))
+        return undefined;
+    const relatorios = lanes.map((l) => l.resultado.junit);
+    const somar = (campo) => relatorios.reduce((total, r) => total + (r[campo] ?? 0), 0);
+    return { caminho: relatorios.map((r) => r.caminho).join(';'), estado: 'lido', testes: somar('testes'),
+        falhas: somar('falhas'), erros: somar('erros'), pulados: somar('pulados'), duracaoMs: somar('duracaoMs') };
+}
 /**
  * O `test` das lanes (D4): ok so com todas ok; a evidencia de quem caiu; a parede e a da lane mais longa. A falha de
  * verdade de uma lane manda, como num comando so do Classic: o estouro ou o relogio sob steal de outra lane nao a esconde.
@@ -414,9 +423,22 @@ function testDasLanes(lanes) {
     const causas = lanes.map((l) => l.resultado.causa).filter((c) => !!c);
     const causa = deVerdade.length ? deVerdade[0].resultado.causa ?? 'exit' : PIOR_CAUSA.find((c) => causas.includes(c));
     const soRelogio = caidas.length > 0 && caidas.every((l) => (l.resultado.relogioSobSteal?.length ?? 0) > 0);
-    const testes = juntar((r) => r.testeQueCaiu).slice(0, 10);
+    const nomesExtraidos = juntar((r) => r.testeQueCaiu);
+    const testes = lanes.some((l) => l.resultado.junit?.estado === 'lido') ? nomesExtraidos : nomesExtraidos.slice(0, 10);
     const falhas = juntar((r) => r.falhasDeTeste);
+    const parciais = lanes.filter((l) => !!l.resultado.parcial);
+    const filtrados = juntar((r) => r.parcial?.testes);
+    const junit = junitDasLanes(lanes);
     const relogio = soRelogio ? juntar((r) => r.relogioSobSteal) : [];
+    const retestes = lanes.map((l) => l.resultado.retesteDeRelogio).filter((r) => !!r);
+    const estadoDoReteste = ['reprovou', 'sem-veredito', 'sem-filtro', 'passou']
+        .find((estado) => retestes.some((r) => r.estado === estado));
+    const reteste = estadoDoReteste ? {
+        testes: [...new Set(retestes.flatMap((r) => r.testes))],
+        estado: estadoDoReteste,
+        ...(retestes.find((r) => r.estado === estadoDoReteste)?.code !== undefined
+            ? { code: retestes.find((r) => r.estado === estadoDoReteste).code } : {}),
+    } : undefined;
     const trechos = caidas.map((l) => l.resultado.trecho).filter((t) => !!t);
     return {
         nome: 'test',
@@ -430,12 +452,22 @@ function testDasLanes(lanes) {
         executado: !tempoComFalha && lanes.every((l) => l.resultado.executado !== false),
         ...(testes.length ? { testeQueCaiu: testes } : {}),
         ...(falhas.length ? { falhasDeTeste: falhas } : {}),
+        ...(junit ? { junit } : {}),
+        ...(parciais.length ? { parcial: { testes: [...new Set(filtrados)] } } : {}),
         ...(trechos.length ? { trecho: trechos.join('\n').slice(0, 1024) } : {}),
         ...(lanes.some((l) => l.resultado.stealPct !== undefined) ? { stealPct: lanes.find((l) => l.resultado.stealPct !== undefined).resultado.stealPct } : {}),
         ...(relogio.length ? { relogioSobSteal: relogio } : {}),
+        ...(reteste ? { retesteDeRelogio: reteste } : {}),
         lanes: lanes.map((l) => ({ lane: l.lane, comando: l.resultado.comando, ok: l.resultado.ok, code: l.resultado.code,
             ...(l.resultado.causa ? { causa: l.resultado.causa } : {}), duracaoMs: l.resultado.duracaoMs ?? 0,
-            ...(l.resultado.testeQueCaiu?.length ? { testeQueCaiu: l.resultado.testeQueCaiu } : {}) })),
+            ...(l.resultado.testeQueCaiu?.length ? { testeQueCaiu: l.resultado.testeQueCaiu } : {}),
+            ...(l.resultado.junit ? { junit: l.resultado.junit } : {}),
+            ...(l.resultado.parcial ? { parcial: l.resultado.parcial } : {}),
+            ...(l.resultado.comandoExecutado ? { comandoExecutado: l.resultado.comandoExecutado } : {}),
+            ...(l.resultado.selecao ? { selecao: l.resultado.selecao } : {}),
+            ...(l.resultado.relogioSobSteal?.length ? { relogioSobSteal: l.resultado.relogioSobSteal } : {}),
+            ...(l.resultado.retesteDeRelogio ? { retesteDeRelogio: l.resultado.retesteDeRelogio } : {}),
+            ...(l.resultado.stealPct !== undefined ? { stealPct: l.resultado.stealPct } : {}) })),
     };
 }
 /**
@@ -466,7 +498,7 @@ function porQueDasLanes(c) {
  * Os comandos do manifesto no Agile (D4): `build` reaproveitado do preparo com a guarda valendo; o resto num grupo
  * paralelo, com as lanes no lugar do `verify.test`, so com a guarda valendo; sem ela, tudo em serie (o Classic).
  */
-function comandosNoAgile(manifesto, cwd, lista, executor, grupo, guarda, preparo) {
+function comandosNoAgile(manifesto, cwd, lista, executor, grupo, guarda, preparo, selecao = { comandos: {}, lanes: {} }, passagemParcial, selecaoPorMudanca = {}) {
     const pecas = [];
     const passosDoPreparo = manifesto.verify.preparo ? passosDoComando(manifesto.verify.preparo) : [];
     const lanesDeclaradas = Object.entries(manifesto.check?.agile?.test ?? {});
@@ -480,7 +512,12 @@ function comandosNoAgile(manifesto, cwd, lista, executor, grupo, guarda, preparo
             pecas.push({ peca: 'grupo', estado: 'fallback', motivo, fallback: 'comandos em serie' });
         if (lanesDeclaradas.length > 0)
             pecas.push({ peca: 'lanes', estado: 'fallback', motivo, fallback: 'verify.test' });
-        return { comandos: lista.map((c) => executor(c.nome, c.comando, cwd)), pecas, paralelo: false, lanes: [] };
+        const executar = (c) => {
+            const parcial = c.filtro && selecao.comandos[c.nome]
+                ? passagemParcial?.(c.nome, c.comando, cwd, c.filtro, selecao.comandos[c.nome]) : null;
+            return parcial && !parcial.ok ? parcial : executor(c.nome, c.comando, cwd);
+        };
+        return { comandos: lista.map(executar), pecas, paralelo: false, lanes: [] };
     }
     // Com a guarda: o build primeiro (do preparo, quando e so passos dele), e o resto junto.
     const build = lista.find((c) => c.nome === 'build');
@@ -499,17 +536,55 @@ function comandosNoAgile(manifesto, cwd, lista, executor, grupo, guarda, preparo
     for (const c of resto) {
         if (c.nome === 'test' && lanesDeclaradas.length > 0) {
             for (const [lane, comando] of lanesDeclaradas) {
+                const junit = manifesto.check?.agile?.junit?.[lane];
+                const filtro = manifesto.check?.agile?.filtro?.[lane];
+                const recursos = manifesto.check?.agile?.recursos?.[lane];
+                const testesFiltrados = selecao.lanes[lane];
+                const porMudanca = selecaoPorMudanca[lane];
+                const efetivo = porMudanca?.comando ?? comando;
+                const dadosDaSelecao = porMudanca ? { comandoIntegral: comando, selecaoPorMudanca: porMudanca } : {};
                 if (depoisDaVarredura.has(lane))
-                    encadeados.push({ nome: `test:${lane}`, comando, apos: ['security_scan'], papelCpu: 'integracao' });
+                    encadeados.push({ nome: `test:${lane}`, comando: efetivo, ...dadosDaSelecao,
+                        ...(junit ? { junit } : {}), ...(filtro ? { filtro } : {}), ...(testesFiltrados ? { testesFiltrados } : {}),
+                        ...(recursos?.length ? { recursos } : {}),
+                        apos: ['security_scan'], papelCpu: 'integracao' });
                 else
-                    itens.push({ nome: `test:${lane}`, comando, papelCpu: lane === 'hermetica' ? 'hermetica' : 'outro' });
+                    itens.push({ nome: `test:${lane}`, comando: efetivo, ...dadosDaSelecao, ...(junit ? { junit } : {}),
+                        ...(filtro ? { filtro } : {}), ...(testesFiltrados ? { testesFiltrados } : {}),
+                        ...(recursos?.length ? { recursos } : {}),
+                        papelCpu: lane === 'hermetica' ? 'hermetica' : 'outro' });
             }
         }
         else
-            itens.push({ nome: c.nome, comando: c.comando, papelCpu: c.nome === 'security_scan' ? 'varredura' : 'outro' });
+            itens.push({ nome: c.nome, comando: c.comando, ...(c.junit ? { junit: c.junit } : {}),
+                ...(c.filtro ? { filtro: c.filtro } : {}), ...(selecao.comandos[c.nome] ? { testesFiltrados: selecao.comandos[c.nome] } : {}),
+                papelCpu: c.nome === 'security_scan' ? 'varredura' : 'outro' });
     }
     itens.push(...encadeados);
-    const resultados = itens.length > 1 ? grupo(itens, cwd) : itens.map((i) => executor(i.nome, i.comando, cwd));
+    const parciaisVermelhas = new Map();
+    for (const item of itens) {
+        if (!item.filtro || !item.testesFiltrados?.length || !passagemParcial)
+            continue;
+        const parcial = passagemParcial(item.nome, item.comando, cwd, item.filtro, item.testesFiltrados);
+        if (parcial && !parcial.ok)
+            parciaisVermelhas.set(item.nome, parcial);
+    }
+    const inteiros = itens.filter((i) => !parciaisVermelhas.has(i.nome));
+    const resultadosInteiros = inteiros.length > 1 ? grupo(inteiros, cwd) : inteiros.map((i) => executor(i.nome, i.comando, cwd));
+    const porItemInteiro = new Map(inteiros.map((item, i) => [item.nome, resultadosInteiros[i]]));
+    const resultados = itens.map((item) => {
+        const parcial = parciaisVermelhas.get(item.nome);
+        if (parcial)
+            return parcial;
+        const resultado = porItemInteiro.get(item.nome);
+        if (!item.selecaoPorMudanca || !item.comandoIntegral)
+            return resultado;
+        const { comando: _comando, ...registro } = item.selecaoPorMudanca;
+        return item.selecaoPorMudanca.modo === 'selecionada'
+            ? { ...resultado, comando: item.comandoIntegral, comandoExecutado: item.comando,
+                parcial: { testes: [] }, selecao: registro }
+            : { ...resultado, comando: item.comandoIntegral, selecao: registro };
+    });
     pecas.push(...(grupo.pecas ?? []));
     const lanes = [];
     itens.forEach((item, i) => {
@@ -590,7 +665,8 @@ exports.RelatorioDoCheck = RelatorioDoCheck;
  */
 function pecasDoRelatorio(linhas) {
     const vistas = new Set();
-    return linhas.filter((l) => l.tipo === 'peca' && typeof l.peca === 'string' && (l.estado === 'agile' || l.estado === 'fallback'))
+    return linhas.filter((l) => l.tipo === 'peca' && typeof l.peca === 'string'
+        && (l.estado === 'agile' || l.estado === 'degradado' || l.estado === 'fallback'))
         .map((l) => ({ peca: l.peca, estado: l.estado,
         ...(typeof l.motivo === 'string' ? { motivo: l.motivo } : {}), ...(typeof l.fallback === 'string' ? { fallback: l.fallback } : {}) }))
         .filter((p) => { const chave = JSON.stringify(p); if (vistas.has(chave))