@orkastery/cli 0.5.6 → 0.6.1

package/dist/security-scan/trabalhador.js

@@ -0,0 +1,74 @@
+"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.comCacheNoHost = comCacheNoHost;
+/**
+ * RM-072 (D9 da ork-check5x): o trabalhador da varredura do Agile Check. Recebe o arquivo com uma ferramenta, as
+ * unidades dela, a config da rodada e o contexto (arvores do HEAD e da base, shas, prazo), roda o mesmo `scanTool` do
+ * Classic com um guarda de rodada proprio (containers e saidas brutas dele) e imprime o resultado em JSON. Quem chama e o
+ * `runScanAgil`, um trabalhador por ferramenta, ao mesmo tempo.
+ */
+const fs = __importStar(require("node:fs"));
+const executor_1 = require("./executor");
+const guard_1 = require("./guard");
+const run_1 = require("./run");
+/**
+ * S6 do CHECK: o binario nativo usa o cache por usuario que o Docker monta (o caminho do host no lugar do caminho do
+ * container), e nao o `/tmp` compartilhado do catalogo, onde outro usuario da maquina deixaria um banco do Trivy.
+ */
+function comCacheNoHost(t) {
+    if (!t.cacheMounts?.length)
+        return t;
+    let args = t.args;
+    for (const m of t.cacheMounts)
+        args = args.map((a) => a.split(m.container).join(m.host));
+    return { ...t, args };
+}
+if (require.main === module) {
+    const trabalho = JSON.parse(fs.readFileSync(process.argv[2], 'utf8'));
+    const guard = new guard_1.RoundGuard(trabalho.ctx.mainRoot);
+    try {
+        const { deadline, ...resto } = trabalho.ctx;
+        // RM-072 (D12): com o binario nativo na versao do catalogo, o Agile o usa antes do Docker (o probe sem Docker faz o
+        // chooseExecutor escolher o nativo); sem ele, o Docker, como no Classic.
+        const sonda = (0, executor_1.defaultProbe)();
+        const probe = trabalho.nativoPrimeiro ? { ...sonda, dockerCli: () => false, dockerDaemon: () => false } : sonda;
+        const r = (0, run_1.scanTool)(trabalho.nativoPrimeiro ? comCacheNoHost(trabalho.tool) : trabalho.tool, trabalho.units, trabalho.config, { ...resto, deadline: deadline ?? Infinity, probe, guard, images: new Map() });
+        process.stdout.write(JSON.stringify(r));
+    }
+    finally {
+        guard.close();
+    }
+}

package/dist/security-scan/types.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LOOP_CATEGORIES = exports.LOOP_CATEGORIES_HIGH = exports.LOOP_CATEGORIES_ANY = void 0;
+exports.isLoop = isLoop;
+/** Categories where any new finding enters the loop. */
+exports.LOOP_CATEGORIES_ANY = ['secret'];
+/** Categories where a new finding enters the loop at high or critical. */
+exports.LOOP_CATEGORIES_HIGH = ['dependency', 'sast', 'iac', 'workflow'];
+/** Every loop category: the categories whose tool, unavailable or failed, leaves the loop unscanned. */
+exports.LOOP_CATEGORIES = [...exports.LOOP_CATEGORIES_ANY, ...exports.LOOP_CATEGORIES_HIGH];
+function isLoop(category, severity) {
+    if (exports.LOOP_CATEGORIES_ANY.includes(category))
+        return true;
+    return exports.LOOP_CATEGORIES_HIGH.includes(category) && (severity === 'high' || severity === 'critical');
+}

package/dist/session-events.js

@@ -49,6 +49,9 @@ const ledger_1 = require("./ledger");
 exports.LIMITE_EVENTO_BYTES = 16384;
 exports.TIPOS_SENSOR = ['permission_prompt', 'permission_request', 'notification',
     'stop', 'subagent_stop', 'commit', 'heartbeat', 'resumed'];
