@orkastery/cli 0.5.3 → 0.6.0

package/dist/steal.js

@@ -0,0 +1,77 @@
+"use strict";
+/**
+ * RM-037 (fatia 6): o steal da CPU durante o `ork verify`, medido em `/proc/stat`.
+ *
+ * Em 23 e 24/09/2026 a VPS perdeu de 67% a 92% da CPU para o hipervisor (sar), e a mesma suite que
+ * leva 3,4 min com CPU livre levou de 24 a 30 min. Teste que mede relogio reprova nessa hora sem que
+ * o codigo tenha mudado. O verify passa a medir o steal na janela de cada comando e da rodada e a
+ * gravar a medida no `verify_run`; a reprovacao de teste com relogio sob steal acima de 40% vira
+ * `verify.timeout` (o retry reexecuta), nunca regressao.
+ *
+ * A linha agregada `cpu` do `/proc/stat` traz, em jiffies desde o boot: user, nice, system, idle,
+ * iowait, irq, softirq, steal, guest e guest_nice. guest e guest_nice ja estao contados em user e
+ * nice, entao o total da janela soma so os oito primeiros.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lerProcStat = exports.FONTE_STEAL = exports.LIMIAR_STEAL_PCT = void 0;
+exports.amostraDoProcStat = amostraDoProcStat;
+exports.stealDaJanela = stealDaJanela;
+exports.abrirJanela = abrirJanela;
+exports.reprovacaoSoDeRelogio = reprovacaoSoDeRelogio;
+exports.stealAlto = stealAlto;
+const node_fs_1 = require("node:fs");
+/** Limiar da recomendada da RM-037: acima dele, o relogio do teste nao julga o codigo. */
+exports.LIMIAR_STEAL_PCT = 40;
+exports.FONTE_STEAL = '/proc/stat';
+const lerProcStat = () => {
+    try {
+        return (0, node_fs_1.readFileSync)(exports.FONTE_STEAL, 'utf8');
+    }
+    catch {
+        return null;
+    }
+};
+exports.lerProcStat = lerProcStat;
+/** A linha `cpu ` (agregada) do `/proc/stat`. Kernel antigo, sem a coluna de steal, nao tem medida. */
+function amostraDoProcStat(conteudo) {
+    if (!conteudo)
+        return null;
+    const linha = conteudo.split('\n').find((l) => /^cpu\s/.test(l));
+    if (!linha)
+        return null;
+    const campos = linha.trim().split(/\s+/).slice(1).map(Number);
+    if (campos.length < 8 || campos.slice(0, 8).some((n) => !Number.isFinite(n) || n < 0))
+        return null;
+    const total = campos.slice(0, 8).reduce((s, n) => s + n, 0);
+    return { steal: campos[7], total };
+}
+/** Steal da janela entre duas amostras, em porcentagem com uma casa. Janela vazia nao tem medida. */
+function stealDaJanela(inicio, fim) {
+    if (!inicio || !fim)
+        return null;
+    const total = fim.total - inicio.total;
+    const steal = fim.steal - inicio.steal;
+    if (total <= 0 || steal < 0)
+        return null;
+    return Math.round((steal / total) * 1000) / 10;
+}
+/** Abre a janela agora; `fechar()` devolve o steal dela (ou `null` sem medida). */
+function abrirJanela(leitor = exports.lerProcStat) {
+    const inicio = amostraDoProcStat(leitor());
+    return { fechar: () => stealDaJanela(inicio, amostraDoProcStat(leitor())) };
+}
+/**
+ * A reprovacao do comando e so de teste com relogio? Todo teste que caiu precisa ser de relogio:
+ * pela assinatura de prazo do runner (estouro do teste ou cancelado pelo pai que estourou) ou pelo
+ * registro de instabilidade. Comando sem teste nomeado (build, tsc, script) nunca entra.
+ */
+function reprovacaoSoDeRelogio(falhas, registro = new Set()) {
+    if (!falhas || falhas.length === 0)
+        return null;
+    const todas = falhas.every((f) => f.relogio || registro.has(f.nome));
+    return todas ? falhas.map((f) => f.nome) : null;
+}
+/** Steal acima do limiar? A medida ausente nunca atenua nada. */
+function stealAlto(pct) {
+    return typeof pct === 'number' && pct > exports.LIMIAR_STEAL_PCT;
+}

