@orkastery/cli 0.6.6 → 0.6.7

package/dist/check-agil.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PECA_SEM_RELATORIO = exports.RelatorioDoCheck = exports.TETO_DO_RELATORIO_BYTES = exports.MAXIMO_DE_PREPAROS_REFEITOS = exports.GuardaDoProduto = void 0;
+exports.assinaturaDoAmbiente = exports.PECA_SEM_RELATORIO = exports.RelatorioDoCheck = exports.TETO_DO_RELATORIO_BYTES = exports.MAXIMO_DE_PREPAROS_REFEITOS = exports.GuardaDoProduto = void 0;
 exports.paralelismoDaVarreduraNoGrupo = paralelismoDaVarreduraNoGrupo;
 exports.passosDoComando = passosDoComando;
 exports.elosDoComando = elosDoComando;
@@ -45,11 +45,13 @@ exports.executorDaClaimNoAgile = executorDaClaimNoAgile;
 exports.refazerPreparo = refazerPreparo;
 exports.testDasLanes = testDasLanes;
 exports.porQueDasLanes = porQueDasLanes;
+exports.comandoDaClaimDependeDasLanes = comandoDaClaimDependeDasLanes;
+exports.planejarClaimsNoAgile = planejarClaimsNoAgile;
 exports.comandosNoAgile = comandosNoAgile;
 exports.pecasDoRelatorio = pecasDoRelatorio;
 exports.listasDasLanes = listasDasLanes;
 exports.resultadosDasLanes = resultadosDasLanes;
-exports.assinaturaDoAmbiente = assinaturaDoAmbiente;
+exports.classificarClaimPelasLanes = classificarClaimPelasLanes;
 exports.executorDaClaimPelasLanes = executorDaClaimPelasLanes;
 /**
  * RM-072 (D3 a D8 da ork-check5x): o motor do Agile Check no verify.
@@ -79,6 +81,7 @@ exports.executorDaClaimPelasLanes = executorDaClaimPelasLanes;
  * ok e e o nome que a baseline compara). Nada aqui decide veredito: a classificacao e a do verify.
  */
 const node_crypto_1 = require("node:crypto");
+const ambiente_funcional_1 = require("./ambiente-funcional");
 const fs = __importStar(require("node:fs"));
 const os = __importStar(require("node:os"));
 const path = __importStar(require("node:path"));
@@ -494,11 +497,78 @@ function porQueDasLanes(c) {
     };
     return caidas.map((l) => `lane ${l.lane}: ${porque(l)}`).join('; ');
 }
