@orkastery/cli 0.6.3 → 0.6.5

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))
@@ -627,8 +703,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,10 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.argvDoItem = argvDoItem;
+exports.workersDaLane = workersDaLane;
+exports.chaveDoPerfilIntegracao = chaveDoPerfilIntegracao;
+exports.picoDaArvoreParaPerfil = picoDaArvoreParaPerfil;
+exports.picoCpuPorFonte = picoCpuPorFonte;
 exports.esperaDoGrupo = esperaDoGrupo;
 exports.rodarEmParalelo = rodarEmParalelo;
 /**
@@ -48,12 +52,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/v2';
+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 +86,299 @@ function vagas(max) {
             livres++; },
     };
 }
+/**
+ * Recursos exclusivos sem dependencia artificial. Cada pedido adquire o conjunto inteiro ou espera, o que evita
+ * deadlock entre listas cruzadas; pedidos disjuntos continuam livres para avancar.
+ */
+function recursosExclusivos() {
+    const ocupados = new Set();
+    const fila = [];
+    const despachar = () => {
+        for (let i = 0; i < fila.length;) {
+            const pedido = fila[i];
+            if (pedido.nomes.some((nome) => ocupados.has(nome))) {
+                i++;
+                continue;
+            }
+            fila.splice(i, 1);
+            pedido.nomes.forEach((nome) => ocupados.add(nome));
+            pedido.pronto(() => {
+                pedido.nomes.forEach((nome) => ocupados.delete(nome));
+                despachar();
+            });
+        }
+    };
+    return {
+        tomar: (nomes) => new Promise((pronto) => {
+            fila.push({ nomes: [...new Set(nomes)], pronto });
+            despachar();
+        }),
+    };
+}
+/** A reserva que vira ORK_WORKERS quando a lane e efetivamente lancada. */
+function workersDaLane(item, plano, cpus, totalDeLanes) {
+    if (!item.nome.startsWith('test:'))
+        return null;
+    const capacidade = (0, agendador_cpu_1.workersDaReserva)(cpus);
+    if (!plano)
+        return Math.max(1, Math.floor(capacidade / Math.max(1, Math.min(capacidade, totalDeLanes))));
+    if (item.papelCpu === 'hermetica')
+        return (0, agendador_cpu_1.workersDaReserva)(plano.cpusHermetica);
+    if (item.papelCpu === 'integracao')
+        return (0, agendador_cpu_1.workersDaReserva)(plano.cpusIntegracao);
+    // Outros fecham a cadeia depois que as reservas da varredura e da integracao voltaram.
+    return capacidade;
+}
+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.picoCpusDaArvore) && p.picoCpusDaArvore > 0 && p.picoCpusDaArvore <= cpus ? p : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Somente uma arvore completa e fisicamente possivel pode ensinar a reserva; lacunas de conteiner ficam na evidencia. */
+function picoDaArvoreParaPerfil(medicao, cpus) {
+    const pico = medicao.picoCpusDaArvore;
+    return medicao.arvoreCompleta && !medicao.anomaliaDaArvore && pico !== null && pico > 0 && pico <= cpus ? pico : null;
+}
+function gravarPerfilIntegracao(chave, cpus, medicao) {
+    const picoCpusDaArvore = picoDaArvoreParaPerfil(medicao, cpus);
+    if (!chave || picoCpusDaArvore === null)
+        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,
+            picoCpusDaArvore, 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 amostrasDaArvore = [];
+    const primeiraCpuDosContainers = new Map();
+    const ultimaCpuDosContainers = new Map();
+    const amostrar = () => {
+        const tabela = processosCpu();
+        const arvore = {};
+        for (const p of arvoreDeProcessos(pid, tabela)) {
+            const x = tabela.get(p);
+            if (x)
+                arvore[`processo:${p}:${x.inicio}`] = x.cpuMs;
+        }
+        const atuais = { ...arvore };
+        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');
+        }
+        const em = Date.now();
+        amostrasDaArvore.push({ em, fontes: arvore });
+        amostras.push({ em, 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);
+            const picoDaArvore = picoCpuPorFonte(amostrasDaArvore, cpus);
+            const arvoreCompleta = arvoreMs > 0 && picoDaArvore.picoCpus !== null && !picoDaArvore.anomalia;
+            return { arvoreMs, containersMs, totalMs: arvoreMs + containersMs, paredeMs,
+                picoCpus: pico.picoCpus, picoCpusDaArvore: picoDaArvore.picoCpus,
+                completa: arvoreCompleta && ausentes.length === 0 && !pico.anomalia, arvoreCompleta,
+                containers: nomes, ausentes, motivosDosAusentes: ausentes.map((container) => ({ container,
+                    motivo: motivos.get(container) ?? 'conteiner terminou antes de uma amostra completa' })),
+                anomalia: pico.anomalia, anomaliaDaArvore: picoDaArvore.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,10 +386,21 @@ 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.picoCpusDaArvore, 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);
+    const tetoInformado = esp.maxParalelo && esp.maxParalelo > 0 ? esp.maxParalelo : itens.length;
+    const limite = vagas(Math.max(1, Math.min(tetoInformado, (0, agendador_cpu_1.workersDaReserva)(cpus))));
+    const exclusivos = recursosExclusivos();
+    const totalDeLanes = itens.filter((item) => item.nome.startsWith('test:')).length;
     const porNome = new Map();
     const indice = new Map(itens.map((item, i) => [item.nome, i]));
     const vezDoItem = (item, i) => {
@@ -102,12 +415,14 @@ async function rodarEspecificacao(esp) {
                 if (j !== undefined)
                     await vezDoItem(itens[j], j);
             }
+            const soltarRecursos = await exclusivos.tomar(item.recursos ?? []);
             await limite.tomar();
             try {
                 return await lancar(item, i);
             }
             finally {
                 limite.soltar();
+                soltarRecursos();
             }
         });
         porNome.set(item.nome, vez);
@@ -119,29 +434,85 @@ 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;
+                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 workers = workersDaLane(item, plano, cpus, totalDeLanes);
+            const ambiente = { ...process.env, ...item.ambiente, ...(workers === null ? {} : { [agendador_cpu_1.ENV_WORKERS]: String(workers) }),
+                ...(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 +541,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;
 }