+/** As contagens de trabalho pendente que o Stop aceita, cada uma um inteiro de 0 a `LIMITE_CONTAGEM_DO_STOP`. */
+const CONTAGENS_DO_STOP = ['backgroundTasks', 'sessionCrons'];
+const LIMITE_CONTAGEM_DO_STOP = 10000;
 /**
  * A adoção governa a identidade de uma sessão que já estava rodando e, por decisão da
  * higiene de runtimes, não inventa data de despacho nem prompt executado. O sensor ancora
@@ -90,11 +93,16 @@ function validarPayload(bruto, tipo, agoraMs) {
     const p = JSON.parse(bruto.trim() || '{}');
     if (!p || typeof p !== 'object' || Array.isArray(p))
         throw new Error('payload deve ser objeto JSON');
-    const campos = ['observedAt', 'eventId', 'notificationType', 'commit'];
+    const campos = ['observedAt', 'eventId', 'notificationType', 'commit', 'accountFailure'];
     for (const [k, v] of Object.entries(p)) {
-        if (!campos.includes(k) || typeof v !== 'string')
+        const valido = CONTAGENS_DO_STOP.includes(k)
+            ? Number.isSafeInteger(v) && v >= 0 && v <= LIMITE_CONTAGEM_DO_STOP
+            : campos.includes(k) && typeof v === 'string';
+        if (!valido)
             throw new Error(`campo de payload inválido: ${k}`);
     }
+    if (tipo !== 'stop' && CONTAGENS_DO_STOP.some((k) => k in p))
+        throw new Error('contagem de trabalho pendente só vale no stop');
     const payload = p;
     if (payload.observedAt !== undefined && (!/^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d\.\d{3}Z$/.test(payload.observedAt) ||
         !Number.isFinite(Date.parse(payload.observedAt)) || new Date(payload.observedAt).toISOString() !== payload.observedAt ||
@@ -105,6 +113,10 @@ function validarPayload(bruto, tipo, agoraMs) {
     if (payload.notificationType !== undefined && !['permission_prompt', 'idle_prompt', 'auth_success', 'elicitation_dialog'].includes(payload.notificationType)) {
         throw new Error('notificationType inválido');
     }
+    if (payload.accountFailure !== undefined &&
+        (payload.accountFailure !== 'runtime.quota-exhausted' || !['notification', 'stop'].includes(tipo))) {
+        throw new Error('accountFailure inválido');
+    }
     if ((tipo === 'commit' && !payload.commit) || (payload.commit !== undefined &&
         (tipo !== 'commit' || !/^(?:[a-f0-9]{40}|[a-f0-9]{64})$/.test(payload.commit))))
         throw new Error('commit exige SHA completo');
@@ -183,6 +195,11 @@ function ingerirEvento(raiz, sessionId, tipoBruto, bruto = '{}', agoraMs = Date.
             // I-34: a notificação de ociosidade depois do Stop não é atividade; sem o tipo gravado,
             // o observador claude-bg não teria como distingui-la e trataria o Stop como superado.
             ...(tipo === 'notification' && payload.notificationType ? { notificationType: payload.notificationType } : {}),
+            // RM-037 (CHECK 3 da ork-rm037defeit2): sem as contagens gravadas, o observador não toma a ociosidade por fim do turno.
+            ...(payload.backgroundTasks !== undefined ? { backgroundTasks: payload.backgroundTasks } : {}),
+            ...(payload.sessionCrons !== undefined ? { sessionCrons: payload.sessionCrons } : {}),
+            ...(payload.accountFailure ? { motivo: payload.accountFailure,
+                falhaDeConta: { motivo: payload.accountFailure, resetEm: null, fonte: 'hook', trecho: 'sinal tipado do hook' } } : {}),
             ...(bloqueio ? { tipoDeHitl: 'permissao', pergunta: null, estadoRuntime: 'blocked' } : {}) };
         if (retomada && ultimo?.tipo === 'sessao_bloqueada' && Date.parse(observedAt) > Date.parse(ultimo.ts)) {
             (0, ledger_1.registrar)(dir, thread.id, 'sessao_destravada', { ...dados, sensorEventId: eventId + ':resume' });

package/dist/session-watcher-claude.js

@@ -33,11 +33,13 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.THREAD_REMOVIDA = exports.ARTEFATO_DA_FASE = exports.INTERVALO_WATCH_CLAUDE_MS = void 0;
+exports.THREAD_REMOVIDA = exports.ARTEFATO_DA_FASE = exports.OCIOSA_DEPOIS_DO_STOP_MS = exports.INTERVALO_WATCH_CLAUDE_MS = void 0;
 exports.normalizarNativo = normalizarNativo;
 exports.stopCorrelacionado = stopCorrelacionado;
+exports.trabalhoPendenteDoStop = trabalhoPendenteDoStop;
 exports.bloqueioPendente = bloqueioPendente;
 exports.classificarSessaoClaude = classificarSessaoClaude;
+exports.arquivoDaTranscricao = arquivoDaTranscricao;
 exports.ultimoErroDeApi = ultimoErroDeApi;
 exports.falhaDeContaDaTranscricao = falhaDeContaDaTranscricao;
 exports.comFalhaDeConta = comFalhaDeConta;
@@ -77,8 +79,19 @@ const thread_1 = require("./thread");
 const util_1 = require("./util");
 const procedencia_1 = require("./procedencia");
 const hitl_1 = require("./hitl");
+const conta_esgotada_1 = require("./conta-esgotada");
 /** Uma consulta nativa custa cerca de 0,3 s; cinco segundos mantém o custo abaixo de 10%. */
 exports.INTERVALO_WATCH_CLAUDE_MS = 5000;
