@orkastery/cli 0.6.2 → 0.6.4

package/dist/hitl-tempo-parado.js

@@ -29,7 +29,7 @@ exports.linhaDoHitlAcimaDaMeta = linhaDoHitlAcimaDaMeta;
  *   aberto              nada disso ainda: a espera corre ate o fim do periodo.
  *
  * Limite dito: o "confirmo" que um condutor pede na conversa, fora do ork, nao chega ao ledger e
- * nao entra aqui. Por isso o canario `fx-pedido-colado` e a regra nos adaptadores existem.
+ * nao entra aqui. Por isso o cenario `fx-pedido-colado` e a regra nos adaptadores existem.
  *
  * Funcoes puras sobre eventos: nao leem disco nem relogio. Ausencia de pedido e zero pedidos, e a
  * mediana sem resposta e `null`, nunca zero inventado. A unica leitura de disco e

package/dist/index.js

@@ -3622,9 +3622,9 @@ function comandoAdapter(args) {
     return 2;
 }
 /**
- * `ork eval`: canarios de comportamento e o corpus das skills finas (bloco B4).
+ * `ork eval`: cenarios de comportamento e o corpus das skills finas (bloco B4).
  *
- * Skill sem eval nao entra, e comportamento sem canario tambem nao. O comando sai diferente
+ * Skill sem eval nao entra, e comportamento sem cenario tambem nao. O comando sai diferente
  * de zero em qualquer falha, para o CI do kit poder barrar merge sem eval.
  */
 function comandoEval(args) {
@@ -3637,8 +3637,8 @@ function comandoEval(args) {
     const r = (0, evalrunner_1.rodarEval)({
         catalogo,
         skills: lista(args.opcoes.skill),
-        canarios: lista(args.opcoes.canario) ?? lista(args.opcoes.fixture),
-        soCanarios: args.opcoes['so-canarios'] === true,
+        cenarios: lista(args.opcoes.cenario) ?? lista(args.opcoes.fixture),
+        soCenarios: args.opcoes['so-cenarios'] === true,
         soSkills: args.opcoes['so-skills'] === true,
     });
     if (args.opcoes.json === true) {

package/dist/init.js

@@ -267,7 +267,7 @@ policies:
  * exemplo) gravava manifesto, `AGENTS.md` e `.orkastery/` ali e saia 0; um repositorio criado depois
  * dentro dessa pasta herdava o manifesto de fora, com outro nome e outra abbrev, e o doctor dizia PRONTO.
  * A CLI recusa antes de gravar qualquer coisa. A funcao `init` segue aceitando qualquer pasta (demo e
- * canarios montam o projeto por ela).
+ * cenarios montam o projeto por ela).
  */
 function exigirRepositorioParaInit(dir) {
     const r = (0, util_1.exec)('git', ['rev-parse', '--is-inside-work-tree'], dir);

package/dist/locale-ajuda.js

@@ -364,8 +364,8 @@ Uso: ork [--projeto <nome|caminho>] <comando> [argumentos]
         [--aceitar-catalogo <arquivo>]           sobrescreve a copia com o catalogo, arquivo a arquivo
         [--manter-copia <arquivo>]               deixa a copia como esta, arquivo a arquivo
 
-  eval [--skill S] [--canario C]            Canarios de comportamento + corpus das skills finas
-        [--so-canarios] [--so-skills] [--json]   (sai != 0 em qualquer falha)
+  eval [--skill S] [--cenario C]            Cenarios de comportamento + corpus das skills finas
+        [--so-cenarios] [--so-skills] [--json]   (sai != 0 em qualquer falha)
 
   audit packs [--estagio E] [--pack P]      Os 7 packs, o estagio que os ativa e a postura
   audit run <pack> [--profile P]            Monta o prompt do pack e despacha pelo runtime adapter
@@ -413,7 +413,7 @@ Fases: GOAL PLAN GO CHECK SHIP MASTER. Modos: ${v.tags}.
 Familias de lease: main-tree, worktree-write:<thread>, path:<glob>, board:<card>, service:<porta>.
 Ciclos: greenfield, merge-branch, goal-plan, gap, feature-xl-faseada.
 Fontes de medida do gate de tokens: runtime_reported, estimated, informada, unavailable.
-Hosts de Camada 1: claude-code, codex, hermes, openclaw. Canarios: fx-happy, fx-hallucination,
+Hosts de Camada 1: claude-code, codex, hermes, openclaw. Cenarios: fx-happy, fx-hallucination,
 fx-stale-base, fx-wiki-destroy, fx-schema-drift, fx-concurrency.
 Packs de auditoria: clean-code, reuse, architecture, data-model, ux, security-privacy, process.
 Superficie de ataque de rede (SP8..SP12, varredura deterministica): rota sem auth, endpoint de
@@ -778,8 +778,8 @@ Usage: ork [--projeto <name|path>] <command> [arguments]
         [--aceitar-catalogo <file>]              overwrites the copy with the catalog, file by file
         [--manter-copia <file>]                  keeps the copy as it is, file by file
 
-  eval [--skill S] [--canario C]            Behavior canaries + corpus of the thin skills
-        [--so-canarios] [--so-skills] [--json]   (exits != 0 on any failure)
+  eval [--skill S] [--cenario C]            Behavior scenarios + corpus of the thin skills
+        [--so-cenarios] [--so-skills] [--json]   (exits != 0 on any failure)
 
   audit packs [--estagio E] [--pack P]      The 7 packs, the stage that activates them and the posture
   audit run <pack> [--profile P]            Builds the pack prompt and dispatches through the runtime adapter
@@ -827,7 +827,7 @@ Phases: GOAL PLAN GO CHECK SHIP MASTER. Modes: ${v.tags}.
 Lease families: main-tree, worktree-write:<thread>, path:<glob>, board:<card>, service:<port>.
 Cycles: greenfield, merge-branch, goal-plan, gap, feature-xl-faseada.
 Token gate measurement sources: runtime_reported, estimated, informada, unavailable.
-Layer 1 hosts: claude-code, codex, hermes, openclaw. Canaries: fx-happy, fx-hallucination,
+Layer 1 hosts: claude-code, codex, hermes, openclaw. Scenarios: fx-happy, fx-hallucination,
 fx-stale-base, fx-wiki-destroy, fx-schema-drift, fx-concurrency.
 Audit packs: clean-code, reuse, architecture, data-model, ux, security-privacy, process.
 Network attack surface (SP8..SP12, deterministic scan): route without auth, exposed admin

package/dist/locale-operacao-restante.js

@@ -339,23 +339,23 @@ exports.OPERACAO_RESTANTE_PT_BR = {
         deveriaAusente: (valor, vezes) => `"${valor}" deveria estar AUSENTE da skill e aparece ${vezes}x`,
         naoExiste: (valor, skill, porque) => `"${valor}" nao existe em skills/.../${skill}/SKILL.md (${porque})`,
         ancora: 'todas as ancoras deste caso estao dentro da tabela de racionalizacoes: a skill lista a desculpa mas nao carrega a regra que responde a ela',
-        filtroVazio: 'filtro de canários vazio: nenhuma prova foi executada',
-        canarioAusente: (id) => `canário solicitado ausente: ${id}`,
+        filtroVazio: 'filtro de cenários vazio: nenhuma prova foi executada',
+        cenarioAusente: (id) => `cenário solicitado ausente: ${id}`,
         casoAusente: (nome) => `${nome}: falta caso.json`,
-        fixtureDiverge: 'id da fixture diverge do canário solicitado',
-        semExecutor: (nome, id) => `${nome}: nenhum executor registrado para o canario "${id}"`,
-        semGit: 'git nao esta nesta maquina: o canario sai unavailable, nunca passing',
+        fixtureDiverge: 'id da fixture diverge do cenário solicitado',
+        semExecutor: (nome, id) => `${nome}: nenhum executor registrado para o cenario "${id}"`,
+        semGit: 'git nao esta nesta maquina: o cenario sai unavailable, nunca passing',
         divergencia: (esperado, observado) => `esperado ${esperado}, observado ${observado}`,
-        canarioSemFixture: (id) => `o canario ${id} existe no codigo e nao tem eval/fixtures/${id}/caso.json`,
+        cenarioSemFixture: (id) => `o cenario ${id} existe no codigo e nao tem eval/fixtures/${id}/caso.json`,
         skillSemEval: (skill) => `skill sem eval nao entra no catalogo: falta eval/casos/${skill}.json`,
         evalSemSkill: 'ha casos para uma skill que nao existe no catalogo',
         titulo: (catalogo) => `ork eval, catalogo em ${catalogo}`,
-        canarios: 'Canarios (comportamento real do nucleo, contra git de verdade)',
-        colunasCanarios: ['CANARIO', 'ESTADO', 'SOBRE'],
+        cenarios: 'Cenarios (comportamento real do nucleo, contra git de verdade)',
+        colunasCenarios: ['CENARIO', 'ESTADO', 'SOBRE'],
         estados: { passou: 'passou', unavailable: 'unavailable', falhou: 'falhou' },
         skills: 'Corpus das skills (a metade estatica: as regras que precisam existir no arquivo)',
         colunasSkills: ['SKILL', 'CASOS', 'ASSERCOES', 'FALHAS'], falhas: 'Falhas',
-        resumoCanarios: (passaram, total, indisponiveis) => `canarios: ${passaram}/${total} verdes${indisponiveis > 0 ? ` (${indisponiveis} unavailable)` : ''}`,
+        resumoCenarios: (passaram, total, indisponiveis) => `cenarios: ${passaram}/${total} verdes${indisponiveis > 0 ? ` (${indisponiveis} unavailable)` : ''}`,
         resumoSkills: (skills, casos, assercoes, falhas) => `skills: ${skills} | casos: ${casos} | assercoes: ${assercoes} | falhas: ${falhas}`,
         metade: 'metade comportamental (o agente resiste a desculpa?): unavailable, julgada por humano ou por modelo, nunca por este runner',
         veredito: (ok) => `VEREDITO: ${ok ? 'verde' : 'vermelho'}`,
@@ -815,23 +815,23 @@ exports.OPERACAO_RESTANTE_EN = {
         deveriaAusente: (value, times) => `"${value}" should be ABSENT from the skill and appears ${times} time(s)`,
         naoExiste: (value, skill, why) => `"${value}" does not exist in skills/.../${skill}/SKILL.md (${why})`,
         ancora: 'every anchor in this case is inside the rationalizations table: the skill lists the excuse but does not carry the rule that answers it',
-        filtroVazio: 'empty canary filter: no evidence was executed',
-        canarioAusente: (id) => `requested canary is missing: ${id}`,
+        filtroVazio: 'empty scenario filter: no evidence was executed',
+        cenarioAusente: (id) => `requested scenario is missing: ${id}`,
         casoAusente: (name) => `${name}: caso.json is missing`,
-        fixtureDiverge: 'fixture id differs from the requested canary',
-        semExecutor: (name, id) => `${name}: no executor registered for canary "${id}"`,
-        semGit: 'git is not on this machine: the canary is unavailable, never passing',
+        fixtureDiverge: 'fixture id differs from the requested scenario',
+        semExecutor: (name, id) => `${name}: no executor registered for scenario "${id}"`,
+        semGit: 'git is not on this machine: the scenario is unavailable, never passing',
         divergencia: (expected, observed) => `expected ${expected}, observed ${observed}`,
-        canarioSemFixture: (id) => `canary ${id} exists in code but has no eval/fixtures/${id}/caso.json`,
+        cenarioSemFixture: (id) => `scenario ${id} exists in code but has no eval/fixtures/${id}/caso.json`,
         skillSemEval: (skill) => `a skill without eval does not enter the catalog: eval/casos/${skill}.json is missing`,
         evalSemSkill: 'there are cases for a skill that does not exist in the catalog',
         titulo: (catalog) => `ork eval, catalog at ${catalog}`,
-        canarios: 'Canaries (real core behavior, against real git)',
-        colunasCanarios: ['CANARY', 'STATE', 'SUBJECT'],
+        cenarios: 'Scenarios (real core behavior, against real git)',
+        colunasCenarios: ['SCENARIO', 'STATE', 'SUBJECT'],
         estados: { passou: 'passed', unavailable: 'unavailable', falhou: 'failed' },
         skills: 'Skills corpus (the static half: rules that must exist in the file)',
         colunasSkills: ['SKILL', 'CASES', 'ASSERTIONS', 'FAILURES'], falhas: 'Failures',
-        resumoCanarios: (passed, total, unavailable) => `canaries: ${passed}/${total} green${unavailable > 0 ? ` (${unavailable} unavailable)` : ''}`,
+        resumoCenarios: (passed, total, unavailable) => `scenarios: ${passed}/${total} green${unavailable > 0 ? ` (${unavailable} unavailable)` : ''}`,
         resumoSkills: (skills, cases, assertions, failures) => `skills: ${skills} | cases: ${cases} | assertions: ${assertions} | failures: ${failures}`,
         metade: 'behavioral half (does the agent resist the excuse?): unavailable, judged by a human or a model, never by this runner',
         veredito: (ok) => `VERDICT: ${ok ? 'green' : 'red'}`,

package/dist/sandbox.js

@@ -1,15 +1,15 @@
 "use strict";
 /**
- * Sandbox deterministica para os canarios de `ork eval` (bloco B4).
+ * Sandbox deterministica para os cenarios de `ork eval` (bloco B4).
  *
- * Um canario precisa exercitar o comportamento REAL do nucleo: git de verdade, worktree de
+ * Um cenario precisa exercitar o comportamento REAL do nucleo: git de verdade, worktree de
  * verdade, lease de verdade. Fazer isso no repositorio do usuario seria inaceitavel, e
  * simular git com dublê seria testar o dublê. A saida e um repositorio git temporario,
  * criado, usado e apagado dentro da mesma execucao.
  *
  * Regras que esta sandbox respeita, e por isso ela pode rodar em `ork eval` na maquina de
  * qualquer builder: nada de rede, nada de credencial, nada fora de um diretorio temporario,
- * e limpeza garantida mesmo quando o canario falha.
+ * e limpeza garantida mesmo quando o cenario falha.
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -55,7 +55,7 @@ const path = __importStar(require("node:path"));
 const init_1 = require("./init");
 const manifest_1 = require("./manifest");
 const util_1 = require("./util");
-/** `git` existe nesta maquina? Sem ele os canarios saem `unavailable`, nunca `passing`. */
+/** `git` existe nesta maquina? Sem ele os cenarios saem `unavailable`, nunca `passing`. */
 function gitDisponivel() {
     return (0, util_1.noPath)('git') !== null;
 }
@@ -75,15 +75,15 @@ function commitar(dir, arquivo, conteudo, mensagem) {
 /**
  * Repositorio git temporario com manifesto gerado pelo proprio `ork init`.
  *
- * O manifesto vem do `init` de verdade e nao de um objeto escrito a mao: canario que monta o
- * proprio manifesto testa o canario, nao o produto.
+ * O manifesto vem do `init` de verdade e nao de um objeto escrito a mao: cenario que monta o
+ * proprio manifesto testa o cenario, nao o produto.
  */
 function sandboxGit(nome, abbrev = 'evl') {
-    // I-49: canario nunca escreve no registro compartilhado de contas do usuario.
+    // I-49: cenario nunca escreve no registro compartilhado de contas do usuario.
     if (!process.env.ORK_CONTAS_DIR) {
         process.env.ORK_CONTAS_DIR = path.join(fs.mkdtempSync(path.join(os.tmpdir(), 'ork-contas-eval-')), 'private');
     }
-    // I-51: canario nunca publica o estado da fabrica.
+    // I-51: cenario nunca publica o estado da fabrica.
     if (process.env.ORK_FABRICA_PUBLICAR === undefined)
         process.env.ORK_FABRICA_PUBLICAR = '0';
     if (!process.env.ORK_USUARIO_DIR)
@@ -91,10 +91,10 @@ function sandboxGit(nome, abbrev = 'evl') {
     const dir = dirTemporario(nome);
     (0, util_1.exec)('git', ['init', '-b', 'main'], dir);
     (0, util_1.exec)('git', ['config', 'user.email', 'eval@orkastery.local'], dir);
-    (0, util_1.exec)('git', ['config', 'user.name', 'Canario do ork eval'], dir);
+    (0, util_1.exec)('git', ['config', 'user.name', 'Cenario do ork eval'], dir);
     (0, util_1.exec)('git', ['config', 'commit.gpgsign', 'false'], dir);
-    commitar(dir, 'README.md', '# projeto do canario\n', 'inicial');
-    (0, init_1.init)(dir, { nome: 'canario', abbrev });
+    commitar(dir, 'README.md', '# projeto do cenario\n', 'inicial');
+    (0, init_1.init)(dir, { nome: 'cenario', abbrev });
     return {
         dir,
         carregado: (0, manifest_1.exigirManifesto)(dir),

package/dist/security-scan/agil.js

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

package/dist/security-scan/executor.js

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

package/dist/security-scan/incremental.js

@@ -0,0 +1,289 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lerCacheIncremental = void 0;
+exports.resolverRegrasSemgrep = resolverRegrasSemgrep;
+exports.consultarCacheIncremental = consultarCacheIncremental;
+exports.gravarCacheIncremental = gravarCacheIncremental;
+/** Cache de resultado normalizado do Agile, por conteúdo e fora do repositório. */
+const crypto = __importStar(require("node:crypto"));
+const node_child_process_1 = require("node:child_process");
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const run_1 = require("./run");
+const CONTRATO = 'ork.security-scan.incremental/v1';
+const LOCKFILES = new Set(['package-lock.json', 'npm-shrinkwrap.json', 'pnpm-lock.yaml', 'yarn.lock', 'poetry.lock',
+    'Pipfile.lock', 'go.mod', 'go.sum']);
+const sha256 = (valor) => crypto.createHash('sha256').update(valor).digest('hex');
+const SCRIPT_DO_REGISTRO = String.raw `
+# ORK_SEMGREP_RESOLVE_V1
+import sys, urllib.request
+pedido = urllib.request.Request(sys.argv[1], headers={"Accept": "application/json", "User-Agent": "orkastery-security-scan"})
+with urllib.request.urlopen(pedido, timeout=20) as resposta:
+    if resposta.status != 200:
+        raise RuntimeError("HTTP " + str(resposta.status))
+    sys.stdout.buffer.write(resposta.read())
+`;
+/** O mesmo endpoint público para o qual o resolvedor do Semgrep mapeia um id do registro. */
+function urlDoRegistro(referencia) {
+    if (/^[prs]\/[A-Za-z0-9._/-]+$/.test(referencia))
+        return `https://semgrep.dev/c/${referencia}`;
+    if (/^https:\/\//.test(referencia))
+        return referencia;
+    return null;
+}
+function baixarDoRegistro(ferramenta, url) {
+    const uid = process.getuid?.() ?? 65534;
+    const gid = process.getgid?.() ?? 65534;
+    const nome = `ork-security-scan-semgrep-registry-${process.pid}-${crypto.randomBytes(4).toString('hex')}`;
+    const r = (0, node_child_process_1.spawnSync)('docker', ['run', '--rm', '--name', nome, '--user', `${uid === 0 ? 65534 : uid}:${uid === 0 ? 65534 : gid}`,
+        '--network', 'default', '--entrypoint', 'python3', ferramenta.image, '-c', SCRIPT_DO_REGISTRO, url], { encoding: 'utf8', timeout: 30_000, maxBuffer: 64 * 1024 * 1024, killSignal: 'SIGKILL' });
+    if (r.error || r.status !== 0)
+        (0, node_child_process_1.spawnSync)('docker', ['rm', '-f', nome], { stdio: 'ignore', timeout: 10_000 });
+    return !r.error && r.status === 0 && r.stdout.trim() ? r.stdout : null;
+}
+/** O conteúdo que o próprio Semgrep extrai da resposta do registro (`rules` direto ou envelope `rule_config`). */
+function conteudoResolvido(resposta) {
+    try {
+        const json = JSON.parse(resposta);
+        const regras = Object.prototype.hasOwnProperty.call(json, 'rules') ? json : json.rule_config;
+        return typeof regras === 'string' ? regras : JSON.stringify(regras);
+    }
+    catch {
+        return resposta;
+    }
+}
+const MARCAS_ENTRE_ARQUIVOS = ['join', 'interfile', 'crossfile', 'multifile'];
+const MARCA_NA_LINHA = /(?:^|[\s{,])(?:mode\s*:\s*)?(?:join|inter[-_ ]?file|cross[-_ ]?file|multi[-_ ]?file)(?:\s*:|\s*$)/i;
+const CHAVE_DA_LINHA = /^(\s*)(-\s+)?([A-Za-z_][\w-]*)\s*:(?:\s+(.*))?$/;
+const normalizar = (chave) => chave.toLowerCase().replace(/[-_]/g, '');
+/**
+ * Se a marca cruza arquivos de fato. `join` cruza em qualquer motor. `interfile` em `options` só cruza no motor Pro do
+ * Semgrep; em `metadata` é rótulo do registro, que o motor ignora. Em qualquer outro lugar, cruza (conservador).
+ */
+function marcaCruzaArquivos(marca, pai, pro) {
+    if (marca === 'join')
+        return true;
+    if (pai === 'metadata')
+        return false;
+    if (pai === 'options')
+        return pro;
+    return true;
+}
+/**
+ * O registro responde em YAML. Toda linha com marca cruza arquivos, menos a chave da própria marca, em bloco e com valor
+ * booleano, cujo pai pela indentação a torna inócua no motor da rodada. Linha de texto que parece chave nunca relaxa nada.
+ */
+function marcaNoYaml(conteudo, pro) {
+    const pais = [];
+    for (const linha of conteudo.split(/\r?\n/)) {
+        const m = CHAVE_DA_LINHA.exec(linha);
+        const coluna = m ? m[1].length + (m[2]?.length ?? 0) : 0;
+        if (m)
+            while (pais.length && pais[pais.length - 1].coluna >= coluna)
+                pais.pop();
+        if (MARCA_NA_LINHA.test(linha)) {
+            const chave = m ? normalizar(m[3]) : null;
+            const booleano = !!m && /^(?:true|false|yes|no|on|off)?\s*(?:#.*)?$/i.test(m[4] ?? '');
+            if (!chave || !MARCAS_ENTRE_ARQUIVOS.includes(chave) || !booleano
+                || marcaCruzaArquivos(chave, pais[pais.length - 1]?.chave ?? null, pro))
+                return true;
+        }
+        if (m)
+            pais.push({ coluna, chave: normalizar(m[3]) });
+    }
+    return false;
+}
+function regraEntreArquivos(conteudo, pro) {
+    let valor;
+    try {
+        valor = JSON.parse(conteudo);
+    }
+    catch {
+        return marcaNoYaml(conteudo, pro);
+    }
+    if (typeof valor === 'string')
+        return marcaNoYaml(valor, pro);
+    const visitar = (atual, pai) => {
+        if (Array.isArray(atual))
+            return atual.some((item) => visitar(item, pai));
+        if (!atual || typeof atual !== 'object')
+            return false;
+        return Object.entries(atual).some(([chave, filho]) => {
+            const normal = normalizar(chave);
+            if (normal === 'mode' && typeof filho === 'string' && /^(join|interfile|crossfile|multifile)$/i.test(filho))
+                return true;
+            if (MARCAS_ENTRE_ARQUIVOS.includes(normal) && filho !== false && filho !== null
+                && marcaCruzaArquivos(normal, pai, pro))
+                return true;
+            return visitar(filho, normal);
+        });
+    };
+    return visitar(valor, null);
+}
+/** O Semgrep da rodada usa o motor Pro, o único que cruza arquivos nas regras `interfile`: `--pro*`, `semgrep ci` ou token. */
+function motorPro(ferramenta, unidades) {
+    const stacks = new Set(unidades.map((u) => u.stack).filter((s) => !!s));
+    const todos = [ferramenta.args, ...[...stacks].map((s) => ferramenta.argsByStack?.[s] ?? [])];
+    return todos.some((args) => args.some((a) => a.startsWith('--pro')) || args.includes('ci'))
+        || Object.keys(ferramenta.env ?? {}).some((k) => /^SEMGREP_APP_TOKEN$/i.test(k));
+}
+function referenciasDasRegras(ferramenta, unidades) {
+    const stacks = new Set(unidades.map((u) => u.stack).filter((s) => !!s));
+    const referencias = new Set();
+    for (const stack of stacks) {
+        const args = ferramenta.argsByStack?.[stack] ?? [];
+        for (let i = 0; i < args.length - 1; i++)
+            if (args[i] === '--config' || args[i] === '-f')
+                referencias.add(args[++i]);
+    }
+    return [...referencias].sort();
+}
+function resolverRegrasSemgrep(ferramenta, unidades, baixar = baixarDoRegistro) {
+    const referencias = referenciasDasRegras(ferramenta, unidades);
+    if (referencias.length === 0)
+        return { reutilizavel: false, hash: null, motivo: 'regras-sem-referencia', referencias };
+    const resolvidas = [];
+    const pro = motorPro(ferramenta, unidades);
+    for (const referencia of referencias) {
+        const url = urlDoRegistro(referencia);
+        if (!url)
+            return { reutilizavel: false, hash: null, motivo: 'referencia-de-regra-nao-resolvivel', referencias };
+        const resposta = baixar(ferramenta, url);
+        if (!resposta)
+            return { reutilizavel: false, hash: null, motivo: 'registro-indisponivel', referencias };
+        const conteudo = conteudoResolvido(resposta);
+        if (regraEntreArquivos(conteudo, pro))
+            return { reutilizavel: false, hash: null, motivo: 'regra-entre-arquivos', referencias };
+        resolvidas.push([referencia, conteudo]);
+    }
+    return { reutilizavel: true, hash: sha256(JSON.stringify(resolvidas)), referencias };
+}
+/** Só habilita o que tem garantia explícita: Semgrep por arquivo e dependências por lockfile. */
+function escopoDaFerramenta(t, trabalho) {
+    if (t.name === 'semgrep') {
+        // A API direta antecede o trabalhador e continua útil para conferir o retrato por arquivo isoladamente. No caminho
+        // real do Agile, `incremental: true` torna obrigatória a identidade das regras resolvidas: ausência, registro
+        // indisponível ou regra entre arquivos nunca cai nesta compatibilidade.
+        if (trabalho.incremental !== true)
+            return 'arquivo';
+        return trabalho.regrasSemgrep?.reutilizavel && trabalho.regrasSemgrep.hash ? 'arquivo' : null;
+    }
+    if (t.category === 'dependency')
+        return 'lockfile';
+    return null;
+}
+function arquivos(root, escopo) {
+    const saida = {};
+    const visitar = (dir) => {
+        let nomes;
+        try {
+            nomes = fs.readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+        }
+        catch {
+            return;
+        }
+        for (const nome of nomes) {
+            if (nome.name === '.git')
+                continue;
+            const absoluto = path.join(dir, nome.name);
+            if (nome.isDirectory()) {
+                visitar(absoluto);
+                continue;
+            }
+            if (!nome.isFile())
+                continue;
+            const relativo = path.relative(root, absoluto).split(path.sep).join('/');
+            const lockfile = LOCKFILES.has(nome.name) || /^requirements(?:\.[^.]+)?\.txt$/.test(nome.name);
+            if (escopo === 'lockfile' && !lockfile)
+                continue;
+            try {
+                saida[relativo] = sha256(fs.readFileSync(absoluto));
+            }
+            catch { /* arquivo mudou durante a leitura: nao entra */ }
+        }
+    };
+    visitar(root);
+    return saida;
+}
+function identidade(trabalho, ferramenta) {
+    return sha256(JSON.stringify({ ferramenta, unidades: trabalho.units, configuracao: trabalho.config, base: trabalho.ctx.base,
+        regrasSemgrep: trabalho.regrasSemgrep?.hash ?? null }));
+}
+function localDaEntrada(chave) {
+    return path.join((0, run_1.cacheRoot)(), 'incremental', `${chave}.json`);
+}
+function consultarCacheIncremental(trabalho, ferramenta) {
+    const escopo = escopoDaFerramenta(ferramenta, trabalho);
+    if (!escopo)
+        return { escopo: null, atual: null, anterior: null, alterados: [], reutilizado: null };
+    const retrato = { escopo, arquivos: arquivos(trabalho.ctx.headTree, escopo) };
+    if (escopo === 'lockfile' && Object.keys(retrato.arquivos).length === 0) {
+        return { escopo, atual: retrato, anterior: null, alterados: [], reutilizado: null };
+    }
+    const chave = identidade(trabalho, ferramenta);
+    try {
+        const entrada = JSON.parse(fs.readFileSync(localDaEntrada(chave), 'utf8'));
+        if (entrada.contrato !== CONTRATO || entrada.chave !== chave || entrada.resultado?.run?.state !== 'ran') {
+            return { escopo, atual: retrato, anterior: null, alterados: [], reutilizado: null };
+        }
+        const nomes = new Set([...Object.keys(entrada.retrato.arquivos), ...Object.keys(retrato.arquivos)]);
+        const alterados = [...nomes].filter((nome) => entrada.retrato.arquivos[nome] !== retrato.arquivos[nome]).sort();
+        return { escopo, atual: retrato, anterior: entrada.resultado, alterados,
+            reutilizado: alterados.length === 0 ? entrada.resultado : null };
+    }
+    catch {
+        return { escopo, atual: retrato, anterior: null, alterados: [], reutilizado: null };
+    }
+}
+const lerCacheIncremental = (trabalho, ferramenta) => consultarCacheIncremental(trabalho, ferramenta).reutilizado;
+exports.lerCacheIncremental = lerCacheIncremental;
+function gravarCacheIncremental(trabalho, ferramenta, resultado) {
+    const escopo = escopoDaFerramenta(ferramenta, trabalho);
+    if (!escopo || resultado.run.state !== 'ran')
+        return;
+    const retrato = { escopo, arquivos: arquivos(trabalho.ctx.headTree, escopo) };
+    if (escopo === 'lockfile' && Object.keys(retrato.arquivos).length === 0)
+        return;
+    const chave = identidade(trabalho, ferramenta), arquivo = localDaEntrada(chave);
+    try {
+        fs.mkdirSync(path.dirname(arquivo), { recursive: true, mode: 0o700 });
+        const temporario = `${arquivo}.${process.pid}.tmp`;
+        const entrada = { contrato: CONTRATO, chave, retrato, resultado };
+        fs.writeFileSync(temporario, JSON.stringify(entrada), { mode: 0o600 });
+        fs.renameSync(temporario, arquivo);
+    }
+    catch { /* cache ausente custa CPU, mas nunca muda o veredito */ }
+}