@orkastery/cli 0.6.0 → 0.6.2

package/dist/check-agil.js

@@ -38,14 +38,19 @@ exports.paralelismoDaVarreduraNoGrupo = paralelismoDaVarreduraNoGrupo;
 exports.passosDoComando = passosDoComando;
 exports.elosDoComando = elosDoComando;
 exports.tirarPassosDoPreparo = tirarPassosDoPreparo;
+exports.tirarPassosDoPreparoAposLeituras = tirarPassosDoPreparoAposLeituras;
 exports.hashDoProduto = hashDoProduto;
 exports.prepararNoAgile = prepararNoAgile;
 exports.executorDaClaimNoAgile = executorDaClaimNoAgile;
 exports.refazerPreparo = refazerPreparo;
 exports.testDasLanes = testDasLanes;
+exports.porQueDasLanes = porQueDasLanes;
 exports.comandosNoAgile = comandosNoAgile;
 exports.pecasDoRelatorio = pecasDoRelatorio;
 exports.listasDasLanes = listasDasLanes;
+exports.resultadosDasLanes = resultadosDasLanes;
+exports.assinaturaDoAmbiente = assinaturaDoAmbiente;
+exports.executorDaClaimPelasLanes = executorDaClaimPelasLanes;
 /**
  * RM-072 (D3 a D8 da ork-check5x): o motor do Agile Check no verify.
  *
@@ -53,12 +58,16 @@ exports.listasDasLanes = listasDasLanes;
  *
  *   - o preparo do Agile (`check.agile.preparo`, como o `tsgo` deste projeto) e, se ele falhar ou nao existir, o
  *     `verify.preparo`, com a peca `preparo` em fallback;
- *   - as claims, uma por vez, contra o produto do preparo: a claim que comeca pelos passos do `verify.preparo` roda sem
+ *   - quando ha lanes, elas rodam antes das claims; `node --test` dos mesmos arquivos, HEAD e ambiente usa o resultado
+ *     nominal da lane, enquanto comando aberto ou evidencia divergente roda inteiro; se uma claim posterior mudar o
+ *     produto, preparo e grupo rodam outra vez sobre o produto final;
+ *   - as demais claims, uma por vez, contra o produto do preparo: a claim que comeca pelos passos do `verify.preparo` roda sem
  *     eles quando a guarda vale (o preparo passou, a arvore e a mesma do fim do preparo e o hash dos caminhos de
  *     `check.agile.produto` tambem); qualquer divergencia roda o comando inteiro, e o motivo vai ao ledger. Passo no meio
- *     da cadeia fica: o que vem antes dele pode mudar a entrada do build (o mutante que edita o fonte e compila). Quando
+ *     da cadeia so sai quando tudo antes dele e uma leitura `grep -q` fechada; qualquer outro elo pode mudar a entrada do
+ *     build (como o mutante que edita o fonte e compila), entao a cadeia fica inteira. Quando
  *     so o produto mudou (a claim anterior compilou de novo no meio da cadeia), o preparo roda de novo antes da proxima
- *     claim que o reaproveitaria, ate `MAXIMO_DE_PREPAROS_REFEITOS` vezes, e uma vez antes do grupo, com a peca
+ *     claim que o reaproveitaria, ate `MAXIMO_DE_PREPAROS_REFEITOS` vezes, e uma vez depois das claims se elas mudarem o produto, com a peca
  *     `preparo-refeito`;
  *   - o `build` que e so passos do preparo, com a guarda valendo, sai do preparo desta rodada sem rodar de novo;
  *   - `typecheck`, as lanes de `test` (`check.agile.test`, ou o `verify.test`) e o `security_scan` num grupo paralelo, so
@@ -74,13 +83,11 @@ const fs = __importStar(require("node:fs"));
 const os = __importStar(require("node:os"));
 const path = __importStar(require("node:path"));
 const check_modo_1 = require("./check-modo");
+const agendador_cpu_1 = require("./agendador-cpu");
 const redacao_url_1 = require("./redacao-url");
-/**
- * Quantas ferramentas a varredura roda ao mesmo tempo dentro do grupo, ao lado das lanes: um terco das CPUs que sobram
- * de uma, e no minimo duas. Numa maquina de 7 CPUs, duas.
- */
+/** Quantas ferramentas cabem na fatia de duas CPUs reservada pelo plano paralelo. */
 function paralelismoDaVarreduraNoGrupo(cpus = os.availableParallelism()) {
-    return Math.max(2, Math.floor((cpus - 1) / 3));
+    return (0, agendador_cpu_1.planejarCpuDoGrupo)(cpus, { carga1: 0, stealPct: 0 }).ferramentasDaVarredura;
 }
 const SEPARADOR = ' && ';
 /** Os passos de um comando encadeado por `&&` no nivel do texto (o preparo e escrito assim no manifesto). */