+/**
+ * RM-037 (defeitos de 19 e 20/10/2026, defeito 4): quanto a sessão fica ociosa no prompt (`working` com `status: idle`)
+ * depois do Stop correlacionado até o observador tomar o turno por encerrado. O Claude Code mantém `working` a sessão cuja
+ * resposta final ele lê como "ainda há passo" e só a encerra (`done`) depois de 60 min ociosa (`bg retire <id>:
+ * idle-prompt, idle 60m` no log do daemon, medido em 20/10/2026), e nesse tempo a sessão segurava a condução. O `status`
+ * ocioso não basta (CHECK 3 da ork-rm037defeit2, medido no Claude Code 2.1.304): com só um despertar agendado a sessão
+ * aparece `idle` e volta a escrever quando ele dispara. Só conta a ociosidade depois do Stop que disse zero tarefa em
+ * segundo plano e zero despertar (`trabalhoPendenteDoStop`).
+ */
+exports.OCIOSA_DEPOIS_DO_STOP_MS = 5 * 60 * 1000;
 const LIMITE_EVIDENCIA_BYTES = 4096;
 /** D15 (5): teto dos textos nativos (`state`, `status`, `id`, `kind`) e do erro do diagnóstico. */
 const LIMITE_TEXTO_NATIVO = 64;
@@ -129,6 +142,22 @@ function stopCorrelacionado(eventos, sessao) {
         return null;
     return correlacionados[ultimo];
 }
