@orkastery/cli 0.6.3 → 0.6.4

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

package/adapters/openclaw/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orkastery/openclaw-plugin",
-  "version": "0.6.3",
+  "version": "0.6.4",
   "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/agendador-cpu.js

@@ -1,6 +1,7 @@
 "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.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.registrarContainerDaLane = registrarContainerDaLane;
 exports.cargaDoProcLoadavg = cargaDoProcLoadavg;
 exports.medirCpuDoGrupo = medirCpuDoGrupo;
 exports.planejarCpuDoGrupo = planejarCpuDoGrupo;
@@ -16,12 +17,25 @@ exports.paredeAgileSimulada = paredeAgileSimulada;
 const node_fs_1 = require("node:fs");
 const steal_1 = require("./steal");
 exports.ENV_CPUS_DA_LANE = 'ORK_CHECK_CPUS_DA_LANE';
+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.LIMIAR_STEAL_DO_AGENDADOR_PCT = 10;
 exports.JANELA_DA_SONDA_MS = 250;
+/** 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 */ }
+}
 const cpusValidas = (cpus) => Math.max(1, Math.floor(Number.isFinite(cpus) ? cpus : 1));
 /** A carga de um minuto de `/proc/loadavg`; entrada invalida ou ausencia nao inventam saturacao. */
 function cargaDoProcLoadavg(conteudo) {
@@ -68,14 +82,23 @@ function planejarCpuDoGrupo(cpusInformadas, medicao) {
     const saturado = motivos.length > 0;
     const fatia = saturado ? classic : Math.min(exports.RESERVA_DO_GRUPO, cpus - 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;
     return {
         cpus,
         ordem: saturado ? 'classic' : 'paralela',
         saturado,
-        motivo: motivos.join('; ') || `carga e steal abaixo dos limiares; ${fatia} CPU(s) reservadas ao grupo`,
-        cpusHermetica: saturado ? classic : Math.max(1, cpus - fatia),
+        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,
-        cpusIntegracao: ferramentas,
+        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 +114,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);

package/dist/check-agil.js

@@ -627,8 +627,8 @@ function resultadosDasLanes(linhas) {
 /** Hash do ambiente funcional; transporte do CHECK, npm e bookkeeping do shell nao mudam o teste. */
 function assinaturaDoAmbiente(env) {
     const ignorada = (nome) => nome.startsWith('npm_') || nome.startsWith('NPM_')
-        || ['ORK_CHECK_RELATORIO', 'ORK_CHECK_CPUS_DA_LANE', 'ORK_CHECK_CPUS_DA_LANE_APOS_RESERVA', 'ORK_CHECK_RESERVA_DEVOLVIDA',
-            'ORK_CHECK_CPUS_DOCKER',
+        || ['ORK_CHECK_RELATORIO', 'ORK_CHECK_CPUS_DA_LANE', 'ORK_CHECK_CPUS_DA_LANE_APOS_VARREDURA',
+            'ORK_CHECK_CPUS_DA_LANE_APOS_RESERVA', 'ORK_CHECK_RESERVA_DEVOLVIDA', 'ORK_CHECK_CONTAINERS_DA_LANE', 'ORK_CHECK_CPUS_DOCKER',
             'NODE_TEST_CONTEXT', 'NODE_COMPILE_CACHE', 'PWD', 'OLDPWD', 'SHLVL', '_', 'INIT_CWD'].includes(nome);
     const pares = Object.entries(env).filter(([nome, valor]) => valor !== undefined && !ignorada(nome))
         .sort(([a], [b]) => a.localeCompare(b));

package/dist/check-paralelo.js

@@ -34,6 +34,8 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.argvDoItem = argvDoItem;
+exports.chaveDoPerfilIntegracao = chaveDoPerfilIntegracao;
+exports.picoCpuPorFonte = picoCpuPorFonte;
 exports.esperaDoGrupo = esperaDoGrupo;
 exports.rodarEmParalelo = rodarEmParalelo;
 /**
@@ -48,12 +50,17 @@ exports.rodarEmParalelo = rodarEmParalelo;
  * de integracao depois da varredura), e `maxParalelo` limita quantos rodam ao mesmo tempo.
  */
 const node_child_process_1 = require("node:child_process");
+const node_crypto_1 = require("node:crypto");
 const fs = __importStar(require("node:fs"));
 const os = __importStar(require("node:os"));
 const path = __importStar(require("node:path"));
 const agendador_cpu_1 = require("./agendador-cpu");
+const integracoes_locais_1 = require("./integracoes-locais");
 const TIMEOUT_BIN = '/usr/bin/timeout';
 const NICE_BIN = '/usr/bin/nice';
+const TIME_BIN = '/usr/bin/time';
+const CONTRATO_PERFIL_INTEGRACAO = 'ork.check.cpu-integracao/v1';
+const INTERVALO_CPU_MS = 100;
 /** O argv de um item: `nice` (se pedido e existir), `timeout(1)` (se existir) e o `argv` do item ou `bash -c`. */
 function argvDoItem(item, comGrupo = fs.existsSync(TIMEOUT_BIN), comNice = fs.existsSync(NICE_BIN)) {
     const programa = item.argv?.length ? item.argv : ['bash', '-c', item.comando];
@@ -77,6 +84,243 @@ function vagas(max) {
             livres++; },
     };
 }
+function arquivoDoPerfilIntegracao() {
+    const base = process.env.XDG_CACHE_HOME && path.isAbsolute(process.env.XDG_CACHE_HOME)
+        ? process.env.XDG_CACHE_HOME : path.join(os.homedir(), '.cache');
+    return path.join(base, 'orkastery', 'check', 'cpu-integracao.json');
+}
+/** Os arquivos da lane de integracao, pela mesma regra do `test-lanes.cjs`: a lista do ambiente ou a do nucleo. */
+function arquivosDaIntegracao(env = process.env) {
+    const lista = env.ORK_LANES_INTEGRACAO !== undefined
+        ? env.ORK_LANES_INTEGRACAO.split(',').map((n) => n.trim()).filter(Boolean) : [...integracoes_locais_1.TESTES_DE_INTEGRACAO_LOCAL];
+    return [...new Set(lista)].sort();
+}
+/**
+ * A medida so atravessa rodadas quando comando, capacidade e entradas que definem a lane continuam iguais: o script das
+ * lanes, a lista de integracao e o conteudo compilado de cada teste dela. Teste novo, mudado ou ausente troca a chave.
+ */
+function chaveDoPerfilIntegracao(itens, cpus, arquivos = arquivosDaIntegracao()) {
+    const integracao = itens.filter((i) => i.papelCpu === 'integracao');
+    if (!integracao.length)
+        return null;
+    const h = (0, node_crypto_1.createHash)('sha256').update(JSON.stringify({ cpus, node: process.version,
+        comandos: integracao.map((i) => i.comando), arquivos }));
+    const cwd = integracao[0].cwd;
+    const relativos = ['core/dist/integracoes-locais.js', 'core/scripts/test-lanes.cjs',
+        ...arquivos.map((nome) => path.join('core', 'dist-test', 'test', nome))];
+    for (const relativo of relativos) {
+        try {
+            h.update(relativo).update(fs.readFileSync(path.join(cwd, relativo)));
+        }
+        catch {
+            h.update(`${relativo}:ausente`);
+        }
+    }
+    return h.digest('hex');
+}
+function lerPerfilIntegracao(chave, cpus) {
+    if (!chave)
+        return null;
+    try {
+        const p = JSON.parse(fs.readFileSync(arquivoDoPerfilIntegracao(), 'utf8'));
+        return p?.contrato === CONTRATO_PERFIL_INTEGRACAO && p.chave === chave && p.cpus === cpus && p.completa
+            && Number.isFinite(p.picoCpus) && p.picoCpus > 0 && p.picoCpus <= cpus ? p : null;
+    }
+    catch {
+        return null;
+    }
+}
+function gravarPerfilIntegracao(chave, cpus, medicao) {
+    if (!chave || !medicao.completa || medicao.anomalia || medicao.picoCpus === null
+        || !(medicao.picoCpus > 0) || medicao.picoCpus > cpus)
+        return;
+    const arquivo = arquivoDoPerfilIntegracao();
+    try {
+        fs.mkdirSync(path.dirname(arquivo), { recursive: true });
+        const temporario = `${arquivo}.${process.pid}.tmp`;
+        const perfil = { contrato: CONTRATO_PERFIL_INTEGRACAO, chave, cpus,
+            picoCpus: medicao.picoCpus, completa: true, medidoEm: new Date().toISOString() };
+        fs.writeFileSync(temporario, JSON.stringify(perfil) + '\n', { mode: 0o600 });
+        fs.renameSync(temporario, arquivo);
+    }
+    catch { /* cache de desempenho ausente conserva a reserva; nunca derruba o CHECK */ }
+}
+const CLK_TCK = (() => {
+    const r = (0, node_child_process_1.spawnSync)('getconf', ['CLK_TCK'], { encoding: 'utf8', timeout: 1000 });
+    const n = Number(r.stdout?.trim());
+    return Number.isFinite(n) && n > 0 ? n : 100;
+})();
+function processosCpu() {
+    const tabela = new Map();
+    let nomes = [];
+    try {
+        nomes = fs.readdirSync('/proc');
+    }
+    catch {
+        return tabela;
+    }
+    for (const nome of nomes) {
+        if (!/^\d+$/.test(nome))
+            continue;
+        try {
+            const stat = fs.readFileSync(`/proc/${nome}/stat`, 'utf8');
+            const depois = stat.slice(stat.lastIndexOf(')') + 2).trim().split(/\s+/);
+            tabela.set(Number(nome), { ppid: Number(depois[1]), cpuMs: (Number(depois[11]) + Number(depois[12])) * 1000 / CLK_TCK,
+                inicio: depois[19] });
+        }
+        catch { /* acabou entre a lista e a leitura */ }
+    }
+    return tabela;
+}
+function arvoreDeProcessos(raiz, tabela) {
+    const filhos = new Map();
+    for (const [pid, p] of tabela) {
+        const lista = filhos.get(p.ppid) ?? [];
+        lista.push(pid);
+        filhos.set(p.ppid, lista);
+    }
+    const vistos = new Set(), pilha = [raiz];
+    while (pilha.length) {
+        const pid = pilha.pop();
+        if (vistos.has(pid))
+            continue;
+        vistos.add(pid);
+        pilha.push(...(filhos.get(pid) ?? []));
+    }
+    return [...vistos];
+}
+function nomesDosContainers(arquivo) {
+    try {
+        return [...new Set(fs.readFileSync(arquivo, 'utf8').split('\n').filter(Boolean).flatMap((linha) => {
+                try {
+                    const r = JSON.parse(linha);
+                    return typeof r.nome === 'string' ? [r.nome] : [];
+                }
+                catch {
+                    return [];
+                }
+            }))];
+    }
+    catch {
+        return [];
+    }
+}
+function arquivoCpuDoContainer(nome) {
+    const r = (0, node_child_process_1.spawnSync)('docker', ['inspect', '--format', '{{.Id}} {{.State.Pid}}', nome], { encoding: 'utf8', timeout: 1000 });
+    const [id = '', pidTexto = ''] = r.stdout?.trim().split(/\s+/) ?? [];
+    const pid = Number(pidTexto);
+    if (r.status !== 0)
+        return { fonte: null, motivo: 'docker inspect nao encontrou o conteiner' };
+    if (!/^[a-f0-9]{12,64}$/.test(id) || !Number.isInteger(pid) || pid <= 0) {
+        return { fonte: null, motivo: 'PID ou identificador do conteiner indisponivel' };
+    }
+    let linhas = '';
+    try {
+        linhas = fs.readFileSync(`/proc/${pid}/cgroup`, 'utf8');
+    }
+    catch {
+        return { fonte: null, motivo: 'cgroup do PID do conteiner indisponivel' };
+    }
+    const unificado = /^0::(.+)$/m.exec(linhas)?.[1];
+    const candidatos = [
+        ...(unificado ? [{ arquivo: path.join('/sys/fs/cgroup', unificado, 'cpu.stat'), divisor: 1000 }] : []),
+        { arquivo: path.join('/sys/fs/cgroup/system.slice', `docker-${id}.scope`, 'cpu.stat'), divisor: 1000 },
+        { arquivo: path.join('/sys/fs/cgroup/docker', id, 'cpu.stat'), divisor: 1000 },
+    ];
+    const legado = /^(?:\d+):[^\n]*(?:cpuacct|cpu)[^\n]*:(.+)$/m.exec(linhas)?.[1];
+    if (legado)
+        candidatos.push({ arquivo: path.join('/sys/fs/cgroup/cpuacct', legado, 'cpuacct.usage'), divisor: 1_000_000 });
+    const fonte = candidatos.find((x) => fs.existsSync(x.arquivo)) ?? null;
+    return fonte ? { fonte, motivo: null }
+        : { fonte: null, motivo: 'cpu.stat ausente no cgroup v2, no escopo do systemd e no caminho legado' };
+}
+function lerCpuDoCgroup(fonte) {
+    try {
+        const texto = fs.readFileSync(fonte.arquivo, 'utf8');
+        const bruto = fonte.arquivo.endsWith('cpu.stat') ? Number(/^usage_usec\s+(\d+)$/m.exec(texto)?.[1]) : Number(texto.trim());
+        return Number.isFinite(bruto) && bruto >= 0 ? bruto / fonte.divisor : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Calcula o pico por fonte. A primeira leitura vira baseline; uma fonte que nasce depois dela contribui com o acumulado
+ * desde seu nascimento, sem despejar na janela o tempo anterior de processos ou conteineres que ja existiam.
+ */
+function picoCpuPorFonte(amostras, cpus) {
+    let pico = 0;
+    for (let i = 1; i < amostras.length; i++) {
+        const anterior = amostras[i - 1], atual = amostras[i];
+        if (!(atual.em > anterior.em))
+            continue;
+        let delta = 0;
+        for (const [fonte, acumulado] of Object.entries(atual.fontes)) {
+            const base = anterior.fontes[fonte];
+            delta += Math.max(0, acumulado - (base ?? 0));
+        }
+        pico = Math.max(pico, delta / (atual.em - anterior.em));
+    }
+    if (pico > cpus + 1e-9) {
+        return { picoCpus: null, anomalia: `pico medido de ${pico.toFixed(2)} CPU excede a capacidade de ${cpus} CPU` };
+    }
+    return { picoCpus: pico > 0 ? Math.ceil(pico * 100) / 100 : null, anomalia: null };
+}
+/** CPU acumulada e pico por janela da integracao; nomes registrados mas nunca observados tornam a medida incompleta. */
+function sondarCpuDaIntegracao(pid, registro, cpus) {
+    const fontes = new Map();
+    const motivos = new Map();
+    const amostras = [];
+    const primeiraCpuDosContainers = new Map();
+    const ultimaCpuDosContainers = new Map();
+    const amostrar = () => {
+        const tabela = processosCpu();
+        const atuais = {};
+        for (const p of arvoreDeProcessos(pid, tabela)) {
+            const x = tabela.get(p);
+            if (x)
+                atuais[`processo:${p}:${x.inicio}`] = x.cpuMs;
+        }
+        for (const nome of nomesDosContainers(registro)) {
+            let fonte = fontes.get(nome);
+            if (!fonte) {
+                const busca = arquivoCpuDoContainer(nome);
+                if (busca.fonte) {
+                    fonte = busca.fonte;
+                    fontes.set(nome, fonte);
+                    motivos.delete(nome);
+                }
+                else if (busca.motivo)
+                    motivos.set(nome, busca.motivo);
+            }
+            const cpu = fonte ? lerCpuDoCgroup(fonte) : null;
+            if (cpu !== null) {
+                atuais[`conteiner:${nome}`] = cpu;
+                if (!primeiraCpuDosContainers.has(nome))
+                    primeiraCpuDosContainers.set(nome, amostras.length === 0 ? cpu : 0);
+                ultimaCpuDosContainers.set(nome, cpu);
+                motivos.delete(nome);
+            }
+            else if (fonte)
+                motivos.set(nome, 'contador de CPU do cgroup ilegivel');
+        }
+        amostras.push({ em: Date.now(), fontes: atuais });
+    };
+    return {
+        amostrar,
+        fechar: (arvoreMs, paredeMs) => {
+            amostrar();
+            const nomes = nomesDosContainers(registro);
+            const containersMs = nomes.reduce((total, nome) => total + Math.max(0, (ultimaCpuDosContainers.get(nome) ?? 0) - (primeiraCpuDosContainers.get(nome) ?? 0)), 0);
+            const ausentes = nomes.filter((nome) => !ultimaCpuDosContainers.has(nome));
+            const pico = picoCpuPorFonte(amostras, cpus);
+            return { arvoreMs, containersMs, totalMs: arvoreMs + containersMs, paredeMs,
+                picoCpus: pico.picoCpus, completa: ausentes.length === 0 && !pico.anomalia,
+                containers: nomes, ausentes, motivosDosAusentes: ausentes.map((container) => ({ container,
+                    motivo: motivos.get(container) ?? 'conteiner terminou antes de uma amostra completa' })), anomalia: pico.anomalia };
+        },
+    };
+}
 /**
  * O lado do auxiliar: lanca cada item quando os de `apos` terminam e ha vaga, espera todos e grava `resultado.json` ao
  * lado das saidas.
@@ -84,7 +328,15 @@ function vagas(max) {
 async function rodarEspecificacao(esp) {
     const comGrupo = fs.existsSync(TIMEOUT_BIN);
     const usaAgendador = esp.itens.some((i) => i.papelCpu === 'hermetica');
-    const plano = usaAgendador ? (0, agendador_cpu_1.planejarCpuDoGrupo)(esp.cpus ?? os.availableParallelism(), esp.medicaoCpu ?? await (0, agendador_cpu_1.medirCpuDoGrupo)()) : undefined;
+    const cpus = esp.cpus ?? os.availableParallelism();
+    const chaveDoPerfil = usaAgendador ? chaveDoPerfilIntegracao(esp.itens, cpus) : null;
+    const perfil = esp.medicaoCpu?.cpusIntegracao === undefined ? lerPerfilIntegracao(chaveDoPerfil, cpus) : null;
+    const medicao = esp.medicaoCpu ?? await (0, agendador_cpu_1.medirCpuDoGrupo)();
+    if (perfil)
+        Object.assign(medicao, { cpusIntegracao: perfil.picoCpus, fonteCpusIntegracao: 'medida' });
+    else if (medicao.cpusIntegracao === undefined)
+        Object.assign(medicao, { cpusIntegracao: null, fonteCpusIntegracao: 'conservadora' });
+    const plano = usaAgendador ? (0, agendador_cpu_1.planejarCpuDoGrupo)(cpus, medicao) : undefined;
     const sinalDaReserva = plano && !plano.saturado ? path.join(esp.dir, 'reserva-devolvida.json') : undefined;
     const itens = plano ? aplicarPlano(esp.itens, plano, sinalDaReserva) : esp.itens;
     const limite = vagas(esp.maxParalelo && esp.maxParalelo > 0 ? esp.maxParalelo : itens.length);
@@ -119,29 +371,86 @@ async function rodarEspecificacao(esp) {
         if (!sinalDaReserva || !reservados.some((item) => item.papelCpu === 'varredura')
             || !reservados.some((item) => item.papelCpu === 'integracao'))
             return;
-        await Promise.all(reservados.map((item) => vezDoItem(item, indice.get(item.nome))));
-        fs.writeFileSync(sinalDaReserva, JSON.stringify({ em: new Date().toISOString(), vagas: plano.cpusHermeticaAposReserva }), { mode: 0o600 });
+        const varreduras = reservados.filter((item) => item.papelCpu === 'varredura');
+        const integracoes = reservados.filter((item) => item.papelCpu === 'integracao');
+        const degrau = async (origem, pecas, vagas, antes) => {
+            await Promise.all(pecas.map((item) => vezDoItem(item, indice.get(item.nome))));
+            fs.appendFileSync(sinalDaReserva, JSON.stringify({ contrato: 'ork.check.reserva-devolvida/v2', origem,
+                em: new Date().toISOString(), vagasGanhas: vagas - antes, vagas }) + '\n', { mode: 0o600 });
+        };
+        if (!plano.integracaoEmParalelo) {
+            await degrau('varredura', varreduras, plano.cpusHermeticaAposVarredura, plano.cpusHermetica);
+            await degrau('integracao', integracoes, plano.cpusHermeticaAposReserva, plano.cpusHermeticaAposVarredura);
+        }
+        else {
+            // As promessas escrevem em série no event loop; o primeiro término recebe somente a reserva da própria peça.
+            let vagas = plano.cpusHermetica;
+            const aoTerminar = async (origem, pecas, libera) => {
+                await Promise.all(pecas.map((item) => vezDoItem(item, indice.get(item.nome))));
+                const antes = vagas;
+                vagas = Math.min(plano.cpus, vagas + libera);
+                fs.appendFileSync(sinalDaReserva, JSON.stringify({ contrato: 'ork.check.reserva-devolvida/v2', origem,
+                    em: new Date().toISOString(), vagasGanhas: vagas - antes, vagas }) + '\n', { mode: 0o600 });
+            };
+            await Promise.all([aoTerminar('varredura', varreduras, plano.cpusDaFatia),
+                aoTerminar('integracao', integracoes, plano.cpusIntegracao)]);
+        }
     };
     const [, terminados] = await Promise.all([devolverReserva(), todos]);
+    const medidaDaIntegracao = terminados.find((t) => t.medicaoCpu)?.medicaoCpu;
+    if (plano && medidaDaIntegracao) {
+        plano.medicaoCpuIntegracao = medidaDaIntegracao;
+        gravarPerfilIntegracao(chaveDoPerfil, cpus, medidaDaIntegracao);
+    }
     fs.writeFileSync(path.join(esp.dir, 'resultado.json'), JSON.stringify({ terminados, ...(plano ? { agendamentoCpu: plano } : {}) }), { mode: 0o600 });
     function lancar(item, i) {
         return new Promise((resolve) => {
             const saida = fs.openSync(path.join(esp.dir, `${i}.out`), 'w', 0o600);
             const erro = fs.openSync(path.join(esp.dir, `${i}.err`), 'w', 0o600);
             const inicio = Date.now();
-            const [bin, ...args] = argvDoItem(item, comGrupo);
+            const medirIntegracao = item.papelCpu === 'integracao';
+            const registro = path.join(esp.dir, `${i}.containers.jsonl`);
+            const tempo = path.join(esp.dir, `${i}.tempo`);
+            if (medirIntegracao)
+                fs.writeFileSync(registro, '', { mode: 0o600 });
+            const base = argvDoItem(item, comGrupo);
+            const medido = medirIntegracao && fs.existsSync(TIME_BIN)
+                ? [TIME_BIN, '-f', '%U %S', '-o', tempo, ...base] : base;
+            const [bin, ...args] = medido;
             let fim = null;
+            let sonda = null;
+            let relogio = null;
             const encerrar = (t) => {
                 if (fim)
                     return;
-                fim = t;
+                if (relogio)
+                    clearInterval(relogio);
+                let arvoreMs = 0;
+                if (medirIntegracao) {
+                    try {
+                        const [user, sys] = fs.readFileSync(tempo, 'utf8').trim().split(/\s+/).map(Number);
+                        arvoreMs = (user + sys) * 1000;
+                    }
+                    catch { /* medida incompleta abaixo */ }
+                }
+                const medicaoCpu = medirIntegracao && sonda ? sonda.fechar(arvoreMs, t.duracaoMs) : undefined;
+                if (medicaoCpu && !(arvoreMs > 0))
+                    medicaoCpu.completa = false;
+                fim = { ...t, ...(medicaoCpu ? { medicaoCpu } : {}) };
                 fs.closeSync(saida);
                 fs.closeSync(erro);
-                resolve(t);
+                resolve(fim);
             };
             // Sem o `timeout(1)`, o proprio auxiliar mata pelo prazo, como o `spawnSync` do `exec` faria.
-            const filho = (0, node_child_process_1.spawn)(bin, args, { cwd: item.cwd, env: { ...process.env, ...item.ambiente }, stdio: ['ignore', saida, erro],
+            const ambiente = { ...process.env, ...item.ambiente,
+                ...(medirIntegracao ? { [agendador_cpu_1.ENV_CONTAINERS_DA_LANE]: registro } : {}) };
+            const filho = (0, node_child_process_1.spawn)(bin, args, { cwd: item.cwd, env: ambiente, stdio: ['ignore', saida, erro],
                 ...(comGrupo ? {} : { timeout: item.prazoMs, killSignal: 'SIGTERM' }) });
+            if (medirIntegracao) {
+                sonda = sondarCpuDaIntegracao(filho.pid, registro, cpus);
+                sonda.amostrar();
+                relogio = setInterval(sonda.amostrar, INTERVALO_CPU_MS);
+            }
             filho.on('error', (e) => encerrar({ nome: item.nome, code: null, signal: null,
                 error: e.code ?? e.message, duracaoMs: Date.now() - inicio, comGrupo }));
             filho.on('close', (code, signal) => encerrar({ nome: item.nome, code, signal,
@@ -170,24 +479,25 @@ function aplicarPlano(originais, plano, sinalDaReserva) {
     const cpusContainer = String(plano.cpusPorContainer);
     ambiente(hermetica, { [agendador_cpu_1.ENV_CPUS_DA_LANE]: String(plano.cpusHermetica), [agendador_cpu_1.ENV_CPUS_DOCKER]: cpusContainer,
         ...(sinalDaReserva && varredura && integracoes.length > 0 ? {
+            [agendador_cpu_1.ENV_CPUS_DA_LANE_APOS_VARREDURA]: String(plano.cpusHermeticaAposVarredura),
             [agendador_cpu_1.ENV_CPUS_DA_LANE_APOS_RESERVA]: String(plano.cpusHermeticaAposReserva), [agendador_cpu_1.ENV_SINAL_DA_RESERVA]: sinalDaReserva,
         } : {}) });
     ambiente(varredura, {
         ORK_CHECK_VARREDURA_PARALELA: String(plano.ferramentasDaVarredura),
         [agendador_cpu_1.ENV_CPUS_DOCKER]: cpusContainer,
     });
-    let anterior = varredura?.nome;
+    let anteriorIntegracao;
     for (const item of integracoes) {
         ambiente(item, { [agendador_cpu_1.ENV_CPUS_DA_LANE]: String(plano.cpusIntegracao), [agendador_cpu_1.ENV_CPUS_DOCKER]: cpusContainer });
-        depender(item, [anterior]);
-        anterior = item.nome;
+        depender(item, [anteriorIntegracao ?? (plano.integracaoEmParalelo ? undefined : varredura?.nome)]);
+        anteriorIntegracao = item.nome;
     }
     if (plano.saturado)
         depender(varredura, [hermetica?.nome]);
     // Comandos sem papel conhecido nao disputam CPU com as tres pecas: fecham a cadeia, um por vez.
     for (const item of outros) {
-        depender(item, [hermetica?.nome, anterior]);
-        anterior = item.nome;
+        depender(item, [hermetica?.nome, varredura?.nome, anteriorIntegracao]);
+        anteriorIntegracao = item.nome;
     }
     return itens;
 }

package/dist/security-scan/agil.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PRAZO_MINIMO_DO_CLASSIC_MS = exports.PRAZO_DO_BUILD_DA_IMAGEM_MS = exports.PRAZO_POR_REGRA_DO_SEMGREP_S = exports.SEMGREP_SEM_CACHE = void 0;
+exports.PRAZO_MINIMO_DO_CLASSIC_MS = exports.PRAZO_DO_BUILD_DA_IMAGEM_MS = exports.PRAZO_POR_REGRA_DO_SEMGREP_S = void 0;
 exports.especificacaoDoAgile = especificacaoDoAgile;
 exports.prazoDoBuildDaImagem = prazoDoBuildDaImagem;
 exports.estourouNoAgile = estourouNoAgile;
@@ -48,9 +48,9 @@ exports.runScanAgil = runScanAgil;
  * ferramentas do catalogo e a mesma classificacao contra a base. O que muda e o empacotamento: a arvore da base sai uma
  * vez, antes, e cada ferramenta roda num trabalhador proprio (`trabalhador.ts`), ao mesmo tempo, chamando o mesmo
  * `scanTool` do Classic; o relatorio sai na ordem do catalogo. As ferramentas do Trivy montam um diretorio persistente
- * por ferramenta no `/tmp/trivy-cache` do catalogo, para o banco nao descer a cada rodada (cache de banco, nunca de
- * resultado: o HEAD e sempre varrido de novo, e a base usa o cache por SHA que o `scanBase` ja tem, com a chave da
- * especificacao do Agile). Cada peca do Agile que nao pode rodar cai para o equivalente do Classic e vai ao relatorio
+ * por ferramenta no `/tmp/trivy-cache` do catalogo. O resultado normalizado do Semgrep e das ferramentas de dependência
+ * fica no cache da máquina, por versão, regras e conteúdo; o Classic continua varrendo toda a árvore. Cada peça do Agile
+ * que não pode rodar cai para o equivalente do Classic e vai ao relatório
  * (`check.pecas`) e ao `ORK_CHECK_RELATORIO` do verify.
  */
 const fs = __importStar(require("node:fs"));
@@ -63,6 +63,7 @@ const redacao_url_1 = require("../redacao-url");
 const compare_1 = require("./compare");
 const config_1 = require("./config");
 const guard_1 = require("./guard");
+const incremental_1 = require("./incremental");
 const run_1 = require("./run");
 const executor_1 = require("./executor");
 const imagem_de_lint_1 = require("./imagem-de-lint");
@@ -71,12 +72,9 @@ const TRABALHADOR = path.join(__dirname, 'trabalhador.js');
 /** Sem prazo da rodada, o trabalhador ganha o maior prazo do catalogo para a HEAD e para a base, com folga. */
 const FOLGA_MS = 60_000;
 /**
- * O Semgrep baixa as regras do registro (`p/typescript`, ...) a cada rodada, e nao tem cache delas. Regra lida de arquivo
- * local ganha outro `check_id` (o prefixo do caminho), o que muda a impressao digital de todo achado: o cache de regras
- * fica de fora, declarado como peca em fallback.
+ * O cache guarda os achados normalizados junto da identidade das regras do registro. Assim uma rodada morna devolve o
+ * `check_id` original, em vez de reler uma regra por arquivo local e reescrever a impressão digital.
  */
-exports.SEMGREP_SEM_CACHE = { peca: 'cache-semgrep', estado: 'fallback',
-    motivo: 'regra lida de arquivo local troca o check_id e a impressao digital', fallback: 'regras do registro a cada rodada, como no Classic' };
 /**
  * O prazo por regra e arquivo do Semgrep no Agile, em segundos. O padrao dele e 5 s; com as ferramentas juntas (e, no
  * verify, junto das lanes de teste) a disputa de CPU fazia uma regra estourar (`partial-timeout` medido na primeira
@@ -284,8 +282,8 @@ function runScanAgil(opts, rodar = check_paralelo_1.rodarEmParalelo) {
             return report;
         }
         report.base = base;
-        if (tools.some(t => t.name === 'semgrep'))
-            pecas.push(exports.SEMGREP_SEM_CACHE);
+        pecas.push({ peca: 'varredura-incremental', estado: 'agile',
+            motivo: 'arquivo pela versao e regras da ferramenta; dependencias pelo lockfile; demais ferramentas rodam inteiras' });
         const count = (0, run_1.git)(root, ['rev-list', '--count', `${base}..${head}`]);
         const deadline = opts.deadlineMs === undefined ? null : Date.now() + opts.deadlineMs;
         // A arvore da base sai uma vez, aqui, e os trabalhadores a dividem (cada um varre a sua ferramenta nela).
@@ -298,6 +296,19 @@ function runScanAgil(opts, rodar = check_paralelo_1.rodarEmParalelo) {
         }
         const dir = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'ork-security-scan-agil-')));
         guard.add('outDirs', dir);
+        // A peça do cache já fazia parte do contrato ordenado do relatório antes das peças de executor. Resolver aqui mantém
+        // essa ordem pública; o mesmo resultado segue no trabalho que será entregue ao processo da ferramenta.
+        const regrasSemgrepPorIndice = new Map();
+        tools.forEach((t, i) => {
+            if (t.name !== 'semgrep')
+                return;
+            const regrasSemgrep = (0, incremental_1.resolverRegrasSemgrep)(t, (0, run_1.unitsOf)(t, pairs));
+            regrasSemgrepPorIndice.set(i, regrasSemgrep);
+            pecas.push(regrasSemgrep.reutilizavel
+                ? { peca: 'cache-semgrep', estado: 'agile', motivo: 'hash do conteúdo das regras resolvidas; check_id preservado' }
+                : { peca: 'cache-semgrep', estado: 'fallback', motivo: regrasSemgrep.motivo,
+                    fallback: 'varredura integral, como no Classic' });
+        });
         // RM-072 (D12): quem tem o binario nativo na versao do catalogo roda sem o Docker; a peca diz quem faltou.
         const probe = opts.probe ?? (0, executor_1.defaultProbe)();
         const comNativo = tools.filter(t => t.native && !t.install);
@@ -310,7 +321,12 @@ function runScanAgil(opts, rodar = check_paralelo_1.rodarEmParalelo) {
         }
         const montados = tools.map((t, i) => {
             const restante = deadline === null ? t.timeoutMs : Math.min(t.timeoutMs, deadline - Date.now());
-            const trabalho = { tool: eslintDoAgile(especificacaoDoAgile(t, pecas), restante, pecas), units: (0, run_1.unitsOf)(t, pairs), config,
+            const units = (0, run_1.unitsOf)(t, pairs);
+            const tool = eslintDoAgile(especificacaoDoAgile(t, pecas), restante, pecas);
+            const regrasSemgrep = regrasSemgrepPorIndice.get(i);
+            const trabalho = { tool, units, config,
+                incremental: true,
+                ...(regrasSemgrep ? { regrasSemgrep } : {}),
                 ...(nativos.has(t.name) ? { nativoPrimeiro: true } : {}),
                 ctx: { headTree, mainRoot, base, head, rangeCommits: count === null ? null : Number(count), deadline, ...(baseTree ? { baseTree } : {}) } };
             const arquivo = path.join(dir, `${i}.json`);

package/dist/security-scan/executor.js

@@ -160,6 +160,7 @@ function runDocker(inv) {
         ...Object.entries(tool.env ?? {}).flatMap(([k, v]) => ['-e', `${k}=${v}`]),
         '--entrypoint', tool.containerBin ?? inv.argv[0], tool.image,
         ...inv.argv.slice(1).map(a => expand(a, values))];
+    (0, agendador_cpu_1.registrarContainerDaLane)(name);
     inv.guard?.add('containers', name);
     const r = (0, node_child_process_1.spawnSync)('docker', args, { encoding: 'utf8', timeout: inv.timeoutMs, killSignal: 'SIGKILL', maxBuffer: MAX_BUFFER, env: process.env });
     const timedOut = r.error?.code === 'ETIMEDOUT';

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

@@ -448,10 +448,21 @@ function executorDoGrupo(manifesto, ambienteDaRodada, instabilidade, leitor, con
         const processos = (0, check_paralelo_1.rodarEmParalelo)(paraOAuxiliar, ambienteDoVerify(), medicaoCpu ? { medicaoCpu } : {});
         if (processos.agendamentoCpu) {
             const p = processos.agendamentoCpu;
+            const medida = p.medicaoCpuIntegracao;
+            const evidencia = medida
+                ? `; CPU da integracao: arvore ${Math.round(medida.arvoreMs)} ms + conteineres ${Math.round(medida.containersMs)} ms` +
+                    ` = ${Math.round(medida.totalMs)} ms, pico ${medida.picoCpus ?? 'indisponivel'} CPU, ` +
+                    (medida.completa ? 'medida completa' : medida.anomalia
+                        ? `medida anomala (${medida.anomalia})`
+                        : `medida incompleta (${medida.motivosDosAusentes.map((x) => `${x.container}: ${x.motivo}`).join('; ')})`)
+                : '';
             executar.pecas = [{ peca: 'agendador-cpu', estado: p.saturado ? 'fallback' : 'agile',
                     motivo: p.saturado
                         ? `${p.motivo}; hermetica com ${p.cpusHermetica}/${p.cpus} CPUs, varredura e integracao depois dela`
-                        : `${p.cpusHermetica}/${p.cpus} CPUs na hermetica e ${p.cpusDaFatia} reservadas; conteineres com ${p.cpusPorContainer} CPU`,
+                        : `${p.cpusHermetica}/${p.cpus} CPUs na hermetica; depois da varredura ${p.cpusHermeticaAposVarredura}` +
+                            ` e depois da integracao ${p.cpusHermeticaAposReserva}; reserva da integracao ${p.fonteCpusIntegracao}` +
+                            ` (${p.cpusIntegracao} CPU), ${p.integracaoEmParalelo ? 'em paralelo com a varredura' : 'encadeada depois da varredura'}` +
+                            `; conteineres com ${p.cpusPorContainer} CPU${evidencia}`,
                     ...(p.saturado ? { fallback: 'ordem do Classic para hermetica, varredura e integracao' } : {}) }];
         }
         const stealPct = janela.fechar();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orkastery/cli",
-  "version": "0.6.3",
+  "version": "0.6.4",
   "description": "A software factory of AI agents that proves its work: parallel threads, verified results, and short decisions only when they matter.",
   "license": "MIT",
   "homepage": "https://github.com/orkastery/orkastery#readme",