@orkastery/cli 0.5.3 → 0.6.0

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
@@ -63,10 +66,12 @@ function exigirSessaoDespachada(sessao, sessionId) {
     }
     return sessao;
 }
-function resolverSessao(raiz, sessionId) {
+function resolverSessao(raiz, sessionId, threadId) {
     if (!/^[a-zA-Z0-9][a-zA-Z0-9_-]{0,127}$/.test(sessionId))
         throw new Error('sessionId inválido');
-    const achadas = (0, thread_1.listarIds)(raiz).flatMap(id => {
+    // Um watcher já vinculado não depende da leitura de threads alheias a cada poll.
+    // O vínculo explícito continua exigindo uma única sessão e o estado canônico.
+    const achadas = (threadId === undefined ? (0, thread_1.listarIds)(raiz) : [threadId]).flatMap(id => {
         const thread = (0, thread_1.lerThread)(raiz, id);
         return thread.sessoes.filter(s => s.sessionId === sessionId).map(sessao => ({ thread, sessao }));
     });
@@ -75,8 +80,10 @@ function resolverSessao(raiz, sessionId) {
     const achada = achadas[0];
     if (achada.thread.worktree) {
         const estado = (0, estado_thread_1.auditarEstado)(raiz, achada.thread.id, achada.thread.worktree);
+        // comEstadoParaGit materializa o estado local durante commit/rebase. Não leia essa
+        // cópia: o watcher pode repetir a auditoria, com seu orçamento finito de falhas.
         if (estado.nivel !== 'ok')
-            throw new Error(estado.detalhe);
+            throw Object.assign(new Error(estado.detalhe), { code: 'SESSION_STATE_SPLIT' });
     }
     return achada;
 }
@@ -86,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 ||
@@ -101,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');
@@ -179,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;
@@ -75,9 +77,21 @@ const session_events_1 = require("./session-events");
 const ledger_1 = require("./ledger");
 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;
@@ -128,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
@@ -200,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) {
@@ -247,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:
@@ -270,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;
@@ -336,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);
@@ -355,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');
@@ -393,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
@@ -471,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'));
     }
@@ -546,6 +594,9 @@ function provaDoOrk(raiz, threadId, sessao, eventos, fonte) {
         const cwd = fonte?.cwd, headNoDespacho = fonte?.head;
         if (!cwd || typeof headNoDespacho !== 'string')
             return falta('HEAD da worktree no despacho não registrado; commit não conferível', { commits: [], recusados: registrados });
+        // RM-047 (P2): o git da prova só roda na worktree registrada; o cwd vem do ledger.
+        if ((0, procedencia_1.cwdLocalOuNulo)(raiz, threadId, cwd, 'ledger') === null)
+            return falta('cwd do despacho fora das worktrees registradas no git; commit não conferível', { commits: [], recusados: registrados });
         const commits = registrados.filter(sha => commitConferido(cwd, sha, headNoDespacho));
         const recusados = registrados.filter(sha => !commits.includes(sha));
         if (!commits.length)
@@ -622,7 +673,9 @@ function garantirFonteClaude(raiz, thread, sessao) {
         if (atual)
             return atual;
         const despacho = eventos.filter(e => e.tipo === 'phase_dispatch' && e.sessionId === sessao.sessionId).at(-1);
-        const cwd = typeof despacho?.cwd === 'string' ? despacho.cwd : thread.worktree ?? raiz;
+        // RM-047 (P2): o cwd do ledger ou do thread.json so vale como worktree registrada no git.
+        const cwd = typeof despacho?.cwd === 'string' ? (0, procedencia_1.exigirCwdLocal)(raiz, thread.id, despacho.cwd, 'ledger')
+            : (0, procedencia_1.diretorioDaThread)(raiz, thread);
         const fonte = { nativo: 'claude-agents', cwd, origem: 'sessions.watch' };
         validarFonteClaude(eventos, sessao.sessionId, fonte);
         if (!(0, ledger_1.registrarSeExiste)(dir, thread.id, 'session_sensor_registered', { fase: sessao.fase, sessionId: sessao.sessionId,
@@ -692,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, () => {