@@ -158,6 +165,78 @@ function tirarPassosDoPreparo(comando, passosDoPreparo) {
     }
     return { passos, resto };
 }
+/** Palavras de um comando simples, sem operadores ou expansoes do shell. */
+function palavrasDoComando(comando) {
+    const palavras = [];
+    let atual = '', aspas = null, escape = false;
+    const fechar = () => { if (atual !== '')
+        palavras.push(atual); atual = ''; };
+    for (const c of comando) {
+        if (escape) {
+            atual += c;
+            escape = false;
+            continue;
+        }
+        if (c === '\\' && aspas !== "'") {
+            escape = true;
+            continue;
+        }
+        if (aspas) {
+            if (c === aspas)
+                aspas = null;
+            else if (aspas === '"' && (c === '$' || c === '`'))
+                return null;
+            else
+                atual += c;
+            continue;
+        }
+        if (c === "'" || c === '"') {
+            aspas = c;
+            continue;
+        }
+        if (/\s/.test(c)) {
+            fechar();
+            continue;
+        }
+        if (';&|<>$`(){}'.includes(c))
+            return null;
+        atual += c;
+    }
+    if (escape || aspas)
+        return null;
+    fechar();
+    return palavras;
+}
+/** Uma leitura sem efeito colateral aceita antes do preparo unico. */
+function comandoGrepQ(comando) {
+    const palavras = palavrasDoComando(comando);
+    if (!palavras || palavras[0] !== 'grep' || palavras[1] !== '-q')
+        return false;
+    const argumentos = palavras[2] === '--' ? palavras.slice(3) : palavras.slice(2);
+    return argumentos.length === 2 && argumentos[0] !== '' && argumentos[1] !== '' && !argumentos[1].startsWith('-');
+}
+/**
+ * Tira passos exatos do preparo que aparecem depois apenas de `grep -q`. A leitura nao altera a entrada do build;
+ * qualquer outro elo antes do preparo conserva a regra antiga e faz a cadeia rodar inteira.
+ */
+function tirarPassosDoPreparoAposLeituras(comando, passosDoPreparo) {
+    const elos = elosDoComando(comando);
+    if (!elos)
+        return { passos: [], resto: comando.trim() };
+    const passos = [];
+    const resto = [];
+    let somenteLeiturasAntes = true;
+    for (const elo of elos) {
+        if (somenteLeiturasAntes && passosDoPreparo.includes(elo)) {
+            passos.push(elo);
+            continue;
+        }
+        resto.push(elo);
+        if (!comandoGrepQ(elo))
+            somenteLeiturasAntes = false;
+    }
+    return passos.length > 0 ? { passos, resto: resto.join(SEPARADOR) } : { passos: [], resto: comando.trim() };
+}
 /**
  * O sha256 do conteudo dos caminhos do produto (arquivos em ordem, com o caminho relativo). Caminho ausente entra como
  * ausente, para o produto que some nao passar por igual; link simbolico entra pelo destino que ele aponta, sem segui-lo.
@@ -257,7 +336,8 @@ function doPreparo(nome, comando, preparo, passos) {
 function executorDaClaimNoAgile(manifesto, executor, vigente, refazer) {
     const passosDoPreparo = manifesto.verify.preparo ? passosDoComando(manifesto.verify.preparo) : [];
     return (nome, comando, cwd) => {
-        const { passos, resto } = tirarPassosDoPreparo(comando, passosDoPreparo);
+        const daFrente = tirarPassosDoPreparo(comando, passosDoPreparo);
+        const { passos, resto } = daFrente.passos.length > 0 ? daFrente : tirarPassosDoPreparoAposLeituras(comando, passosDoPreparo);
         if (passos.length === 0)
             return executor(nome, comando, cwd);
         let motivo = vigente.guarda.conferir();
@@ -311,21 +391,25 @@ function caiuDeVerdade(r) {
 /**
  * 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.
- * O relogio sob steal so vale quando toda lane que caiu caiu so nele, e a pior causa so vale sem falha de verdade. N1 do
- * CHECK 2 e N6 do CHECK 4: com uma lane caida sem veredito (fora o caso em que todas as caidas estouraram ou cairam so
- * no relogio, que o agregado ja diz por tempo), o `test` nao tem veredito inteiro (`executado` falso): no verify ele
- * bloqueia como sem veredito, mesmo com a baseline `ja-falhava`, e na baseline ele e `sem-veredito`, em qualquer ordem das
- * lanes; com falha de verdade junto, a causa, os testes e o trecho continuam os dela. A lane sozinha que sai com 124 antes
- * do prazo de fora fica sem veredito, mais estrita que o comando unico do Classic, que a compara com a baseline.
+ * O relogio sob steal so vale quando toda lane que caiu caiu so nele, e a pior causa so vale sem falha de verdade.
+ *
+ * RM-074 (F4): a lane que nao terminou sozinha fora do tempo (sinal, comando ausente, o codigo de quem nao a deixou
+ * terminar, de 124 em diante antes do prazo de fora) da ao `test` o codigo dela, e o `test` segue com veredito, como o
+ * comando unico do Classic que terminasse assim: no verify ele e comparado com a baseline (regressao, ja falhava ou falha
+ * sem baseline), e na baseline ele e `sem-veredito`, porque o codigo nao e da propria lane, em qualquer ordem das lanes;
+ * com falha de verdade junto, a causa, os testes e o trecho continuam os dela. So a lane que nao rodou (`executado`
+ * falso, como o comando que o Classic nao lancou) deixa o `test` sem veredito inteiro. O caso por tempo segue o de antes
+ * (N1 do CHECK 2 e N6 do CHECK 4): o estouro ou o relogio de uma lane junto de falha de verdade de outra tambem deixa o
+ * `test` sem veredito inteiro, e as caidas so por tempo dao o agregado por tempo.
  */
 function testDasLanes(lanes) {
     const caidas = lanes.filter((l) => !l.resultado.ok);
     const deVerdade = caidas.filter((l) => caiuDeVerdade(l.resultado));
     const semVeredito = caidas.filter((l) => !caiuDeVerdade(l.resultado));
-    // N6 do CHECK 4: so o estouro e o relogio sob steal ja dizem "sem veredito" pelo agregado (a causa ou o relogio dele);
-    // qualquer outra lane sem veredito deixa o `test` sem veredito inteiro, em qualquer ordem das lanes.
-    const soPorTempo = deVerdade.length === 0 && semVeredito.length > 0
-        && semVeredito.every((l) => l.resultado.causa === 'timeout' || (l.resultado.relogioSobSteal?.length ?? 0) > 0);
+    const porTempo = (r) => r.causa === 'timeout' || (r.relogioSobSteal?.length ?? 0) > 0;
+    // RM-074 (F4): a lane sem veredito fora do tempo da o codigo ao `test`, que o verify compara com a baseline.
+    const foraDoTempo = semVeredito.filter((l) => !porTempo(l.resultado));
+    const tempoComFalha = deVerdade.length > 0 && semVeredito.some((l) => porTempo(l.resultado));
     const juntar = (f) => lanes.flatMap((l) => f(l.resultado) ?? []);
     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));
