@orkastery/cli 0.5.6 → 0.6.0

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, () => {

package/dist/session-watcher.js

@@ -35,7 +35,10 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BLOCO_WATCH_BYTES = exports.MAX_FALHAS_WATCH = exports.MAX_ESPERA_ERRO_WATCH_MS = exports.INTERVALO_WATCH_MS = exports.LIMITE_MORTE_MS = void 0;
 exports.observarSessao = observarSessao;
+exports.reconciliarSessaoSemWatcher = reconciliarSessaoSemWatcher;
+exports.validarRegistroWatcher = validarRegistroWatcher;
 exports.validarFonteWatcher = validarFonteWatcher;
+exports.prepararFonteWatcher = prepararFonteWatcher;
 exports.iniciarWatcher = iniciarWatcher;
 exports.acompanharSessao = acompanharSessao;
 /** D6: observador restrito a uma sessão, cursor canônico e resultados idempotentes. */
@@ -55,6 +58,8 @@ const codex_controller_sensor_1 = require("./adapters/codex-controller-sensor");
 const retry_1 = require("./retry");
 const ratelimit_1 = require("./ratelimit");
 const session_watcher_claude_1 = require("./session-watcher-claude");
+const conta_esgotada_1 = require("./conta-esgotada");
+const trabalho_thread_1 = require("./trabalho-thread");
 /** Falhas operacionais e bloqueios sem retry automático não alegam conclusão do produto. */
 function bloqueioPreservado(terminal) {
     return terminal.classificacao === 'gate_blocked' && terminal.motivo !== null &&
@@ -325,6 +330,9 @@ function diagnosticoWatcher(e) {
             erro: 'estado canônico temporariamente sem vínculo; auditoria será repetida', transitorio: true };
     if (['ENOENT', 'EAGAIN', 'EBUSY', 'EINTR'].includes(erro?.code ?? ''))
         return { ...base, categoria, erro: `leitura temporariamente indisponível (${erro.code})`, transitorio: true };
+    if (mensagem === 'runtime.unavailable: rollout do controller ausente' ||
+        mensagem === 'runtime.unavailable: rollout do controller sem session_meta conferível')
+        return { ...base, categoria, erro: 'fonte do runtime ainda não está pronta', transitorio: true };
     if (e instanceof SyntaxError || /^JSON invalido em /.test(erro?.message ?? '') ||
         metadado)
         return { ...base, categoria: metadado ? categoria : 'json.invalido', erro: 'metadado JSON indisponível ou incompleto', transitorio: true };
@@ -374,6 +382,111 @@ function observarSessao(carregado, sessionId, opcoes = {}) {
         throw e;
     }
 }
+/**
+ * RM-064 T9: a batida não depende do processo watcher ter nascido. Para a última sessão
+ * despachada e verificada, recompõe a fonte do próprio despacho, observa o runtime diretamente
+ * e, depois do mesmo limite do watcher, registra uma parada tipada que o retry consegue tratar.
+ */
+function reconciliarSessaoSemWatcher(carregado, threadId, agoraMs = Date.now()) {
+    const thread = (0, thread_1.lerThread)(carregado.raiz, threadId);
+    const sessao = thread.sessoes.at(-1);
+    const ignorada = (detalhe) => ({ thread: threadId,
+        sessionId: sessao?.sessionId ?? null, estado: 'ignorada', detalhe });
+    if (thread.status === 'fechada' || !sessao || sessao.verificada !== true ||
+        !['codex', 'claude-bg'].includes(sessao.runtime) || typeof sessao.despachadaEm !== 'string')
+        return ignorada('sem sessão despachada e verificada que o watcher possa reconciliar');
+    const dir = (0, thread_1.dirThread)(carregado.raiz, threadId);
+    let eventos = (0, ledger_1.lerLedger)(dir);
+    if (eventos.some(e => e.tipo === 'phase_result' && e.sessionId === sessao.sessionId &&
+        (e.despachoEm === undefined || e.despachoEm === sessao.despachadaEm)))
+        return ignorada('sessão já possui phase_result');
+    const iniciado = eventos.filter(e => e.tipo === 'session_watcher_started' && e.sessionId === sessao.sessionId &&
+        e.despachoEm === sessao.despachadaEm).at(-1);
+    const identidade = iniciado?.identidade;
+    if (identidade && iniciado?.pid === identidade.pid && (0, codex_runner_1.estadoProcesso)(identidade) === 'vivo')
+        return ignorada('watcher verificado continua vivo');
+    try {
+        const registro = eventos.filter(e => e.tipo === 'session_sensor_registered' && e.sessionId === sessao.sessionId &&
+            e.despachoEm === sessao.despachadaEm).at(-1);
+        if (!registro && sessao.runtime === 'claude-bg') {
+            (0, session_watcher_claude_1.garantirFonteClaude)(carregado.raiz, thread, (0, session_events_1.exigirSessaoDespachada)(sessao, sessao.sessionId));
+        }
+        else if (!registro && sessao.runtime === 'codex') {
+            const despacho = eventos.filter(e => e.tipo === 'phase_dispatch' && e.sessionId === sessao.sessionId).at(-1);
+            const controlador = (despacho?.controlador ?? sessao.controlador);
+            const cwd = despacho?.cwd;
+            if (controlador && cwd) {
+                const fonte = { controlador, cwd };
+                validarRegistroWatcher(carregado.raiz, sessao.sessionId, fonte);
+                (0, session_events_1.comLockDeSessao)(dir, () => {
+                    const atuais = (0, ledger_1.lerLedger)(dir);
+                    if (!atuais.some(e => e.tipo === 'session_sensor_registered' && e.sessionId === sessao.sessionId &&
+                        e.despachoEm === sessao.despachadaEm)) {
+                        (0, ledger_1.registrar)(dir, threadId, 'session_sensor_registered', { fase: sessao.fase, sessionId: sessao.sessionId,
+                            despachoEm: sessao.despachadaEm, ...fonte, origem: 'conducao.batida',
+                            ...(despacho?.perfil ? { perfil: despacho.perfil } : {}) });
+                    }
+                });
+            }
+        }
+        const observado = observarSessao(carregado, sessao.sessionId, { threadId, agoraMs });
+        if (!observado.ocupado) {
+            const observadoEm = new Date(agoraMs).toISOString();
+            (0, session_events_1.comLockDeSessao)(dir, () => {
+                const atuais = (0, ledger_1.lerLedger)(dir);
+                if (!atuais.some(e => e.tipo === 'session_watcher_observed' && e.sessionId === sessao.sessionId &&
+                    e.despachoEm === sessao.despachadaEm && e.ts === observadoEm)) {
+                    (0, ledger_1.registrar)(dir, threadId, 'session_watcher_observed', { ts: observadoEm, fase: sessao.fase,
+                        sessionId: sessao.sessionId, despachoEm: sessao.despachadaEm, origem: 'conducao.batida' });
+                }
+            });
+        }
+        if (observado.concluido)
+            return { thread: threadId, sessionId: sessao.sessionId,
+                estado: 'concluida', detalhe: `runtime observado: ${observado.classificacao ?? 'terminal'}` };
+        return { thread: threadId, sessionId: sessao.sessionId, estado: 'acompanhada',
+            detalhe: observado.ocupado ? 'observação ocupada; nova batida repetirá' : 'runtime ainda sem terminal' };
+    }
+    catch (erro) {
+        // `observarSessao` diagnostica sua própria falha; a recomposição estrutural passa pelo mesmo
+        // recibo. Só depois do limite a batida transforma a ausência persistente em parada.
+        tentarRegistrarErroWatcher(carregado.raiz, threadId, sessao.sessionId, erro);
+        eventos = (0, ledger_1.lerLedger)(dir);
+        const doIntervalo = (0, session_watcher_claude_1.eventosDoIntervalo)(eventos, (0, session_events_1.exigirSessaoDespachada)(sessao, sessao.sessionId));
+        const uteis = doIntervalo.filter(e => ['runtime_heartbeat', 'runtime_event', 'runtime_stop', 'runtime_subagent_stop', 'commit',
+            'mcp_git_committed', 'sessao_bloqueada', 'sessao_destravada'].includes(e.tipo));
+        const observacoesBoas = doIntervalo.filter(e => e.sessionId === sessao.sessionId &&
+            (e.tipo === 'session_watcher_observed' || e.tipo === 'session_watcher_error' && e.encerramento === 'recuperado'));
+        const ultimaObservacao = Math.max(Date.parse(sessao.despachadaEm), ...[...uteis, ...observacoesBoas].map(e => Date.parse(e.ts)).filter(Number.isFinite));
+        const errosDaSerie = doIntervalo.filter(e => e.tipo === 'session_watcher_error' && e.sessionId === sessao.sessionId &&
+            e.encerramento !== 'recuperado').map(e => Date.parse(e.ts)).filter(ts => Number.isFinite(ts) && ts >= ultimaObservacao);
+        const primeiroErro = errosDaSerie.length > 0 ? Math.min(...errosDaSerie) : Number.NEGATIVE_INFINITY;
+        const ultimoUtil = Math.max(ultimaObservacao, primeiroErro);
+        if (agoraMs - ultimoUtil < exports.LIMITE_MORTE_MS)
+            return { thread: threadId, sessionId: sessao.sessionId,
+                estado: 'acompanhada', detalhe: 'fonte ainda indisponível dentro do limite de estabilidade' };
+        const sessionId = sessao.sessionId;
+        const chave = (0, node_crypto_1.createHash)('sha256').update(sessionId + '|' + sessao.despachadaEm).digest('hex');
+        const sensorResultId = `codex:${chave}`;
+        (0, session_events_1.comLockDeSessao)(dir, () => {
+            const atuais = (0, ledger_1.lerLedger)(dir);
+            if (atuais.some(e => e.tipo === 'phase_result' && e.sessionId === sessao.sessionId &&
+                e.despachoEm === sessao.despachadaEm))
+                return;
+            const dados = { fase: sessao.fase, sessionId: sessao.sessionId, despachoEm: sessao.despachadaEm,
+                sensorResultId, classificacao: 'gate_blocked', motivo: 'runtime.unavailable', runtime: sessao.runtime,
+                fonte: 'conducao.batida: sessão verificada sem watcher e sem evento útil', fonteVencedora: null,
+                ok: false, conclusaoNativa: false, conclusaoNativaAusente: 'watcher ausente e fonte indisponível além do limite',
+                estado: 'bloqueada', observadoEm: new Date(agoraMs).toISOString(), gate: 'phase.dispatch',
+                origem: 'conducao.batida', morteLatenciaMs: agoraMs - ultimoUtil };
+            (0, ledger_1.registrar)(dir, threadId, 'sessao_morta', dados);
+            (0, ledger_1.registrar)(dir, threadId, 'gate_blocked', dados);
+            (0, ledger_1.registrar)(dir, threadId, 'phase_result', dados);
+        });
+        return { thread: threadId, sessionId: sessao.sessionId, estado: 'parada',
+            detalhe: 'sessão verificada sem watcher e sem evento útil além do limite' };
+    }
+}
 function observarSessaoResolvida(carregado, sessionId, { thread, sessao: registrada }, opcoes) {
     const sessao = (0, session_events_1.exigirSessaoDespachada)(registrada, sessionId);
     if (sessao.runtime !== 'codex' && sessao.runtime !== 'claude-bg')
@@ -413,7 +526,8 @@ function observarSessaoResolvida(carregado, sessionId, { thread, sessao: registr
                 thread, sessao, dir, pasta, chave, agoraMs: now, limiteMs: exports.LIMITE_MORTE_MS, consulta: opcoes.consultaClaude, carregado })) ?? { ...base, ocupado: true };
             return (0, ledger_1.threadPresente)(dir) ? r : desfazer();
         }