package/dist/superficie.js

@@ -90,6 +90,7 @@ exports.blocoDoFormato = blocoDoFormato;
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const util_1 = require("./util");
+const locale_1 = require("./locale");
 /** Ordem canonica das regras novas, usada no catalogo e nas saidas. */
 exports.REGRAS_DE_SUPERFICIE = ['SP8', 'SP9', 'SP10', 'SP11', 'SP12'];
 /** O que cada nivel de confianca significa, dito por extenso em toda saida. */
@@ -1286,8 +1287,9 @@ function entradaBrutaDaSuperficie(a) {
 }
 /** Tabela dos achados da varredura. */
 function tabelaDaVarredura(r) {
+    const m = (0, locale_1.msg)().audit.superficie;
     if (r.achados.length === 0) {
-        return `Nenhum achado de superficie de ataque. ${r.detalhe}`;
+        return m.vazia(r.detalhe);
     }
     const linhas = r.achados.map((a) => [
         a.regra,
@@ -1298,30 +1300,31 @@ function tabelaDaVarredura(r) {
         `${a.arquivo}:${a.linha}`,
         a.titulo,
     ]);
-    return (0, util_1.tabela)(['REGRA', 'SEVERIDADE', 'CONFIANCA', 'FRAMEWORK', 'ROTA', 'EVIDENCIA', 'TITULO'], linhas);
+    return (0, util_1.tabela)([...m.cabecalho], linhas);
 }
 /** Texto completo de `ork audit surface`. */
 function textoDaVarredura(r) {
+    const m = (0, locale_1.msg)().audit.superficie;
     const L = [];
-    L.push('Varredura deterministica da superficie de ataque de rede (pack security-privacy, SP8..SP12)');
+    L.push(m.titulo);
     L.push('');
-    L.push(`  raiz          ${r.raiz}`);
-    L.push(`  escopo        ${r.detalhe}`);
-    L.push(`  frameworks    ${r.frameworks.length > 0 ? r.frameworks.join(', ') : '(nenhum reconhecido)'}`);
-    L.push(`  teto          ${r.limitePorRegra} achado(s) por regra`);
+    L.push(m.campo(m.campos.raiz, r.raiz));
+    L.push(m.campo(m.campos.escopo, r.detalhe));
+    L.push(m.campo(m.campos.frameworks, r.frameworks.length > 0 ? r.frameworks.join(', ') : m.nenhumFramework));
+    L.push(m.campo(m.campos.teto, m.teto(r.limitePorRegra)));
     L.push('');
     L.push(tabelaDaVarredura(r));
     L.push('');
     for (const t of r.truncados) {
-        L.push(`  ATENCAO: ${t.ocultos} achado(s) de ${t.regra} ficaram fora do teto desta varredura.`);
+        L.push(m.truncado(t.ocultos, t.regra));
     }
     const baixas = r.achados.filter((a) => a.confianca === 'baixa').length;
     if (baixas > 0) {
-        L.push(`  ${baixas} achado(s) sairam com confianca baixa: ${exports.DESCRICAO_DA_CONFIANCA.baixa}`);
+        L.push(m.baixa(baixas, exports.DESCRICAO_DA_CONFIANCA.baixa));
     }
     L.push('');
-    L.push('Cada achado carrega o comando que o reexecuta no HEAD real (o auditor nao tem self-report).');
-    L.push('Para registrar no board de divida de uma rodada: ork audit surface --registrar <rodada>');
+    L.push(m.claims);
+    L.push(m.registrar);
     return L.join('\n');
 }
 /** O bloco que a rodada deixa no `FORMATO.md` para o auditor nao repetir o que ja foi achado. */

package/dist/thread-close.js

@@ -48,19 +48,20 @@ const estado_thread_1 = require("./estado-thread");
 const util_1 = require("./util");
 const fabrica_publicar_1 = require("./fabrica-publicar");
 const fechamento_1 = require("./fechamento");
+const locale_1 = require("./locale");
 function validarArtefato(raiz, arquivo, sha256) {
     if (!/^[a-f0-9]{64}$/.test(sha256))
-        throw new Error('sha256 inválido');
+        throw new locale_1.ErroDoCatalogo((m) => m.thread.sha256Invalido);
     const root = fs.realpathSync((0, estado_thread_1.raizDoEstado)(raiz));
     const destino = fs.realpathSync(path.resolve(root, arquivo));
     const relativo = path.relative(root, destino);
     if (!relativo || relativo === '..' || relativo.startsWith(`..${path.sep}`) || path.isAbsolute(relativo)) {
-        throw new Error('artefato deve estar dentro do projeto');
+        throw new locale_1.ErroDoCatalogo((m) => m.thread.artefatoForaDoProjeto);
     }
     if (!fs.statSync(destino).isFile())
-        throw new Error('artefato deve ser arquivo regular');
+        throw new locale_1.ErroDoCatalogo((m) => m.thread.artefatoNaoRegular);
     if ((0, node_crypto_1.createHash)('sha256').update(fs.readFileSync(destino)).digest('hex') !== sha256) {
-        throw new Error('hash do artefato diverge');
+        throw new locale_1.ErroDoCatalogo((m) => m.thread.artefatoDiverge);
     }
     return { tipo: 'artefato', arquivo: relativo, sha256 };
 }
@@ -80,33 +81,33 @@ function provaDeEntrega(raiz, id) {
 function exigirEntrega(raiz, id) {
     const t = (0, thread_1.lerThread)(raiz, id);
     if (t.fechamentoAdmin)
-        throw new Error('thread encerrada administrativamente não pode receber MASTER');
+        throw new locale_1.ErroDoCatalogo((m) => m.master.encerradaAdmin);
     const prova = provaDeEntrega(raiz, id);
     if (!prova)
-        throw new Error('MASTER exige entrega: ship_done ou artefato existente com hash verificado');
+        throw new locale_1.ErroDoCatalogo((m) => m.master.exigeEntrega);
     return prova;
 }
 function registrarArtefato(raiz, id, arquivo, sha256, por) {
     const t = (0, thread_1.lerThread)(raiz, id);
     if (t.status === 'fechada' || !por.trim())
-        throw new Error('artefato exige thread aberta e autoria explícita');
+        throw new locale_1.ErroDoCatalogo((m) => m.thread.artefatoExige);
     const prova = validarArtefato(raiz, arquivo, sha256);
     (0, ledger_1.registrar)((0, thread_1.dirThread)(raiz, id), id, ledger_1.TIPOS_DE_EVENTO.artefatoEntregue, { arquivo, sha256, fase: 'SHIP', por: por.trim() });
     return prova;
 }
 function fecharAdministrativamente(raiz, id, opcoes) {
     if (!['orfa', 'engano', 'superada'].includes(opcoes.motivo))
-        throw new Error('motivo deve ser orfa, engano ou superada');
+        throw new locale_1.ErroDoCatalogo((m) => m.thread.motivoDoFechamento);
     if (!opcoes.por.trim() || opcoes.justificativa.trim().length < 3)
-        throw new Error('fechamento exige autoria e justificativa');
+        throw new locale_1.ErroDoCatalogo((m) => m.thread.fechamentoExige);
     const t = (0, thread_1.lerThread)(raiz, id);
     if (t.fechamentoAdmin) {
         if (t.fechamentoAdmin.motivo !== opcoes.motivo)
-            throw new Error('thread já encerrada por outro motivo');
+            throw new locale_1.ErroDoCatalogo((m) => m.thread.encerradaPorOutroMotivo);
         return t;
     }
     if (provaDeEntrega(raiz, id) || t.score)
-        throw new Error('thread entregue ou pontuada exige MASTER, não fechamento administrativo');
+        throw new locale_1.ErroDoCatalogo((m) => m.thread.entregueExigeMaster);
     t.fechamentoAdmin = { motivo: opcoes.motivo, por: opcoes.por.trim(), justificativa: opcoes.justificativa.trim(), fechadoEm: (0, util_1.agora)() };
     (0, ledger_1.registrar)((0, thread_1.dirThread)(raiz, id), id, ledger_1.TIPOS_DE_EVENTO.threadFechadaAdmin, t.fechamentoAdmin);
     t.status = 'fechada';