+/** A mesma gramatica fechada que o reaproveitamento usa, sem precisar esperar a lane para classificar a dependencia. */
+function comandoDaClaimDependeDasLanes(manifesto, comando, cwd) {
+    const passosDoPreparo = manifesto.verify.preparo ? passosDoComando(manifesto.verify.preparo) : [];
+    const daFrente = tirarPassosDoPreparo(comando, passosDoPreparo);
+    const { resto } = daFrente.passos.length > 0 ? daFrente : tirarPassosDoPreparoAposLeituras(comando, passosDoPreparo);
+    if (!resto)
+        return false;
+    const elos = elosDoComando(resto);
+    return !!elos?.length && elos.every((elo) => comandoGrepQ(elo) || !!auditoriaTap(elo, cwd) || !!comandoNodeTest(elo, cwd))
+        && elos.some((elo) => !!auditoriaTap(elo, cwd) || !!comandoNodeTest(elo, cwd));
+}
+/**
+ * Claims dependentes de lane conservam a ordem antiga. As demais entram no grupo; a ordem interna e claims sobre o
+ * mesmo arquivo formam cadeias, enquanto arquivos distintos podem usar vagas diferentes do pool de claims.
+ */
+function planejarClaimsNoAgile(manifesto, claims, cwd, guarda, preparo) {
+    if (guarda.conferir())
+        return { execucoes: [], ids: [], cadeias: 0 };
+    const passosDoPreparo = manifesto.verify.preparo ? passosDoComando(manifesto.verify.preparo) : [];
+    const ultimosPorArquivo = new Map();
+    const execucoes = [];
+    const ids = [];
+    for (const claim of claims) {
+        const usaPreparo = (comando) => {
+            const daFrente = tirarPassosDoPreparo(comando, passosDoPreparo);
+            return (daFrente.passos.length > 0 ? daFrente : tirarPassosDoPreparoAposLeituras(comando, passosDoPreparo)).passos.length > 0;
+        };
+        // A guarda e o teto de refacoes sao seriais: claim que consome o preparo continua no caminho anterior.
+        if (!claim.verificar.length || claim.verificar.some((comando) => comandoDaClaimDependeDasLanes(manifesto, comando, cwd)
+            || usaPreparo(comando)))
+            continue;
+        ids.push(claim.id);
+        let anterior = ultimosPorArquivo.get(claim.arquivo);
+        claim.verificar.forEach((comando, i) => {
+            const nome = `${claim.id}.${i + 1}`;
+            const daFrente = tirarPassosDoPreparo(comando, passosDoPreparo);
+            const tirado = daFrente.passos.length > 0 ? daFrente : tirarPassosDoPreparoAposLeituras(comando, passosDoPreparo);
+            if (tirado.passos.length > 0 && tirado.resto === '') {
+                execucoes.push({ nome, comando, resultado: doPreparo(nome, comando, preparo, tirado.passos) });
+                return;
+            }
+            const executado = tirado.passos.length > 0 ? tirado.resto : comando;
+            const item = { nome: `claim:${nome}`, comando: executado, papelCpu: 'claim',
+                ...(anterior ? { apos: [anterior] } : {}) };
+            execucoes.push({ nome, comando, item,
+                ...(executado !== comando ? { comandoExecutado: executado,
+                    preparo: { reaproveitado: true, passos: tirado.passos } } : {}) });
+            anterior = item.nome;
+        });
+        if (anterior)
+            ultimosPorArquivo.set(claim.arquivo, anterior);
+    }
+    return { execucoes, ids, cadeias: ultimosPorArquivo.size };
+}
+function resultadosDasClaimsAntecipadas(plano, porItem) {
+    if (!plano)
+        return {};
+    return Object.fromEntries(plano.execucoes.map((e) => {
+        if (e.resultado)
+            return [e.nome, { ...e.resultado, agendamento: 'antecipada' }];
+        const bruto = porItem.get(e.item.nome);
+        return [e.nome, { ...bruto, nome: e.nome, comando: e.comando,
+                agendamento: 'antecipada',
+                ...(e.comandoExecutado ? { comandoExecutado: e.comandoExecutado } : {}),
+                ...(e.preparo ? { preparo: e.preparo } : {}) }];
+    }));
+}
 /**
  * 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, selecao = { comandos: {}, lanes: {} }, passagemParcial, selecaoPorMudanca = {}) {
+function comandosNoAgile(manifesto, cwd, lista, executor, grupo, guarda, preparo, selecao = { comandos: {}, lanes: {} }, passagemParcial, selecaoPorMudanca = {}, claimsAntecipadas) {
     const pecas = [];
     const passosDoPreparo = manifesto.verify.preparo ? passosDoComando(manifesto.verify.preparo) : [];
     const lanesDeclaradas = Object.entries(manifesto.check?.agile?.test ?? {});
@@ -517,7 +587,7 @@ function comandosNoAgile(manifesto, cwd, lista, executor, grupo, guarda, preparo
                 ? 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: [] };
+        return { comandos: lista.map(executar), claimsAntecipadas: {}, 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');
@@ -560,7 +630,7 @@ function comandosNoAgile(manifesto, cwd, lista, executor, grupo, guarda, preparo
                 ...(c.filtro ? { filtro: c.filtro } : {}), ...(selecao.comandos[c.nome] ? { testesFiltrados: selecao.comandos[c.nome] } : {}),
                 papelCpu: c.nome === 'security_scan' ? 'varredura' : 'outro' });
     }
-    itens.push(...encadeados);
+    itens.push(...(claimsAntecipadas?.execucoes.flatMap((e) => e.item ? [e.item] : []) ?? []), ...encadeados);
     const parciaisVermelhas = new Map();
     for (const item of itens) {
         if (!item.filtro || !item.testesFiltrados?.length || !passagemParcial)
@@ -590,7 +660,7 @@ function comandosNoAgile(manifesto, cwd, lista, executor, grupo, guarda, preparo
     itens.forEach((item, i) => {
         if (item.nome.startsWith('test:'))
             lanes.push({ lane: item.nome.slice('test:'.length), resultado: resultados[i] });
-        else
+        else if (!item.nome.startsWith('claim:'))
             porNome.set(item.nome, resultados[i]);
     });
     // As lanes voltam na ordem do manifesto, mesmo com a encadeada no fim do grupo.
@@ -602,7 +672,9 @@ function comandosNoAgile(manifesto, cwd, lista, executor, grupo, guarda, preparo
     }
     if (itens.length > 1)
         pecas.push({ peca: 'grupo', estado: 'agile' });
-    return { comandos: lista.map((c) => porNome.get(c.nome)), pecas, paralelo: itens.length > 1, lanes: lanes.map((l) => l.lane) };
+    return { comandos: lista.map((c) => porNome.get(c.nome)),
+        claimsAntecipadas: resultadosDasClaimsAntecipadas(claimsAntecipadas, porItemInteiro),
+        pecas, paralelo: itens.length > 1, lanes: lanes.map((l) => l.lane) };
 }
 /** O teto da leitura do relatorio da rodada. */
 exports.TETO_DO_RELATORIO_BYTES = 4 * 1024 * 1024;