-        return comLockWatcher(pasta, () => {
+        let contaParaReconciliar = null;
+        const observado = comLockWatcher(pasta, () => {
             const eventos = (0, ledger_1.lerLedger)(dir), resultadoId = `codex:${chave}`;
             const pronto = eventos.find(e => e.tipo === 'phase_result' && e.sensorResultId === resultadoId);
             if (pronto)
@@ -610,10 +724,12 @@ function observarSessaoResolvida(carregado, sessionId, { thread, sessao: registr
                     terminal = { ...terminal, classificacao: 'gate_blocked', motivo: 'runtime.unavailable' };
                 }
                 // I-33 (D12): o turno terminou pela CONTA (cota, credito ou login), dito pelo proprio runtime.
-                // E bloqueio, nunca conclusao; a D11c decide no retry se houve producao antes da morte.
+                // É bloqueio, nunca conclusão; o retry deriva checkpoint quando já houve produção.
                 if (conta)
                     terminal = { ...terminal, classificacao: 'gate_blocked', motivo: conta.falha.motivo, falhaDeConta: conta.falha,
                         fonte: `${conta.fonte}: ${conta.falha.motivo} (${conta.falha.trecho})` };
+                const respostaFinal = terminal.respostaFinal
+                    ? (0, trabalho_thread_1.gravarRespostaFinalDaSessao)(carregado.raiz, thread.id, sessionId, terminal.respostaFinal) : null;
                 const dados = { fase: sessao.fase, sessionId, despachoEm: sessao.despachadaEm, sensorResultId: resultadoId,
                     classificacao: terminal.classificacao, motivo: terminal.motivo, runtime: 'codex', fonte: terminal.fonte,
                     fonteVencedora: incompleto || invalido || aberto || descorrelacionado ? null : terminais[0]?.nome ?? null,
@@ -627,13 +743,18 @@ function observarSessaoResolvida(carregado, sessionId, { thread, sessao: registr
                     estado: terminal.classificacao === 'fase_concluida' ? 'concluida' : 'bloqueada',
                     observadoEm: terminal.timestamp, gate: 'phase.dispatch', origem: 'sessions.watch',
                     morteLatenciaMs: morte ? now - cursor.progressoEm : null, ...(perfil ? { perfil } : {}),
+                    ...(respostaFinal ? { respostaFinal: { arquivo: (0, trabalho_thread_1.caminhoDoTrabalho)(thread.id) + respostaFinal.arquivo,
+                            sha256: respostaFinal.sha256, bytes: respostaFinal.bytes, truncada: respostaFinal.truncada } } : {}),
                     ...(conta ? { falhaDeConta: { motivo: conta.falha.motivo, resetEm: conta.falha.resetEm, fonte: conta.falha.fonte,
                             trecho: conta.falha.trecho } } : {}) };
                 const tipo = semTerminal && morte && !incompleto && !conta ? 'sessao_morta' : terminal.classificacao;
                 // I-33 (D12): o perfil sai do rodizio na primeira gravacao do resultado, onde a evidencia esta.
                 if (conta && perfil && !atuais.some(e => e.tipo === 'phase_result' && e.sensorResultId === resultadoId)) {
                     try {
-                        (0, ratelimit_1.marcarContaDaFalha)(carregado, perfil, conta.falha, now);
+                        const marcado = (0, ratelimit_1.marcarContaDaFalha)(carregado, perfil, conta.falha, now);
+                        if (marcado?.esgotadoAte)
+                            contaParaReconciliar = { perfil, falha: conta.falha,
+                                esgotadoAte: marcado.esgotadoAte, erroEm: terminal.timestamp };
                     }
                     catch { /* store ocupado ou invalido: o retry marca de novo pelo gate tipado */ }
                 }
@@ -646,7 +767,11 @@ function observarSessaoResolvida(carregado, sessionId, { thread, sessao: registr
                     (0, ledger_1.registrar)(dir, thread.id, 'phase_result', dados);
                 return { ...base, bytesLidos, concluido: true, classificacao: terminal.classificacao };
             });
-        }) ?? { ...base, ocupado: true };
+        });
+        const episodio = contaParaReconciliar;
+        if (episodio)
+            (0, conta_esgotada_1.reconciliarContaEsgotada)({ raiz: carregado.raiz, agoraMs: now, ...episodio });
+        return observado ?? { ...base, ocupado: true };
     }
     catch (e) {
         // Thread apagada no meio da observação: encerra sem erro, sem recriar a pasta e sem resíduo.
@@ -655,8 +780,8 @@ function observarSessaoResolvida(carregado, sessionId, { thread, sessao: registr
         throw e;
     }
 }
-/** Valida a fonte antes de registro, stderr ou spawn; tambem usada na recuperacao. */
-function validarFonteWatcher(raiz, sessionId, fonte) {
+/** Valida vínculo, variante e perfil sem exigir que o runtime já tenha publicado seus metadados. */
+function validarRegistroWatcher(raiz, sessionId, fonte) {
     const { thread, sessao: registrada } = (0, session_events_1.resolverSessao)(raiz, sessionId);
     const sessao = (0, session_events_1.exigirSessaoDespachada)(registrada, sessionId);
     const dir = (0, thread_1.dirThread)(raiz, thread.id);
@@ -669,9 +794,16 @@ function validarFonteWatcher(raiz, sessionId, fonte) {
     // I-33 (D4): perfil invalido ou divergente do despacho reprova antes de observar pela conta errada.
     (0, runtime_profiles_1.perfilDoRegistro)([...eventos, ...(fonte ? [{ tipo: 'session_sensor_registered', sessionId,
                 despachoEm: sessao.despachadaEm, ...fonte }] : [])], sessao);
+    if (registro.nativo !== undefined && sessao.runtime !== 'claude-bg')
+        throw new Error('fonte nativa claude-agents em sessão de outro runtime');
+    if (registro.controlador && sessao.runtime !== 'codex')
+        throw new Error('fonte do controller Codex em sessão de outro runtime');
+    return { thread, sessao, dir, eventos, registro };
+}
+/** Validação profunda feita pelo laço: prontidão eventual nunca impede o registro do vínculo. */
+function validarFonteWatcher(raiz, sessionId, fonte) {
+    const { thread, sessao, dir, eventos, registro } = validarRegistroWatcher(raiz, sessionId, fonte);
     if (registro.nativo !== undefined) {
-        if (sessao.runtime !== 'claude-bg')
-            throw new Error('fonte nativa claude-agents em sessão de outro runtime');
         (0, session_watcher_claude_1.validarFonteClaude)(eventos, sessionId, registro);
         return;
     }
@@ -690,6 +822,20 @@ function validarFonteWatcher(raiz, sessionId, fonte) {
         (0, codex_controller_sensor_1.lerSnapshotController)(fixada);
     }
 }
+/**
+ * No despacho, fixa a fonte que já está pronta e recusa corrupção permanente antes de
+ * registrar ou iniciar o watcher. A publicação ainda incompleta do controller é deixada
+ * para o laço do watcher, que repete a mesma validação profunda com prazo e diagnóstico.
+ */
+function prepararFonteWatcher(raiz, sessionId, fonte) {
+    try {
+        validarFonteWatcher(raiz, sessionId, fonte);
+    }
+    catch (e) {
+        if (!diagnosticoWatcher(e).transitorio)
+            throw e;
+    }
+}
 function iniciarWatcher(raiz, sessionId) {
     const { thread, sessao: registrada } = (0, session_events_1.resolverSessao)(raiz, sessionId);
     const sessao = (0, session_events_1.exigirSessaoDespachada)(registrada, sessionId);
@@ -697,7 +843,7 @@ function iniciarWatcher(raiz, sessionId) {
     // I-34: sessão claude-bg despachada antes do registro nativo ganha a fonte derivada do despacho.
     if (sessao.runtime === 'claude-bg')
         (0, session_watcher_claude_1.garantirFonteClaude)(raiz, thread, sessao);
-    validarFonteWatcher(raiz, sessionId);
+    validarRegistroWatcher(raiz, sessionId);
     const anterior = (0, ledger_1.lerLedger)(dir).filter(e => e.tipo === 'session_watcher_started' &&
         e.sessionId === sessionId && e.despachoEm === sessao.despachadaEm).at(-1);
     const identidadeAnterior = anterior?.identidade;
@@ -762,7 +908,7 @@ async function acompanhar() {
     try {
         const readyPath = process.argv[5], token = process.argv[6];
         if (readyPath && token) {
-            validarFonteWatcher(carregado.raiz, sessionId);
+            validarRegistroWatcher(carregado.raiz, sessionId);
             const sessao = (0, session_events_1.exigirSessaoDespachada)((0, session_events_1.resolverSessao)(carregado.raiz, sessionId, threadId).sessao, sessionId);
             const identidade = (0, codex_runner_1.identidadeProcesso)(process.pid);
             if (!identidade)

package/dist/sessoes-contas.js

@@ -35,6 +35,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.pidVivo = pidVivo;
 exports.ehFantasma = ehFantasma;
+exports.encerradaNaLista = encerradaNaLista;
 exports.contasDeSessoes = contasDeSessoes;
 exports.consultarContas = consultarContas;
 exports.estadosNasContas = estadosNasContas;
@@ -75,6 +76,14 @@ function pidVivo(pid) {
 function ehFantasma(runtime, s, vivo = pidVivo) {
     return runtime === 'claude-bg' && !TERMINAIS.includes(estadoDe(s)) && !vivo(s.pid);
 }
+/**
+ * RM-037 (ork-rm037esperas, D7): o runtime mostra a sessao encerrada: estado terminal (`done`, `completed`, `exited`,
+ * `stopped`, `failed`) ou fantasma, registro sem processo que trabalhe por ele. Domicilio unico dessa leitura: o portao
+ * de vaga do `ork phase run` (`vagaDoDespacho`) e a capacidade do #Noctum a usam.
+ */
+function encerradaNaLista(s) {
+    return s.fantasma || TERMINAIS.includes(estadoDe(s));
+}
 const real = (dir) => { try {
     return fs.realpathSync(dir);
 }

package/dist/sessoes-inventario.js

@@ -71,7 +71,7 @@ function raizesDeRegistros(cwds) {
 function inventariarSessoes(raiz, opcoes = {}) {
     const canonica = (0, estado_thread_1.raizDoEstado)(raiz);
     // RM-056 (D4): a conta do processo e cada perfil do store, sem repetir diretorio.
-    const contas = (0, sessoes_contas_1.consultarContas)(canonica, { todas: opcoes.todas });
+    const contas = (0, sessoes_contas_1.consultarContas)(canonica, { todas: opcoes.todas, ...(opcoes.prazoMs ? { prazoMs: opcoes.prazoMs } : {}) });
     const fontes = contas.fontes;
     const todas = contas.sessoes.map(s => ({ ...s, vinculos: [] }));
     // O cruzamento usa o universo global mesmo quando a apresentação é local.

package/dist/sessoes.js

@@ -54,24 +54,26 @@ const util_1 = require("./util");
 const estado_thread_1 = require("./estado-thread");
 const ledger_1 = require("./ledger");
 const thread_1 = require("./thread");
+const locale_1 = require("./locale");
 function textoDoInventario(r) {
+    const m = (0, locale_1.msg)().operacao.restante.sessions.inventario;
     const linhas = [
-        `Inventário ${r.escopo.global ? 'global' : 'do projeto'} da conta ${r.escopo.usuario}; histórico: ${r.escopo.historico ? 'incluído' : 'omitido'}.`,
-        `Fontes: ${r.fontes.map(f => `${f.origem} (${f.ausente ? 'ausente' : f.ok ? 'ok' : 'FALHA'})`).join('; ')}`,
-        `Total: ${r.total}; sem thread: ${r.semThread}; ambíguas: ${r.ambiguas}; fantasmas: ${r.fantasmas}; consulta: ${r.ok ? 'válida' : 'INCOMPLETA'}.`,
+        m.abertura(r.escopo.global, r.escopo.usuario, r.escopo.historico),
+        m.fontes(r.fontes.map(f => `${f.origem} (${f.ausente ? m.fonteEstado.ausente : f.ok ? m.fonteEstado.ok : m.fonteEstado.falha})`).join('; ')),
+        m.resumo(r.total, r.semThread, r.ambiguas, r.fantasmas, r.ok),
     ];
     // RM-056 (D4): a coluna PERFIL e o id do perfil (`processo` sem perfil), nunca o diretorio da conta.
     if (r.sessoes.length)
-        linhas.push((0, util_1.tabela)(['ID', 'RUNTIME', 'PERFIL', 'ESTADO', 'THREAD/FASE'], r.sessoes.map(s => [s.sessionId, s.runtime, s.perfil ?? 'processo',
-            `${s.state ?? s.status ?? 'unknown'}${s.fantasma ? ' (fantasma)' : ''}`,
-            s.vinculos.map(v => `${v.thread}/${v.fase}`).join(', ') || '(fora do ork)'])));
+        linhas.push((0, util_1.tabela)([...m.colunas], r.sessoes.map(s => [s.sessionId, s.runtime, s.perfil ?? m.processo,
+            `${s.state ?? s.status ?? m.desconhecido}${s.fantasma ? ` (${m.fantasma})` : ''}`,
+            s.vinculos.map(v => `${v.thread}/${v.fase}`).join(', ') || m.fora])));
     if (r.fantasmas > 0)
-        linhas.push('Fantasma: registro sem processo vivo, não ocupa vaga; `ork sessions limpar-fantasmas` solta o vínculo do ork sem tocar no runtime.');
+        linhas.push(m.explicacaoFantasma);
     for (const f of r.fontes.filter(f => !f.ok))
-        linhas.push(`Falha: ${f.detalhe}`);
+        linhas.push(m.falha(f.detalhe));
     // Fatia 2 do ensaio da 0.5.0 (P1): a fonte ausente nao e falha, mas diz o que falta e como ter.
     for (const f of r.fontes.filter(f => f.ausente))
-        linhas.push(`Ausente: ${f.detalhe}${f.correcao ? `; correção: ${f.correcao}` : ''}`);
+        linhas.push(m.ausente(f.detalhe, f.correcao ?? null));
     return linhas.join('\n');
 }
 function tabelaDeSessoes(raiz, todas = false) {
@@ -83,6 +85,7 @@ function tabelaDeSessoes(raiz, todas = false) {
  * viva). So uma conta pode responder; duas viram recusa, nenhuma mantem a mensagem de antes.
  */
 function localizarSessao(chave, raiz) {
+    const m = (0, locale_1.msg)().operacao.restante.sessions.localizar;
     let perfis = [];
     const falhas = [];
     if (raiz) {
@@ -99,10 +102,9 @@ function localizarSessao(chave, raiz) {
         return { achada: r.achadas[0] };
     if (r.achadas.length > 1) {
         const contas = r.achadas.map(a => `${a.perfil?.id ?? 'processo'} (${a.sessao.sessionId})`).join(', ');
-        return { texto: `sessao "${chave}" encontrada em mais de uma conta: ${contas}; use o id completo`, codigo: 1 };
+        return { texto: m.ambigua(chave, contas), codigo: 1 };
     }
-    return { texto: `sessao "${chave}" nao encontrada no runtime` + (falhas.length ? `; contas sem resposta: ${falhas.join('; ')}` : ''),
-        codigo: 1 };
+    return { texto: m.ausente(chave, falhas.join('; ')), codigo: 1 };
 }
 /** Logs de uma sessao pelo id curto, id completo ou nome, lidos na conta onde ela esta. */
 function logsDaSessao(chave, linhas, raiz) {
@@ -120,7 +122,7 @@ function pararSessao(chave, raiz) {
         return l;
     const { sessao, perfil, ambiente } = l.achada;
     const r = adapter.pararAchada(sessao, ambiente);
-    return { texto: r.texto || `sessao ${sessao.sessionId} parada${perfil ? ` (perfil ${perfil.id})` : ''}`, codigo: r.ok ? 0 : 1 };
+    return { texto: r.texto || (0, locale_1.msg)().operacao.restante.sessions.localizar.parada(sessao.sessionId, perfil?.id ?? null), codigo: r.ok ? 0 : 1 };
 }
 /** Comando de attach (precisa de TTY, entao o CLI imprime em vez de executar). */
 function comandoDeAttach(chave, raiz) {
@@ -138,9 +140,9 @@ const ENCERRAM_A_SESSAO = ['phase_result', 'sessao_morta', 'session_superseded']
  */
 function limparFantasmas(raiz, opcoes = {}) {
     const canonica = (0, estado_thread_1.raizDoEstado)(raiz);
-    const inv = (0, sessoes_inventario_1.inventariarSessoes)(canonica, { global: true });
+    const inv = opcoes.inventario ?? (0, sessoes_inventario_1.inventariarSessoes)(canonica, { global: true });
     const itens = [];
-    for (const s of inv.sessoes.filter(x => x.fantasma)) {
+    for (const s of inv.sessoes.filter(x => x.fantasma && (!opcoes.sessoes || opcoes.sessoes.includes(x.sessionId)))) {
         // Fechamento (RM-056, ao fechar): so os vinculos da thread que fecha; o resto fica como estava.
         const vinculos = opcoes.thread ? s.vinculos.filter(v => v.thread === opcoes.thread && v.raiz === canonica) : s.vinculos;
         if (opcoes.thread && vinculos.length === 0)
@@ -186,18 +188,18 @@ function sessoesSemFim(raiz, threadId) {
     return [...new Set(ids)].filter(id => !encerradas.has(id));
 }
 function textoDaLimpeza(r) {
+    const m = (0, locale_1.msg)().operacao.restante.sessions.limpeza;
     if (r.itens.length === 0)
-        return `Nenhuma sessão fantasma${r.ok ? '' : ' nas contas que responderam'}.` +
-            r.falhas.map(f => `\nFalha: ${f}`).join('');
+        return m.nenhuma(!r.ok) + r.falhas.map(f => `\n${m.falha(f)}`).join('');
     const verbo = {
-        solto: r.dryRun ? 'soltaria (sessao_morta no ledger)' : 'solto: sessao_morta no ledger',
-        'ja-solto': 'já encerrada no ledger', 'sem-thread': 'fora do ork: nada a soltar',
-        'outro-projeto': 'vínculo de outro projeto: rode lá',
+        solto: r.dryRun ? m.acoes.soltaria : m.acoes.solto,
+        'ja-solto': m.acoes.jaSolto, 'sem-thread': m.acoes.semThread,
+        'outro-projeto': m.acoes.outroProjeto,
     };
     return [
-        `Sessões fantasma (sem pid e sem processo)${r.dryRun ? ', ensaio: nada foi gravado' : ''}. O runtime não foi tocado.`,
-        (0, util_1.tabela)(['ID', 'PERFIL', 'THREAD/FASE', 'AÇÃO'], r.itens.map(i => [i.sessionId, i.perfil ?? 'processo',
+        m.abertura(r.dryRun),
+        (0, util_1.tabela)([...m.colunas], r.itens.map(i => [i.sessionId, i.perfil ?? m.processo,
             i.thread ? `${i.thread}/${i.fase}` : '-', verbo[i.acao]])),
-        ...r.falhas.map(f => `Falha: ${f}`),
+        ...r.falhas.map(f => m.falha(f)),
     ].join('\n');
 }