@orkastery/cli 0.6.1 → 0.6.2

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,157 @@ function listasDasLanes(linhas) {
         return { lane: l.lane, arquivos, sha256: (0, node_crypto_1.createHash)('sha256').update(arquivos.join('\n')).digest('hex') };
     });
 }
+/** Evidencia nominal produzida pelo reporter, sem confiar em campos abertos do JSONL. */
+function resultadosDasLanes(linhas) {
+    return linhas.filter((l) => l.tipo === 'resultados' && typeof l.lane === 'string' && typeof l.head === 'string'
+        && typeof l.ambiente === 'string' && Array.isArray(l.testes))
+        .map((l) => ({ lane: l.lane, head: l.head, ambiente: l.ambiente,
+        testes: l.testes.flatMap((t) => {
+            if (!t || typeof t !== 'object' || Array.isArray(t))
+                return [];
+            const x = t;
+            if (typeof x.arquivo !== 'string' || typeof x.nome !== 'string' || !Number.isInteger(x.nesting)
+                || !['pass', 'fail', 'skip', 'todo'].includes(String(x.estado)))
+                return [];
+            return [{ arquivo: x.arquivo, nome: x.nome, nesting: x.nesting,
+                    estado: x.estado }];
+        }) }));
+}
+/** Hash do ambiente funcional; transporte do CHECK, npm e bookkeeping do shell nao mudam o teste. */
+function assinaturaDoAmbiente(env) {
+    const ignorada = (nome) => nome.startsWith('npm_') || nome.startsWith('NPM_')
+        || ['ORK_CHECK_RELATORIO', 'ORK_CHECK_CPUS_DA_LANE', 'ORK_CHECK_CPUS_DOCKER',
+            'NODE_TEST_CONTEXT', 'NODE_COMPILE_CACHE', 'PWD', 'OLDPWD', 'SHLVL', '_', 'INIT_CWD'].includes(nome);
+    const pares = Object.entries(env).filter(([nome, valor]) => valor !== undefined && !ignorada(nome))
+        .sort(([a], [b]) => a.localeCompare(b));
+    return (0, node_crypto_1.createHash)('sha256').update(JSON.stringify(pares)).digest('hex');
+}
+/** Le somente a gramatica aceita para reaproveitar: `node --test [--test-name-pattern P] arquivo...`. */
+function comandoNodeTest(comando, cwd) {
+    const palavras = palavrasDoComando(comando);
+    if (!palavras)
+        return null;
+    if (palavras[0] !== 'node' || palavras[1] !== '--test')
+        return null;
+    let padrao;
+    const arquivos = [];
+    for (let i = 2; i < palavras.length; i++) {
+        const p = palavras[i];
+        if (p === '--test-name-pattern') {
+            if (padrao !== undefined || !palavras[++i])
+                return null;
+            padrao = palavras[i];
+            continue;
+        }
+        if (p.startsWith('--test-name-pattern=')) {
+            if (padrao !== undefined)
+                return null;
+            padrao = p.slice('--test-name-pattern='.length);
+            continue;
+        }
+        if (p.startsWith('-') || /[*?\[]/.test(p))
+            return null;
+        const absoluto = path.resolve(cwd, p);
+        const relativo = path.relative(path.join(cwd, 'core', 'dist-test', 'test'), absoluto);
+        if (!relativo || relativo.startsWith('..') || path.isAbsolute(relativo) || relativo !== path.basename(relativo)
+            || !relativo.endsWith('.test.js'))
+            return null;
+        arquivos.push(path.basename(absoluto));
+    }
+    if (padrao !== undefined) {
+        try {
+            void new RegExp(padrao);
+        }
+        catch {
+            return null;
+        }
+    }
+    return arquivos.length > 0 ? { arquivos: [...new Set(arquivos)], ...(padrao !== undefined ? { padrao } : {}) } : null;
+}
+/** A forma fechada usada pelas claims para provar contagem, zero falhas e zero skips no TAP. */
+function auditoriaTap(comando, cwd) {
+    const divisor = ' | ';
+    const i = comando.indexOf(divisor);
+    if (i < 0 || comando.indexOf(divisor, i + divisor.length) >= 0)
+        return null;
+    const node = comando.slice(0, i).trim();
+    const awk = comando.slice(i + divisor.length).trim();
+    const pedido = comandoNodeTest(node.replace(/^node --test-reporter=tap\b/, 'node --test'), cwd);
+    if (!pedido || pedido.arquivos.length !== 1 || pedido.padrao !== undefined)
+        return null;
+    const m = /^awk '\/\^ \*not ok\/{f\+\+} \/# SKIP\/{s\+\+} \/\^ \*ok \[0-9\]\+ - ([A-Z][A-Z0-9_-]*)\[0-9\]\+:\/{p\+\+} END\{exit !\(p>=([1-9][0-9]*) && f==0 && s==0\)\}'$/.exec(awk);
+    return m ? { pedido, prefixo: m[1], minimo: Number(m[2]) } : null;
+}
+function resultadoReaproveitado(nome, comando, pedido, usadas, esperado, nomes) {
+    const lanes = [...new Set(usadas.filter((e) => e.testes.some((t) => pedido.arquivos.includes(t.arquivo))).map((e) => e.lane))];
+    return { nome, comando, ok: true, code: 0, causa: 'exit', duracaoMs: 0, executado: true,
+        resumo: `reaproveitado das lanes ${lanes.join(', ')} desta rodada`,
+        lane: { reaproveitada: true, lanes, arquivos: pedido.arquivos,
+            nomes: nomes ?? (pedido.padrao === undefined ? pedido.arquivos.map((a) => `${a}:todos`) : pedido.arquivos.map((a) => `${a}:/${pedido.padrao}/`)),
+            head: esperado.head, ambiente: esperado.ambiente } };
+}
+/**
+ * Reaproveita uma claim somente quando a lane terminou todos os arquivos pedidos no mesmo HEAD e ambiente. Um arquivo
+ * inteiro verde e evidencia mais forte que `--test-name-pattern`: o padrao fica registrado em `nomes`.
+ */
+function executorDaClaimPelasLanes(base, evidencias, esperado) {
+    const assinatura = assinaturaDoAmbiente(esperado.ambiente);
+    return (nome, comando, cwd) => {
+        const executar = esperado.executorEquivalente ?? base;
+        if (esperado.podeReaproveitar?.() === false)
+            return executar(nome, comando, cwd);
+        const elos = elosDoComando(comando);
+        if (!elos)
+            return base(nome, comando, cwd);
+        const planejados = [];
+        for (const elo of elos) {
+            if (comandoGrepQ(elo)) {
+                planejados.push({ tipo: 'grep', comando: elo });
+                continue;
+            }
+            const tap = auditoriaTap(elo, cwd);
+            const pedido = tap?.pedido ?? comandoNodeTest(elo, cwd);
+            if (!pedido)
+                return base(nome, comando, cwd);
+            const usadas = evidencias.filter((e) => e.head === esperado.head && e.ambiente === assinatura
+                && e.testes.some((t) => pedido.arquivos.includes(t.arquivo)));
+            const cobertos = pedido.arquivos.every((arquivo) => {
+                const vistos = usadas.flatMap((e) => e.testes.filter((t) => t.arquivo === arquivo));
+                if (vistos.length === 0 || vistos.some((t) => t.estado === 'fail'))
+                    return false;
+                if (vistos.some((t) => t.estado === 'skip' || t.estado === 'todo'))
+                    return false;
+                if (!tap)
+                    return true;
+                const doArquivo = vistos.filter((t) => t.nesting === 0);
+                return doArquivo.filter((t) => t.estado === 'pass' && new RegExp(`^${tap.prefixo}[0-9]+:`).test(t.nome)).length >= tap.minimo;
+            });
+            if (!cobertos)
+                return executar(nome, comando, cwd);
+            const nomes = tap ? pedido.arquivos.map((a) => `${a}:${tap.prefixo}>=${tap.minimo};sem-falha;sem-skip`) : undefined;
+            planejados.push({ tipo: 'lane', resultado: resultadoReaproveitado(nome, elo, pedido, usadas, { head: esperado.head, ambiente: assinatura }, nomes) });
+        }
+        let duracaoMs = 0;
+        const resumos = [];
+        let ultimo = null;
+        const lanes = new Set(), arquivos = new Set(), nomes = new Set();
+        for (const item of planejados) {
+            const r = item.tipo === 'grep' ? base(nome, item.comando, cwd) : item.resultado;
+            duracaoMs += r.duracaoMs ?? 0;
+            resumos.push(r.resumo);
+            ultimo = r;
+            if (!r.ok)
+                return { ...r, comando, comandoExecutado: item.tipo === 'grep' ? item.comando : r.comando, duracaoMs };
+            for (const lane of r.lane?.lanes ?? [])
+                lanes.add(lane);
+            for (const arquivo of r.lane?.arquivos ?? [])
+                arquivos.add(arquivo);
+            for (const n of r.lane?.nomes ?? [])
+                nomes.add(n);
+        }
+        if (!ultimo || lanes.size === 0)
+            return base(nome, comando, cwd);
+        return { ...ultimo, nome, comando, duracaoMs, resumo: resumos.filter(Boolean).join('\n'),
+            lane: { reaproveitada: true, lanes: [...lanes], arquivos: [...arquivos], nomes: [...nomes], head: esperado.head, ambiente: assinatura } };
+    };
+}

package/dist/ci.js

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

package/dist/claim-lint.js

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

package/dist/claims.js

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

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';
@@ -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/fila-pesada.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ErroDaFilaPesada = exports.ENV_DONO_DA_FILA = exports.CONTRATO_FILA_PESADA = void 0;
+exports.avaliarVidaDoOcupante = avaliarVidaDoOcupante;
 exports.kernelDisponivel = kernelDisponivel;
 exports.tentarTravaExclusiva = tentarTravaExclusiva;
 exports.dirDaFilaPesada = dirDaFilaPesada;
@@ -66,6 +67,7 @@ const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const node_crypto_1 = require("node:crypto");
 const node_child_process_1 = require("node:child_process");
+const node_worker_threads_1 = require("node:worker_threads");
 const estado_thread_1 = require("./estado-thread");
 const horario_1 = require("./horario");
 exports.CONTRATO_FILA_PESADA = 'ork.fila-pesada/v1';
@@ -75,11 +77,27 @@ const FLOCK = '/usr/bin/flock';
 const DIR = 'fila-pesada';
 /** Entre uma tentativa e outra. A vez costuma durar minutos; meio segundo não pesa em ninguém. */
 const PAUSA_MS = 500;
+/** A batida e complementar ao flock: atravessa a observacao de um sandbox com outro namespace de PID. */
+const BATIDA_CADA_MS = 1_000;
+const BATIDA_VALE_MS = 5_000;
+function avaliarVidaDoOcupante(e) {
+    if (e.trava === 'ocupada')
+        return { vida: 'vivo', prova: 'trava-kernel' };
+    if (e.trava === 'livre')
+        return { vida: 'morto', prova: 'trava-livre' };
+    if (e.batidaValida)
+        return { vida: 'vivo', prova: 'batida' };
+    if (e.mesmoHost && e.mesmoEspacoPids && e.processo === 'vivo')
+        return { vida: 'vivo', prova: 'processo' };
+    if (e.mesmoHost && e.mesmoEspacoPids && e.processo === 'ausente')
+        return { vida: 'morto', prova: 'processo-ausente' };
+    return { vida: 'desconhecido', prova: 'indeterminada' };
+}
 /** A recusa é resposta, não falha: o CLI a imprime como a da condução, e sai com 3. */
 class ErroDaFilaPesada extends Error {
     recusa;
     constructor(recusa) {
-        super(`fila-pesada.ocupada: ${recusa.texto}`);
+        super(`${recusa.motivo}: ${recusa.texto}`);
         this.name = 'ErroDaFilaPesada';
         this.recusa = recusa;
     }
@@ -88,11 +106,17 @@ exports.ErroDaFilaPesada = ErroDaFilaPesada;
 function kernelDisponivel() {
     return process.platform === 'linux' && fs.existsSync(FLOCK);
 }
-/** O `flock` exclusivo sem espera sobre um descritor já aberto. O helper tranca a descrição de arquivo, que fica do processo. */
-function trancar(fd) {
+/** Diferencia a contencao provada do erro de observacao; erro nunca vira trava livre. */
+function observarTrava(fd) {
     const r = (0, node_child_process_1.spawnSync)(FLOCK, ['--exclusive', '--nonblock', '3'], { stdio: ['ignore', 'ignore', 'ignore', fd], timeout: 5000 });
-    return r.status === 0 && !r.error;
+    if (!r.error && r.status === 0)
+        return 'adquirida';
+    if (!r.error && r.status === 1)
+        return 'ocupada';
+    return 'desconhecida';
 }
+/** Tomar a trava exige prova positiva. Contencao e observacao inconclusiva falham fechadas. */
+function trancar(fd) { return observarTrava(fd) === 'adquirida'; }
 function abrirTrava(arquivo, criar) {
     const fd = fs.openSync(arquivo, fs.constants.O_RDWR | fs.constants.O_NOFOLLOW | (criar ? fs.constants.O_CREAT : 0), 0o600);
     const st = fs.fstatSync(fd);
@@ -210,11 +234,57 @@ function minhaVez(dir, senha) {
     }
     return true;
 }
+function hashLocal(valor) { return (0, node_crypto_1.createHash)('sha256').update(valor).digest('hex').slice(0, 24); }
+/** Identidades opacas: provam igualdade sem publicar hostname, boot id ou inode do namespace. */
+function identidadeDaMaquina() {
+    let host = null, espacoPids = null;
+    try {
+        host = hashLocal(fs.readFileSync('/proc/sys/kernel/random/boot_id', 'utf8').trim());
+    }
+    catch { /* nao observavel */ }
+    try {
+        espacoPids = hashLocal(fs.readlinkSync('/proc/self/ns/pid'));
+    }
+    catch { /* nao observavel */ }
+    return { host, espacoPids };
+}
 function gravarDono(fd, dono, posse) {
     const bytes = Buffer.from(JSON.stringify({ contrato: exports.CONTRATO_FILA_PESADA, ...dono, posse }) + '\n', 'utf8');
     fs.ftruncateSync(fd, 0);
     fs.writeSync(fd, bytes, 0, bytes.length, 0);
 }
+function arquivoDaBatida(dir, slot, posse) {
+    return path.join(dir, `vaga-${slot}.${posse}.heartbeat.json`);
+}
+/** Worker nativo: a batida continua enquanto o verify sincrono bloqueia a thread JS, sem processo shell perdido. */
+function iniciarBatida(dir, slot, posse) {
+    const arquivo = arquivoDaBatida(dir, slot, posse);
+    try {
+        const worker = new node_worker_threads_1.Worker(`
+      const fs = require('node:fs');
+      const { parentPort, workerData } = require('node:worker_threads');
+      const { randomUUID } = require('node:crypto');
+      let ativo = true;
+      parentPort.on('message', () => { ativo = false; });
+      function bater() {
+        if (!ativo) return;
+        const tmp = workerData.arquivo + '.' + randomUUID() + '.tmp';
+        try {
+          fs.writeFileSync(tmp, JSON.stringify({ contrato: 'ork.fila-pesada-heartbeat/v1', posse: workerData.posse,
+            expiraEm: new Date(Date.now() + workerData.validadeMs).toISOString() }) + '\\n', { flag: 'wx', mode: 0o600 });
+          fs.renameSync(tmp, workerData.arquivo);
+        } catch (_) { try { fs.unlinkSync(tmp); } catch (_) {} }
+        if (ativo) setTimeout(bater, workerData.intervaloMs);
+      }
+      bater();
+    `, { eval: true, workerData: { arquivo, posse, intervaloMs: BATIDA_CADA_MS, validadeMs: BATIDA_VALE_MS } });
+        worker.unref();
+        return { worker, arquivo };
+    }
+    catch {
+        return null;
+    }
+}
 /** O artefato primeiro, depois a primeira vaga livre; sem vaga, solta o artefato. Nunca espera segurando nada. */
 function tentarVaga(dir, pedido) {
     const fdArtefato = tentarTravaExclusiva(path.join(dir, `artefato-${chaveDoArtefato(pedido.artefato)}.lock`));
@@ -224,17 +294,29 @@ function tentarVaga(dir, pedido) {
         const fdVaga = tentarTravaExclusiva(path.join(dir, `vaga-${slot}.lock`));
         if (fdVaga === null)
             continue;
-        const dono = { slot, operacao: pedido.operacao, thread: pedido.thread, artefato: path.resolve(pedido.artefato),
-            pid: process.pid, desde: new Date().toISOString() };
         const id = (0, node_crypto_1.randomUUID)();
+        const identidade = identidadeDaMaquina();
+        const dono = { slot, operacao: pedido.operacao, thread: pedido.thread, artefato: path.resolve(pedido.artefato),
+            pid: process.pid, desde: new Date().toISOString(), inicio: inicioDoProcesso(process.pid), ...identidade };
         gravarDono(fdVaga, dono, id);
         gravarDono(fdArtefato, dono, id);
-        return { fdArtefato, fdVaga, slot, id };
+        const batida = iniciarBatida(dir, slot, id);
+        return { fdArtefato, fdVaga, slot, id, batida: batida?.worker ?? null, arquivoDaBatida: batida?.arquivo ?? null };
     }
     fs.closeSync(fdArtefato);
     return null;
 }
 function soltar(posse) {
+    try {
+        posse.batida?.postMessage('parar');
+        void posse.batida?.terminate();
+    }
+    catch { /* o processo tambem encerra o worker */ }
+    if (posse.arquivoDaBatida)
+        try {
+            fs.unlinkSync(posse.arquivoDaBatida);
+        }
+        catch { /* batida expira sozinha */ }
     for (const fd of [posse.fdVaga, posse.fdArtefato]) {
         try {
             fs.ftruncateSync(fd, 0);
@@ -264,7 +346,8 @@ function ocupantesDaFilaPesada(raiz) {
             continue;
         }
         try {
-            if (trancar(fd))
+            const trava = observarTrava(fd);
+            if (trava === 'adquirida')
                 continue;
             const slot = Number(/^vaga-(\d+)\.lock$/.exec(nome)[1]);
             let dono = {};
@@ -272,9 +355,31 @@ function ocupantesDaFilaPesada(raiz) {
                 dono = JSON.parse(fs.readFileSync(path.join(dir, nome), 'utf8'));
             }
             catch { /* dono ainda gravando */ }
+            let batidaExpiraEm = null;
+            if (typeof dono.posse === 'string') {
+                try {
+                    const batida = JSON.parse(fs.readFileSync(arquivoDaBatida(dir, slot, dono.posse), 'utf8'));
+                    if (batida.posse === dono.posse && typeof batida.expiraEm === 'string')
+                        batidaExpiraEm = batida.expiraEm;
+                }
+                catch { /* batida ausente, vencida ou ainda sendo publicada */ }
+            }
+            const local = identidadeDaMaquina();
+            const mesmoHost = typeof dono.host === 'string' && local.host === dono.host;
+            const mesmoEspacoPids = typeof dono.espacoPids === 'string' && local.espacoPids === dono.espacoPids;
+            let processo = 'desconhecido';
+            if (mesmoHost && mesmoEspacoPids && typeof dono.pid === 'number' && typeof dono.inicio === 'string') {
+                const atual = inicioDoProcesso(dono.pid);
+                processo = atual === dono.inicio ? 'vivo' : atual === null ? 'ausente' : 'ausente';
+            }
+            const estado = avaliarVidaDoOcupante({ trava: trava === 'ocupada' ? 'ocupada' : 'desconhecida',
+                batidaValida: batidaExpiraEm !== null && Date.parse(batidaExpiraEm) > Date.now(), mesmoHost, mesmoEspacoPids, processo });
             ocupantes.push({ slot, operacao: typeof dono.operacao === 'string' ? dono.operacao : 'desconhecida',
                 thread: typeof dono.thread === 'string' ? dono.thread : null, artefato: typeof dono.artefato === 'string' ? dono.artefato : '',
-                pid: typeof dono.pid === 'number' ? dono.pid : 0, desde: typeof dono.desde === 'string' ? dono.desde : '' });
+                pid: typeof dono.pid === 'number' ? dono.pid : 0, desde: typeof dono.desde === 'string' ? dono.desde : '',
+                inicio: typeof dono.inicio === 'string' ? dono.inicio : null, host: typeof dono.host === 'string' ? dono.host : null,
+                espacoPids: typeof dono.espacoPids === 'string' ? dono.espacoPids : null,
+                posse: typeof dono.posse === 'string' ? dono.posse : undefined, batidaExpiraEm, ...estado });
         }
         finally {
             fs.closeSync(fd);
@@ -283,19 +388,24 @@ function ocupantesDaFilaPesada(raiz) {
     return ocupantes;
 }
 function recusaDaFila(pedido, esperouMs, ocupantes) {
+    const indeterminado = ocupantes.some(o => o.vida === 'desconhecido');
+    const motivo = indeterminado ? 'concurrency.lease-indeterminado' : 'fila-pesada.ocupada';
     const espera = esperouMs < 60000 ? `${Math.round(esperouMs / 1000)} s` : `${Math.round(esperouMs / 60000)} min`;
     const linhas = [
         `Operação pesada não executada: ${pedido.operacao}${pedido.thread ? ` da thread ${pedido.thread}` : ''} esperou ${espera} ` +
             `e a fila de recursos pesados não liberou a vez (até ${pedido.slots} ao mesmo tempo, concurrency.max_parallel_heavy). ` +
             'Verify e build juntos nesta máquina dão regressão falsa.',
         ...(ocupantes.length ? ocupantes.map(o => `  Quem ocupa: ${o.operacao}${o.thread ? ` da thread ${o.thread}` : ''}, ` +
-            `desde ${(0, horario_1.formatarDesde)(o.desde)}, processo ${o.pid}.`) : ['  Quem ocupa: a vez é de outro pedido que chegou antes e ainda espera.']),
+            `desde ${(0, horario_1.formatarDesde)(o.desde)}, processo ${o.pid}${o.vida === 'desconhecido' ? '; vida indeterminada' : ''}.`) :
+            ['  Quem ocupa: a vez é de outro pedido que chegou antes e ainda espera.']),
+        ...(indeterminado ? ['A vida do lease não pôde ser comprovada deste ambiente; “não sei” nunca é órfão. ' +
+                'Espere com --esperar ou devolva à condução com concurrency.lease-indeterminado.'] : []),
         'O que você pode fazer:',
         '  1. Esperar a vez: o dono da vaga segue rodando e, quando ele termina ou morre, a vaga volta sozinha.',
         ...(pedido.comandoDeEsperar ? [`     ${pedido.comandoDeEsperar}`] : []),
         '  2. Desligar a fila só nesta máquina, se ela aguenta: concurrency.max_parallel_heavy no orkastery.yaml (0 desliga).',
     ];
-    return { contrato: 'ork.fila-pesada-recusa/v1', motivo: 'fila-pesada.ocupada', operacao: pedido.operacao, thread: pedido.thread,
+    return { contrato: 'ork.fila-pesada-recusa/v1', motivo, operacao: pedido.operacao, thread: pedido.thread,
         slots: pedido.slots, esperouMs, ocupantes, texto: linhas.join('\n') };
 }
 const pausa = new Int32Array(new SharedArrayBuffer(4));

package/dist/hitl-classificacao.js

@@ -71,6 +71,7 @@ exports.MOTIVOS_DO_ORQUESTRADOR = Object.freeze([
     'verify.failed', 'verify.regression', 'verify.timeout', 'verify.sem-veredito',
     'claims.failed', 'claims.unverifiable', 'ci.failed', 'hitl.formato',
     'lease.busy', 'vaga.stale', 'conducao.em-andamento', 'concurrency.limite',
+    'concurrency.lease-indeterminado', 'conducao.acao-necessaria',
 ]);
 function quemDecide(motivo) {
     return exports.MOTIVOS_DO_ORQUESTRADOR.includes(String(motivo ?? '')) ? 'orquestrador' : 'dono';