@@ -700,16 +772,8 @@ function resultadosDasLanes(linhas) {
                     estado: x.estado }];
         }) }));
 }
-/** 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_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));
-    return (0, node_crypto_1.createHash)('sha256').update(JSON.stringify(pares)).digest('hex');
-}
+var ambiente_funcional_2 = require("./ambiente-funcional");
+Object.defineProperty(exports, "assinaturaDoAmbiente", { enumerable: true, get: function () { return ambiente_funcional_2.assinaturaDoAmbiente; } });
 /** Le somente a gramatica aceita para reaproveitar: `node --test [--test-name-pattern P] arquivo...`. */
 function comandoNodeTest(comando, cwd) {
     const palavras = palavrasDoComando(comando);
@@ -774,68 +838,148 @@ function resultadoReaproveitado(nome, comando, pedido, usadas, esperado, nomes)
             nomes: nomes ?? (pedido.padrao === undefined ? pedido.arquivos.map((a) => `${a}:todos`) : pedido.arquivos.map((a) => `${a}:/${pedido.padrao}/`)),
             head: esperado.head, ambiente: esperado.ambiente } };
 }
+function recusaPelasLanes(motivo, arquivos, esperado, assinatura, candidata, usarExecutorEquivalente = candidata) {
+    return { decisao: { reaproveitada: false, motivo, arquivos: [...new Set(arquivos)], head: esperado.head, ambiente: assinatura },
+        candidata, usarExecutorEquivalente, elos: [] };
+}
+/** Casos nominais ficam exatamente um nivel abaixo do evento que representa o arquivo no runner isolado. */
+function casosNominaisDoArquivo(vistos, arquivo) {
+    const niveisDoArquivo = vistos.filter((t) => path.basename(t.nome) === arquivo).map((t) => t.nesting);
+    if (niveisDoArquivo.length === 0)
+        return [];
+    const nivelDosCasos = Math.min(...niveisDoArquivo) + 1;
+    return vistos.filter((t) => t.nesting === nivelDosCasos);
+}
+/** Reconhece especificamente o TAP com filtro: ele e fechado, mas a lane inteira nao prova a auditoria filtrada. */
+function tapComPadraoDeNome(comando, cwd) {
+    const divisor = ' | ';
+    const i = comando.indexOf(divisor);
+    if (i < 0 || comando.indexOf(divisor, i + divisor.length) >= 0)
+        return null;
+    const node = comando.slice(0, i).trim();
+    if (!/^node --test-reporter=tap\b/.test(node))
+        return null;
+    const pedido = comandoNodeTest(node.replace(/^node --test-reporter=tap\b/, 'node --test'), cwd);
+    return pedido?.padrao !== undefined ? pedido : null;
+}
+function planejarClaimPelasLanes(comando, cwd, evidencias, esperado) {
+    const assinatura = (0, ambiente_funcional_1.assinaturaDoAmbiente)(esperado.ambiente);
+    const elos = elosDoComando(comando);
+    if (!elos)
+        return recusaPelasLanes('comando-aberto', [], esperado, assinatura, false, false);
+    const planejados = [];
+    const arquivos = [];
+    for (const elo of elos) {
+        if (comandoGrepQ(elo)) {
+            planejados.push({ tipo: 'grep', comando: elo });
+            continue;
+        }
+        const tap = auditoriaTap(elo, cwd);
+        const comPadrao = tap ? null : tapComPadraoDeNome(elo, cwd);
+        if (comPadrao)
+            return recusaPelasLanes('tap-com-test-name-pattern', [...arquivos, ...comPadrao.arquivos], esperado, assinatura, true);
+        const pedido = tap?.pedido ?? comandoNodeTest(elo, cwd);
+        if (!pedido)
+            return recusaPelasLanes('comando-nao-elegivel', arquivos, esperado, assinatura, false, false);
+        arquivos.push(...pedido.arquivos);
+        planejados.push({ tipo: 'lane', comando: elo, pedido, usadas: [],
+            ...(tap ? { nomes: pedido.arquivos.map((a) => `${a}:${tap.prefixo}>=${tap.minimo};sem-falha;sem-skip`) } : {}) });
+    }
+    if (!planejados.some((p) => p.tipo === 'lane')) {
+        return recusaPelasLanes('comando-nao-elegivel', arquivos, esperado, assinatura, false, false);
+    }
+    const vigencia = esperado.podeReaproveitar?.();
+    if (vigencia === false)
+        return recusaPelasLanes('lanes-invigentes', arquivos, esperado, assinatura, true);
+    if (typeof vigencia === 'string')
+        return recusaPelasLanes(vigencia, arquivos, esperado, assinatura, true);
+    if (evidencias.length === 0)
+        return recusaPelasLanes('evidencia-vazia', arquivos, esperado, assinatura, true);
+    for (const item of planejados) {
+        if (item.tipo !== 'lane')
+            continue;
+        const tap = auditoriaTap(item.comando, cwd);
+        const usadasDoElo = new Set();
+        for (const arquivo of item.pedido.arquivos) {
+            const comArquivo = evidencias.filter((e) => e.testes.some((t) => t.arquivo === arquivo));
+            if (comArquivo.length === 0)
+                return recusaPelasLanes('arquivo-nao-executado', arquivos, esperado, assinatura, true);
+            const noHead = comArquivo.filter((e) => e.head === esperado.head);
+            if (noHead.length === 0)
+                return recusaPelasLanes('head-divergente', arquivos, esperado, assinatura, true);
+            const noAmbiente = noHead.filter((e) => e.ambiente === assinatura);
+            if (noAmbiente.length === 0) {
+                return recusaPelasLanes('ambiente-funcional-divergente', arquivos, esperado, assinatura, true);
+            }
+            const vistos = noAmbiente.flatMap((e) => e.testes.filter((t) => t.arquivo === arquivo));
+            if (vistos.some((t) => t.estado === 'fail'))
+                return recusaPelasLanes('falha-na-lane', arquivos, esperado, assinatura, true);
+            if (vistos.some((t) => t.estado === 'skip' || t.estado === 'todo')) {
+                return recusaPelasLanes('skip-ou-todo-na-lane', arquivos, esperado, assinatura, true);
+            }
+            if (tap) {
+                const doArquivo = casosNominaisDoArquivo(vistos, arquivo).filter((t) => t.estado === 'pass');
+                const doPrefixo = doArquivo.filter((t) => new RegExp(`^${tap.prefixo}[0-9]+:`).test(t.nome));
+                if (doPrefixo.length === 0)
+                    return recusaPelasLanes('prefixo-divergente', arquivos, esperado, assinatura, true);
+                if (doPrefixo.length < tap.minimo) {
+                    return recusaPelasLanes('contagem-abaixo-do-minimo', arquivos, esperado, assinatura, true);
+                }
+            }
+            noAmbiente.forEach((e) => usadasDoElo.add(e));
+        }
+        item.usadas = [...usadasDoElo];
+    }
+    const usadas = planejados.flatMap((p) => p.tipo === 'lane' ? p.usadas : []);
+    const lanes = [...new Set(usadas.map((e) => e.lane))];
+    const nomes = planejados.flatMap((p) => p.tipo !== 'lane' ? [] : p.nomes ?? (p.pedido.padrao === undefined
+        ? p.pedido.arquivos.map((a) => `${a}:todos`) : p.pedido.arquivos.map((a) => `${a}:/${p.pedido.padrao}/`)));
+    return { decisao: { reaproveitada: true, lanes, arquivos: [...new Set(arquivos)], nomes: [...new Set(nomes)],
+            head: esperado.head, ambiente: assinatura }, candidata: true, usarExecutorEquivalente: false, elos: planejados };
+}
+/** A classificacao pura usada pelo executor e, na M12, pelo planejador dos lotes de claims. */
+function classificarClaimPelasLanes(comando, cwd, evidencias, esperado) {
+    const p = planejarClaimPelasLanes(comando, cwd, evidencias, esperado);
+    return { decisao: p.decisao, candidata: p.candidata, usarExecutorEquivalente: p.usarExecutorEquivalente };
+}
 /**
  * Reaproveita uma claim somente quando a lane terminou todos os arquivos pedidos no mesmo HEAD e ambiente. Um arquivo
  * inteiro verde e evidencia mais forte que `--test-name-pattern`: o padrao fica registrado em `nomes`.
  */
 function executorDaClaimPelasLanes(base, evidencias, esperado) {
-    const assinatura = assinaturaDoAmbiente(esperado.ambiente);
     return (nome, comando, cwd) => {
         const executar = esperado.executorEquivalente ?? base;
-        if (esperado.podeReaproveitar?.() === false)
-            return executar(nome, comando, cwd);
-        const elos = elosDoComando(comando);
-        if (!elos)
-            return base(nome, comando, cwd);
-        const planejados = [];
-        for (const elo of elos) {
-            if (comandoGrepQ(elo)) {
-                planejados.push({ tipo: 'grep', comando: elo });
-                continue;
-            }
-            const tap = auditoriaTap(elo, cwd);
-            const pedido = tap?.pedido ?? comandoNodeTest(elo, cwd);
-            if (!pedido)
-                return base(nome, comando, cwd);
-            const usadas = evidencias.filter((e) => e.head === esperado.head && e.ambiente === assinatura
-                && e.testes.some((t) => pedido.arquivos.includes(t.arquivo)));
-            const cobertos = pedido.arquivos.every((arquivo) => {
-                const vistos = usadas.flatMap((e) => e.testes.filter((t) => t.arquivo === arquivo));
-                if (vistos.length === 0 || vistos.some((t) => t.estado === 'fail'))
-                    return false;
-                if (vistos.some((t) => t.estado === 'skip' || t.estado === 'todo'))
-                    return false;
-                if (!tap)
-                    return true;
-                const doArquivo = vistos.filter((t) => t.nesting === 0);
-                return doArquivo.filter((t) => t.estado === 'pass' && new RegExp(`^${tap.prefixo}[0-9]+:`).test(t.nome)).length >= tap.minimo;
-            });
-            if (!cobertos)
-                return executar(nome, comando, cwd);
-            const nomes = tap ? pedido.arquivos.map((a) => `${a}:${tap.prefixo}>=${tap.minimo};sem-falha;sem-skip`) : undefined;
-            planejados.push({ tipo: 'lane', resultado: resultadoReaproveitado(nome, elo, pedido, usadas, { head: esperado.head, ambiente: assinatura }, nomes) });
+        const plano = planejarClaimPelasLanes(comando, cwd, evidencias, esperado);
+        if (!plano.decisao.reaproveitada) {
+            const r = (plano.usarExecutorEquivalente ? executar : base)(nome, comando, cwd);
+            // Comando fora da gramatica das lanes nao foi recusado por elas: ele segue sem inventar uma decisao nominal.
+            return plano.candidata ? { ...r, lane: plano.decisao } : r;
         }
         let duracaoMs = 0;
         const resumos = [];
         let ultimo = null;
         const lanes = new Set(), arquivos = new Set(), nomes = new Set();
-        for (const item of planejados) {
-            const r = item.tipo === 'grep' ? base(nome, item.comando, cwd) : item.resultado;
+        for (const item of plano.elos) {
+            const r = item.tipo === 'grep' ? base(nome, item.comando, cwd)
+                : resultadoReaproveitado(nome, item.comando, item.pedido, item.usadas, { head: esperado.head, ambiente: plano.decisao.ambiente }, item.nomes);
             duracaoMs += r.duracaoMs ?? 0;
             resumos.push(r.resumo);
             ultimo = r;
             if (!r.ok)
-                return { ...r, comando, comandoExecutado: item.tipo === 'grep' ? item.comando : r.comando, duracaoMs };
-            for (const lane of r.lane?.lanes ?? [])
-                lanes.add(lane);
-            for (const arquivo of r.lane?.arquivos ?? [])
-                arquivos.add(arquivo);
-            for (const n of r.lane?.nomes ?? [])
-                nomes.add(n);
+                return { ...r, comando, comandoExecutado: item.comando, duracaoMs, lane: plano.decisao };
+            if (r.lane?.reaproveitada) {
+                for (const lane of r.lane.lanes)
+                    lanes.add(lane);
+                for (const arquivo of r.lane.arquivos)
+                    arquivos.add(arquivo);
+                for (const n of r.lane.nomes)
+                    nomes.add(n);
+            }
         }
         if (!ultimo || lanes.size === 0)
             return base(nome, comando, cwd);
         return { ...ultimo, nome, comando, duracaoMs, resumo: resumos.filter(Boolean).join('\n'),
-            lane: { reaproveitada: true, lanes: [...lanes], arquivos: [...arquivos], nomes: [...nomes], head: esperado.head, ambiente: assinatura } };
+            lane: { reaproveitada: true, lanes: [...lanes], arquivos: [...arquivos], nomes: [...nomes], head: esperado.head,
+                ambiente: plano.decisao.ambiente } };
     };
 }

package/dist/check-paralelo.js

@@ -34,10 +34,14 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.argvDoItem = argvDoItem;
+exports.limiteDeVagas = limiteDeVagas;
 exports.workersDaLane = workersDaLane;
 exports.chaveDoPerfilIntegracao = chaveDoPerfilIntegracao;
 exports.picoDaArvoreParaPerfil = picoDaArvoreParaPerfil;
 exports.picoCpuPorFonte = picoCpuPorFonte;
+exports.devolucoesDaReserva = devolucoesDaReserva;
+exports.aplicarDevolucaoDaReserva = aplicarDevolucaoDaReserva;
+exports.aplicarPlanoCpu = aplicarPlanoCpu;
 exports.esperaDoGrupo = esperaDoGrupo;
 exports.rodarEmParalelo = rodarEmParalelo;
 /**
@@ -58,19 +62,21 @@ 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 ambiente_funcional_1 = require("./ambiente-funcional");
 const TIMEOUT_BIN = '/usr/bin/timeout';
 const NICE_BIN = '/usr/bin/nice';
 const TIME_BIN = '/usr/bin/time';
+const BASH_BIN = '/usr/bin/bash';
 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];
+    const programa = item.argv?.length ? item.argv : [BASH_BIN, '--noprofile', '--norc', '-c', item.comando];
     const base = comGrupo ? [TIMEOUT_BIN, '--kill-after=15', `${Math.ceil(item.prazoMs / 1000)}`, ...programa] : programa;
     return item.nice && comNice ? [NICE_BIN, '-n', String(item.nice), ...base] : base;
 }
 /** As vagas do grupo: no maximo `max` comandos ao mesmo tempo, na ordem em que pediram. */
-function vagas(max) {
+function limiteDeVagas(max) {
     let livres = max;
     const fila = [];
     return {
@@ -125,7 +131,7 @@ function workersDaLane(item, plano, cpus, 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);
+        return (0, agendador_cpu_1.workersDaReserva)(plano.cpusIntegracaoEmUso);
     // Outros fecham a cadeia depois que as reservas da varredura e da integracao voltaram.
     return capacidade;
 }
@@ -255,6 +261,25 @@ function nomesDosContainers(arquivo) {
         return [];
     }
 }
+function evidenciaDaCotaDocker(arquivo) {
+    try {
+        const evidencias = fs.readFileSync(arquivo, 'utf8').split('\n').filter(Boolean).flatMap((linha) => {
+            try {
+                const r = JSON.parse(linha);
+                return r.tipo === 'cota-docker' && ['aplicada', 'fallback'].includes(String(r.estado))
+                    && Number.isFinite(r.cota) && Number(r.cota) > 0 && typeof r.motivo === 'string'
+                    ? [{ estado: r.estado, cota: Number(r.cota), motivo: r.motivo }] : [];
+            }
+            catch {
+                return [];
+            }
+        });
+        return evidencias.find((x) => x.estado === 'fallback') ?? evidencias.at(-1);
+    }
+    catch {
+        return undefined;
+    }
+}
 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+/) ?? [];
@@ -394,11 +419,15 @@ async function rodarEspecificacao(esp) {
         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 nomesDasClaims = new Set(esp.itens.filter((i) => i.papelCpu === 'claim').map((i) => i.nome));
+    const cadeiasDeClaims = esp.itens.filter((i) => i.papelCpu === 'claim'
+        && !(i.apos ?? []).some((nome) => nomesDasClaims.has(nome))).length;
+    const plano = usaAgendador ? (0, agendador_cpu_1.planejarCpuDoGrupo)(cpus, medicao, { cadeiasDeClaims }) : 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 itens = plano ? aplicarPlanoCpu(esp.itens, plano, sinalDaReserva) : esp.itens;
     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 limite = limiteDeVagas(Math.max(1, Math.min(tetoInformado, (0, agendador_cpu_1.workersDaReserva)(cpus))));
+    const limiteDasClaims = plano?.cpusClaims ? limiteDeVagas(plano.cpusClaims) : null;
     const exclusivos = recursosExclusivos();
     const totalDeLanes = itens.filter((item) => item.nome.startsWith('test:')).length;
     const porNome = new Map();
@@ -416,12 +445,16 @@ async function rodarEspecificacao(esp) {
                     await vezDoItem(itens[j], j);
             }
             const soltarRecursos = await exclusivos.tomar(item.recursos ?? []);
+            if (item.papelCpu === 'claim')
+                await limiteDasClaims?.tomar();
             await limite.tomar();
             try {
                 return await lancar(item, i);
             }
             finally {
                 limite.soltar();
+                if (item.papelCpu === 'claim')
+                    limiteDasClaims?.soltar();
                 soltarRecursos();
             }
         });
