@orkastery/cli 0.5.3 → 0.6.0

package/dist/session-watcher.js

@@ -33,10 +33,14 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BLOCO_WATCH_BYTES = exports.INTERVALO_WATCH_MS = exports.LIMITE_MORTE_MS = void 0;
+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. */
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
@@ -54,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 &&
@@ -110,6 +116,8 @@ function semProvaNativa(snapshot, terminal, fonteVencedora, fechamento, sessionI
 }
 exports.LIMITE_MORTE_MS = 600000;
 exports.INTERVALO_WATCH_MS = 1000;
+exports.MAX_ESPERA_ERRO_WATCH_MS = 30000;
+exports.MAX_FALHAS_WATCH = 12;
 exports.BLOCO_WATCH_BYTES = codex_events_1.LIMITE_LINHA_CODEX + 65536;
 function lerJson(file) {
     if (!fs.existsSync(file))
@@ -291,8 +299,195 @@ function desfazerNaThreadRemovida(pasta, criadas) {
         catch { /* já removida ou não vazia */ }
     }
 }
+/** Diagnóstico fechado: mensagens de E/S e JSON podem conter caminhos e segredos. */
+function diagnosticoWatcher(e) {
+    const erro = e;
+    const code = ['ENOENT', 'EAGAIN', 'EBUSY', 'EINTR', 'EACCES', 'EPERM', 'EIO', 'ENOSPC', 'SESSION_STATE_SPLIT']
+        .includes(erro?.code ?? '') ? erro.code : null;
+    const nome = e instanceof Error ? e.constructor.name : '';
+    const construtor = ['Error', 'SyntaxError', 'TypeError', 'RangeError', 'ReferenceError', 'URIError', 'EvalError', 'AggregateError']
+        .includes(nome) ? nome : 'desconhecido';
+    const base = { code, construtor };
+    const mensagem = erro?.message ?? '';
+    if (mensagem === 'prazo de observação esgotado')
+        return { ...base, categoria: 'observacao.prazo',
+            erro: 'nenhuma observação bem-sucedida dentro do orçamento de espera', transitorio: false };
+    // Só motivos literais do núcleo saem no diagnóstico: nenhum conteúdo de metadado.
+    const motivos = ['sessão do controller divergente', 'instância do controller divergente',
+        'vínculo thread/fase/prompt do controller divergente', 'cwd do controller divergente',
+        'identidade do controller divergente da registrada', 'identidade do runtime divergente da registrada',
+        'rollout do controller ausente', 'rollout do controller divergente do registrado',
+        'rollout do controller rotacionado sem vínculo provado com a fonte fixada',
+        'descritor consumidor de rollout divergente da fonte fixada'];
+    const metadado = /^runtime\.unavailable: metadado (state\.json|launch\.json|process-launch\.json) de controller (inválido|ausente)$/.test(mensagem);
+    const categoria = metadado || motivos.some(m => mensagem === `runtime.unavailable: ${m}`) ? mensagem
+        : mensagem === 'controlador registrado divergente do despacho' ? 'controller.registro-divergente'
+            : mensagem === 'despacho do controller sem cwd registrado' ? 'controller.cwd-ausente'
+                : mensagem.startsWith('runtime.unavailable:') ? 'runtime.unavailable: motivo não categorizado'
+                    : code ? `io.${code}` : construtor;
+    if (code === 'SESSION_STATE_SPLIT')
+        return { ...base, categoria: 'estado.dividido',
+            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 };
+    if (/^(ingestão ocupada|creation\.busy:)/.test(erro?.message ?? ''))
+        return { ...base, categoria: 'observacao.ocupada', erro: 'observação ocupada; nova tentativa agendada', transitorio: true };
+    return { ...base, categoria, erro: 'falha permanente na observação; confira vínculo e fonte do sensor', transitorio: false };
+}
+const errosRegistrados = new WeakSet();
+function registrarErroWatcher(raiz, threadId, sessionId, e, serie) {
+    if (!serie && e && typeof e === 'object' && errosRegistrados.has(e))
+        return true;
+    const dados = diagnosticoWatcher(e);
+    if (dados.categoria === 'observacao.ocupada')
+        return true;
+    const registrado = (0, ledger_1.registrarSeExiste)((0, thread_1.dirThread)(raiz, threadId), threadId, 'session_watcher_error', {
+        sessionId, motivo: 'runtime.unavailable', ...dados, ...serie,
+        transitorio: dados.transitorio && (!serie?.encerramento || serie.encerramento === 'recuperado'), origem: 'sessions.watch',
+    });
+    if (registrado && e && typeof e === 'object')
+        errosRegistrados.add(e);
+    return registrado !== null;
+}
+/** Falhar ao diagnosticar não troca o erro observado nem interrompe o retry transitório. */
+function tentarRegistrarErroWatcher(...args) {
+    try {
+        return registrarErroWatcher(...args);
+    }
+    catch {
+        return false;
+    }
+}
+function observarSemDiagnostico(carregado, sessionId, opcoes) {
+    return observarSessaoResolvida(carregado, sessionId, (0, session_events_1.resolverSessao)(carregado.raiz, sessionId, opcoes.threadId), opcoes);
+}
 function observarSessao(carregado, sessionId, opcoes = {}) {
-    const { thread, sessao: registrada } = (0, session_events_1.resolverSessao)(carregado.raiz, sessionId);
+    let threadId = opcoes.threadId;
+    try {
+        const resolvida = (0, session_events_1.resolverSessao)(carregado.raiz, sessionId, threadId);
+        // Recusa de entrada sem despacho não é falha de um watcher ancorado.
+        threadId = resolvida.sessao.origem !== 'adocao' && resolvida.sessao.despachadaEm
+            ? resolvida.thread.id : undefined;
+        return observarSessaoResolvida(carregado, sessionId, resolvida, opcoes);
+    }
+    catch (e) {
+        if (threadId)
+            tentarRegistrarErroWatcher(carregado.raiz, threadId, sessionId, e);
+        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')
         throw new Error('watch requer sessão Codex ou claude-bg registrada');
@@ -331,7 +526,8 @@ function observarSessao(carregado, sessionId, opcoes = {}) {
                 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)
@@ -398,6 +594,27 @@ function observarSessao(carregado, sessionId, opcoes = {}) {
                     cursor.progressoEm = Math.max(cursor.progressoEm, leitura.quando);
                 }
             }
+            // Commit MCP é produção do núcleo, mesmo quando app-server não avança o rollout.
+            // Só renova inatividade com ambos os processos vivos, dentro deste despacho e
+            // sem terminal/erro nativo. Não substitui terminal, close ou prova de conclusão.
+            let progressoMcpEventId;
+            if (snapshot?.estadoController === 'vivo' && snapshot.estadoRuntime === 'vivo' &&
+                ['working', 'running'].includes(snapshot.estado) && !snapshot.fechamento &&
+                !snapshot.terminalNativo && !snapshot.erro && !snapshot.limitacao) {
+                for (const e of (0, session_watcher_claude_1.eventosDoIntervalo)(eventos, sessao)) {
+                    const quando = Date.parse(e.ts);
+                    if (e.tipo !== 'mcp_git_committed' || e.thread !== thread.id || e.origem !== 'mcp.git' ||
+                        e.estadoAuditado !== true || typeof e.commit !== 'string' || !/^[a-f0-9]{40}$/.test(e.commit) ||
+                        (e.sessionId !== undefined && e.sessionId !== sessionId) ||
+                        (e.despachoEm !== undefined && e.despachoEm !== sessao.despachadaEm) ||
+                        quando > now || quando <= cursor.progressoEm)
+                        continue;
+                    cresceu = true;
+                    cursor.crescimentoEm = Math.max(cursor.crescimentoEm, quando);
+                    cursor.progressoEm = quando;
+                    progressoMcpEventId = e.eventId;
+                }
+            }
             // Erro de metadados posterior não obriga a reler o mesmo backlog no restart.
             (0, codex_runner_1.gravarAtomico)(file, cursor);
             const processo = registro?.processoPath ? lerJson(registro.processoPath) : null;
@@ -482,7 +699,8 @@ function observarSessao(carregado, sessionId, opcoes = {}) {
                     if (!atuais.some(e => e.sensorEventId === heartbeatId))
                         (0, ledger_1.registrar)(dir, thread.id, 'runtime_heartbeat', {
                             ts: new Date(cursor.crescimentoEm).toISOString(), fase: sessao.fase, sessionId, despachoEm: sessao.despachadaEm,
-                            sensorEventId: heartbeatId, fonte: 'progresso reconhecido do stream/rollout', bytesLidos,
+                            sensorEventId: heartbeatId, fonte: progressoMcpEventId ? 'mcp_git_committed do despacho' : 'progresso reconhecido do stream/rollout',
+                            ...(progressoMcpEventId ? { mcpEventId: progressoMcpEventId } : {}), bytesLidos,
                         });
                     cursor.heartbeatEm = cursor.crescimentoEm;
                     (0, codex_runner_1.gravarAtomico)(file, cursor);
@@ -506,10 +724,12 @@ function observarSessao(carregado, sessionId, opcoes = {}) {
                     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,
@@ -523,13 +743,18 @@ function observarSessao(carregado, sessionId, opcoes = {}) {
                     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 */ }
                 }
@@ -542,24 +767,21 @@ function observarSessao(carregado, sessionId, opcoes = {}) {
                     (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.
         if (!(0, ledger_1.threadPresente)(dir))
             return desfazer();
-        if (!/ocupad/.test(e.message) && !(0, ledger_1.registrarSeExiste)(dir, thread.id, 'session_watcher_error', {
-            fase: sessao.fase, sessionId, despachoEm: sessao.despachadaEm, motivo: 'runtime.unavailable',
-            // Não copiar conteúdo de metadados/logs em mensagens de JSON.parse.
-            erro: e instanceof SyntaxError ? 'metadado JSON inválido' : e.message,
-            origem: 'sessions.watch',
-        }))
-            return removida;
         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);
@@ -572,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;
     }
@@ -593,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);
@@ -600,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;
@@ -612,7 +855,7 @@ function iniciarWatcher(raiz, sessionId) {
     const err = fs.openSync(path.join(dir, `watcher-${sessionId}.stderr`), 'a', 0o600);
     let child;
     try {
-        child = (0, node_child_process_1.spawn)(process.execPath, [__filename, '--run', raiz, sessionId, readyPath, token], {
+        child = (0, node_child_process_1.spawn)(process.execPath, [__filename, '--run', raiz, sessionId, readyPath, token, thread.id], {
             cwd: raiz, detached: true, stdio: ['ignore', 'ignore', err],
         });
     }
@@ -661,47 +904,102 @@ function iniciarWatcher(raiz, sessionId) {
 }
 async function acompanhar() {
     const carregado = (0, manifest_1.exigirManifesto)(process.argv[3]), sessionId = process.argv[4];
-    const { thread } = (0, session_events_1.resolverSessao)(carregado.raiz, sessionId);
-    const readyPath = process.argv[5], token = process.argv[6];
-    if (readyPath && token) {
-        validarFonteWatcher(carregado.raiz, sessionId);
-        const sessao = (0, session_events_1.exigirSessaoDespachada)((0, session_events_1.resolverSessao)(carregado.raiz, sessionId).sessao, sessionId);
-        const identidade = (0, codex_runner_1.identidadeProcesso)(process.pid);
-        if (!identidade)
-            throw new Error('watcher sem identidade propria');
-        (0, codex_runner_1.gravarAtomico)(readyPath, { token, sessionId, despachoEm: sessao.despachadaEm, identidade });
-        const deadline = Date.now() + 5000;
-        while (lerJson(readyPath + '.ack')?.token !== token) {
-            if (Date.now() >= deadline)
-                throw new Error('watcher sem confirmacao do pai');
-            await new Promise(r => setTimeout(r, 10));
+    const threadId = process.argv[7] ?? (0, session_events_1.resolverSessao)(carregado.raiz, sessionId).thread.id;
+    try {
+        const readyPath = process.argv[5], token = process.argv[6];
+        if (readyPath && token) {
+            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)
+                throw new Error('watcher sem identidade propria');
+            (0, codex_runner_1.gravarAtomico)(readyPath, { token, sessionId, despachoEm: sessao.despachadaEm, identidade });
+            const deadline = Date.now() + 5000;
+            while (lerJson(readyPath + '.ack')?.token !== token) {
+                if (Date.now() >= deadline)
+                    throw new Error('watcher sem confirmacao do pai');
+                await new Promise(r => setTimeout(r, 10));
+            }
         }
+        await acompanharSessao(carregado, sessionId, { threadId });
     }
-    const dir = (0, thread_1.dirThread)(carregado.raiz, thread.id);
+    catch (e) {
+        tentarRegistrarErroWatcher(carregado.raiz, threadId, sessionId, e);
+        throw e;
+    }
+}
+/** Mesmo laço do processo destacado, com relógio e espera injetáveis para regressões. */
+async function acompanharSessao(carregado, sessionId, opcoes) {
+    const dir = (0, thread_1.dirThread)(carregado.raiz, opcoes.threadId);
+    const esperar = opcoes.esperar ?? ((ms) => new Promise(r => setTimeout(r, ms)));
+    const agora = opcoes.agora ?? Date.now;
+    let falhas = 0, tentativas = 0, esperas = 0, ultimaObservacao = agora(), ultimoErro;
     for (;;) {
         // Projeto ou thread apagados encerram o laço em silêncio: nada a observar nem a recriar.
         if (!(0, ledger_1.threadPresente)(dir))
             return;
         let atual;
         try {
-            atual = (0, thread_1.lerThread)(carregado.raiz, thread.id);
+            atual = (0, thread_1.lerThread)(carregado.raiz, opcoes.threadId);
             if (atual.status !== 'aberta' || atual.sessoes.at(-1)?.sessionId !== sessionId)
                 return;
-            const r = observarSessao(carregado, sessionId);
+            // O laço agrega sua série de erros; a API de observação avulsa diagnostica separadamente.
+            const r = observarSemDiagnostico(carregado, sessionId, { threadId: opcoes.threadId, agoraMs: opcoes.agora?.() });
+            if (r.ocupado)
+                throw new Error('ingestão ocupada; tente novamente');
+            if (!r.ocupado) {
+                if (falhas)
+                    tentarRegistrarErroWatcher(carregado.raiz, opcoes.threadId, sessionId, ultimoErro, { falhasConsecutivas: falhas, etapa: 'final', encerramento: 'recuperado' });
+                falhas = 0;
+                tentativas = 0;
+                esperas = 0;
+                ultimaObservacao = agora();
+            }
             if (r.concluido || r.encerrado)
                 return;
         }
         catch (e) {
             if (!(0, ledger_1.threadPresente)(dir))
                 return;
-            if (!/ocupad/.test(e.message))
-                throw e;
+            esperas++;
+            const dados = diagnosticoWatcher(e), ocupado = dados.categoria === 'observacao.ocupada';
+            const expirou = agora() - ultimaObservacao >= exports.LIMITE_MORTE_MS;
+            // Contenção não é erro. Estado dividido exige nova auditoria; ambos consomem
+            // só tempo, sem antecipar os 600 s pelo teto das outras falhas.
+            if (!ocupado || expirou) {
+                if (ocupado)
+                    e = new Error('prazo de observação esgotado');
+                falhas++;
+                if (!ocupado && dados.categoria !== 'estado.dividido')
+                    tentativas++;
+                ultimoErro = e;
+                const encerramento = ocupado ? 'prazo' : !dados.transitorio ? 'permanente'
+                    : expirou ? 'prazo' : tentativas >= exports.MAX_FALHAS_WATCH ? 'tentativas' : undefined;
+                if (falhas === 1 || encerramento)
+                    tentarRegistrarErroWatcher(carregado.raiz, opcoes.threadId, sessionId, e, { falhasConsecutivas: falhas, etapa: encerramento ? 'final' : 'inicial', ...(encerramento ? { encerramento } : {}) });
+                if (encerramento)
+                    throw e;
+            }
         }
-        await new Promise(r => setTimeout(r, atual?.sessoes.at(-1)?.runtime === 'claude-bg' ? session_watcher_claude_1.INTERVALO_WATCH_CLAUDE_MS : exports.INTERVALO_WATCH_MS));
+        await esperar(esperas ? Math.min(exports.MAX_ESPERA_ERRO_WATCH_MS, exports.INTERVALO_WATCH_MS * 2 ** Math.min(esperas - 1, 5), Math.max(1, exports.LIMITE_MORTE_MS - (agora() - ultimaObservacao)))
+            : atual?.sessoes.at(-1)?.runtime === 'claude-bg' ? session_watcher_claude_1.INTERVALO_WATCH_CLAUDE_MS : exports.INTERVALO_WATCH_MS);
     }
 }
 if (require.main === module && process.argv[2] === '--run')
-    acompanhar().catch(() => {
-        process.stderr.write('ork watcher: observação interrompida; confira session_watcher_error e estado canônico.\n');
+    acompanhar().catch(e => {
+        // O dispatcher fornece o vínculo antes do spawn: até falha ao carregar o manifesto
+        // precisa de diagnóstico. Sem ledger acessível, o stderr não promete um recibo inexistente.
+        let registroIndisponivel = !process.argv[7];
+        if (process.argv[7]) {
+            try {
+                registroIndisponivel = !registrarErroWatcher(process.argv[3], process.argv[7], process.argv[4], e);
+            }
+            catch {
+                registroIndisponivel = true;
+            }
+        }
+        process.stderr.write(registroIndisponivel
+            ? 'ork watcher: observação interrompida; não foi possível registrar session_watcher_error.\n'
+            : 'ork watcher: observação interrompida; confira session_watcher_error e estado canônico.\n');
         process.exitCode = 1;
     });

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);
 }
@@ -132,7 +141,7 @@ function consultarContas(raiz, opcoes = {}) {
                 fontes.push({ origem: `claude agents (${rotulo(conta)})`, ok: false, detalhe: e.message });
                 continue;
             }
-            const r = (0, claude_bg_1.consultarSessoes)(undefined, opcoes.todas, ambiente);
+            const r = (0, claude_bg_1.consultarSessoes)(undefined, opcoes.todas, ambiente, opcoes.prazoMs);
             const origem = `claude agents --json${opcoes.todas ? ' --all' : ''} (${rotulo(conta)})`;
             // Fatia 2 do ensaio da 0.5.0 (P1): só o ENOENT antes da consulta prova a fonte ausente; qualquer
             // outra falha do `claude` continua deixando o inventário incompleto.

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.