@@ -338,20 +422,45 @@ function testDasLanes(lanes) {
         nome: 'test',
         comando: lanes.map((l) => `${l.lane}: ${l.resultado.comando}`).join('; '),
         ok: caidas.length === 0,
-        code: (deVerdade[0] ?? caidas[0])?.resultado.code ?? 0,
+        code: (foraDoTempo[0] ?? deVerdade[0] ?? caidas[0])?.resultado.code ?? 0,
         resumo: (caidas.length ? caidas : lanes).map((l) => `[${l.lane}] ${l.resultado.resumo}`).join('\n').slice(-800),
         ...(causa ? { causa } : {}),
         prazoMs: Math.max(...lanes.map((l) => l.resultado.prazoMs ?? 0)),
         duracaoMs: Math.max(...lanes.map((l) => l.resultado.duracaoMs ?? 0)),
-        executado: semVeredito.length === 0 || soPorTempo ? lanes.every((l) => l.resultado.executado !== false) : false,
+        executado: !tempoComFalha && lanes.every((l) => l.resultado.executado !== false),
         ...(testes.length ? { testeQueCaiu: testes } : {}),
         ...(falhas.length ? { falhasDeTeste: falhas } : {}),
         ...(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 } : {}),
         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.causa ? { causa: l.resultado.causa } : {}), duracaoMs: l.resultado.duracaoMs ?? 0,