+/**
+ * RM-037 (CHECK 3 da ork-rm037defeit2): o trabalho que o Stop disse que ainda vai acordar a sessão, ou `null` quando ele
+ * gravou as duas contagens (`backgroundTasks` e `sessionCrons`, da entrada do hook) e as duas são zero. No Claude Code
+ * 2.1.304 o `status` fica `shell` com Bash em segundo plano e `idle` com despertar agendado (`CronCreate`,
+ * `ScheduleWakeup`, `/loop`) ou tarefa MCP. O Stop sem as contagens (hook ou runtime de antes) não prova que nada vai
+ * voltar: a sessão segue esperando, como antes desta regra, o `done` do runtime.
+ */
+function trabalhoPendenteDoStop(stop) {
+    const { backgroundTasks: tarefas, sessionCrons: despertares } = stop;
+    if (tarefas === 0 && despertares === 0)
+        return null;
+    if (typeof tarefas !== 'number' || typeof despertares !== 'number') {
+        return 'o Stop não disse se há tarefa em segundo plano ou despertar agendado (sem background_tasks e session_crons)';
+    }
+    return `o Stop registrou ${tarefas} tarefa(s) em segundo plano e ${despertares} despertar(es) agendado(s)`;
+}
 /**
  * O último entre bloqueio, destravamento e Stop da sessão, depois do despacho, é bloqueio?
  * O Stop resolve o bloqueio anterior: o turno só termina depois que o prompt de permissão
@@ -201,6 +230,8 @@ function classificarSessaoClaude(e) {
         delete cursor.mortoDesde;
     if (estado !== 'blocked')
         delete cursor.bloqueadoDesde;
+    if (estado !== 'working')
+        delete cursor.ociosaDesde;
     if (['done', 'failed', 'stopped', 'working', 'blocked'].includes(estado ?? ''))
         delete cursor.desconhecidoDesde;
     switch (estado) {
@@ -248,6 +279,27 @@ function classificarSessaoClaude(e) {
                 return esperaHumana();
             }
             delete cursor.bloqueadoDesde;
+            // RM-037 (defeito 4 de 19 e 20/10/2026): turno encerrado pelo Stop e a sessão ociosa no prompt (`status: idle`). O
+            // runtime só a encerra depois de 60 min; passado `OCIOSA_DEPOIS_DO_STOP_MS` sem atividade, vale a prova do `ork`, como
+            // no `done`, mas só depois do Stop que disse zero tarefa em segundo plano e zero despertar agendado (CHECK 3): o
+            // despertar deixa a sessão `idle` até disparar. O prazo conta da primeira leitura ociosa e nunca de antes do Stop: a
+            // sessão que voltou e parou de novo recomeça a contagem.
+            if (estado === 'working' && r.status === 'idle' && stop && !bloqueioPendente(e.eventos, e.sessao)) {
+                const pendente = trabalhoPendenteDoStop(stop);
+                if (pendente !== null) {
+                    delete cursor.ociosaDesde;
+                    return espera(`turno encerrado pelo Stop com a sessão ociosa no prompt (working/idle), mas ${pendente}; ` +
+                        'a ociosidade não encerra o turno');
+                }
+                cursor.ociosaDesde ??= agora;
+                const desde = Math.max(cursor.ociosaDesde, Date.parse(stop.ts) || 0);
+                if (agora - desde < exports.OCIOSA_DEPOIS_DO_STOP_MS) {
+                    return espera('turno encerrado pelo Stop com a sessão ociosa no prompt (working/idle); aguardando o prazo da ociosidade');
+                }
+                return concluir(`Stop correlacionado e sessão ociosa no prompt (working/idle) por ${exports.OCIOSA_DEPOIS_DO_STOP_MS / 60000} min, ` +
+                    'sem tarefa em segundo plano nem despertar agendado no Stop', false);
+            }
+            delete cursor.ociosaDesde;
             return espera(estado === 'blocked' ? 'sessão bloqueada à espera humana' : 'sessão trabalhando');
         }
         default:
@@ -271,7 +323,10 @@ function textoDoErroDeApi(e) {
     return (0, hitl_1.redigirSegredos)([codigo, textos.filter(Boolean).join(' ')].filter(Boolean).join(': ')).slice(0, 4096);
 }
 const UUID = /^[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$/i;
-/** A transcricao da sessao no diretorio do perfil (ou no implicito, sem perfil); `null` com sessao que nao e uuid. */
+/**
+ * A transcricao da sessao no diretorio do perfil (ou no implicito, sem perfil); `null` com sessao que nao e uuid.
+ * RM-059 (F9): o Mensageiro de Sessoes (`entrega-por-mod.ts`) acha nela o turno em que a sessao parou.
+ */
 function arquivoDaTranscricao(perfil, cwd, sessionId) {
     if (!UUID.test(sessionId))
         return null;
@@ -337,15 +392,6 @@ function falhaDeContaDaTranscricao(perfil, cwd, sessionId, agoraMs = Date.now())
 function falhaDoErro(erro, agoraMs) {
     return erro ? (0, claude_bg_1.parseFalhaDeConta)(erro.texto, erro.em ? Date.parse(erro.em) : agoraMs) : null;
 }
-/**
- * RM-037 (fatia 5): a cota vista com a sessao viva. Em 02/10/2026 as sessoes de uma conta pararam as 06:00Z no
- * limite de gasto ("your session limit resets 4:40am (<fuso>)"), sem Stop e com o processo vivo por mais uma
- * hora; o perfil so saiu do rodizio as 07:15Z, quando o processo morreu, e o redespacho das 06:14Z caiu na mesma
- * conta. Aqui, a cada volta com a transcricao maior que na anterior, o ultimo erro de API depois do despacho passa
- * pelo criterio unico da D16; esgotamento com prazo futuro marca o perfil ate a hora dita (ou a janela padrao
- * contada da mensagem) e grava `runtime_quota_detected` uma vez por erro. A fase nao fecha e a conducao nao muda:
- * a sessao continua viva, e o fecho segue o caminho de sempre, sem marcar de novo o mesmo erro.
- */
 function cotaAoVivo(ctx, perfil, cwd, cursor, erroDaTranscricao, gravar) {
     const { sessao, dir } = ctx;
     const arquivo = arquivoDaTranscricao(perfil, cwd, sessao.sessionId);
@@ -356,22 +402,22 @@ function cotaAoVivo(ctx, perfil, cwd, cursor, erroDaTranscricao, gravar) {
         tamanho = st?.isFile() ? st.size : NaN;
     }
     catch {
-        return;
+        return null;
     }
     if (!Number.isFinite(tamanho) || cursor.transcricaoBytes === tamanho)
-        return;
+        return null;
     cursor.transcricaoBytes = tamanho;
     const erro = erroDaTranscricao();
     const erroMs = erro?.em ? Date.parse(erro.em) : NaN;
     // Linha sem instante, ou de antes deste despacho (sessao retomada), nao prova que a cota e deste turno.
     if (!erro || !Number.isFinite(erroMs) || erroMs < Date.parse(sessao.despachadaEm))
-        return;
+        return null;
     const falha = falhaDoErro(erro, ctx.agoraMs);
     if (falha?.motivo !== 'runtime.quota-exhausted' || !ctx.carregado)
-        return;
+        return null;
     const esgotadoAte = (0, ratelimit_1.prazoDaCotaVista)(ctx.carregado.manifesto, falha, erroMs, ctx.agoraMs);
     if (!esgotadoAte)
-        return;
+        return null;
     // A chave do erro: o uuid da linha ou, sem ele, o instante e o trecho (dado de maquina, nunca texto).
     const sensorEventId = (0, node_crypto_1.createHash)('sha256')
         .update(JSON.stringify([sessao.sessionId, sessao.despachadaEm, erro.uuid ?? [erro.em, falha.trecho]])).digest('hex');
@@ -394,6 +440,7 @@ function cotaAoVivo(ctx, perfil, cwd, cursor, erroDaTranscricao, gravar) {
             esgotadoAte, trecho: falha.trecho.replace(/\p{Cc}/gu, ' '), perfil: perfil ? { id: perfil.id, runtime: perfil.runtime } : null,
             perfilMarcado: !!perfil, origem: 'sessions.watch' });
     });
