@orkastery/cli 0.5.1 → 0.5.3

package/dist/retry.js

@@ -97,6 +97,7 @@ const modos_1 = require("./modos");
 const thread_1 = require("./thread");
 const tokens_1 = require("./tokens");
 const util_1 = require("./util");
+const impedimento_1 = require("./impedimento");
 const worktree_1 = require("./worktree");
 const delegation_1 = require("./delegation");
 const gates_2 = require("./gates");
@@ -163,6 +164,14 @@ exports.POLITICA_DE_RETRY = {
         porque: 'repetir o despacho no MESMO runtime daria o mesmo resultado: o que falta nao e tentativa, e um validador que nao seja quem executou. Escolher o outro runtime e decisao de conducao, nao retry',
         correcao: 'despache o CHECK em outro runtime (`ork phase run <thread> CHECK --runtime <outro>`), ou tire a exigencia de validacao cruzada da thread se ela nao se justifica',
     },
+    // RM-056 (D1): o perfil pedido nao existe ou e de outro runtime. Quem corrige e quem pediu.
+    'runtime.profile-invalid': {
+        motivo: 'runtime.profile-invalid',
+        acao: 'escalar-humano',
+        automatica: false,
+        porque: 'o perfil foi pedido pelo dono (--perfil) e nao existe no store ou e de outro runtime: repetir o pedido daria a mesma recusa, e trocar de perfil sozinho desobedeceria o pedido',
+        correcao: 'ork accounts list mostra os perfis de cada runtime; repita o despacho com um perfil do runtime certo ou sem --perfil',
+    },
     'cost.violation': {
         motivo: 'cost.violation',
         acao: 'sem-retry',
@@ -251,6 +260,22 @@ exports.POLITICA_DE_RETRY = {
         porque: 'o modelo pedido nao existe ou a conta nao tem acesso a ele: o MESMO prompt, com o mesmo sha256, segue no proximo perfil do mesmo runtime com o mesmo modelo e depois no fallback do bloco, nunca de novo no par que ja recusou',
         correcao: 'ork retry run <thread> troca o destino; sem destino, ork setup <modo> --bloco N --model <modelo acessivel> ou --fallback runtime:modelo',
     },
+    // RM-055: so o dono destrava, no terminal. O retry nao repete o despacho as cegas: confere antes se o
+    // impedimento saiu (a confianca do diretorio tem prova local) e, sem prova, deixa o runtime decidir.
+    'runtime.workspace-untrusted': {
+        motivo: 'runtime.workspace-untrusted',
+        acao: 'reexecutar',
+        automatica: true,
+        porque: 'o runtime recusou o diretorio da worktree antes de rodar qualquer coisa: depois que o dono aceita a confianca no terminal, o MESMO prompt, com o mesmo sha256, volta a mesma fase; enquanto a confianca nao aparece no .claude.json da conta, nada e despachado',
+        correcao: 'o dono roda o comando da pausa (cd <worktree> && claude, aceita a confianca); ork retry run <thread> re-despacha o prompt ja gravado',
+    },
+    'runtime.consent-pending': {
+        motivo: 'runtime.consent-pending',
+        acao: 'reexecutar',
+        automatica: true,
+        porque: 'o runtime espera o dono aceitar termos novos antes de rodar qualquer coisa: depois do aceite, o MESMO prompt, com o mesmo sha256, volta a mesma fase; se o runtime recusar de novo, a mesma pausa do dono volta',
+        correcao: 'o dono abre o CLI do runtime e aceita os termos; ork retry run <thread> re-despacha o prompt ja gravado',
+    },
     'tree.blocked': {
         motivo: 'tree.blocked',
         acao: 'sincronizar-worktree',
@@ -258,6 +283,13 @@ exports.POLITICA_DE_RETRY = {
         porque: 'a arvore de destino andou por baixo da thread: rebasar a worktree contra a base e o passo que desbloqueia, e reexecutar antes disso so repete o conflito',
         correcao: 'ork worktree sync <thread> e so entao repetir o passo',
     },
+    'lease.resume-unavailable': {
+        motivo: 'lease.resume-unavailable',
+        acao: 'escalar-humano',
+        automatica: false,
+        porque: 'sem inode seguro, a remocao forcada exige avaliar a posse antes de retomar',
+        correcao: 'ork lease release <nome> --forcar; depois repita a aquisicao',
+    },
     'lease.busy': {
         motivo: 'lease.busy',
         acao: 'reexecutar',
@@ -677,8 +709,19 @@ tomadaPrevia) {
         if (!resultado.ok || !resultado.sessionId) {
             (0, ledger_1.registrar)((0, thread_1.dirThread)(raiz, thread.id), thread.id, 'phase_dispatch_failed', { fase, runtime, slug, cwd,
                 promptPath: absoluto, promptSha256: sha, controlador: resultado.controlador, model, effort,
-                erro: resultado.erro ?? 'runtime.unavailable: sem sessionId', origem: 'retry', ...(perfil ? { perfil } : {}) });
+                erro: resultado.erro ?? 'runtime.unavailable: sem sessionId', stderr: (resultado.stderr ?? '').slice(0, 500),
+                origem: 'retry', ...(perfil ? { perfil } : {}) });
             const sinal = resultado.rateLimit ?? null;
+            // RM-055: o redespacho recusado pelo que so o dono resolve reabre a pausa dele, com o mesmo comando.
+            const impedimento = !resultado.falhaDeConta && !sinal
+                ? (0, impedimento_1.registrarImpedimentoDoDono)((0, thread_1.dirThread)(raiz, thread.id), thread, { fase, slug, runtime, cwd, origem: 'retry',
+                    promptPath: absoluto, promptSha256: sha, perfil, saida: `${resultado.stderr ?? ''}\n${resultado.erro ?? ''}` })
+                : null;
+            if (impedimento) {
+                return { ok: false, slug, sessionId: null, verificada: false, motivo: impedimento.motivo,
+                    detalhe: `${impedimento.motivo}: ${impedimento.trecho}`, sinal: null, falhaDeConta: null, perfil: perfil ?? null,
+                    comando: resultado.comando, controlador: resultado.controlador, dryRun: false };
+            }
             // I-33 (D5): a conta recusou o redespacho; o perfil sai do rodizio aqui, onde a evidencia esta.
             if (resultado.falhaDeConta) {
                 try {
@@ -1121,6 +1164,17 @@ function jaMarcado(raiz, perfil, falha, agoraMs = Date.now()) {
         ? atual.estado === 'esgotado' && atual.esgotadoAte !== null && Date.parse(atual.esgotadoAte) > agoraMs
         : atual.estado === 'sem-auth';
 }
+/**
+ * RM-037 (fatia 5, aviso da rodada 1 do CHECK): a cota que o observador viu ao vivo (`runtime_quota_detected`, da mesma
+ * sessao e do mesmo despacho, com o mesmo prazo dito) ja tirou o perfil do rodizio ate a hora da mensagem. Marcar de
+ * novo aqui, depois dessa hora, pela janela padrao (A10), tiraria do rodizio uma conta que ja voltou.
+ */
+function cotaJaVistaAoVivo(eventos, gate, falha) {
+    if (falha.motivo !== 'runtime.quota-exhausted' || typeof gate?.sessionId !== 'string')
+        return false;
+    return eventos.some((e) => e.tipo === ledger_1.TIPOS_DE_EVENTO.cotaVistaNaTranscricao && e.sessionId === gate.sessionId &&
+        e.despachoEm === gate.despachoEm && (e.resetEm ?? null) === falha.resetEm);
+}
 function sinalDoGate(gate, motivo) {
     const f = gate?.falhaDeConta;
     return { motivo: motivo === 'runtime.auth-missing' ? 'runtime.auth-missing' : 'runtime.quota-exhausted',
@@ -1282,6 +1336,18 @@ function executarRetry(carregado, threadId, opcoes = {}) {
         registrarTentativa(false, detalhe);
         return { ...vazio, detalhe };
     }
+    // RM-055: o impedimento do dono com prova local (confianca do diretorio) so volta ao runtime depois de
+    // resolvido. Sem a prova, nada e despachado e a tentativa nao conta: a pausa do dono continua aberta.
+    if (plano.motivo && (0, impedimento_1.ehImpedimentoDoDono)(plano.motivo) && typeof falho.cwd === 'string') {
+        const perfilFalho = perfilDoEvento(falho);
+        const resolvido = (0, impedimento_1.impedimentoResolvido)(plano.motivo, { cwd: falho.cwd,
+            runtime: typeof falho.runtime === 'string' ? falho.runtime : '', configDir: perfilFalho?.configDir ?? null });
+        if (resolvido === false) {
+            const detalhe = `${plano.motivo}: o runtime ainda nao confia em ${falho.cwd}; nada foi despachado. ` +
+                `Rode \`cd ${falho.cwd} && claude\`, aceite a confianca e repita \`ork retry run ${threadId}\``;
+            return { ...vazio, detalhe };
+        }
+    }
     const redespacho = redespachar(carregado, thread, plano.fase, falho.promptPath, falho.promptSha256, {
         effort: plano.effort,
         runtime: typeof falho.runtime === 'string' ? falho.runtime : null,
@@ -1349,7 +1415,8 @@ function rotacionarConta(carregado, thread, plano, opcoes, vazio, registrarTenta
     const politica = (0, runtime_profiles_1.politicaDeRotacao)(manifesto);
     const falha = sinalDoGate(gate, motivo);
     // I-33 (D12): o observador ja marca o perfil no caminho terminal; remarcar empurraria o prazo a cada retry.
-    if (!opcoes.dryRun && perfil && !jaMarcado(raiz, perfil, falha)) {
+    // RM-037 (fatia 5, aviso da rodada 1 do CHECK): a cota que ele viu ao vivo ja marcou ate a hora da mensagem.
+    if (!opcoes.dryRun && perfil && !jaMarcado(raiz, perfil, falha) && !cotaJaVistaAoVivo(eventos, gate, falha)) {
         try {
             (0, ratelimit_1.marcarContaDaFalha)(carregado, perfil, falha);
         }

package/dist/roadmap-status.js

@@ -37,6 +37,7 @@ const horario_1 = require("./horario");
 const projeto_alvo_1 = require("./projeto-alvo");
 const fabrica_estado_1 = require("./fabrica-estado");
 const hitl_resumo_1 = require("./hitl-resumo");
+const hitl_tempo_parado_1 = require("./hitl-tempo-parado");
 const manifest_1 = require("./manifest");
 const maquina_1 = require("./maquina");
 const parado_no_condutor_1 = require("./parado-no-condutor");
@@ -129,8 +130,13 @@ function fatosLocais(raiz, quando, fuso) {
         if (entregas !== undefined)
             return entregas;
         try {
-            const retrato = (0, parado_no_condutor_1.lerRetratoDePrs)(raiz);
-            entregas = (0, parado_no_condutor_1.entregasDoProjeto)((0, manifest_1.exigirManifesto)(raiz), { quando, lerPrs: () => (retrato ? { ok: true, retrato } : null) });
+            const carregado = (0, manifest_1.exigirManifesto)(raiz);
+            // RM-037 (fatia 5, A5): a forja sem leitura que o pulse ja disse vale sobre o retrato, que e de antes dela (a
+            // leitura boa apaga a marca), e a linha nao diz "PR nao lido".
+            const aviso = (0, parado_no_condutor_1.forjaSemLeituraDoRemoto)(raiz, carregado.manifesto.fabrica.remoto);
+            const retrato = aviso ? null : (0, parado_no_condutor_1.lerRetratoDePrs)(raiz);
+            entregas = (0, parado_no_condutor_1.entregasDoProjeto)(carregado, { quando, lerPrs: () => (retrato ? { ok: true, retrato }
+                    : aviso ? { ok: false, lidoEm: aviso.ditoEm, erro: aviso.motivo, semLeitura: { remoto: aviso.remoto, host: aviso.host } } : null) });
         }
         catch {
             entregas = null;
@@ -221,8 +227,18 @@ function montarStatusDoRoadmap(raiz, opcoes = {}) {
     catch {
         fabrica = undefined;
     }
+    // RM-057 (fatia 3): leitura pura do ledger; sem ela o relatorio sai como antes.
+    let hitlDeConducao;
+    try {
+        const h = (0, hitl_tempo_parado_1.lerHitlDeConducaoAgora)(raiz, quando);
+        if (h.abertas.length || h.seteDias.pedidos || h.seteDias.respondidos)
+            hitlDeConducao = h;
+    }
+    catch {
+        hitlDeConducao = undefined;
+    }
     return montarStatusDeFatos((0, docs_1.carregarDocs)(raiz).docs, fatosLocais(raiz, quando), { quando, projeto: opcoes.projeto, consulta: opcoes.consulta,
-        ...(fabrica ? { fabrica } : {}) });
+        ...(fabrica ? { fabrica } : {}), ...(hitlDeConducao ? { hitlDeConducao } : {}) });
 }
 /** O relatorio a partir das paginas do roadmap e dos fatos das threads, de onde quer que venham. */
 function montarStatusDeFatos(docs, fatos, opcoes) {
@@ -271,6 +287,7 @@ function montarStatusDeFatos(docs, fatos, opcoes) {
         emSeguida: itens.filter(i => i.conduzindo && !i.hitl).map(i => ({ item: i.id, ...i.conduzindo })),
         ...(opcoes.consulta ? { consulta: opcoes.consulta } : {}),
         ...(opcoes.fabrica ? { fabrica: opcoes.fabrica } : {}),
+        ...(opcoes.hitlDeConducao ? { hitlDeConducao: opcoes.hitlDeConducao } : {}),
     };
 }
 /** "orkastery" vira "Orkastery": o titulo diz o nome do projeto como gente escreve. */
@@ -341,6 +358,9 @@ function textoDoStatusDoRoadmap(s, fuso, opcoes = {}) {
         ...(s.precisaDeVoce.length ? cortar(s.precisaDeVoce, x => `• ${x.item}${naMaquina(x.espera.maquina)}: ${x.espera.pergunta}` +
             (x.espera.codigo ? ` Responda ${x.espera.codigo} ${x.espera.recomendada ?? 'a'} (ou outra letra).` : ' A pergunta chega no próximo resumo.'))
             : ['• Nada agora.']),
+        // RM-057 (fatia 3): ha quanto tempo cada pergunta de conducao parou a thread, e a mediana da semana.
+        ...(s.hitlDeConducao ? [`• HITL de condução: ${s.hitlDeConducao.abertas.length} aberta(s); ${(0, hitl_tempo_parado_1.textoDaMediana)(s.hitlDeConducao)}.`,
+            ...cortar(s.hitlDeConducao.abertas, a => `  ${(0, hitl_tempo_parado_1.linhaDaPerguntaParada)(a, { agora: s.consultadoEm, fuso })}.`)] : []),
         '', 'O que eu faço em seguida',
         ...(s.emSeguida.length ? cortar(s.emSeguida, x => linhaDoQueVem(x, s.consultadoEm, fuso))
             : ['• Nada em andamento; sigo o que você priorizar.']),

package/dist/runtime-profiles.js

@@ -67,6 +67,7 @@ exports.perfisDoRuntime = perfisDoRuntime;
 exports.perfilDisponivel = perfilDisponivel;
 exports.politicaDeRotacao = politicaDeRotacao;
 exports.proximoPerfilDisponivel = proximoPerfilDisponivel;
+exports.proximoPerfilPorCarga = proximoPerfilPorCarga;
 exports.prazoDoRuntime = prazoDoRuntime;
 exports.prazoDaFila = prazoDaFila;
 exports.menorEsgotadoAte = menorEsgotadoAte;
@@ -794,7 +795,8 @@ exports.POLITICA_PADRAO = { mesmoRuntimePorCota: true, mesmoRuntimePorAuth: true
 function politicaDeRotacao(manifesto) {
     const r = manifesto.runtime_profiles;
     return { mesmoRuntimePorCota: r?.rotate_same_runtime_on_quota !== false,
-        mesmoRuntimePorAuth: r?.rotate_same_runtime_on_auth !== false };
+        mesmoRuntimePorAuth: r?.rotate_same_runtime_on_auth !== false,
+        ...(r?.distribuir === 'carga' ? { distribuir: 'carga' } : {}) };
 }
 /**
  * D14: o perfil da vez do runtime, na ordem do store. `desativado` e `provider-pago` nunca foram
@@ -819,6 +821,25 @@ function proximoPerfilDisponivel(store, runtime, politica, opcoes = {}) {
     }
     return null;
 }
+/**
+ * RM-056 (D3): a escolha por carga. Respeita a politica da D14 (sem perfil da vez pela ordem, sem
+ * perfil nenhum: a mesma retencao do runtime), e entre os perfis disponiveis vence o de menor
+ * carga (sessoes vivas da conta nesta maquina); empate pelo `ultimoUso` mais antigo (nunca usado
+ * primeiro), depois a ordem do store. O `ultimoUso` e gravado no despacho, entao dois despachos
+ * seguidos com carga igual vao a perfis diferentes mesmo antes de o runtime listar a sessao.
+ */
+function proximoPerfilPorCarga(store, runtime, politica, carga, opcoes = {}) {
+    const daVez = proximoPerfilDisponivel(store, runtime, politica, opcoes);
+    if (!daVez)
+        return null;
+    const agoraMs = opcoes.agoraMs ?? Date.now();
+    const candidatos = perfisDoRuntime(store, runtime)
+        .map((p, i) => ({ p, i }))
+        .filter(({ p }) => !(opcoes.excluir ?? []).includes(p.id) && perfilDisponivel(p, agoraMs));
+    const uso = (p) => p.ultimoUso === null ? -Infinity : Date.parse(p.ultimoUso);
+    candidatos.sort((x, y) => (carga.get(x.p.id) ?? 0) - (carga.get(y.p.id) ?? 0) || uso(x.p) - uso(y.p) || x.i - y.i);
+    return candidatos[0]?.p ?? daVez;
+}
 /**
  * D14: quando o runtime volta a ter perfil da vez, pela mesma regra da escolha. Com a troca por
  * cota desligada, e o prazo do perfil que segura o runtime; ligada, o menor prazo entre os

package/dist/saida-segura.js

@@ -0,0 +1,58 @@
+"use strict";
+/**
+ * RM-053 (fatia 2): o saneador de saida comum ao nucleo.
+ *
+ * Texto que vem de fora (o retrato de outra maquina, a branch `ork/fabrica-estado` do remoto de um
+ * projeto, onde outras pessoas escrevem) chega a tela do dono. A rede ja limpava o que imprime desde
+ * a revisao 4; o `ork fabrica` imprimia o `por` e o `projeto` legados crus. Este modulo e a regra
+ * unica: quem imprime valor alheio passa por aqui.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emUmaLinha = exports.INVISIVEL = exports.CF_VISIVEL = void 0;
+exports.valoresEmUmaLinha = valoresEmUmaLinha;
+exports.jsonSemInvisivel = jsonSemInvisivel;
+/**
+ * Y4 do CHECK 7: as marcas de `Cf` que se veem, lista fechada (todo `Prepended_Concatenation_Mark=Yes`
+ * do Unicode 17: os sinais numericos arabes U+0600 a U+0605, o fim de aya U+06DD, a abreviacao siriaca
+ * U+070F, as marcas de libra e piastra U+0890 e U+0891, o sanah U+08E2 e as marcas de numero kaithi
+ * U+110BD e U+110CD). Elas tem glifo e nao movem o texto, ao contrario das bidi, de largura zero e das
+ * tags, que seguem invisiveis. O regex do JS nao aceita `\p{Prepended_Concatenation_Mark}`; por isso a
+ * lista literal, presa ao `INVISIVEL` e conferida ponto a ponto no teste.
+ */
+exports.CF_VISIVEL = Object.freeze([
+    0x0600, 0x0601, 0x0602, 0x0603, 0x0604, 0x0605, 0x06dd, 0x070f, 0x0890, 0x0891, 0x08e2, 0x110bd, 0x110cd,
+]);
+/**
+ * V2 da revisao 4, W11 da revisao 5 e X3 da revisao 6: caractere que o terminal executa ou que
+ * ninguem ve, pelas classes do Unicode: controles (`Cc`: ESC, BEL, CSI, quebra de linha), formato
+ * (`Cf`: bidi, largura zero, tags), separadores de linha e todo `Default_Ignorable_Code_Point`
+ * (preenchimentos Hangul, seletores de variacao, os de musica e de estenografia), mais o braile
+ * vazio. Ficam de fora o ZWJ (U+200D) e os seletores U+FE0E e U+FE0F: eles montam emoji comuns, e as
+ * marcas visiveis de `Cf` (`CF_VISIVEL`, Y4 do CHECK 7).
+ */
+exports.INVISIVEL = /(?![\u200d\ufe0e\ufe0f\u0600-\u0605\u06dd\u070f\u0890\u0891\u08e2\u{110bd}\u{110cd}])[\p{Cc}\p{Cf}\p{Zl}\p{Zp}\p{Default_Ignorable_Code_Point}\u2800]/u;
+const INVISIVEIS = new RegExp(exports.INVISIVEL.source, 'gu');
+/**
+ * W4 da revisao 5: o valor numa linha so, sem nada invisivel. A quebra de linha (e a tabulacao) vira
+ * espaco: um valor que vem de fora nunca abre uma linha propria na saida, como se fosse do `ork`.
+ */
+const emUmaLinha = (texto) => texto.replace(INVISIVEIS, (c) => (/[\t\n\v\f\r\u0085\u2028\u2029]/.test(c) ? ' ' : ''));
+exports.emUmaLinha = emUmaLinha;
+/**
+ * Cada texto de uma estrutura (objeto, lista, aninhados) em uma linha, sem invisivel; numero,
+ * booleano e `null` ficam como estao (X5 da revisao 6: a ida e volta em JSON trocava `NaN` por `null`).
+ */
+function valoresEmUmaLinha(valor) {
+    const limpar = (v) => typeof v === 'string' ? (0, exports.emUmaLinha)(v)
+        : Array.isArray(v) ? v.map(limpar)
+            : v && typeof v === 'object' ? Object.fromEntries(Object.entries(v).map(([k, x]) => [k, limpar(x)])) : v;
+    return limpar(valor);
+}
+/**
+ * O JSON para a tela: o mesmo valor, com os caracteres invisiveis escritos como `\uXXXX` (quem le o
+ * JSON recebe o mesmo texto; so o terminal deixa de executa-lo). A quebra de linha da indentacao fica.
+ */
+function jsonSemInvisivel(valor) {
+    return JSON.stringify(valor, null, 2).replace(INVISIVEIS, (c) => c === '\n' ? c
+        : Array.from({ length: c.length }, (_, i) => `\\u${c.charCodeAt(i).toString(16).padStart(4, '0')}`).join(''));
+}

package/dist/session-watcher-claude.js

@@ -38,6 +38,7 @@ exports.normalizarNativo = normalizarNativo;
 exports.stopCorrelacionado = stopCorrelacionado;
 exports.bloqueioPendente = bloqueioPendente;
 exports.classificarSessaoClaude = classificarSessaoClaude;
+exports.ultimoErroDeApi = ultimoErroDeApi;
 exports.falhaDeContaDaTranscricao = falhaDeContaDaTranscricao;
 exports.comFalhaDeConta = comFalhaDeConta;
 exports.processoNativo = processoNativo;
@@ -268,22 +269,27 @@ function textoDoErroDeApi(e) {
     const codigo = typeof e.error === 'string' ? e.error : '';
     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. */
+function arquivoDaTranscricao(perfil, cwd, sessionId) {
+    if (!UUID.test(sessionId))
+        return null;
+    return path.join((0, runtime_profiles_1.diretorioEfetivo)('claude-bg', perfil), 'projects', path.resolve(cwd).replace(/[^a-zA-Z0-9-]/g, '-'), `${sessionId}.jsonl`);
+}
 /**
- * I-33 (D11b): falha de conta registrada pelo proprio Claude Code na transcricao da sessao, no
- * diretorio do perfil (ou no implicito, sem perfil). So entram linhas marcadas como erro de API
- * (`isApiErrorMessage` ou campo `error`): texto do agente nunca vira motivo. Leitura limitada
- * da cauda, sem seguir link; ausencia de transcricao e ausencia de evidencia. Vale o ULTIMO erro de API
- * (N3), o que encerrou a sessao. O codigo `rate_limit`
- * do Claude Code cobre tanto o limite do plano quanto o 429 transitorio ("Request rejected (429)",
- * "not your usage limit"): quem separa e o criterio unico da D16 (`naturezaDoLimite`), pela frase.
+ * I-33 (D11b): o erro de API que o proprio Claude Code gravou na transcricao da sessao. So entram linhas marcadas
+ * como erro de API (`isApiErrorMessage` ou campo `error`): texto do agente nunca vira motivo. Leitura limitada da
+ * cauda, sem seguir link; ausencia de transcricao e ausencia de evidencia. Vale o ULTIMO erro de API (N3), o que
+ * encerrou a sessao. RM-037 (fatia 5): com ele vem o instante da linha, que e a ancora da hora dita.
  */
-function falhaDeContaDaTranscricao(perfil, cwd, sessionId, agoraMs = Date.now()) {
-    if (!/^[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$/i.test(sessionId))
+function ultimoErroDeApi(perfil, cwd, sessionId) {
+    const arquivo = arquivoDaTranscricao(perfil, cwd, sessionId);
+    if (!arquivo)
         return null;
-    const arquivo = path.join((0, runtime_profiles_1.diretorioEfetivo)('claude-bg', perfil), 'projects', path.resolve(cwd).replace(/[^a-zA-Z0-9-]/g, '-'), `${sessionId}.jsonl`);
     let fd;
+    // O_NONBLOCK: um FIFO no lugar da transcricao nao trava o observador no open (sugestao da rodada 1 do CHECK).
     try {
-        fd = fs.openSync(arquivo, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
+        fd = fs.openSync(arquivo, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW | fs.constants.O_NONBLOCK);
     }
     catch {
         return null;
@@ -300,7 +306,7 @@ function falhaDeContaDaTranscricao(perfil, cwd, sessionId, agoraMs = Date.now())
     finally {
         fs.closeSync(fd);
     }
-    const erros = [];
+    let ultimo = null;
     for (const linha of cauda.split('\n')) {
         let e;
         try {
@@ -311,14 +317,82 @@ function falhaDeContaDaTranscricao(perfil, cwd, sessionId, agoraMs = Date.now())
         }
         if (!e || typeof e !== 'object' || (e.isApiErrorMessage !== true && e.error === undefined))
             continue;
-        erros.push(textoDoErroDeApi(e));
+        const ms = typeof e.timestamp === 'string' ? Date.parse(e.timestamp) : NaN;
+        ultimo = { texto: textoDoErroDeApi(e), em: Number.isFinite(ms) ? new Date(ms).toISOString() : null,
+            uuid: typeof e.uuid === 'string' && UUID.test(e.uuid) ? e.uuid.toLowerCase() : null };
     }
-    if (!erros.length)
-        return null;
-    // I-33 (N3): o criterio roda sobre o erro que encerrou a sessao (o ultimo erro de API), nunca sobre os
-    // anteriores juntos: um 429 transitorio do meio nao esconde o limite que matou a sessao, e um
-    // esgotamento ja superado nao tira o perfil do rodizio por causa de um 429 transitorio no fim.
-    return (0, claude_bg_1.parseFalhaDeConta)(erros[erros.length - 1], agoraMs);
+    return ultimo;
+}
+/**
+ * I-33 (D11b): falha de conta registrada pelo Claude Code na transcricao da sessao. O codigo `rate_limit` do
+ * Claude Code cobre tanto o limite do plano quanto o 429 transitorio ("Request rejected (429)", "not your usage
+ * limit"): quem separa e o criterio unico da D16 (`naturezaDoLimite`), pela frase. I-33 (N3): o criterio roda
+ * sobre o erro que encerrou a sessao, nunca sobre os anteriores juntos. RM-037 (fatia 5): a hora dita e ancorada
+ * no instante da mensagem; sem instante na linha, no relogio de quem le, como antes.
+ */
+function falhaDeContaDaTranscricao(perfil, cwd, sessionId, agoraMs = Date.now()) {
+    return falhaDoErro(ultimoErroDeApi(perfil, cwd, sessionId), agoraMs);
+}
+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);
+    let tamanho;
+    try {
+        const st = arquivo ? fs.lstatSync(arquivo) : null;
+        // Link, FIFO ou diretorio no lugar da transcricao nao e transcricao: nada a ler.
+        tamanho = st?.isFile() ? st.size : NaN;
+    }
+    catch {
+        return;
+    }
+    if (!Number.isFinite(tamanho) || cursor.transcricaoBytes === tamanho)
+        return;
+    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;
+    const falha = falhaDoErro(erro, ctx.agoraMs);
+    if (falha?.motivo !== 'runtime.quota-exhausted' || !ctx.carregado)
+        return;
+    const esgotadoAte = (0, ratelimit_1.prazoDaCotaVista)(ctx.carregado.manifesto, falha, erroMs, ctx.agoraMs);
+    if (!esgotadoAte)
+        return;
+    // 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');
+    (0, session_events_1.comLockDeSessao)(dir, () => {
+        if ((0, ledger_1.lerLedger)(dir).some(e => e.tipo === ledger_1.TIPOS_DE_EVENTO.cotaVistaNaTranscricao && e.sensorEventId === sensorEventId))
+            return;
+        if (perfil) {
+            try {
+                (0, ratelimit_1.marcarContaDaFalha)(ctx.carregado, perfil, falha, ctx.agoraMs, esgotadoAte);
+            }
+            catch {
+                // Store ocupado ou invalido: a proxima volta le a transcricao de novo e tenta outra vez.
+                delete cursor.transcricaoBytes;
+                return;
+            }
+        }
+        gravar(ledger_1.TIPOS_DE_EVENTO.cotaVistaNaTranscricao, { fase: sessao.fase, sessionId: sessao.sessionId, despachoEm: sessao.despachadaEm,
+            runtime: 'claude-bg', sensorEventId, motivo: falha.motivo, erroEm: erro.em, resetEm: falha.resetEm, fonteDoPrazo: falha.fonte,
+            // O trecho ja vem redigido e numa linha; sem controle, como no store de perfis.
+            esgotadoAte, trecho: falha.trecho.replace(/\p{Cc}/gu, ' '), perfil: perfil ? { id: perfil.id, runtime: perfil.runtime } : null,
+            perfilMarcado: !!perfil, origem: 'sessions.watch' });
+    });
 }
 /**
  * I-33 (D11): precedencia entre a prova da I-34 e a falha de conta. Com Stop correlacionado vale
@@ -360,8 +434,10 @@ function estadoDoArtefato(raiz, threadId, arquivo) {
     const file = path.join((0, thread_1.dirThread)(raiz, threadId), arquivo);
     const vazio = { sha256: null, mtimeMs: null, texto: null };
     let fd;
+    // RM-037 (fatia 5, sugestao da rodada 2 do CHECK): O_NONBLOCK, como na transcricao, para um FIFO no lugar do
+    // artefato nao travar o observador no open; o `isFile` abaixo o recusa.
     try {
-        fd = fs.openSync(file, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
+        fd = fs.openSync(file, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW | fs.constants.O_NONBLOCK);
     }
     catch (erro) {
         return erro.code === 'ENOENT' ? vazio : { ...vazio, invalido: true };
@@ -600,9 +676,13 @@ function observarClaudeSobLock(ctx) {
     const registro = consulta.ok ? consulta.registros.find(s => s.sessionId === sessao.sessionId && s.cwd === fonte.cwd) ?? null : null;
     const artefato = saidaDoArtefato(raiz, thread.id, sessao, fonte, eventos);
     let prova;
+    // RM-037 (fatia 5): o ultimo erro de API da transcricao, lido no maximo uma vez por volta, serve a cota ao vivo
+    // e ao fecho.
+    let erroLido;
+    const erroDaTranscricao = () => erroLido !== undefined ? erroLido : (erroLido = ultimoErroDeApi(perfil, fonte.cwd, sessao.sessionId));
     const { c, falha } = comFalhaDeConta(classificarSessaoClaude({ sessao, eventos, consulta, registro, cursor, agoraMs: ctx.agoraMs,
         limiteMs: ctx.limiteMs, pausaAoFim: (0, thread_1.pausaNaThread)(thread, sessao.fase),
-        prova: () => prova ??= provaDoOrk(raiz, thread.id, sessao, eventos, fonte), processo: processoNativo }), () => falhaDeContaDaTranscricao(perfil, fonte.cwd, sessao.sessionId, ctx.agoraMs));
+        prova: () => prova ??= provaDoOrk(raiz, thread.id, sessao, eventos, fonte), processo: processoNativo }), () => falhaDoErro(erroDaTranscricao(), ctx.agoraMs));
     (0, codex_runner_1.gravarAtomico)(arquivoCursor, cursor);
     // GO-FIX 3 (achado 1): cursor gravado numa thread que sumiu durante a consulta é desfeito aqui;
     // as pastas criadas pela observação, pelo `session-watcher`.
@@ -610,6 +690,12 @@ function observarClaudeSobLock(ctx) {
         fs.rmSync(arquivoCursor, { force: true });
         throw new Error(exports.THREAD_REMOVIDA);
     }
+    if (!c.terminal) {
+        const lidos = cursor.transcricaoBytes;
+        cotaAoVivo(ctx, perfil, fonte.cwd, cursor, erroDaTranscricao, gravar);
+        if (cursor.transcricaoBytes !== lidos)
+            (0, codex_runner_1.gravarAtomico)(arquivoCursor, cursor);
+    }
     if (!c.terminal && c.inconclusivo)
         return (0, session_events_1.comLockDeSessao)(dir, () => {
             const diagnosticoId = `${resultadoId}:inconclusivo`;
@@ -649,8 +735,12 @@ function observarClaudeSobLock(ctx) {
             observadoEm, gate: 'phase.dispatch', origem: 'sessions.watch' };
         if (!atuais.some(e => e.tipo === c.classificacao && e.sensorResultId === resultadoId))
             gravar(c.classificacao, dados);
-        // I-33 (D12): o perfil sai do rodizio na primeira gravacao do resultado, onde a evidencia esta.
-        if (falha && perfil && ctx.carregado && !atuais.some(e => e.tipo === 'phase_result' && e.sensorResultId === resultadoId)) {
+        // I-33 (D12): o perfil sai do rodizio na primeira gravacao do resultado, onde a evidencia esta. RM-037 (fatia 5):
+        // o erro que a cota ao vivo ja marcou nao marca de novo; depois do prazo dito, marcar de novo tiraria do
+        // rodizio uma conta que ja voltou.
+        const jaVista = !!erroLido?.em && atuais.some(e => e.tipo === ledger_1.TIPOS_DE_EVENTO.cotaVistaNaTranscricao &&
+            e.sessionId === sessao.sessionId && e.despachoEm === sessao.despachadaEm && e.erroEm === erroLido.em);
+        if (falha && perfil && ctx.carregado && !jaVista && !atuais.some(e => e.tipo === 'phase_result' && e.sensorResultId === resultadoId)) {
             try {
                 (0, ratelimit_1.marcarContaDaFalha)(ctx.carregado, perfil, falha, ctx.agoraMs);
             }