+            ...(l.resultado.testeQueCaiu?.length ? { testeQueCaiu: l.resultado.testeQueCaiu } : {}) })),
+    };
+}
+/**
+ * RM-074 (F4): por que cada lane caida do `test` ficou como ficou, para o texto do gate dizer qual lane ficou sem veredito
+ * e por que. Le so o que o ledger grava da lane (codigo e causa); o relogio sob steal vem do agregado, que so o traz quando
+ * toda lane caida caiu so nele. Vazio fora do Agile (sem lanes) e com todas as lanes ok.
+ */
+function porQueDasLanes(c) {
+    const caidas = (c.lanes ?? []).filter((l) => !l.ok);
+    const porque = (l) => {
+        if (l.causa === 'timeout')
+            return 'estourou o prazo';
+        if (l.causa === 'nao-encontrado')
+            return `comando nao encontrado (codigo ${l.code})`;
+        if (l.code === -1)
+            return 'sem codigo de saida: nao rodou, ou o auxiliar do grupo morreu antes de gravar o resultado';
+        if (l.causa === 'sinal')
+            return `morta por sinal (codigo ${l.code})`;
+        if (c.relogioSobSteal?.length)
+            return `caiu so em teste com relogio sob steal (${c.relogioSobSteal.join(', ')})`;
+        if (Number.isInteger(l.code) && l.code >= 1 && l.code <= MAIOR_CODIGO_DA_LANE)
+            return `caiu com o codigo ${l.code}`;
+        return `saiu com ${l.code}, o codigo de quem nao a deixou terminar`;
     };
+    return caidas.map((l) => `lane ${l.lane}: ${porque(l)}`).join('; ');
 }
 /**
  * Os comandos do manifesto no Agile (D4): `build` reaproveitado do preparo com a guarda valendo; o resto num grupo
@@ -391,16 +500,17 @@ function comandosNoAgile(manifesto, cwd, lista, executor, grupo, guarda, preparo
         if (c.nome === 'test' && lanesDeclaradas.length > 0) {
             for (const [lane, comando] of lanesDeclaradas) {
                 if (depoisDaVarredura.has(lane))
-                    encadeados.push({ nome: `test:${lane}`, comando, apos: ['security_scan'] });
+                    encadeados.push({ nome: `test:${lane}`, comando, apos: ['security_scan'], papelCpu: 'integracao' });
                 else
-                    itens.push({ nome: `test:${lane}`, comando });
+                    itens.push({ nome: `test:${lane}`, comando, papelCpu: lane === 'hermetica' ? 'hermetica' : 'outro' });
             }
         }
         else
-            itens.push({ nome: c.nome, comando: c.comando });
+            itens.push({ nome: c.nome, comando: c.comando, 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));
+    pecas.push(...(grupo.pecas ?? []));
     const lanes = [];
     itens.forEach((item, i) => {
         if (item.nome.startsWith('test:'))
@@ -498,3 +608,157 @@ function listasDasLanes(linhas) {
         return { lane: l.lane, arquivos, sha256: (0, node_crypto_1.createHash)('sha256').update(arquivos.join('\n')).digest('hex') };
     });
 }
+/** Evidencia nominal produzida pelo reporter, sem confiar em campos abertos do JSONL. */
+function resultadosDasLanes(linhas) {
+    return linhas.filter((l) => l.tipo === 'resultados' && typeof l.lane === 'string' && typeof l.head === 'string'
+        && typeof l.ambiente === 'string' && Array.isArray(l.testes))
+        .map((l) => ({ lane: l.lane, head: l.head, ambiente: l.ambiente,
+        testes: l.testes.flatMap((t) => {
+            if (!t || typeof t !== 'object' || Array.isArray(t))
+                return [];
+            const x = t;
+            if (typeof x.arquivo !== 'string' || typeof x.nome !== 'string' || !Number.isInteger(x.nesting)
+                || !['pass', 'fail', 'skip', 'todo'].includes(String(x.estado)))
+                return [];
+            return [{ arquivo: x.arquivo, nome: x.nome, nesting: x.nesting,
+                    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_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');
+}
+/** Le somente a gramatica aceita para reaproveitar: `node --test [--test-name-pattern P] arquivo...`. */
+function comandoNodeTest(comando, cwd) {
+    const palavras = palavrasDoComando(comando);
+    if (!palavras)
+        return null;
+    if (palavras[0] !== 'node' || palavras[1] !== '--test')
+        return null;
+    let padrao;
+    const arquivos = [];
+    for (let i = 2; i < palavras.length; i++) {
+        const p = palavras[i];
+        if (p === '--test-name-pattern') {
+            if (padrao !== undefined || !palavras[++i])
+                return null;
+            padrao = palavras[i];
+            continue;
+        }
+        if (p.startsWith('--test-name-pattern=')) {
+            if (padrao !== undefined)
+                return null;
+            padrao = p.slice('--test-name-pattern='.length);
+            continue;
+        }
+        if (p.startsWith('-') || /[*?\[]/.test(p))
+            return null;
+        const absoluto = path.resolve(cwd, p);
+        const relativo = path.relative(path.join(cwd, 'core', 'dist-test', 'test'), absoluto);
+        if (!relativo || relativo.startsWith('..') || path.isAbsolute(relativo) || relativo !== path.basename(relativo)
+            || !relativo.endsWith('.test.js'))
+            return null;
+        arquivos.push(path.basename(absoluto));
+    }
+    if (padrao !== undefined) {
+        try {
+            void new RegExp(padrao);
+        }
+        catch {
+            return null;
+        }
+    }
+    return arquivos.length > 0 ? { arquivos: [...new Set(arquivos)], ...(padrao !== undefined ? { padrao } : {}) } : null;
+}
+/** A forma fechada usada pelas claims para provar contagem, zero falhas e zero skips no TAP. */
+function auditoriaTap(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();
+    const awk = comando.slice(i + divisor.length).trim();
+    const pedido = comandoNodeTest(node.replace(/^node --test-reporter=tap\b/, 'node --test'), cwd);
+    if (!pedido || pedido.arquivos.length !== 1 || pedido.padrao !== undefined)
+        return null;
+    const m = /^awk '\/\^ \*not ok\/{f\+\+} \/# SKIP\/{s\+\+} \/\^ \*ok \[0-9\]\+ - ([A-Z][A-Z0-9_-]*)\[0-9\]\+:\/{p\+\+} END\{exit !\(p>=([1-9][0-9]*) && f==0 && s==0\)\}'$/.exec(awk);
+    return m ? { pedido, prefixo: m[1], minimo: Number(m[2]) } : null;
+}
+function resultadoReaproveitado(nome, comando, pedido, usadas, esperado, nomes) {
+    const lanes = [...new Set(usadas.filter((e) => e.testes.some((t) => pedido.arquivos.includes(t.arquivo))).map((e) => e.lane))];
+    return { nome, comando, ok: true, code: 0, causa: 'exit', duracaoMs: 0, executado: true,
+        resumo: `reaproveitado das lanes ${lanes.join(', ')} desta rodada`,
+        lane: { reaproveitada: true, lanes, arquivos: pedido.arquivos,
+            nomes: nomes ?? (pedido.padrao === undefined ? pedido.arquivos.map((a) => `${a}:todos`) : pedido.arquivos.map((a) => `${a}:/${pedido.padrao}/`)),
+            head: esperado.head, ambiente: esperado.ambiente } };
+}
+/**
+ * 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) });
+        }
+        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;
+            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);
+        }
+        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 } };
+    };
+}

package/dist/check-paralelo.js

@@ -51,13 +51,13 @@ const node_child_process_1 = require("node:child_process");
 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 TIMEOUT_BIN = '/usr/bin/timeout';
 const NICE_BIN = '/usr/bin/nice';
-/** O argv de um item: `nice` (se pedido e existir), `timeout(1)` (se existir) e `bash -c`. */
+/** 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 base = comGrupo
-        ? [TIMEOUT_BIN, '--kill-after=15', `${Math.ceil(item.prazoMs / 1000)}`, 'bash', '-c', item.comando]
-        : ['bash', '-c', item.comando];
+    const programa = item.argv?.length ? item.argv : ['bash', '-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. */
@@ -83,12 +83,24 @@ function vagas(max) {
  */
 async function rodarEspecificacao(esp) {
     const comGrupo = fs.existsSync(TIMEOUT_BIN);
-    const limite = vagas(esp.maxParalelo && esp.maxParalelo > 0 ? esp.maxParalelo : esp.itens.length);
+    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 itens = plano ? aplicarPlano(esp.itens, plano) : esp.itens;
+    const limite = vagas(esp.maxParalelo && esp.maxParalelo > 0 ? esp.maxParalelo : itens.length);
     const porNome = new Map();
-    const terminados = await Promise.all(esp.itens.map((item, i) => {
-        const vez = (async () => {
-            for (const nome of item.apos ?? [])
-                await porNome.get(nome);
+    const indice = new Map(itens.map((item, i) => [item.nome, i]));
+    const vezDoItem = (item, i) => {
+        const existente = porNome.get(item.nome);
+        if (existente)
+            return existente;
+        // O primeiro `then` deixa a promessa entrar no mapa antes de resolver dependencias; assim `apos` funciona mesmo
+        // quando o plano põe uma dependencia que aparece depois na ordem canonica dos resultados.
+        const vez = Promise.resolve().then(async () => {
+            for (const nome of item.apos ?? []) {
+                const j = indice.get(nome);
+                if (j !== undefined)
+                    await vezDoItem(itens[j], j);
+            }
             await limite.tomar();
             try {
                 return await lancar(item, i);
@@ -96,11 +108,12 @@ async function rodarEspecificacao(esp) {
             finally {
                 limite.soltar();
             }
-        })();
+        });
         porNome.set(item.nome, vez);
         return vez;
-    }));
-    fs.writeFileSync(path.join(esp.dir, 'resultado.json'), JSON.stringify(terminados), { mode: 0o600 });
+    };
+    const terminados = await Promise.all(itens.map(vezDoItem));
+    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);
@@ -127,12 +140,50 @@ async function rodarEspecificacao(esp) {
         });
     }
 }
+/** Aplica a mesma conta aos processos, as lanes e aos conteineres que eles criarem. */
+function aplicarPlano(originais, plano) {
+    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 outros = porPapel('outro');
+    const depender = (item, nomes) => {
+        if (!item)
+            return;
+        item.apos = [...new Set([...(item.apos ?? []), ...nomes.filter((n) => !!n && n !== item.nome)])];
+    };
+    const ambiente = (item, valores) => {
+        if (item)
+            item.ambiente = { ...item.ambiente, ...valores };
+    };
+    const cpusContainer = String(plano.cpusPorContainer);
+    ambiente(hermetica, { [agendador_cpu_1.ENV_CPUS_DA_LANE]: String(plano.cpusHermetica), [agendador_cpu_1.ENV_CPUS_DOCKER]: cpusContainer });
+    ambiente(varredura, {
+        ORK_CHECK_VARREDURA_PARALELA: String(plano.ferramentasDaVarredura),
+        [agendador_cpu_1.ENV_CPUS_DOCKER]: cpusContainer,
+    });
+    let anterior = varredura?.nome;
+    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;
+    }
+    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;
+    }
+    return itens;
+}
 /**
  * A espera do grupo inteiro: o maior prazo, ou a soma deles quando ha fila (item com `apos` ou vagas a menos que itens),
  * que e o teto do pior caso.
  */
 function esperaDoGrupo(itens, maxParalelo) {
-    const comFila = itens.some((i) => i.apos?.length) || (!!maxParalelo && maxParalelo < itens.length);
+    const comFila = itens.some((i) => i.apos?.length || i.papelCpu) || (!!maxParalelo && maxParalelo < itens.length);
     return comFila ? itens.reduce((t, i) => t + i.prazoMs, 0) : Math.max(...itens.map((i) => i.prazoMs));
 }
 /**
@@ -145,18 +196,19 @@ function rodarEmParalelo(itens, ambiente = process.env, opcoes = {}) {
     const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'ork-check-paralelo-'));
     try {
         const especificacao = path.join(dir, 'especificacao.json');
-        const esp = { itens, dir, ...(opcoes.maxParalelo ? { maxParalelo: opcoes.maxParalelo } : {}) };
+        const esp = { itens, dir, ...(opcoes.maxParalelo ? { maxParalelo: opcoes.maxParalelo } : {}),
+            ...(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,
             killSignal: 'SIGKILL' });
-        let terminados = [];
+        let lido = { terminados: [] };
         try {
-            terminados = JSON.parse(fs.readFileSync(path.join(dir, 'resultado.json'), 'utf8'));
+            lido = JSON.parse(fs.readFileSync(path.join(dir, 'resultado.json'), 'utf8'));
         }
         catch { /* abaixo */ }
-        return itens.map((item, i) => {
-            const t = terminados[i];
+        const processos = itens.map((item, i) => {
+            const t = lido.terminados[i];
             const ler = (sufixo) => { try {
                 return fs.readFileSync(path.join(dir, `${i}.${sufixo}`), 'utf8');
             }
@@ -172,6 +224,9 @@ function rodarEmParalelo(itens, ambiente = process.env, opcoes = {}) {
             return { nome: item.nome, ok: t.code === 0, code: t.code ?? -1, signal: t.signal, ...(t.error ? { error: t.error } : {}),
                 stdout: ler('out'), stderr: ler('err'), duracaoMs: t.duracaoMs, comGrupo: t.comGrupo };
         });
+        if (lido.agendamentoCpu)
+            processos.agendamentoCpu = lido.agendamentoCpu;
+        return processos;
     }
     finally {
         fs.rmSync(dir, { recursive: true, force: true });

package/dist/ci.js

@@ -389,10 +389,11 @@ function lintDoBundle(claims) {
     for (const claim of claims) {
         for (const achado of (0, claim_lint_1.analisarComandos)(claim.verificar)) {
             const linha = (0, claim_lint_1.linhaDoLintDeClaim)(claim.id, achado);
-            if (achado.regra === 'suite-inteira' && claim.lint !== undefined)
+            const bloqueiaNova = achado.regra === 'suite-inteira' || (0, claim_lint_1.regraFatalDeClaim)(achado.regra);
+            if (bloqueiaNova && claim.lint !== undefined)
                 recusas.push(linha);
             else
-                avisos.push(achado.regra === 'suite-inteira' ? anteriorAoLint(linha) : linha);
+                avisos.push(bloqueiaNova ? anteriorAoLint(linha) : linha);
         }
     }
     return { recusas, avisos };

package/dist/claim-lint.js

@@ -16,6 +16,8 @@
  * alheia e mexer em estado de quem nao pediu (D16). Nada de data de corte no codigo.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.REGRAS_FATAIS_DE_CLAIM = void 0;
+exports.regraFatalDeClaim = regraFatalDeClaim;
 exports.analisarComando = analisarComando;
 exports.analisarComandos = analisarComandos;
 exports.linhaDoLintDeClaim = linhaDoLintDeClaim;
@@ -29,7 +31,18 @@ const CORRECAO = {
     'suite-inteira': (0, locale_1.msg)('pt-BR').claims.correcoesDoLint['suite-inteira'],
     'sha-intermediario': (0, locale_1.msg)('pt-BR').claims.correcoesDoLint['sha-intermediario'],
     'contagem-de-commits': (0, locale_1.msg)('pt-BR').claims.correcoesDoLint['contagem-de-commits'],
+    'binario-rg': (0, locale_1.msg)('pt-BR').claims.correcoesDoLint['binario-rg'],
+    'ork-fora-do-path': (0, locale_1.msg)('pt-BR').claims.correcoesDoLint['ork-fora-do-path'],
+    'estado-local': (0, locale_1.msg)('pt-BR').claims.correcoesDoLint['estado-local'],
+    'aspas-escapadas': (0, locale_1.msg)('pt-BR').claims.correcoesDoLint['aspas-escapadas'],
 };
+/** RM-037: estes achados tornam uma claim nova inexequivel no checkout do runner. */
+exports.REGRAS_FATAIS_DE_CLAIM = new Set([
+    'binario-rg', 'ork-fora-do-path', 'estado-local', 'aspas-escapadas',
+]);
+function regraFatalDeClaim(regra) {
+    return exports.REGRAS_FATAIS_DE_CLAIM.has(regra);
+}
 /**
  * (a) `npm [--prefix <dir>] [run] test` sem subcomando (`test:ci` nao casa) e sem arquivos
  * nomeados depois de `--` (o comando que nomeia `.test.ts`/`.js` depois de `--` e focado).
@@ -41,8 +54,24 @@ const SO_ANCESTRALIDADE = /merge-base\s+--is-ancestor\s+\S+\s+\S+/g;
 /** (b2) Contagem de commits comparada a um numero. */
 const CONTAGEM = /rev-list\s+(?:[^|;&]*\s)?--count\b|\bgit\s+log\b[^|;&]*\|\s*wc\s+-l\b/;
 const COMPARACAO = /-(?:eq|ne|gt|lt|ge|le)\s+['"]?\d|[^=!<>]==?\s*['"]?\d|grep\s+-(?:q?x|xq)\s+['"]?\d/;
+/** Executavel em posicao de comando, no inicio ou depois de um operador do shell. */
+function executavelDireto(comando, nome) {
+    return new RegExp(`(?:^|&&|\\|\\||[;|(])\\s*(?:command\\s+|env\\s+)?(${nome})(?=\\s|$)`).exec(comando);
+}
 function analisarComando(comando) {
     const achados = [];
+    const rg = executavelDireto(comando, 'rg');
+    if (rg)
+        achados.push({ regra: 'binario-rg', trecho: rg[1], correcao: CORRECAO['binario-rg'] });
+    const ork = executavelDireto(comando, 'ork');
+    if (ork)
+        achados.push({ regra: 'ork-fora-do-path', trecho: ork[1], correcao: CORRECAO['ork-fora-do-path'] });
+    const estado = /(?:^|[\s"'=])((?:\.\/)?\.orkastery(?:[\\/][^\s"']*)?)/.exec(comando);
+    if (estado)
+        achados.push({ regra: 'estado-local', trecho: estado[1], correcao: CORRECAO['estado-local'] });
+    const aspas = /\\x(?:22|27)/i.exec(comando);
+    if (aspas)
+        achados.push({ regra: 'aspas-escapadas', trecho: aspas[0], correcao: CORRECAO['aspas-escapadas'] });
     const suite = SUITE_INTEIRA.exec(comando);
     if (suite)
         achados.push({ regra: 'suite-inteira', trecho: suite[0].trim(), correcao: CORRECAO['suite-inteira'] });

package/dist/claims.js

@@ -154,6 +154,10 @@ function adicionarClaim(raiz, threadId, opcoes) {
         verificar: opcoes.verificar,
         origem: opcoes.origem,
     });
+    const recusas = (claim.lint ?? []).filter((a) => (0, claim_lint_1.regraFatalDeClaim)(a.regra));
+    if (recusas.length > 0) {
+        throw new locale_1.ErroDoCatalogo((m) => m.claims.lintRecusado(recusas.map((a) => `claims.lint.${a.regra}: ${(0, claim_lint_1.linhaDoLintDeClaim)(claim.id, a)}`).join('\n  ')));
+    }
     const negativa = claim.negativa;
     const verificar = claim.verificar;
     gravarClaim(raiz, claim);