@orkastery/cli 0.5.6 → 0.6.0

package/dist/security-scan/agil.js

@@ -0,0 +1,355 @@
+"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.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.especificacaoDoAgile = especificacaoDoAgile;
+exports.estourouNoAgile = estourouNoAgile;
+exports.motivoSemCredencial = motivoSemCredencial;
+exports.resultadoDoTrabalhador = resultadoDoTrabalhador;
+exports.catalogoDoAgile = catalogoDoAgile;
+exports.runScanAgil = runScanAgil;
+/**
+ * RM-072 (D9, D10 da ork-check5x): a varredura do Agile Check.
+ *
+ * A rodada e a mesma do Classic (`runScan`): a arvore do HEAD por worktree destacada, a base resolvida igual, as mesmas
+ * 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
+ * (`check.pecas`) e ao `ORK_CHECK_RELATORIO` do verify.
+ */
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const check_paralelo_1 = require("../check-paralelo");
+const check_modo_1 = require("../check-modo");
+const estado_thread_1 = require("../estado-thread");
+const redacao_url_1 = require("../redacao-url");
+const compare_1 = require("./compare");
+const config_1 = require("./config");
+const guard_1 = require("./guard");
+const run_1 = require("./run");
+const executor_1 = require("./executor");
+const imagem_de_lint_1 = require("./imagem-de-lint");
+const tools_1 = require("./tools");
+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;
+const aspas = (s) => `'${s.replace(/'/g, `'\\''`)}'`;
+/**
+ * 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.
+ */
+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
+ * rodada real), e regra que estoura pode deixar de achar. O prazo maior nao troca regra nem arquivo varrido.
+ */
+exports.PRAZO_POR_REGRA_DO_SEMGREP_S = 30;
+/** O Semgrep do Agile com o prazo por regra maior, antes do diretorio da stack (o ultimo argumento). */
+function semgrepDoAgile(t, pecas) {
+    if (!t.argsByStack)
+        return t;
+    const comPrazo = (args) => args.length === 0 || args.includes('--timeout') ? args
+        : [...args.slice(0, -1), '--timeout', String(exports.PRAZO_POR_REGRA_DO_SEMGREP_S), args[args.length - 1]];
+    pecas.push({ peca: 'semgrep-prazo-por-regra', estado: 'agile',
+        motivo: `${exports.PRAZO_POR_REGRA_DO_SEMGREP_S} s por regra e arquivo (o padrao do semgrep e 5 s), para a disputa de CPU nao derrubar regra` });
+    return { ...t, argsByStack: Object.fromEntries(Object.entries(t.argsByStack).map(([stack, args]) => [stack, comPrazo(args ?? [])])) };
+}
+/**
+ * A especificacao da ferramenta no Agile: as do Trivy montam o cache persistente dela no `/tmp/trivy-cache` que o
+ * catalogo ja usa (sem o diretorio, a do catalogo, com a peca em fallback); o Semgrep ganha o prazo por regra maior.
+ */
+function especificacaoDoAgile(t, pecas) {
+    if (t.name === 'semgrep')
+        return semgrepDoAgile(t, pecas);
+    if (!t.name.startsWith('trivy-') || !t.args.includes('/tmp/trivy-cache'))
+        return t;
+    const host = path.join((0, run_1.cacheRoot)(), 'cache', t.name);
+    try {
+        fs.mkdirSync(host, { recursive: true, mode: 0o700 });
+        pecas.push({ peca: `cache-${t.name}`, estado: 'agile' });
+        return { ...t, cacheMounts: [{ host, container: '/tmp/trivy-cache' }] };
+    }
+    catch (e) {
+        pecas.push({ peca: `cache-${t.name}`, estado: 'fallback', motivo: e.code ?? e.message,
+            fallback: 'cache efemero do catalogo' });
+        return t;
+    }
+}
+function relatar(pecas) {
+    const arquivo = process.env[check_modo_1.ENV_RELATORIO_DO_CHECK];
+    if (!arquivo)
+        return;
+    try {
+        fs.appendFileSync(arquivo, pecas.map((p) => JSON.stringify({ tipo: 'peca', ...p })).join('\n') + '\n');
+    }
+    catch { /* o relatorio e evidencia do verify, nao condicao da varredura */ }
+}
+/**
+ * RM-072 (D11): o `eslint` com a imagem de lint pre-montada; sem ela (build que falhou, sem rede, catalogo mudou), o do
+ * catalogo, com a peca em fallback.
+ */
+function eslintDoAgile(t, prazoMs, pecas) {
+    if (t.name !== 'eslint' || !t.install?.length)
+        return t;
+    // A4 do CHECK: o build roda antes dos trabalhadores; com teto curto, um link lento nao consome o prazo da varredura toda.
+    const imagem = (0, imagem_de_lint_1.garantirImagemDeLint)(t, Math.min(prazoMs, exports.PRAZO_DO_BUILD_DA_IMAGEM_MS));
+    const comImagem = 'tag' in imagem ? (0, imagem_de_lint_1.eslintComImagem)(t, imagem.tag) : null;
+    if (comImagem) {
+        pecas.push({ peca: 'imagem-de-lint', estado: 'agile' });
+        return comImagem;
+    }
+    pecas.push({ peca: 'imagem-de-lint', estado: 'fallback', motivo: 'motivo' in imagem ? imagem.motivo : 'script do catalogo sem o npm install esperado',
+        fallback: 'eslint do catalogo, com npm install no container' });
+    return t;
+}
+/** O teto do build da imagem de lint (A4 do CHECK): estourou, o `eslint` do catalogo, com a peca em fallback. */
+exports.PRAZO_DO_BUILD_DA_IMAGEM_MS = 180_000;
+/** O prazo minimo que sobra para a ferramenta que caiu no Agile rodar pelo caminho do Classic (A5 do CHECK). */
+exports.PRAZO_MINIMO_DO_CLASSIC_MS = 30_000;
+/** Os motivos tipados de estouro que o `scanTool` grava: o prazo da HEAD e o da base. */
+const MOTIVOS_DE_ESTOURO = new Set(['timeout', 'base-timeout']);
+/**
+ * N2 do CHECK 2: a ferramenta estourou o prazo, e o caminho do Classic estouraria igual. Decide pelo motivo tipado da
+ * rodada ou pelo trabalhador cortado no prazo dele, nunca pelo texto do stderr: o erro de trava do cache do Trivy termina
+ * em `timeout` ("cache may be in use by another process: timeout") e e justamente a peca do Agile que o Classic cobre.
+ */
+function estourouNoAgile(motivo, trabalhador) {
+    if (trabalhador)
+        return trabalhador.duracaoMs >= trabalhador.prazoMs;
+    return MOTIVOS_DE_ESTOURO.has(motivo ?? '');
+}
+/**
+ * A URL que vai ate o fim do texto, do esquema em diante e sem espaco. Cortada, o login dela pode ter ficado pela metade,
+ * com `/`, `?`, `#` ou um segundo `@` que o redator so reconheceria inteiro; por isso ela sai toda, cortada ou nao. A URL
+ * legitima no fim tambem sai: o motivo e diagnostico, e a troca e a favor de nao vazar login.
+ */
+const URL_NO_FIM = /[a-z][a-z0-9+.-]*:\/\/\S*$/i;
+/**
+ * S-k do CHECK 3 e N7 do CHECK 4: o texto que vai ao ledger sem credencial de URL. A URL que chega ate o fim sai inteira
+ * antes da redacao (o texto pode ter vindo cortado, como o motivo do Classic, cortado em 200 sem redigir); o resto e
+ * redigido antes do corte, e o que o corte deixar de URL no fim tambem sai. O resultado nunca passa do teto.
+ */
+function motivoSemCredencial(texto, teto) {
+    const semUrlNoFim = (t) => t.trimEnd().replace(URL_NO_FIM, '<url cortada>');
+    return semUrlNoFim((0, redacao_url_1.redigirCredenciaisUrl)(semUrlNoFim(texto)).slice(0, teto)).slice(0, teto);
+}
+/**
+ * O resultado de um trabalhador da varredura e se ele estourou (N2 do CHECK 2, S-j do CHECK 3): o relatorio que ele
+ * gravou ou, sem ele, a falha do proprio trabalhador, com a ultima linha do stderr (nunca a de um detector de segredo) e o
+ * estouro pelo prazo dele.
+ */
+function resultadoDoTrabalhador(t, p, prazoMs) {
+    let lido = null;
+    try {
+        lido = JSON.parse(p.stdout);
+    }
+    catch {
+        lido = null;
+    }
+    if (lido && lido.run)
+        return { r: lido, estourou: estourouNoAgile(lido.run.reason) };
+    const motivo = motivoSemCredencial(p.stderr.split('\n').filter(l => l.trim()).pop() ?? '', 160);
+    const r = { run: { name: t.name, category: t.category, version: t.version, executor: null, state: 'failed',
+            reason: `agile-worker-${p.code}${motivo && t.category !== 'secret' ? `: ${motivo}` : ''}`, counts: (0, run_1.emptyCounts)() }, head: [], base: [] };
+    return { r, estourou: estourouNoAgile(r.run.reason, { duracaoMs: p.duracaoMs, prazoMs }) };
+}
+/** RM-072 (D12): o binario nativo na versao do catalogo, quando a ferramenta o declara e nao instala pacote no container. */
+function nativoDisponivel(t, probe) {
+    if (!t.native || t.install)
+        return false;
+    const saida = probe.nativeVersion(t.native.bin, t.native.versionArgs);
+    return saida !== null && new RegExp(t.native.versionPattern, 'm').test(saida);
+}
+/**
+ * RM-072 (D13): o catalogo do Agile com as duas chaves: `osv_scanner` troca `trivy-vuln` e `npm-audit` pelo `osv-scanner`
+ * (no lugar do `trivy-vuln`), e `oxlint` acrescenta o primeiro passe antes do `eslint`, sem tirar o `eslint`. Desligadas,
+ * o catalogo do Classic.
+ */
+function catalogoDoAgile(catalogo, agile, pecas) {
+    if (!agile?.osv_scanner && !agile?.oxlint)
+        return catalogo;
+    const extras = (0, tools_1.loadAgileTools)();
+    const osv = extras.find(t => t.name === 'osv-scanner');
+    const ox = extras.find(t => t.name === 'oxlint');
+    const lista = [];
+    for (const t of catalogo) {
+        if (agile.osv_scanner && t.name === 'trivy-vuln') {
+            lista.push(osv);
+            continue;
+        }
+        if (agile.osv_scanner && t.name === 'npm-audit')
+            continue;
+        if (agile.oxlint && t.name === 'eslint')
+            lista.push(ox);
+        lista.push(t);
+    }
+    if (agile.osv_scanner)
+        pecas.push({ peca: 'osv-scanner', estado: 'agile', motivo: 'no lugar de trivy-vuln e npm-audit (check.agile.osv_scanner)' });
+    if (agile.oxlint)
+        pecas.push({ peca: 'oxlint', estado: 'agile', motivo: 'primeiro passe antes do eslint, sem tirar regra dele (check.agile.oxlint)' });
+    return lista;
+}
+/** A rodada do Agile: as mesmas regras do `runScan`, com as ferramentas em paralelo e os caches de banco. */
+function runScanAgil(opts) {
+    const start = path.resolve(opts.root);
+    const root = (0, run_1.git)(start, ['rev-parse', '--show-toplevel']) ?? start;
+    const generatedAt = (opts.now ?? (() => new Date()))().toISOString();
+    const head = (0, run_1.git)(root, ['rev-parse', 'HEAD']) ?? '';
+    let mainRoot = root;
+    try {
+        mainRoot = (0, estado_thread_1.raizDoEstado)(root);
+    }
+    catch { /* not a linked worktree git understands: use the root itself */ }
+    const pecas = [{ peca: 'varredura-paralela', estado: 'agile' }];
+    const report = { schema: 'ork.security-scan/v1', base: '', head, generatedAt, stacks: [], tools: [], excluded: [], findings: [],
+        check: { modo: 'agile', pecas } };
+    const catalog = catalogoDoAgile(opts.tools ?? (0, tools_1.loadTools)(), opts.agile, pecas);
+    if (!head) {
+        const config = (0, config_1.loadConfig)(root);
+        const pairs = (0, run_1.stackPairs)(root, config);
+        report.stacks = [...new Set(pairs.map(p => p.stack))];
+        report.tools = (0, run_1.failedAll)((0, tools_1.toolsFor)(report.stacks, catalog).filter(t => (0, run_1.unitsOf)(t, pairs).length > 0), config, 'base-unresolved');
+        relatar(pecas);
+        return report;
+    }
+    const guard = new guard_1.RoundGuard(mainRoot);
+    try {
+        let headTree;
+        try {
+            headTree = (0, run_1.checkout)(mainRoot, head, guard);
+        }
+        catch (e) {
+            const config = (0, config_1.loadConfig)(root);
+            const pairs = (0, run_1.stackPairs)(root, config);
+            report.stacks = [...new Set(pairs.map(p => p.stack))];
+            report.tools = (0, run_1.failedAll)((0, tools_1.toolsFor)(report.stacks, catalog).filter(t => (0, run_1.unitsOf)(t, pairs).length > 0), config, `head-${(e.message.split('\n')[0] ?? '').slice(0, 200)}`);
+            return report;
+        }
+        const config = (0, config_1.loadConfig)(headTree);
+        const dismissals = (0, config_1.loadDismissals)(headTree);
+        const pairs = (0, run_1.stackPairs)(headTree, config);
+        report.stacks = [...new Set(pairs.map(p => p.stack))];
+        const tools = (0, tools_1.toolsFor)(report.stacks, catalog).filter(t => (0, run_1.unitsOf)(t, pairs).length > 0);
+        const base = (0, run_1.resolveBase)(root, path.resolve(opts.stateRoot), opts.base);
+        if (!base) {
+            report.tools = (0, run_1.failedAll)(tools, config, 'base-unresolved');
+            return report;
+        }
+        report.base = base;
+        if (tools.some(t => t.name === 'semgrep'))
+            pecas.push(exports.SEMGREP_SEM_CACHE);
+        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).
+        let baseTree = base === head ? headTree : undefined;
+        if (!baseTree) {
+            try {
+                baseTree = (0, run_1.checkout)(mainRoot, base, guard);
+            }
+            catch { /* cada trabalhador tenta de novo e falha com base-worktree-failed */ }
+        }
+        const dir = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'ork-security-scan-agil-')));
+        guard.add('outDirs', dir);
+        // 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);
+        const nativos = new Set(comNativo.filter(t => nativoDisponivel(t, probe)).map(t => t.name));
+        if (comNativo.length > 0) {
+            const faltam = comNativo.filter(t => !nativos.has(t.name)).map(t => t.name);
+            pecas.push(nativos.size > 0
+                ? { peca: 'binarios-nativos', estado: 'agile', motivo: `nativos: ${[...nativos].join(', ')}${faltam.length ? `; sem binario: ${faltam.join(', ')}` : ''}` }
+                : { peca: 'binarios-nativos', estado: 'fallback', motivo: `sem binario nativo na versao do catalogo: ${faltam.join(', ')}`, fallback: 'Docker, como no Classic' });
+        }
+        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,
+                ...(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`);
+            fs.writeFileSync(arquivo, JSON.stringify(trabalho), { mode: 0o600 });
+            return { nome: t.name, comando: `${aspas(process.execPath)} ${aspas(TRABALHADOR)} ${aspas(arquivo)}`, cwd: root };
+        });
+        // S-f do CHECK 2: o teto dos trabalhadores e contado depois de todos montados, com o build da imagem de lint ja feito.
+        const prazo = deadline === null ? Math.max(...tools.map(t => t.timeoutMs)) * 2 + FOLGA_MS : Math.max(1000, deadline - Date.now() + FOLGA_MS);
+        const trabalhos = montados.map((m) => ({ ...m, prazoMs: prazo }));
+        // RM-072: no grupo do verify, ao lado das lanes, a varredura roda poucas ferramentas por vez; sozinha, todas juntas.
+        const teto = Number(process.env[check_modo_1.ENV_VARREDURA_PARALELA_DO_CHECK]);
+        const maxParalelo = Number.isInteger(teto) && teto > 0 ? teto : undefined;
+        if (maxParalelo)
+            pecas[0] = { ...pecas[0], motivo: `ate ${maxParalelo} ferramenta(s) ao mesmo tempo, ao lado das lanes do verify` };
+        const processos = (0, check_paralelo_1.rodarEmParalelo)(trabalhos, process.env, maxParalelo ? { maxParalelo } : {});
+        const excluded = new Set();
+        tools.forEach((t, i) => {
+            const trabalhador = resultadoDoTrabalhador(t, processos[i], trabalhos[i].prazoMs);
+            let r = trabalhador.r;
+            // A5 do CHECK: a ferramenta que caiu por uma peca do Agile (o trabalhador que morreu, o nativo que falhou, o cache do
+            // Trivy disputado por outra rodada) roda uma vez pelo caminho do Classic, Docker primeiro e sem cache, dentro do prazo.
+            // Estouro de prazo nao repete: o Classic estouraria igual.
+            if (r.run.state === 'failed' && !trabalhador.estourou) {
+                // S-c do CHECK 2 e S-k do CHECK 3: o motivo vem do stderr da ferramenta e vai ao ledger sem credencial de URL.
+                const motivo = motivoSemCredencial(`no Agile: ${r.run.reason ?? 'falhou'}`, 200);
+                if (deadline === null || deadline - Date.now() >= exports.PRAZO_MINIMO_DO_CLASSIC_MS) {
+                    r = (0, run_1.scanTool)(t, (0, run_1.unitsOf)(t, pairs), config, { headTree, mainRoot, base, head, rangeCommits: count === null ? null : Number(count),
+                        deadline: deadline ?? Infinity, probe, guard, images: new Map(), ...(baseTree ? { baseTree } : {}) });
+                    pecas.push({ peca: `classic-${t.name}`, estado: 'fallback', motivo, fallback: 'a ferramenta pelo caminho do Classic' });
+                }
+                else {
+                    pecas.push({ peca: `classic-${t.name}`, estado: 'fallback', motivo, fallback: 'nenhum: sem prazo para o caminho do Classic' });
+                }
+            }
+            if (r.run.state === 'ran') {
+                const c = (0, compare_1.classify)(r.head, r.base, dismissals, config.exclude);
+                for (const f of c.findings)
+                    r.run.counts[f.status][f.severity]++;
+                report.findings.push(...c.findings);
+                c.excluded.forEach(e => excluded.add(e));
+            }
+            report.tools.push(r.run);
+        });
+        report.excluded = [...excluded].sort();
+        return report;
+    }
+    finally {
+        guard.close();
+        relatar(pecas);
+    }
+}

package/dist/security-scan/cli.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executarSecurityScan = executarSecurityScan;
+/**
+ * `ork security-scan [--base <ref>] [--json] [--check classic|agile]` (spec sections 5.4 and 5.5): runs the round, writes `report.json` and
+ * `report.md` under `<state of the main tree>/security-scan/<head-sha>/`, prints a short summary whose last line is the path of
+ * `report.md` (with `--json` it prints the ScanReport JSON instead, with no path line), and returns the exit code.
+ * Environment: ORK_SECURITY_SCAN_REQUIRED=1 makes an unavailable or failed loop-category tool exit 1;
+ * ORK_SECURITY_SCAN_DEADLINE_MS bounds the whole round. `ctx.estado` is the state root of the main tree (`raizDoEstado`). Invalid config or dismissals exit 1 without scanning.
+ * RM-072 (D9): the round is the Classic one (`runScan`) or the Agile one (`runScanAgil`, the same tools in parallel with
+ * the database caches); the mode comes from `--check`, then ORK_CHECK_MODO (set by `ork verify` for its round), then the
+ * manifest `check.mode`, then the default (agile).
+ */
+const locale_1 = require("../locale");
+const check_modo_1 = require("../check-modo");
+const agil_1 = require("./agil");
+const report_1 = require("./report");
+const run_1 = require("./run");
+function executarSecurityScan(argv, ctx) {
+    const m = (0, locale_1.msg)().securityScan;
+    let base;
+    let json = false;
+    let check;
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === '--json')
+            json = true;
+        else if (a === '--check' || a.startsWith('--check=')) {
+            const valor = a === '--check' ? (i + 1 < argv.length && !argv[i + 1].startsWith('--') ? argv[++i] : null) : a.slice(8);
+            const modo = (0, check_modo_1.lerModo)(valor);
+            if (!modo) {
+                console.error(`${m.checkInvalido(valor)}\n${m.usage}`);
+                return 2;
+            }
+            check = modo;
+        }
+        else if (a === '--base' && i + 1 < argv.length && !argv[i + 1].startsWith('--'))
+            base = argv[++i];
+        else if (a.startsWith('--base=') && a.length > 7)
+            base = a.slice(7);
+        else {
+            console.error(`${m.unknownFlag(a)}\n${m.usage}`);
+            return 2;
+        }
+    }
+    const required = process.env.ORK_SECURITY_SCAN_REQUIRED === '1';
+    const deadline = Number(process.env.ORK_SECURITY_SCAN_DEADLINE_MS);
+    let report;
+    try {
+        const modo = check ?? (0, check_modo_1.lerModo)(process.env[check_modo_1.ENV_MODO_DO_CHECK]) ?? ctx.modoDoManifesto ?? check_modo_1.MODO_PADRAO;
+        const opcoes = { root: ctx.raiz, stateRoot: ctx.estado, base, deadlineMs: Number.isFinite(deadline) && deadline > 0 ? deadline : undefined };
+        report = modo === 'agile' ? (0, agil_1.runScanAgil)({ ...opcoes, ...(ctx.agile ? { agile: ctx.agile } : {}) }) : (0, run_1.runScan)(opcoes);
+    }
+    catch (e) {
+        const message = e.message;
+        if (!/^security-scan\.(config-invalid|dismissal-invalid)/.test(message))
+            throw e;
+        console.error(message);
+        return 1;
+    }
+    const files = (0, report_1.writeReport)(ctx.estado, report);
+    if (json)
+        ctx.escrever(JSON.stringify(report, null, 2));
+    else {
+        const t = (0, report_1.tally)(report);
+        ctx.escrever(m.summary(t.new, t.existing, t.dismissed, t.loop));
+        const notRun = report.tools.filter(r => r.state !== 'ran');
+        if (notRun.length) {
+            ctx.escrever(m.notRunHeading);
+            for (const r of notRun)
+                ctx.escrever(m.notRun(r.name, m.states[r.state] ?? r.state, r.reason ?? ''));
+        }
+        ctx.escrever(files.md);
+    }
+    return (0, report_1.exitCodeOf)(report, required);
+}

package/dist/security-scan/compare.js

@@ -0,0 +1,149 @@
+"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.fingerprintOf = fingerprintOf;
+exports.matchesGlob = matchesGlob;
+exports.mergeByFingerprint = mergeByFingerprint;
+exports.classify = classify;
+const crypto = __importStar(require("node:crypto"));
+const types_1 = require("./types");
+/**
+ * sha256 of `tool|rule|file|snippet`, whitespace collapsed. The line is not part of it (a shift must not make a finding
+ * new) and neither is the message. For secrets the snippet already is the sha256 of the value.
+ */
+function fingerprintOf(f) {
+    const text = [f.tool, f.rule, f.file, f.snippet].map(p => p.replace(/\s+/g, ' ').trim()).join('|');
+    return crypto.createHash('sha256').update(text).digest('hex');
+}
+/**
+ * Glob over repository-relative posix paths, no dependency (`path.matchesGlob` needs Node 22, the package supports 20),
+ * with gitignore-like semantics: `**` crosses directories, `*` and `?` stay inside one segment, and a match on a
+ * directory also covers everything under it (`src/*` matches `src/a/b/c.js` through `src/a`; `vendor` excludes
+ * `vendor/x/y.js`).
+ */
+function matchesGlob(file, pattern) {
+    const pat = pattern.replace(/^\.\//, '').replace(/\/+$/, '');
+    let re = '';
+    for (let i = 0; i < pat.length; i++) {
+        const c = pat[i];
+        if (c === '*' && pat[i + 1] === '*') {
+            if (pat[i + 2] === '/') {
+                re += '(?:.*/)?';
+                i += 2;
+            }
+            else {
+                re += '.*';
+                i += 1;
+            }
+        }
+        else if (c === '*')
+            re += '[^/]*';
+        else if (c === '?')
+            re += '[^/]';
+        else
+            re += c.replace(/[.+^${}()|[\]\\]/g, '\\$&');
+    }
+    return new RegExp(`^${re}(?:/.*)?$`).test(file);
+}
+/**
+ * Union of several scans of the same tree state (Gitleaks HEAD: `dir` scan and `git` scan of base..HEAD) without double
+ * counting. Per fingerprint the merged count is the MAX of the per-list counts, not the sum, and the occurrences come
+ * from the list holding that max; on a tie the earliest list wins, so pass the `dir` scan first (its line numbers are
+ * those of the current tree). Order follows the first appearance of each fingerprint.
+ */
+function mergeByFingerprint(lists) {
+    const groups = new Map();
+    for (const [i, list] of lists.entries()) {
+        for (const f of list) {
+            const fp = fingerprintOf(f);
+            const per = groups.get(fp) ?? lists.map(() => []);
+            per[i].push(f);
+            groups.set(fp, per);
+        }
+    }
+    const out = [];
+    for (const per of groups.values())
+        out.push(...per.reduce((best, cur) => cur.length > best.length ? cur : best));
+    return out;
+}
+/**
+ * Classifies the HEAD findings against the base ones. Dismissal (by fingerprint) wins, then presence in the base
+ * (`existing`), else `new`. Equal fingerprints are matched by count: occurrences beyond what the base had are `new`.
+ * `loop` is true only for `new` findings that `isLoop` accepts. Findings in an excluded path leave `findings`; their
+ * paths are listed (deduplicated, sorted) in `excluded`.
+ */
+function classify(head, base, dismissals, exclude) {
+    const excluded = new Set();
+    const isExcluded = (f) => exclude.some(p => matchesGlob(f.file, p));
+    const baseLines = new Map();
+    for (const b of base)
+        if (!isExcluded(b)) {
+            const fp = fingerprintOf(b);
+            baseLines.set(fp, [...(baseLines.get(fp) ?? []), b.line ?? 0]);
+        }
+    const headByFp = new Map();
+    head.forEach((h, i) => { if (!isExcluded(h)) {
+        const fp = fingerprintOf(h);
+        headByFp.set(fp, [...(headByFp.get(fp) ?? []), i]);
+    } });
+    // Same-fingerprint occurrences are paired with the base by nearest line, so the `new` one is the inserted one.
+    const paired = new Set();
+    for (const [fp, idxs] of headByFp) {
+        const lines = baseLines.get(fp) ?? [];
+        const pairs = idxs.flatMap(hi => lines.map((bl, bi) => ({ hi, bi, d: Math.abs((head[hi].line ?? 0) - bl) })));
+        const usedH = new Set();
+        const usedB = new Set();
+        for (const p of pairs.sort((x, y) => x.d - y.d || x.hi - y.hi || x.bi - y.bi)) {
+            if (usedH.has(p.hi) || usedB.has(p.bi))
+                continue;
+            usedH.add(p.hi);
+            usedB.add(p.bi);
+            paired.add(p.hi);
+        }
+    }
+    const dismissed = new Set(dismissals.map(d => d.fingerprint));
+    const findings = [];
+    for (const [i, h] of head.entries()) {
+        if (isExcluded(h)) {
+            excluded.add(h.file);
+            continue;
+        }
+        const fingerprint = fingerprintOf(h);
+        const status = dismissed.has(fingerprint) ? 'dismissed' : paired.has(i) ? 'existing' : 'new';
+        const { snippet: _snippet, ...rest } = h;
+        findings.push({ ...rest, fingerprint, status, loop: status === 'new' && (0, types_1.isLoop)(h.category, h.severity) });
+    }
+    return { findings, excluded: [...excluded].sort() };
+}

package/dist/security-scan/config.js

@@ -0,0 +1,93 @@
+"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.loadConfig = loadConfig;
+exports.loadDismissals = loadDismissals;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const tools_1 = require("./tools");
+function readJson(root, name) {
+    const file = path.join(root, '.ork-security', name);
+    if (!fs.existsSync(file))
+        return undefined;
+    try {
+        return JSON.parse(fs.readFileSync(file, 'utf8'));
+    }
+    catch (e) {
+        throw Error(`security-scan.config-invalid: ${name}: ${e.message}`);
+    }
+}
+const strings = (v, name, field) => {
+    if (v === undefined)
+        return [];
+    if (!Array.isArray(v) || v.some(x => typeof x !== 'string'))
+        throw Error(`security-scan.config-invalid: ${name}: ${field} must be a list of strings`);
+    return v;
+};
+/** `.ork-security/config.json` under `root`; absent means empty defaults. */
+function loadConfig(root) {
+    const raw = readJson(root, 'config.json');
+    if (raw === undefined)
+        return { exclude: [], tools: {}, stacks: { add: [], remove: [] } };
+    if (typeof raw !== 'object' || raw === null || Array.isArray(raw))
+        throw Error('security-scan.config-invalid: config.json: expected an object');
+    const c = raw;
+    // Swapping a tool version is not supported in this version: a declared version other than the catalog's is an error,
+    // never silently ignored (the scan would claim a version it did not run).
+    const catalog = new Map((0, tools_1.loadTools)().map(t => [t.name, t.version]));
+    for (const [name, t] of Object.entries(c.tools ?? {})) {
+        if (t?.version !== undefined && t.version !== catalog.get(name))
+            throw Error(`security-scan.config-invalid: tools.${name}.version`);
+    }
+    return {
+        exclude: strings(c.exclude, 'config.json', 'exclude'),
+        tools: c.tools ?? {},
+        stacks: { add: strings(c.stacks?.add, 'config.json', 'stacks.add'), remove: strings(c.stacks?.remove, 'config.json', 'stacks.remove') },
+    };
+}
+/** `.ork-security/dismissals.json` under `root` (a list); absent means none. An entry without `reason` or `decisionRef` throws. */
+function loadDismissals(root) {
+    const raw = readJson(root, 'dismissals.json');
+    if (raw === undefined)
+        return [];
+    if (!Array.isArray(raw))
+        throw Error('security-scan.config-invalid: dismissals.json: expected a list');
+    return raw.map((d) => {
+        const filled = (v) => typeof v === 'string' && v.trim() !== '';
+        if (!filled(d?.fingerprint) || !filled(d.reason) || !filled(d.decisionRef))
+            throw Error(`security-scan.dismissal-invalid: ${d?.fingerprint ?? '(no fingerprint)'}`);
+        return d;
+    });
+}