@orkastery/cli 0.6.1 → 0.6.3

package/dist/check-agil.js

@@ -38,6 +38,7 @@ exports.paralelismoDaVarreduraNoGrupo = paralelismoDaVarreduraNoGrupo;
 exports.passosDoComando = passosDoComando;
 exports.elosDoComando = elosDoComando;
 exports.tirarPassosDoPreparo = tirarPassosDoPreparo;
+exports.tirarPassosDoPreparoAposLeituras = tirarPassosDoPreparoAposLeituras;
 exports.hashDoProduto = hashDoProduto;
 exports.prepararNoAgile = prepararNoAgile;
 exports.executorDaClaimNoAgile = executorDaClaimNoAgile;
@@ -47,6 +48,9 @@ exports.porQueDasLanes = porQueDasLanes;
 exports.comandosNoAgile = comandosNoAgile;
 exports.pecasDoRelatorio = pecasDoRelatorio;
 exports.listasDasLanes = listasDasLanes;
+exports.resultadosDasLanes = resultadosDasLanes;
+exports.assinaturaDoAmbiente = assinaturaDoAmbiente;
+exports.executorDaClaimPelasLanes = executorDaClaimPelasLanes;
 /**
  * RM-072 (D3 a D8 da ork-check5x): o motor do Agile Check no verify.
  *
@@ -54,12 +58,16 @@ exports.listasDasLanes = listasDasLanes;
  *
  *   - o preparo do Agile (`check.agile.preparo`, como o `tsgo` deste projeto) e, se ele falhar ou nao existir, o
  *     `verify.preparo`, com a peca `preparo` em fallback;
- *   - as claims, uma por vez, contra o produto do preparo: a claim que comeca pelos passos do `verify.preparo` roda sem
+ *   - quando ha lanes, elas rodam antes das claims; `node --test` dos mesmos arquivos, HEAD e ambiente usa o resultado
+ *     nominal da lane, enquanto comando aberto ou evidencia divergente roda inteiro; se uma claim posterior mudar o
+ *     produto, preparo e grupo rodam outra vez sobre o produto final;
+ *   - as demais claims, uma por vez, contra o produto do preparo: a claim que comeca pelos passos do `verify.preparo` roda sem
  *     eles quando a guarda vale (o preparo passou, a arvore e a mesma do fim do preparo e o hash dos caminhos de
  *     `check.agile.produto` tambem); qualquer divergencia roda o comando inteiro, e o motivo vai ao ledger. Passo no meio
- *     da cadeia fica: o que vem antes dele pode mudar a entrada do build (o mutante que edita o fonte e compila). Quando
+ *     da cadeia so sai quando tudo antes dele e uma leitura `grep -q` fechada; qualquer outro elo pode mudar a entrada do
+ *     build (como o mutante que edita o fonte e compila), entao a cadeia fica inteira. Quando
  *     so o produto mudou (a claim anterior compilou de novo no meio da cadeia), o preparo roda de novo antes da proxima
- *     claim que o reaproveitaria, ate `MAXIMO_DE_PREPAROS_REFEITOS` vezes, e uma vez antes do grupo, com a peca
+ *     claim que o reaproveitaria, ate `MAXIMO_DE_PREPAROS_REFEITOS` vezes, e uma vez depois das claims se elas mudarem o produto, com a peca
  *     `preparo-refeito`;
  *   - o `build` que e so passos do preparo, com a guarda valendo, sai do preparo desta rodada sem rodar de novo;
  *   - `typecheck`, as lanes de `test` (`check.agile.test`, ou o `verify.test`) e o `security_scan` num grupo paralelo, so
@@ -157,6 +165,78 @@ function tirarPassosDoPreparo(comando, passosDoPreparo) {
     }
     return { passos, resto };
 }
+/** Palavras de um comando simples, sem operadores ou expansoes do shell. */
+function palavrasDoComando(comando) {
+    const palavras = [];
+    let atual = '', aspas = null, escape = false;
+    const fechar = () => { if (atual !== '')
+        palavras.push(atual); atual = ''; };
+    for (const c of comando) {
+        if (escape) {
+            atual += c;
+            escape = false;
+            continue;
+        }
+        if (c === '\\' && aspas !== "'") {
+            escape = true;
+            continue;
+        }
+        if (aspas) {
+            if (c === aspas)
+                aspas = null;
+            else if (aspas === '"' && (c === '$' || c === '`'))
+                return null;
+            else
+                atual += c;
+            continue;
+        }
+        if (c === "'" || c === '"') {
+            aspas = c;
+            continue;
+        }
+        if (/\s/.test(c)) {
+            fechar();
+            continue;
+        }
+        if (';&|<>$`(){}'.includes(c))
+            return null;
+        atual += c;
+    }
+    if (escape || aspas)
+        return null;
+    fechar();
+    return palavras;
+}
+/** Uma leitura sem efeito colateral aceita antes do preparo unico. */
+function comandoGrepQ(comando) {
+    const palavras = palavrasDoComando(comando);
+    if (!palavras || palavras[0] !== 'grep' || palavras[1] !== '-q')
+        return false;
+    const argumentos = palavras[2] === '--' ? palavras.slice(3) : palavras.slice(2);
+    return argumentos.length === 2 && argumentos[0] !== '' && argumentos[1] !== '' && !argumentos[1].startsWith('-');
+}
+/**
+ * Tira passos exatos do preparo que aparecem depois apenas de `grep -q`. A leitura nao altera a entrada do build;
+ * qualquer outro elo antes do preparo conserva a regra antiga e faz a cadeia rodar inteira.
+ */
+function tirarPassosDoPreparoAposLeituras(comando, passosDoPreparo) {
+    const elos = elosDoComando(comando);
+    if (!elos)
+        return { passos: [], resto: comando.trim() };
+    const passos = [];
+    const resto = [];
+    let somenteLeiturasAntes = true;
+    for (const elo of elos) {
+        if (somenteLeiturasAntes && passosDoPreparo.includes(elo)) {
+            passos.push(elo);
+            continue;
+        }
+        resto.push(elo);
+        if (!comandoGrepQ(elo))
+            somenteLeiturasAntes = false;
+    }
+    return passos.length > 0 ? { passos, resto: resto.join(SEPARADOR) } : { passos: [], resto: comando.trim() };
+}
 /**
  * O sha256 do conteudo dos caminhos do produto (arquivos em ordem, com o caminho relativo). Caminho ausente entra como
  * ausente, para o produto que some nao passar por igual; link simbolico entra pelo destino que ele aponta, sem segui-lo.
@@ -256,7 +336,8 @@ function doPreparo(nome, comando, preparo, passos) {
 function executorDaClaimNoAgile(manifesto, executor, vigente, refazer) {
     const passosDoPreparo = manifesto.verify.preparo ? passosDoComando(manifesto.verify.preparo) : [];
     return (nome, comando, cwd) => {
-        const { passos, resto } = tirarPassosDoPreparo(comando, passosDoPreparo);
+        const daFrente = tirarPassosDoPreparo(comando, passosDoPreparo);
+        const { passos, resto } = daFrente.passos.length > 0 ? daFrente : tirarPassosDoPreparoAposLeituras(comando, passosDoPreparo);
         if (passos.length === 0)
             return executor(nome, comando, cwd);
         let motivo = vigente.guarda.conferir();
@@ -353,7 +434,8 @@ function testDasLanes(lanes) {
         ...(lanes.some((l) => l.resultado.stealPct !== undefined) ? { stealPct: lanes.find((l) => l.resultado.stealPct !== undefined).resultado.stealPct } : {}),
         ...(relogio.length ? { relogioSobSteal: relogio } : {}),
         lanes: lanes.map((l) => ({ lane: l.lane, comando: l.resultado.comando, ok: l.resultado.ok, code: l.resultado.code,
-            ...(l.resultado.causa ? { causa: l.resultado.causa } : {}), duracaoMs: l.resultado.duracaoMs ?? 0 })),
+            ...(l.resultado.causa ? { causa: l.resultado.causa } : {}), duracaoMs: l.resultado.duracaoMs ?? 0,
+            ...(l.resultado.testeQueCaiu?.length ? { testeQueCaiu: l.resultado.testeQueCaiu } : {}) })),
     };
 }
 /**
@@ -526,3 +608,158 @@ function listasDasLanes(linhas) {
         return { lane: l.lane, arquivos, sha256: (0, node_crypto_1.createHash)('sha256').update(arquivos.join('\n')).digest('hex') };
     });
 }
+/** Evidencia nominal produzida pelo reporter, sem confiar em campos abertos do JSONL. */
+function resultadosDasLanes(linhas) {
+    return linhas.filter((l) => l.tipo === 'resultados' && typeof l.lane === 'string' && typeof l.head === 'string'
+        && typeof l.ambiente === 'string' && Array.isArray(l.testes))
+        .map((l) => ({ lane: l.lane, head: l.head, ambiente: l.ambiente,
+        testes: l.testes.flatMap((t) => {
+            if (!t || typeof t !== 'object' || Array.isArray(t))
+                return [];
+            const x = t;
+            if (typeof x.arquivo !== 'string' || typeof x.nome !== 'string' || !Number.isInteger(x.nesting)
+                || !['pass', 'fail', 'skip', 'todo'].includes(String(x.estado)))
+                return [];
+            return [{ arquivo: x.arquivo, nome: x.nome, nesting: x.nesting,
+                    estado: x.estado }];
+        }) }));
+}
+/** Hash do ambiente funcional; transporte do CHECK, npm e bookkeeping do shell nao mudam o teste. */
+function assinaturaDoAmbiente(env) {
+    const ignorada = (nome) => nome.startsWith('npm_') || nome.startsWith('NPM_')
+        || ['ORK_CHECK_RELATORIO', 'ORK_CHECK_CPUS_DA_LANE', 'ORK_CHECK_CPUS_DA_LANE_APOS_RESERVA', 'ORK_CHECK_RESERVA_DEVOLVIDA',
+            'ORK_CHECK_CPUS_DOCKER',
+            'NODE_TEST_CONTEXT', 'NODE_COMPILE_CACHE', 'PWD', 'OLDPWD', 'SHLVL', '_', 'INIT_CWD'].includes(nome);
+    const pares = Object.entries(env).filter(([nome, valor]) => valor !== undefined && !ignorada(nome))
+        .sort(([a], [b]) => a.localeCompare(b));
+    return (0, node_crypto_1.createHash)('sha256').update(JSON.stringify(pares)).digest('hex');
+}
+/** Le somente a gramatica aceita para reaproveitar: `node --test [--test-name-pattern P] arquivo...`. */
+function comandoNodeTest(comando, cwd) {
+    const palavras = palavrasDoComando(comando);
+    if (!palavras)
+        return null;
+    if (palavras[0] !== 'node' || palavras[1] !== '--test')
+        return null;
+    let padrao;
+    const arquivos = [];
+    for (let i = 2; i < palavras.length; i++) {
+        const p = palavras[i];
+        if (p === '--test-name-pattern') {
+            if (padrao !== undefined || !palavras[++i])
+                return null;
+            padrao = palavras[i];
+            continue;
+        }
+        if (p.startsWith('--test-name-pattern=')) {
+            if (padrao !== undefined)
+                return null;
+            padrao = p.slice('--test-name-pattern='.length);
+            continue;
+        }
+        if (p.startsWith('-') || /[*?\[]/.test(p))
+            return null;
+        const absoluto = path.resolve(cwd, p);
+        const relativo = path.relative(path.join(cwd, 'core', 'dist-test', 'test'), absoluto);
+        if (!relativo || relativo.startsWith('..') || path.isAbsolute(relativo) || relativo !== path.basename(relativo)
+            || !relativo.endsWith('.test.js'))
+            return null;
+        arquivos.push(path.basename(absoluto));
+    }
+    if (padrao !== undefined) {
+        try {
+            void new RegExp(padrao);
+        }
+        catch {
+            return null;
+        }
+    }
+    return arquivos.length > 0 ? { arquivos: [...new Set(arquivos)], ...(padrao !== undefined ? { padrao } : {}) } : null;
+}
+/** A forma fechada usada pelas claims para provar contagem, zero falhas e zero skips no TAP. */
+function auditoriaTap(comando, cwd) {
+    const divisor = ' | ';
+    const i = comando.indexOf(divisor);
+    if (i < 0 || comando.indexOf(divisor, i + divisor.length) >= 0)
+        return null;
+    const node = comando.slice(0, i).trim();
+    const awk = comando.slice(i + divisor.length).trim();
+    const pedido = comandoNodeTest(node.replace(/^node --test-reporter=tap\b/, 'node --test'), cwd);
+    if (!pedido || pedido.arquivos.length !== 1 || pedido.padrao !== undefined)
+        return null;
+    const m = /^awk '\/\^ \*not ok\/{f\+\+} \/# SKIP\/{s\+\+} \/\^ \*ok \[0-9\]\+ - ([A-Z][A-Z0-9_-]*)\[0-9\]\+:\/{p\+\+} END\{exit !\(p>=([1-9][0-9]*) && f==0 && s==0\)\}'$/.exec(awk);
+    return m ? { pedido, prefixo: m[1], minimo: Number(m[2]) } : null;
+}
+function resultadoReaproveitado(nome, comando, pedido, usadas, esperado, nomes) {
+    const lanes = [...new Set(usadas.filter((e) => e.testes.some((t) => pedido.arquivos.includes(t.arquivo))).map((e) => e.lane))];
+    return { nome, comando, ok: true, code: 0, causa: 'exit', duracaoMs: 0, executado: true,
+        resumo: `reaproveitado das lanes ${lanes.join(', ')} desta rodada`,
+        lane: { reaproveitada: true, lanes, arquivos: pedido.arquivos,
+            nomes: nomes ?? (pedido.padrao === undefined ? pedido.arquivos.map((a) => `${a}:todos`) : pedido.arquivos.map((a) => `${a}:/${pedido.padrao}/`)),
+            head: esperado.head, ambiente: esperado.ambiente } };
+}
+/**
+ * Reaproveita uma claim somente quando a lane terminou todos os arquivos pedidos no mesmo HEAD e ambiente. Um arquivo
+ * inteiro verde e evidencia mais forte que `--test-name-pattern`: o padrao fica registrado em `nomes`.
+ */
+function executorDaClaimPelasLanes(base, evidencias, esperado) {
+    const assinatura = assinaturaDoAmbiente(esperado.ambiente);
+    return (nome, comando, cwd) => {
+        const executar = esperado.executorEquivalente ?? base;
+        if (esperado.podeReaproveitar?.() === false)
+            return executar(nome, comando, cwd);
+        const elos = elosDoComando(comando);
+        if (!elos)
+            return base(nome, comando, cwd);
+        const planejados = [];
+        for (const elo of elos) {
+            if (comandoGrepQ(elo)) {
+                planejados.push({ tipo: 'grep', comando: elo });
+                continue;
+            }
+            const tap = auditoriaTap(elo, cwd);
+            const pedido = tap?.pedido ?? comandoNodeTest(elo, cwd);
+            if (!pedido)
+                return base(nome, comando, cwd);
+            const usadas = evidencias.filter((e) => e.head === esperado.head && e.ambiente === assinatura
+                && e.testes.some((t) => pedido.arquivos.includes(t.arquivo)));
+            const cobertos = pedido.arquivos.every((arquivo) => {
+                const vistos = usadas.flatMap((e) => e.testes.filter((t) => t.arquivo === arquivo));
+                if (vistos.length === 0 || vistos.some((t) => t.estado === 'fail'))
+                    return false;
+                if (vistos.some((t) => t.estado === 'skip' || t.estado === 'todo'))
+                    return false;
+                if (!tap)
+                    return true;
+                const doArquivo = vistos.filter((t) => t.nesting === 0);
+                return doArquivo.filter((t) => t.estado === 'pass' && new RegExp(`^${tap.prefixo}[0-9]+:`).test(t.nome)).length >= tap.minimo;
+            });
+            if (!cobertos)
+                return executar(nome, comando, cwd);
+            const nomes = tap ? pedido.arquivos.map((a) => `${a}:${tap.prefixo}>=${tap.minimo};sem-falha;sem-skip`) : undefined;
+            planejados.push({ tipo: 'lane', resultado: resultadoReaproveitado(nome, elo, pedido, usadas, { head: esperado.head, ambiente: assinatura }, nomes) });
+        }
+        let duracaoMs = 0;
+        const resumos = [];
+        let ultimo = null;
+        const lanes = new Set(), arquivos = new Set(), nomes = new Set();
+        for (const item of planejados) {
+            const r = item.tipo === 'grep' ? base(nome, item.comando, cwd) : item.resultado;
+            duracaoMs += r.duracaoMs ?? 0;
+            resumos.push(r.resumo);
+            ultimo = r;
+            if (!r.ok)
+                return { ...r, comando, comandoExecutado: item.tipo === 'grep' ? item.comando : r.comando, duracaoMs };
+            for (const lane of r.lane?.lanes ?? [])
+                lanes.add(lane);
+            for (const arquivo of r.lane?.arquivos ?? [])
+                arquivos.add(arquivo);
+            for (const n of r.lane?.nomes ?? [])
+                nomes.add(n);
+        }
+        if (!ultimo || lanes.size === 0)
+            return base(nome, comando, cwd);
+        return { ...ultimo, nome, comando, duracaoMs, resumo: resumos.filter(Boolean).join('\n'),
+            lane: { reaproveitada: true, lanes: [...lanes], arquivos: [...arquivos], nomes: [...nomes], head: esperado.head, ambiente: assinatura } };
+    };
+}

package/dist/check-paralelo.js

@@ -85,7 +85,8 @@ async function rodarEspecificacao(esp) {
     const comGrupo = fs.existsSync(TIMEOUT_BIN);
     const usaAgendador = esp.itens.some((i) => i.papelCpu === 'hermetica');
     const plano = usaAgendador ? (0, agendador_cpu_1.planejarCpuDoGrupo)(esp.cpus ?? os.availableParallelism(), esp.medicaoCpu ?? await (0, agendador_cpu_1.medirCpuDoGrupo)()) : undefined;
-    const itens = plano ? aplicarPlano(esp.itens, plano) : esp.itens;
+    const sinalDaReserva = plano && !plano.saturado ? path.join(esp.dir, 'reserva-devolvida.json') : undefined;
+    const itens = plano ? aplicarPlano(esp.itens, plano, sinalDaReserva) : esp.itens;
     const limite = vagas(esp.maxParalelo && esp.maxParalelo > 0 ? esp.maxParalelo : itens.length);
     const porNome = new Map();
     const indice = new Map(itens.map((item, i) => [item.nome, i]));
@@ -112,7 +113,16 @@ async function rodarEspecificacao(esp) {
         porNome.set(item.nome, vez);
         return vez;
     };
-    const terminados = await Promise.all(itens.map(vezDoItem));
+    const todos = Promise.all(itens.map(vezDoItem));
+    const reservados = itens.filter((item) => item.papelCpu === 'varredura' || item.papelCpu === 'integracao');
+    const devolverReserva = async () => {
+        if (!sinalDaReserva || !reservados.some((item) => item.papelCpu === 'varredura')
+            || !reservados.some((item) => item.papelCpu === 'integracao'))
+            return;
+        await Promise.all(reservados.map((item) => vezDoItem(item, indice.get(item.nome))));
+        fs.writeFileSync(sinalDaReserva, JSON.stringify({ em: new Date().toISOString(), vagas: plano.cpusHermeticaAposReserva }), { mode: 0o600 });
+    };
+    const [, terminados] = await Promise.all([devolverReserva(), todos]);
     fs.writeFileSync(path.join(esp.dir, 'resultado.json'), JSON.stringify({ terminados, ...(plano ? { agendamentoCpu: plano } : {}) }), { mode: 0o600 });
     function lancar(item, i) {
         return new Promise((resolve) => {
@@ -141,7 +151,7 @@ async function rodarEspecificacao(esp) {
     }
 }
 /** Aplica a mesma conta aos processos, as lanes e aos conteineres que eles criarem. */
-function aplicarPlano(originais, plano) {
+function aplicarPlano(originais, plano, sinalDaReserva) {
     const itens = originais.map((item) => ({ ...item, ambiente: { ...item.ambiente } }));
     const porPapel = (papel) => itens.filter((i) => i.papelCpu === papel);
     const hermetica = porPapel('hermetica')[0];
@@ -158,7 +168,10 @@ function aplicarPlano(originais, plano) {
             item.ambiente = { ...item.ambiente, ...valores };
     };
     const cpusContainer = String(plano.cpusPorContainer);
-    ambiente(hermetica, { [agendador_cpu_1.ENV_CPUS_DA_LANE]: String(plano.cpusHermetica), [agendador_cpu_1.ENV_CPUS_DOCKER]: cpusContainer });
+    ambiente(hermetica, { [agendador_cpu_1.ENV_CPUS_DA_LANE]: String(plano.cpusHermetica), [agendador_cpu_1.ENV_CPUS_DOCKER]: cpusContainer,
+        ...(sinalDaReserva && varredura && integracoes.length > 0 ? {
+            [agendador_cpu_1.ENV_CPUS_DA_LANE_APOS_RESERVA]: String(plano.cpusHermeticaAposReserva), [agendador_cpu_1.ENV_SINAL_DA_RESERVA]: sinalDaReserva,
+        } : {}) });
     ambiente(varredura, {
         ORK_CHECK_VARREDURA_PARALELA: String(plano.ferramentasDaVarredura),
         [agendador_cpu_1.ENV_CPUS_DOCKER]: cpusContainer,

package/dist/ci.js

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

package/dist/claim-lint.js

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

package/dist/claims.js

@@ -127,7 +127,7 @@ function montarClaim(entrada) {
         criadoEm: (0, util_1.agora)(),
         estado: verificar.length > 0 ? 'pendente' : 'nao-verificavel',
         ...(entrada.origem ? { origem: entrada.origem } : {}),
-        // I-53 (RM-037, P6): a mesma regra para CLI, MCP, canarios e auditor, porque todos passam aqui.
+        // I-53 (RM-037, P6): a mesma regra para CLI, MCP, cenarios e auditor, porque todos passam aqui.
         lint: (0, claim_lint_1.analisarComandos)(verificar),
     };
 }
@@ -154,6 +154,10 @@ function adicionarClaim(raiz, threadId, opcoes) {
         verificar: opcoes.verificar,
         origem: opcoes.origem,
     });
+    const recusas = (claim.lint ?? []).filter((a) => (0, claim_lint_1.regraFatalDeClaim)(a.regra));
+    if (recusas.length > 0) {
+        throw new locale_1.ErroDoCatalogo((m) => m.claims.lintRecusado(recusas.map((a) => `claims.lint.${a.regra}: ${(0, claim_lint_1.linhaDoLintDeClaim)(claim.id, a)}`).join('\n  ')));
+    }
     const negativa = claim.negativa;
     const verificar = claim.verificar;
     gravarClaim(raiz, claim);

package/dist/docs.js

@@ -82,6 +82,7 @@ const ledger_1 = require("./ledger");
 const branch_de_estado_1 = require("./branch-de-estado");
 const locale_1 = require("./locale");
 const merge_da_entrega_1 = require("./merge-da-entrega");
+const changelog_check_1 = require("./changelog-check");
 exports.DIR_PRODUTO = 'docs/produto';
 exports.DIR_ROADMAP = 'docs/roadmap';
 exports.DIR_PADROES = 'docs/padroes';
@@ -109,7 +110,7 @@ exports.DIMENSOES = {
     codigo: ['Não iniciado', 'Branch criada', 'PR aberto', 'Mesclado'],
     testes: ['Não iniciados', 'Em execução', 'Aprovados', 'Falhando'],
     deploy: ['Não implantado', 'Dev', 'Staging', 'Produção'],
-    exposicao: ['Flag desligada', 'Piloto/Canary', 'Parcial', 'Geral'],
+    exposicao: ['Flag desligada', 'Piloto/Gradual', 'Parcial', 'Geral'],
     habilitacao: ['Pendente', 'Em andamento', 'Concluída'],
 };
 exports.CATEGORIAS = ['iniciativa', 'épico', 'feature', 'melhoria'];
@@ -265,6 +266,12 @@ function verificarDocs(raiz, opcoes = {}) {
     if (!opcoes.semGit && !base) {
         achados.push(aviso('.', undefined, 'docs.git.base', (m) => m.baseAusente(opcoes.baseBranch ?? 'main'), (m) => m.baseAusenteCorrecao));
     }
+    if (opcoes.pr && base) {
+        const changelog = (0, changelog_check_1.checarChangelog)(raiz, { base, head: 'HEAD', baseCarimbada: opcoes.baseCarimbada });
+        if (!changelog.ok) {
+            achados.push(erro(changelog_check_1.CHANGELOG, undefined, changelog.motivo ?? 'changelog.invalido', () => changelog.detalhe, () => changelog.correcao ?? 'corrija o CHANGELOG e repita a verificação'));
+        }
+    }
     const comandos = opcoes.ajudaDoCli ? comandosDaAjuda(opcoes.ajudaDoCli) : null;
     for (const d of docs) {
         if (!TIPOS.includes(d.tipo))

package/dist/evalrunner.js

@@ -4,7 +4,7 @@
  *
  * Ele julga duas coisas, e diz em voz alta que so uma delas ele consegue julgar.
  *
- *  1. **Os canarios** (`eval/fixtures/fx-*`): comportamento real do nucleo, exercitado ponta a
+ *  1. **Os cenarios** (`eval/fixtures/fx-*`): comportamento real do nucleo, exercitado ponta a
  *     ponta contra git de verdade, comparado com o que a fixture declara esperar.
  *  2. **O corpus das skills** (`eval/casos/*.json`): as regras que precisam EXISTIR no arquivo
  *     da skill para o comportamento ser possivel. Isso e deterministico, e e o que o runner
@@ -60,12 +60,12 @@ exports.posicoesDaAssercao = posicoesDaAssercao;
 exports.dirDeCasos = dirDeCasos;
 exports.dirDeFixtures = dirDeFixtures;
 exports.lerCasos = lerCasos;
-exports.rodarCanarios = rodarCanarios;
+exports.rodarCenarios = rodarCenarios;
 exports.rodarEval = rodarEval;
 exports.textoDoEval = textoDoEval;
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
-const canarios_1 = require("./canarios");
+const cenarios_1 = require("./cenarios");
 const catalogo_1 = require("./catalogo");
 const util_1 = require("./util");
 const locale_1 = require("./locale");
@@ -271,20 +271,20 @@ function comparar(esperado, observado) {
     }
     return divergencias;
 }
-/** Roda os canarios cujas fixtures existem em `eval/fixtures/fx-*`. */
-function rodarCanarios(catalogo, filtro) {
+/** Roda os cenarios cujas fixtures existem em `eval/fixtures/fx-*`. */
+function rodarCenarios(catalogo, filtro) {
     const dir = dirDeFixtures(catalogo);
     const resultados = [];
     const falhas = [];
     const m = (0, locale_1.msg)().operacao.restante.eval;
-    const temGit = (0, canarios_1.gitDisponivel)();
+    const temGit = (0, cenarios_1.gitDisponivel)();
     const nomes = fs.existsSync(dir) ? fs.readdirSync(dir).sort() : [];
     if (filtro && filtro.length === 0) {
         falhas.push({ codigo: 'fixture-invalida', detalhe: m.filtroVazio });
     }
     for (const id of new Set(filtro ?? [])) {
-        if (!nomes.includes(id) || !(0, canarios_1.canarioPorId)(id)) {
-            falhas.push({ codigo: 'canario-sem-executor', caso: id, detalhe: m.canarioAusente(id) });
+        if (!nomes.includes(id) || !(0, cenarios_1.cenarioPorId)(id)) {
+            falhas.push({ codigo: 'cenario-sem-executor', caso: id, detalhe: m.cenarioAusente(id) });
         }
     }
     for (const nome of nomes) {
@@ -305,22 +305,22 @@ function rodarCanarios(catalogo, filtro) {
             falhas.push({ codigo: 'fixture-invalida', detalhe: `${nome}: ${e.message}` });
             continue;
         }
-        const canario = (0, canarios_1.canarioPorId)(fixture.id ?? nome);
+        const cenario = (0, cenarios_1.cenarioPorId)(fixture.id ?? nome);
         if (fixture.id !== nome) {
             falhas.push({ codigo: 'fixture-invalida', caso: nome, detalhe: m.fixtureDiverge });
             continue;
         }
-        if (!canario) {
+        if (!cenario) {
             falhas.push({
-                codigo: 'canario-sem-executor',
+                codigo: 'cenario-sem-executor',
                 detalhe: m.semExecutor(nome, fixture.id ?? nome),
             });
             continue;
         }
-        if (canario.precisaDeGit && !temGit) {
+        if (cenario.precisaDeGit && !temGit) {
             resultados.push({
-                id: canario.id,
-                sobre: canario.sobre,
+                id: cenario.id,
+                sobre: cenario.sobre,
                 estado: 'unavailable',
                 divergencias: [],
                 motivo: m.semGit,
@@ -329,11 +329,11 @@ function rodarCanarios(catalogo, filtro) {
             continue;
         }
         try {
-            const observado = canario.rodar({ catalogo });
+            const observado = cenario.rodar({ catalogo });
             const divergencias = comparar(fixture.esperado ?? {}, observado);
             resultados.push({
-                id: canario.id,
-                sobre: canario.sobre,
+                id: cenario.id,
+                sobre: cenario.sobre,
                 estado: divergencias.length === 0 ? 'passou' : 'falhou',
                 divergencias,
                 motivo: divergencias.length === 0 ? '' : `${divergencias.length} chave(s) divergente(s)`,
@@ -341,33 +341,33 @@ function rodarCanarios(catalogo, filtro) {
             });
             for (const d of divergencias) {
                 falhas.push({
-                    codigo: 'canario',
-                    caso: `${canario.id}/${d.chave}`,
+                    codigo: 'cenario',
+                    caso: `${cenario.id}/${d.chave}`,
                     detalhe: m.divergencia(JSON.stringify(d.esperado), JSON.stringify(d.observado)),
                 });
             }
         }
         catch (e) {
             resultados.push({
-                id: canario.id,
-                sobre: canario.sobre,
+                id: cenario.id,
+                sobre: cenario.sobre,
                 estado: 'falhou',
                 divergencias: [],
                 motivo: e.message,
                 observado: {},
             });
-            falhas.push({ codigo: 'canario', caso: canario.id, detalhe: e.message });
+            falhas.push({ codigo: 'cenario', caso: cenario.id, detalhe: e.message });
         }
     }
-    // Canario registrado no codigo e sem fixture em disco tambem e defeito: a expectativa
+    // Cenario registrado no codigo e sem fixture em disco tambem e defeito: a expectativa
     // precisa ser dado versionado, revisavel por quem nao le TypeScript.
     if (!filtro) {
-        for (const c of canarios_1.CANARIOS) {
+        for (const c of cenarios_1.CENARIOS) {
             if (!fs.existsSync(path.join(dir, c.id, 'caso.json'))) {
                 falhas.push({
                     codigo: 'fixture-invalida',
                     caso: c.id,
-                    detalhe: m.canarioSemFixture(c.id),
+                    detalhe: m.cenarioSemFixture(c.id),
                 });
             }
         }
@@ -377,20 +377,20 @@ function rodarCanarios(catalogo, filtro) {
 // ---------------------------------------------------------------------------
 // Orquestracao
 // ---------------------------------------------------------------------------
-/** Roda o eval inteiro: canarios mais corpus das skills. */
+/** Roda o eval inteiro: cenarios mais corpus das skills. */
 function rodarEval(opcoes) {
     const { catalogo } = opcoes;
     const falhas = [];
     const linhas = [];
-    let canarios = [];
+    let cenarios = [];
     if (!opcoes.soSkills) {
-        const r = rodarCanarios(catalogo, opcoes.canarios);
-        canarios = r.resultados;
+        const r = rodarCenarios(catalogo, opcoes.cenarios);
+        cenarios = r.resultados;
         falhas.push(...r.falhas);
     }
     let totalDeCasos = 0;
     let totalDeAssercoes = 0;
-    if (!opcoes.soCanarios) {
+    if (!opcoes.soCenarios) {
         const { arquivos, falhas: falhasDeLeitura } = lerCasos(catalogo);
         falhas.push(...falhasDeLeitura);
         const doCatalogo = (0, catalogo_1.skillsDoCatalogo)(catalogo);
@@ -428,7 +428,7 @@ function rodarEval(opcoes) {
     return {
         catalogo,
         skills: linhas,
-        canarios,
+        cenarios,
         falhas,
         totalDeCasos,
         totalDeAssercoes,
@@ -442,10 +442,10 @@ function textoDoEval(r) {
     const linhas = [];
     linhas.push(m.titulo(r.catalogo));
     linhas.push('');
-    if (r.canarios.length > 0) {
-        linhas.push(m.canarios);
+    if (r.cenarios.length > 0) {
+        linhas.push(m.cenarios);
         linhas.push('');
-        linhas.push((0, util_1.tabela)([...m.colunasCanarios], r.canarios.map((c) => [c.id, m.estados[c.estado] ?? c.estado, c.estado === 'passou' ? c.sobre : c.motivo || c.sobre])));
+        linhas.push((0, util_1.tabela)([...m.colunasCenarios], r.cenarios.map((c) => [c.id, m.estados[c.estado] ?? c.estado, c.estado === 'passou' ? c.sobre : c.motivo || c.sobre])));
         linhas.push('');
     }
     if (r.skills.length > 0) {
@@ -463,9 +463,9 @@ function textoDoEval(r) {
         }
         linhas.push('');
     }
-    const passaram = r.canarios.filter((c) => c.estado === 'passou').length;
-    const indisponiveis = r.canarios.filter((c) => c.estado === 'unavailable').length;
-    linhas.push(m.resumoCanarios(passaram, r.canarios.length, indisponiveis));
+    const passaram = r.cenarios.filter((c) => c.estado === 'passou').length;
+    const indisponiveis = r.cenarios.filter((c) => c.estado === 'unavailable').length;
+    linhas.push(m.resumoCenarios(passaram, r.cenarios.length, indisponiveis));
     linhas.push(m.resumoSkills(r.skills.length, r.totalDeCasos, r.totalDeAssercoes, r.falhas.length));
     linhas.push(m.metade);
     linhas.push(m.veredito(r.ok));