+    return { falha, esgotadoAte, erroEm: erro.em };
 }
 /**
  * I-33 (D11): precedencia entre a prova da I-34 e a falha de conta. Com Stop correlacionado vale
@@ -472,11 +519,11 @@ function saidaDoArtefato(raiz, threadId, sessao, fonte, eventos) {
         : atual.mtimeMs !== null && atual.mtimeMs >= Date.parse(sessao.despachadaEm);
     return { arquivo, produzido, sha256: atual.sha256, sha256Base: base?.sha256 ?? null, texto: atual.texto };
 }
-/** Exatamente um veredito legível numa linha `Veredito: ...` (PASSOU, PRECISA DE MUDANCA ou BLOQUEADO). */
+/** Exatamente um veredito legível numa linha `Veredito: ...`, incluindo a reprovação curta do prompt de CHECK. */
 function vereditoDoParecer(texto) {
     const achados = new Set();
     for (const linha of texto.split('\n')) {
-        const m = /^[#>*_`\s-]*veredito[*_`\s]*:[*_`\s]*(passou|precisa de mudan[cç]a|bloqueado)(?![\p{L}\p{N}])/iu.exec(linha);
+        const m = /^[#>*_`\s-]*veredito[*_`\s]*:[*_`\s]*(passou|reprovou|precisa de mudan[cç]a|bloqueado)(?![\p{L}\p{N}])/iu.exec(linha);
         if (m)
             achados.add(m[1].toUpperCase().replace('Ç', 'C'));
     }
@@ -698,9 +745,17 @@ function observarClaudeSobLock(ctx) {
     }
     if (!c.terminal) {
         const lidos = cursor.transcricaoBytes;
-        cotaAoVivo(ctx, perfil, fonte.cwd, cursor, erroDaTranscricao, gravar);
+        const cota = cotaAoVivo(ctx, perfil, fonte.cwd, cursor, erroDaTranscricao, gravar);
         if (cursor.transcricaoBytes !== lidos)
             (0, codex_runner_1.gravarAtomico)(arquivoCursor, cursor);
+        if (cota && perfil && ctx.carregado) {
+            (0, conta_esgotada_1.reconciliarContaEsgotada)({ raiz, perfil, falha: cota.falha, esgotadoAte: cota.esgotadoAte,
+                erroEm: cota.erroEm, agoraMs: ctx.agoraMs });
+            const terminal = (0, ledger_1.lerLedger)(dir).find(e => e.tipo === 'phase_result' && e.sessionId === sessao.sessionId &&
+                e.motivo === 'runtime.quota-exhausted');
+            if (terminal)
+                return { ...base, concluido: true, classificacao: 'gate_blocked' };
+        }
     }
     if (!c.terminal && c.inconclusivo)
         return (0, session_events_1.comLockDeSessao)(dir, () => {