@@ -429,35 +462,33 @@ async function rodarEspecificacao(esp) {
         return vez;
     };
     const todos = Promise.all(itens.map(vezDoItem));
-    const reservados = itens.filter((item) => item.papelCpu === 'varredura' || item.papelCpu === 'integracao');
+    const reservados = itens.filter((item) => ['varredura', 'integracao', 'claim'].includes(item.papelCpu ?? ''));
     const devolverReserva = async () => {
-        if (!sinalDaReserva || !reservados.some((item) => item.papelCpu === 'varredura')
-            || !reservados.some((item) => item.papelCpu === 'integracao'))
+        if (!sinalDaReserva || !reservados.length)
             return;
         const varreduras = reservados.filter((item) => item.papelCpu === 'varredura');
         const integracoes = reservados.filter((item) => item.papelCpu === 'integracao');
-        const degrau = async (origem, pecas, vagas, antes) => {
+        const claims = reservados.filter((item) => item.papelCpu === 'claim');
+        let vagas = plano.cpusHermetica;
+        const devolucoes = devolucoesDaReserva(plano);
+        const degrau = async (origem, pecas) => {
+            if (!pecas.length)
+                return;
             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 });
+            const registro = aplicarDevolucaoDaReserva(vagas, plano.capacidadeEfetiva, origem, devolucoes[origem], new Date().toISOString());
+            vagas = registro.vagas;
+            fs.appendFileSync(sinalDaReserva, JSON.stringify(registro) + '\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 devolverInfraestrutura = plano.integracaoEmParalelo
+            ? Promise.all([degrau('varredura', varreduras), degrau('integracao', integracoes)])
+            : (async () => {
+                await degrau('varredura', varreduras);
+                await degrau('integracao', integracoes);
+            })();
+        await Promise.all([
+            degrau('claims', claims),
+            devolverInfraestrutura,
+        ]);
     };
     const [, terminados] = await Promise.all([devolverReserva(), todos]);
     const medidaDaIntegracao = terminados.find((t) => t.medicaoCpu)?.medicaoCpu;
@@ -465,6 +496,10 @@ async function rodarEspecificacao(esp) {
         plano.medicaoCpuIntegracao = medidaDaIntegracao;
         gravarPerfilIntegracao(chaveDoPerfil, cpus, medidaDaIntegracao);
     }
+    if (plano) {
+        const cotas = terminados.flatMap((t) => t.cotaDocker ? [t.cotaDocker] : []);
+        plano.cotaDosContainersDaIntegracao = cotas.find((x) => x.estado === 'fallback') ?? cotas.at(-1);
+    }
     fs.writeFileSync(path.join(esp.dir, 'resultado.json'), JSON.stringify({ terminados, ...(plano ? { agendamentoCpu: plano } : {}) }), { mode: 0o600 });
     function lancar(item, i) {
         return new Promise((resolve) => {
@@ -497,14 +532,18 @@ async function rodarEspecificacao(esp) {
                     catch { /* medida incompleta abaixo */ }
                 }
                 const medicaoCpu = medirIntegracao && sonda ? sonda.fechar(arvoreMs, t.duracaoMs) : undefined;
-                fim = { ...t, ...(medicaoCpu ? { medicaoCpu } : {}) };
+                const cotaDocker = medirIntegracao ? evidenciaDaCotaDocker(registro) : undefined;
+                fim = { ...t, ...(medicaoCpu ? { medicaoCpu } : {}), ...(cotaDocker ? { cotaDocker } : {}) };
                 fs.closeSync(saida);
                 fs.closeSync(erro);
                 resolve(fim);
             };
             // Sem o `timeout(1)`, o proprio auxiliar mata pelo prazo, como o `spawnSync` do `exec` faria.
             const workers = workersDaLane(item, plano, cpus, totalDeLanes);
-            const ambiente = { ...process.env, ...item.ambiente, ...(workers === null ? {} : { [agendador_cpu_1.ENV_WORKERS]: String(workers) }),
+            const baseDoFilho = item.ambienteFuncional
+                ? (0, ambiente_funcional_1.ambienteFuncionalDosTestes)(process.env, item.ambiente ?? {})
+                : { ...process.env, ...item.ambiente };
+            const ambiente = { ...baseDoFilho, ...(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' }) });
@@ -521,13 +560,26 @@ async function rodarEspecificacao(esp) {
         });
     }
 }
-/** Aplica a mesma conta aos processos, as lanes e aos conteineres que eles criarem. */
-function aplicarPlano(originais, plano, sinalDaReserva) {
+/** Reservas que cada peça devolve; a integração encadeada usa a fatia da varredura desde que ela termina. */
+function devolucoesDaReserva(plano) {
+    return {
+        varredura: plano.integracaoEmParalelo ? plano.cpusDaFatia : 0,
+        integracao: plano.cpusIntegracaoEmUso,
+        claims: plano.cpusClaims,
+    };
+}
+/** Transição pura do sinal; relógio e estado entram por argumento para a prova não depender da parede da máquina. */
+function aplicarDevolucaoDaReserva(vagasAtuais, capacidade, origem, libera, em) {
+    const vagas = Math.min(capacidade, vagasAtuais + Math.max(0, libera));
+    return { contrato: 'ork.check.reserva-devolvida/v2', origem, em, vagasGanhas: vagas - vagasAtuais, vagas };
+}
+function aplicarPlanoCpu(originais, plano, sinalDaReserva) {
     const itens = originais.map((item) => ({ ...item, ambiente: { ...item.ambiente } }));
     const porPapel = (papel) => itens.filter((i) => i.papelCpu === papel);
     const hermetica = porPapel('hermetica')[0];
     const varredura = porPapel('varredura')[0];
     const integracoes = porPapel('integracao');
+    const claims = porPapel('claim');
     const outros = porPapel('outro');
     const depender = (item, nomes) => {
         if (!item)
@@ -540,7 +592,7 @@ 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 ? {
+        ...(sinalDaReserva && (varredura || integracoes.length > 0 || claims.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,
         } : {}) });
@@ -549,11 +601,21 @@ function aplicarPlano(originais, plano, sinalDaReserva) {
         [agendador_cpu_1.ENV_CPUS_DOCKER]: cpusContainer,
     });
     let anteriorIntegracao;
+    const workersDaIntegracao = (0, agendador_cpu_1.workersDaReserva)(plano.cpusIntegracaoEmUso);
+    const cotaDoContainerDaIntegracao = String(Math.floor((plano.cpusIntegracaoEmUso / workersDaIntegracao) * 100) / 100);
     for (const item of integracoes) {
-        ambiente(item, { [agendador_cpu_1.ENV_CPUS_DA_LANE]: String(plano.cpusIntegracao), [agendador_cpu_1.ENV_CPUS_DOCKER]: cpusContainer });
+        ambiente(item, { [agendador_cpu_1.ENV_CPUS_DA_LANE]: String(plano.cpusIntegracaoEmUso),
+            [agendador_cpu_1.ENV_CPUS_DOCKER]: cotaDoContainerDaIntegracao });
         depender(item, [anteriorIntegracao ?? (plano.integracaoEmParalelo ? undefined : varredura?.nome)]);
         anteriorIntegracao = item.nome;
     }
+    if (plano.cpusClaims === 0) {
+        let anteriorClaim = anteriorIntegracao;
+        for (const item of claims) {
+            depender(item, [anteriorClaim ?? varredura?.nome, hermetica?.nome]);
+            anteriorClaim = 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.
@@ -585,7 +647,10 @@ function rodarEmParalelo(itens, ambiente = process.env, opcoes = {}) {
             ...(opcoes.cpus ? { cpus: opcoes.cpus } : {}), ...(opcoes.medicaoCpu ? { medicaoCpu: opcoes.medicaoCpu } : {}) };
         fs.writeFileSync(especificacao, JSON.stringify(esp), { mode: 0o600 });
         const prazo = esperaDoGrupo(itens, opcoes.maxParalelo) + 60_000;
-        const r = (0, node_child_process_1.spawnSync)(process.execPath, [__filename, especificacao], { env: ambiente, encoding: 'utf8', timeout: prazo,
+        const ambienteDoAuxiliar = { ...ambiente };
+        // Contexto privado do harness: herdá-lo faz este Node comum falar o protocolo binário de um filho de `node --test`.
+        delete ambienteDoAuxiliar.NODE_TEST_CONTEXT;
+        const r = (0, node_child_process_1.spawnSync)(process.execPath, [__filename, especificacao], { env: ambienteDoAuxiliar, encoding: 'utf8', timeout: prazo,
             killSignal: 'SIGKILL' });
         let lido = { terminados: [] };
         try {