@orkastery/cli 0.5.1 → 0.5.6

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/runtimes.js

@@ -55,6 +55,7 @@ exports.resolverRuntime = resolverRuntime;
 const claudeBg = __importStar(require("./adapters/claude-bg"));
 const codex = __importStar(require("./adapters/codex"));
 const hitl_ingress_receipt_1 = require("./hitl-ingress-receipt");
+const locale_1 = require("./locale");
 exports.RUNTIME_PADRAO = 'claude-bg';
 /** Phase e retry atravessam o mesmo preparo, antes de retirar segredos do filho. */
 function comRecibosPublicos(p, dispatch) {
@@ -97,7 +98,7 @@ function runtimeConhecido(nome) {
 function resolverRuntime(nome) {
     const adapter = exports.RUNTIMES[nome];
     if (!adapter) {
-        throw new Error(`runtime de despacho desconhecido: "${nome}" (homologados: ${exports.ORDEM_DOS_RUNTIMES.join(', ')})`);
+        throw new locale_1.ErroDoCatalogo((m) => m.phase.runtimeDesconhecido(nome, exports.ORDEM_DOS_RUNTIMES.join(', ')));
     }
     return adapter;
 }

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-events.js

@@ -63,10 +63,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 +77,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;
 }

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;
@@ -74,6 +75,7 @@ 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");
 /** Uma consulta nativa custa cerca de 0,3 s; cinco segundos mantém o custo abaixo de 10%. */
 exports.INTERVALO_WATCH_CLAUDE_MS = 5000;
@@ -268,22 +270,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 +307,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 +318,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 +435,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 };
@@ -470,6 +547,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)
@@ -546,7 +626,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,
@@ -600,9 +682,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 +696,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 +741,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);
             }