@orkastery/cli 0.6.3 → 0.6.5

package/dist/manifest.js

@@ -257,6 +257,197 @@ function lerCheck(v, erros, avisos) {
 }
 /** Nome de lane: o que vira `test:<lane>` no ledger. */
 const NOME_DE_LANE = /^[a-z0-9][a-z0-9-]{0,31}$/;
+/** RM-081 F1: o relatorio e sempre um caminho POSIX relativo, nunca uma busca ou um caminho da maquina. */
+function caminhoJUnit(chave, v, erros) {
+    if (typeof v !== 'string' || !v.trim()) {
+        erros.push(`${chave} precisa ser um caminho relativo, em texto`);
+        return undefined;
+    }
+    const bruto = v.trim();
+    const normal = path.posix.normalize(bruto);
+    if (bruto.includes('\\') || bruto.includes('\0') || path.posix.isAbsolute(bruto) || path.win32.isAbsolute(bruto)
+        || normal === '.' || normal === '..' || normal.startsWith('../')) {
+        erros.push(`${chave}: ${exibir(v)} precisa ser um caminho relativo dentro da worktree`);
+        return undefined;
+    }
+    return normal;
+}
+/** RM-081 F3: o runner recebe a lista somente no marcador fechado, uma vez. */
+function filtroDoComando(chave, v, erros) {
+    if (v === undefined || v === null)
+        return undefined;
+    if (typeof v !== 'string' || !v.trim()) {
+        erros.push(`${chave} precisa ser um comando em texto com o marcador {testes}`);
+        return undefined;
+    }
+    const filtro = v.trim();
+    const marcadores = filtro.match(/\{testes\}/g)?.length ?? 0;
+    if (marcadores !== 1) {
+        erros.push(`${chave} precisa ter o marcador {testes} exatamente uma vez`);
+        return undefined;
+    }
+    return filtro;
+}
+/** RM-081 F5: caminho ou glob POSIX relativo, sem sair da worktree nem alcançar estado do nucleo. */
+function caminhoDaSelecao(chave, v, erros) {
+    if (typeof v !== 'string' || !v.trim()) {
+        erros.push(`${chave} precisa ser um caminho ou glob relativo, em texto`);
+        return undefined;
+    }
+    const bruto = v.trim().replace(/\/+$/, '');
+    const normal = path.posix.normalize(bruto);
+    if (!bruto || bruto.includes('\\') || bruto.includes('\0') || path.posix.isAbsolute(bruto)
+        || path.win32.isAbsolute(bruto) || normal === '.' || normal === '..' || normal.startsWith('../')
+        || /^(\.orkastery|\.git)(\/|$)/.test(normal)) {
+        erros.push(`${chave}: ${exibir(v)} precisa ficar dentro da worktree, fora de .orkastery e .git`);
+        return undefined;
+    }
+    return normal;
+}
+/** RM-081 F5: o manifesto declara o mecanismo e a superficie que o runner sabe relacionar. */
+function selecaoDoComando(chave, v, erros) {
+    if (v === undefined || v === null)
+        return undefined;
+    if (typeof v !== 'object' || Array.isArray(v)) {
+        erros.push(`${chave} precisa ser um mapa com comando, mapeia e configuracao opcional`);
+        return undefined;
+    }
+    for (const nome of Object.keys(v)) {
+        if (!['comando', 'mapeia', 'configuracao'].includes(nome)) {
+            erros.push(`${chave}.${nome} desconhecida; use somente comando, mapeia e configuracao`);
+        }
+    }
+    const comando = typeof v.comando === 'string' ? v.comando.trim() : '';
+    const bases = comando.match(/\{base\}/g)?.length ?? 0;
+    const arquivos = comando.match(/\{arquivos\}/g)?.length ?? 0;
+    if (!comando || bases + arquivos !== 1) {
+        erros.push(`${chave}.comando precisa ter exatamente um marcador {base} ou {arquivos}`);
+    }
+    const lista = (nome) => {
+        const valor = v[nome];
+        if (valor === undefined || valor === null)
+            return [];
+        const itens = Array.isArray(valor) ? valor : [valor];
+        return itens.flatMap((item, indice) => {
+            const lido = caminhoDaSelecao(`${chave}.${nome}[${indice}]`, item, erros);
+            return lido ? [lido] : [];
+        });
+    };
+    const mapeia = lista('mapeia');
+    const configuracao = lista('configuracao');
+    return comando && bases + arquivos === 1
+        ? { comando, mapeia, ...(configuracao.length ? { configuracao } : {}) }
+        : undefined;
+}
+/** RM-081 F2: uma unica estrategia, fechada e validada antes de qualquer teste rodar. */
+function relogioDoComando(chave, v, erros) {
+    if (v === undefined || v === null)
+        return undefined;
+    if (typeof v !== 'object' || Array.isArray(v)) {
+        erros.push(`${chave} precisa ser um mapa com exatamente uma de nome, marcador ou tag`);
+        return undefined;
+    }
+    const conhecidas = ['nome', 'marcador', 'tag'];
+    for (const nome of Object.keys(v)) {
+        if (!conhecidas.includes(nome))
+            erros.push(`${chave}.${nome} desconhecida; use somente nome, marcador ou tag`);
+    }
+    const presentes = conhecidas.filter((nome) => v[nome] !== undefined && v[nome] !== null);
+    if (presentes.length !== 1) {
+        erros.push(`${chave} precisa declarar exatamente uma de nome, marcador ou tag`);
+        return undefined;
+    }
+    const estrategia = presentes[0];
+    if (estrategia === 'nome') {
+        const valores = Array.isArray(v.nome) ? v.nome : [v.nome];
+        const padroes = valores.flatMap((item) => typeof item === 'string' && item.trim() ? [item.trim()] : []);
+        if (padroes.length !== valores.length || padroes.length === 0 || padroes.length > 20) {
+            erros.push(`${chave}.nome precisa ter de 1 a 20 expressoes regulares em texto`);
+            return undefined;
+        }
+        for (const padrao of padroes) {
+            try {
+                void new RegExp(padrao);
+            }
+            catch {
+                erros.push(`${chave}.nome contem expressao regular invalida: ${exibir(padrao)}`);
+                return undefined;
+            }
+        }
+        return { nome: padroes };
+    }
+    const valor = v[estrategia];
+    if (typeof valor !== 'string' || !valor.trim()) {
+        erros.push(`${chave}.${estrategia} precisa ser texto nao vazio`);
+        return undefined;
+    }
+    return estrategia === 'marcador' ? { marcador: valor.trim() } : { tag: valor.trim() };
+}
+/** RM-081 F4: recursos da lane sao nomes locais a rodada, unicos e de uma linha. */
+function recursosDoComando(chave, v, erros) {
+    if (v === undefined)
+        return undefined;
+    if (!Array.isArray(v) || v.length === 0) {
+        erros.push(`${chave} precisa ser uma lista nao vazia de textos`);
+        return undefined;
+    }
+    const lidos = [];
+    let valido = true;
+    for (const recurso of v) {
+        if (typeof recurso !== 'string' || !recurso.trim() || recurso.trim().length > 80 || /[\r\n]/.test(recurso)) {
+            erros.push(`${chave}: ${exibir(recurso)} precisa ser texto de uma linha, de 1 a 80 caracteres`);
+            valido = false;
+        }
+        else if (lidos.includes(recurso.trim())) {
+            erros.push(`${chave}: ${exibir(recurso.trim())} esta repetido`);
+            valido = false;
+        }
+        else
+            lidos.push(recurso.trim());
+    }
+    return valido ? lidos : undefined;
+}
+/** Texto continua sendo o contrato legado; o objeto exige comando e aceita os opt-ins da superficie. */
+function lerComando(chave, v, erros, aceitaSelecao = false, aceitaRecursos = false) {
+    if (v === undefined || v === null)
+        return {};
+    if (typeof v === 'string')
+        return { comando: v };
+    if (typeof v !== 'object' || Array.isArray(v)) {
+        erros.push(`${chave} precisa ser o comando em texto ou um mapa com comando (recebido ${exibir(v)})`);
+        return {};
+    }
+    const conhecidas = ['comando', 'junit', 'filtro', 'relogio', ...(aceitaSelecao ? ['selecao'] : []),
+        ...(aceitaRecursos ? ['recursos'] : [])];
+    for (const nome of Object.keys(v)) {
+        if (!conhecidas.includes(nome)) {
+            erros.push(`${chave}.${nome} desconhecida; use somente ${conhecidas.join(', ')}`);
+        }
+    }
+    const comando = typeof v.comando === 'string' && v.comando.trim() ? v.comando.trim() : undefined;
+    if (!comando)
+        erros.push(`${chave}.comando precisa ser texto nao vazio`);
+    const junit = v.junit === undefined ? undefined : caminhoJUnit(`${chave}.junit`, v.junit, erros);
+    const dispensaJUnit = aceitaRecursos && v.recursos !== undefined && v.recursos !== null;
+    if (v.junit === undefined) {
+        const dependencias = ['filtro', 'relogio']
+            .filter((dependencia) => v[dependencia] !== undefined && v[dependencia] !== null);
+        for (const dependencia of dependencias) {
+            if (v[dependencia] !== undefined && v[dependencia] !== null) {
+                erros.push(`${chave}.junit precisa ser declarado porque ${chave}.${dependencia} depende do relatorio JUnit`);
+            }
+        }
+        if (!dependencias.length && !dispensaJUnit) {
+            erros.push(`${chave}.junit precisa ser declarado no objeto de comando`);
+        }
+    }
+    const filtro = filtroDoComando(`${chave}.filtro`, v.filtro, erros);
+    const relogio = relogioDoComando(`${chave}.relogio`, v.relogio, erros);
+    const selecao = aceitaSelecao ? selecaoDoComando(`${chave}.selecao`, v.selecao, erros) : undefined;
+    const recursos = aceitaRecursos ? recursosDoComando(`${chave}.recursos`, v.recursos, erros) : undefined;
+    return { ...(comando ? { comando } : {}), ...(junit ? { junit } : {}), ...(filtro ? { filtro } : {}),
+        ...(relogio ? { relogio } : {}), ...(selecao ? { selecao } : {}), ...(recursos ? { recursos } : {}) };
+}
 /**
  * RM-072 (D3): o bloco `check.agile`. Cada chave liga uma peca do Agile; tipo errado e erro do manifesto, porque uma
  * peca mal escrita que sumisse em silencio mudaria o que o CHECK roda. `produto` so aceita caminho relativo dentro da
@@ -302,16 +493,42 @@ function lerAgile(v, erros, avisos) {
         }
         else {
             const lanes = {};
-            for (const [lane, comando] of Object.entries(v.test)) {
+            const junit = {};
+            const filtro = {};
+            const relogio = {};
+            const selecao = {};
+            const recursos = {};
+            for (const [lane, valor] of Object.entries(v.test)) {
                 if (!NOME_DE_LANE.test(lane))
                     erros.push(`check.agile.test.${lane}: nome de lane aceita [a-z0-9-], ate 32 caracteres`);
-                else if (typeof comando !== 'string' || !comando.trim())
-                    erros.push(`check.agile.test.${lane} precisa ser o comando, em texto`);
-                else
-                    lanes[lane] = comando.trim();
+                else {
+                    const lido = lerComando(`check.agile.test.${lane}`, valor, erros, true, true);
+                    if (lido.comando)
+                        lanes[lane] = lido.comando.trim();
+                    if (lido.junit)
+                        junit[lane] = lido.junit;
+                    if (lido.filtro)
+                        filtro[lane] = lido.filtro;
+                    if (lido.relogio)
+                        relogio[lane] = lido.relogio;
+                    if (lido.selecao)
+                        selecao[lane] = lido.selecao;
+                    if (lido.recursos)
+                        recursos[lane] = lido.recursos;
+                }
             }
             if (Object.keys(lanes).length)
                 agile.test = lanes;
+            if (Object.keys(junit).length)
+                agile.junit = junit;
+            if (Object.keys(filtro).length)
+                agile.filtro = filtro;
+            if (Object.keys(relogio).length)
+                agile.relogio = relogio;
+            if (Object.keys(selecao).length)
+                agile.selecao = selecao;
+            if (Object.keys(recursos).length)
+                agile.recursos = recursos;
         }
     }
     if (v.apos_a_varredura !== undefined && v.apos_a_varredura !== null) {
@@ -666,6 +883,14 @@ function carregarManifesto(dirInicial = diretorioDoProjeto()) {
             '(esperado nome de branch do git, sem "-" no começo e sem "..")');
     }
     const verify = mapa(dados.verify);
+    const comandosVerify = Object.fromEntries(['build', 'test', 'typecheck', 'security_scan']
+        .map((nome) => [nome, lerComando(`verify.${nome}`, verify[nome], erros)]));
+    const junitVerify = Object.fromEntries(Object.entries(comandosVerify)
+        .flatMap(([nome, lido]) => lido.junit ? [[nome, lido.junit]] : []));
+    const filtroVerify = Object.fromEntries(Object.entries(comandosVerify)
+        .flatMap(([nome, lido]) => lido.filtro ? [[nome, lido.filtro]] : []));
+    const relogioVerify = Object.fromEntries(Object.entries(comandosVerify)
+        .flatMap(([nome, lido]) => lido.relogio ? [[nome, lido.relogio]] : []));
     const ci = mapa(dados.ci);
     const concurrency = mapa(dados.concurrency);
     const handoff = mapa(dados.handoff);
@@ -879,15 +1104,14 @@ function carregarManifesto(dirInicial = diretorioDoProjeto()) {
             ...dependenciasDaWorktree(worktree.dependencias, erros),
         },
         verify: {
-            build: verify.build === null || verify.build === undefined ? undefined : texto(verify.build, ''),
-            test: verify.test === null || verify.test === undefined ? undefined : texto(verify.test, ''),
+            build: comandosVerify.build.comando,
+            test: comandosVerify.test.comando,
             ...prazosDoVerify(verify, erros),
-            typecheck: verify.typecheck === null || verify.typecheck === undefined
-                ? undefined
-                : texto(verify.typecheck, ''),
-            security_scan: verify.security_scan === null || verify.security_scan === undefined
-                ? undefined
-                : texto(verify.security_scan, ''),
+            typecheck: comandosVerify.typecheck.comando,
+            security_scan: comandosVerify.security_scan.comando,
+            ...(Object.keys(junitVerify).length ? { junit: junitVerify } : {}),
+            ...(Object.keys(filtroVerify).length ? { filtro: filtroVerify } : {}),
+            ...(Object.keys(relogioVerify).length ? { relogio: relogioVerify } : {}),
             // I-54 (RM-037, D10): o preparo unico da rodada de verify, quando declarado.
             ...(typeof verify.preparo === 'string' && verify.preparo.trim() ? { preparo: verify.preparo.trim() } : {}),
         },

package/dist/retry.js

@@ -117,6 +117,8 @@ const postura_local_1 = require("./postura-local");
 const locale_1 = require("./locale");
 const locale_retry_1 = require("./locale-retry");
 const retomada_checkpoint_1 = require("./retomada-checkpoint");
+const codex_task_complete_1 = require("./codex-task-complete");
+const session_events_1 = require("./session-events");
 /** RM-061 (F2b, D3): `porque` e `correcao` de cada motivo tem a fonte no catalogo pt-BR; o `--json` nao muda. */
 const TEXTOS_DA_POLITICA = locale_retry_1.RETRY_PT_BR.politica;
 /**
@@ -385,6 +387,31 @@ function blocoPausa(thread, fase) {
 function estadoTerminalDeRetry(estado) {
     return ['completed', 'failed', 'stopped', 'cancelled', 'interrupted', 'terminated'].includes(estado.trim().toLowerCase());
 }
+/** Prova estreita: somente o rollout fixado da sessão Codex que originou o gate da fase. */
+function faseJaTerminouPorTaskComplete(raiz, thread, fase, evento) {
+    const candidata = [...thread.sessoes].reverse().find(s => s.runtime === 'codex' && s.fase === fase &&
+        typeof s.despachadaEm === 'string' && (typeof evento?.sessionId !== 'string' || s.sessionId === evento.sessionId) &&
+        (typeof evento?.despachoEm !== 'string' || s.despachadaEm === evento.despachoEm));
+    if (!candidata)
+        return false;
+    try {
+        const prova = (0, codex_task_complete_1.taskCompleteFixadoDaSessao)(raiz, thread, (0, session_events_1.exigirSessaoDespachada)(candidata, candidata.sessionId), (0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, thread.id)));
+        // task_complete encerra o turno, mas pode carregar uma falha estruturada de runtime.
+        // Só o resultado que concluiu a fase impede nova tentativa; cota/auth/modelo mantêm
+        // a política tipada de recuperação já existente.
+        return prova?.terminal.classificacao === 'fase_concluida';
+    }
+    catch {
+        return false;
+    }
+}
+function planoProtegidoPorTaskComplete(thread, fase, limite, effort) {
+    return { thread: thread.id, modo: thread.modo, fase, motivo: null,
+        detalhe: 'rollout autenticado da sessão despachada já contém task_complete', politica: null,
+        acao: 'sem-retry', tentativas: 0, limite, effort, effortAnterior: effort, automatica: false,
+        bloqueio: 'gate.sem-reprovacao',
+        razao: 'rollout autenticado já contém task_complete; a fase terminou e não será redespachada' };
+}
 /**
  * Calcula o plano de retry SEM executar nada.
  *
@@ -417,6 +444,8 @@ function planejarRetry(carregado, threadId, opcoes = {}) {
         };
     }
     const fase = opcoes.fase ?? (evento ? faseDoEvento(evento, thread) : thread.faseAtual);
+    if (faseJaTerminouPorTaskComplete(raiz, thread, fase, evento))
+        return planoProtegidoPorTaskComplete(thread, fase, limite, effortBase);
     const politica = politicaDoMotivo(motivo);
     const tentativas = tentativasFeitas(raiz, threadId, fase, motivo);
     const detalhe = evento && typeof evento.detalhe === 'string' ? evento.detalhe : '';
@@ -1429,6 +1458,12 @@ function executarRetry(carregado, threadId, opcoes = {}) {
         }
     }
     const thread = (0, thread_1.lerThread)(raiz, threadId);
+    // D4: reconfirma imediatamente antes do primeiro efeito do retry; o plano anterior pode ter
+    // sido calculado enquanto o runtime ainda anexava o terminal ao rollout.
+    if (plano.motivo !== null && plano.fase &&
+        faseJaTerminouPorTaskComplete(raiz, thread, plano.fase, ultimaReprovacao(raiz, threadId))) {
+        plano = planoProtegidoPorTaskComplete(thread, plano.fase, plano.limite, plano.effortAnterior);
+    }
     const dir = (0, thread_1.dirThread)(raiz, threadId);
     const vazio = {
         plano,

package/dist/security-scan/agil.js

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

package/dist/security-scan/executor.js

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