@orkastery/cli 0.2.0 → 0.3.0

package/dist/session-watcher.js

@@ -0,0 +1,683 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BLOCO_WATCH_BYTES = exports.INTERVALO_WATCH_MS = exports.LIMITE_MORTE_MS = void 0;
+exports.observarSessao = observarSessao;
+exports.validarFonteWatcher = validarFonteWatcher;
+exports.iniciarWatcher = iniciarWatcher;
+/** 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"));
+const node_crypto_1 = require("node:crypto");
+const node_child_process_1 = require("node:child_process");
+const codex_1 = require("./adapters/codex");
+const runtime_profiles_1 = require("./runtime-profiles");
+const codex_events_1 = require("./adapters/codex-events");
+const codex_runner_1 = require("./adapters/codex-runner");
+const thread_1 = require("./thread");
+const session_events_1 = require("./session-events");
+const ledger_1 = require("./ledger");
+const manifest_1 = require("./manifest");
+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");
+/** 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 &&
+        ((0, retry_1.politicaDoMotivo)(terminal.motivo)?.automatica === false ||
+            ['runtime.rate-limited', 'runtime.unavailable', 'runtime.silencio', 'tree.blocked', 'lease.busy'].includes(terminal.motivo) ||
+            // I-33 (D12): falha da conta com erro estruturado do runtime tambem nao alega conclusao.
+            (!!terminal.falhaDeConta && terminal.motivo === terminal.falhaDeConta.motivo));
+}
+/**
+ * I-33 (D12): falha da CONTA no caminho terminal do turno codex. Duas fontes do proprio runtime,
+ * nunca texto do agente: o `task_complete.error` do rollout (valido e com o turno fechado) e o erro
+ * nativo do `turn/completed` `failed` gravado pelo controller. O incidente de 18/09 tinha as duas.
+ */
+function falhaDeContaDoTerminal(terminal, rolloutConfiavel, snapshot, agoraMs) {
+    if (rolloutConfiavel && terminal?.falhaDeConta)
+        return { falha: terminal.falhaDeConta, fonte: `${terminal.fonte}.error` };
+    const nativo = snapshot?.terminalNativo;
+    if (nativo?.status !== 'failed' || !nativo.erro)
+        return null;
+    const falha = (0, codex_events_1.falhaDeContaDoErroCodex)(nativo.erro, agoraMs);
+    return falha ? { falha, fonte: 'controller.turn/completed.error' } : null;
+}
+/**
+ * Portao I04 do transporte do controller. Enumera o que falta para o sucesso ser prova,
+ * nunca o contrario: devolve `null` so quando terminal nativo `completed`, estado sem erro
+ * nem limitacao, correlacao de thread, cwd e turno e `close` real zero estao todos
+ * demonstrados. Prefixo de texto nao e proveniencia: id de origem gerada nao vincula turno.
+ */
+function semProvaNativa(snapshot, terminal, fonteVencedora, fechamento, sessionId, cwd) {
+    const nativo = snapshot.terminalNativo;
+    if (!nativo)
+        return 'terminal nativo ausente na fonte do controller';
+    if (nativo.status !== 'completed') {
+        const conhecido = nativo.status === 'failed' || nativo.status === 'interrupted';
+        return `terminal nativo com status ${conhecido ? nativo.status : 'desconhecido'}`;
+    }
+    if (nativo.threadId !== sessionId)
+        return 'terminal nativo de outra thread';
+    if (snapshot.erro || snapshot.limitacao)
+        return 'estado do controller com erro ou limitacao tipada';
+    if (snapshot.fonte.cwd !== cwd)
+        return 'cwd da fonte divergente do despacho';
+    if (snapshot.turno !== nativo.turnId)
+        return 'turno do estado divergente do terminal nativo';
+    if (fonteVencedora !== 'rollout')
+        return 'terminal observado fora do rollout fixado';
+    if (terminal.turnIdOrigem !== 'explicito')
+        return 'id de turno sem proveniencia explicita e sem vinculacao alternativa provada';
+    if (terminal.turnId !== nativo.turnId)
+        return 'turno observado divergente do terminal nativo';
+    if (!fechamento || fechamento.exitCode !== 0 || fechamento.signal || fechamento.erro)
+        return 'close real zero do controller ausente';
+    return null;
+}
+exports.LIMITE_MORTE_MS = 600000;
+exports.INTERVALO_WATCH_MS = 1000;
+exports.BLOCO_WATCH_BYTES = codex_events_1.LIMITE_LINHA_CODEX + 65536;
+function lerJson(file) {
+    if (!fs.existsSync(file))
+        return null;
+    if (fs.statSync(file).size > 65536)
+        throw new Error('metadado de sensor excessivo');
+    return JSON.parse(fs.readFileSync(file, 'utf8'));
+}
+/** Recovery serializado: quem perde o mutex não remove lock recém-adquirido. */
+function comLockWatcher(dir, action) {
+    const lock = path.join(dir, 'watch.lock'), recover = path.join(dir, 'recover.lock');
+    const dono = { identidade: (0, codex_runner_1.identidadeProcesso)(process.pid), token: (0, node_crypto_1.randomUUID)() };
+    const owner = path.join(lock, 'owner.json');
+    const criar = () => { fs.mkdirSync(lock); (0, codex_runner_1.gravarAtomico)(owner, dono); };
+    try {
+        criar();
+    }
+    catch (e) {
+        if (e.code !== 'EEXIST')
+            throw e;
+        try {
+            fs.mkdirSync(recover);
+        }
+        catch {
+            return null;
+        }
+        try {
+            const atual = lerJson(owner);
+            if (atual ? (0, codex_runner_1.estadoProcesso)(atual.identidade) !== 'ausente' : Date.now() - fs.statSync(lock).mtimeMs < 60000)
+                return null;
+            if (atual)
+                fs.unlinkSync(owner);
+            fs.rmdirSync(lock);
+            try {
+                criar();
+            }
+            catch (erro) {
+                if (erro.code === 'EEXIST')
+                    return null;
+                throw erro;
+            }
+        }
+        finally {
+            fs.rmdirSync(recover);
+        }
+    }
+    try {
+        return action();
+    }
+    finally {
+        if (lerJson(owner)?.token === dono.token) {
+            fs.unlinkSync(owner);
+            fs.rmdirSync(lock);
+        }
+    }
+}
+function lerFonte(file, anterior, agoraMs, sessionId, fixada) {
+    const fd = fs.openSync(file, fixada
+        ? fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW | fs.constants.O_NONBLOCK : 'r');
+    try {
+        const stat = fs.fstatSync(fd);
+        if (fixada) {
+            // A validação anterior do sensor não autentica um pathname reaberto depois.
+            // Os bytes precisam vir do próprio descritor vinculado à identidade fixada.
+            const pai = fs.statSync(path.dirname(file));
+            if (file !== fixada.rollout || !stat.isFile() || stat.ino !== fixada.rolloutIno ||
+                stat.dev !== fixada.rolloutDev || stat.uid !== fixada.uid || (stat.mode & 0o022) !== 0 ||
+                fs.realpathSync(file) !== file || !pai.isDirectory() || pai.uid !== fixada.uid ||
+                (pai.mode & 0o022) !== 0) {
+                throw new Error('runtime.unavailable: descritor consumidor de rollout divergente da fonte fixada');
+            }
+        }
+        const mesmo = anterior?.file === file && anterior.ino === stat.ino && stat.size >= anterior.offset;
+        const parser = new codex_events_1.ParserCodex(mesmo ? anterior.parser : undefined);
+        // Corrupção já observada continua relevante depois de truncamento/rotação.
+        parser.estado.invalido ||= anterior?.parser.invalido ?? false;
+        let offset = mesmo ? anterior.offset : 0;
+        const buffer = Buffer.alloc(Math.min(exports.BLOCO_WATCH_BYTES, stat.size - offset));
+        const n = fs.readSync(fd, buffer, 0, buffer.length, offset);
+        const fim = buffer.subarray(0, n).lastIndexOf(10);
+        let terminal = mesmo ? anterior.terminal : null;
+        if (fim >= 0) {
+            for (const linha of buffer.subarray(0, fim + 1).toString('utf8').split('\n')) {
+                let e;
+                try {
+                    e = JSON.parse(linha);
+                }
+                catch {
+                    continue;
+                }
+                if ((e?.type === 'thread.started' && e.thread_id !== sessionId) ||
+                    (e?.type === 'session_meta' && e.payload?.id !== sessionId))
+                    throw new Error('log/rollout pertence a outra sessão');
+            }
+            for (const t of parser.push(buffer.subarray(0, fim + 1), agoraMs))
+                terminal = t;
+            offset += fim + 1;
+        }
+        else if (n >= codex_events_1.LIMITE_LINHA_CODEX) {
+            // Uma linha sem limite não retém o cursor para sempre nem permite alegar sucesso.
+            parser.estado.invalido = true;
+            offset += n;
+        }
+        if (parser.estado.turnoAberto || (terminal?.numeroTurno ?? 0) < parser.estado.turnos)
+            terminal = null;
+        const parcial = n < exports.BLOCO_WATCH_BYTES && stat.size > offset;
+        return { cursor: { file, ino: stat.ino, tamanho: stat.size, offset, parser: parser.estado, terminal, parcial },
+            cresceu: parser.eventosValidos > 0,
+            quando: Math.min(agoraMs, stat.mtimeMs), bytes: n, temMais: stat.size > offset };
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+function conferirRegistro(dir, registro) {
+    // A variante nativa não declara arquivo: a fonte é o `claude agents` e o cwd do despacho.
+    if (registro.nativo !== undefined) {
+        if (registro.logPath || registro.processoPath || registro.reciboPath || registro.controlador)
+            throw new Error('registro de sensor mistura fonte nativa e arquivo');
+        return;
+    }
+    const esperado = path.join(dir, 'sessoes') + path.sep;
+    for (const file of [registro.logPath, registro.processoPath, registro.reciboPath, registro.controlador].filter(Boolean)) {
+        if (!path.resolve(file).startsWith(esperado) ||
+            (fs.existsSync(file) && !fs.realpathSync(file).startsWith(esperado)))
+            throw new Error('fonte de sensor fora do diretório canônico de sessões');
+    }
+    // A variante do controller dispensa logPath; a histórica continua exigindo o log e seus sufixos.
+    if (registro.controlador) {
+        if (registro.logPath || registro.processoPath || registro.reciboPath)
+            throw new Error('registro de sensor mistura controller e log supervisionado');
+        return;
+    }
+    if (!registro.logPath)
+        throw new Error('registro de sensor sem fonte declarada');
+    if ((registro.processoPath && registro.processoPath !== registro.logPath + '.process.json') ||
+        (registro.reciboPath && registro.reciboPath !== registro.logPath + '.exit.json'))
+        throw new Error('recibo não corresponde ao log registrado');
+}
+/**
+ * GO-FIX 3 (achado 1): apaga os cursores da pasta de sensores e as pastas que a observação
+ * criou, da mais funda para a raiz. Pasta que já sumiu, ou que ganhou entrada alheia, fica
+ * com o dono da remoção.
+ */
+function desfazerNaThreadRemovida(pasta, criadas) {
+    for (const cursor of ['cursor.json', 'cursor-claude.json']) {
+        try {
+            fs.rmSync(path.join(pasta, cursor), { force: true });
+        }
+        catch { /* pasta já removida */ }
+    }
+    for (const nivel of [...criadas].reverse()) {
+        try {
+            fs.rmdirSync(nivel);
+        }
+        catch { /* já removida ou não vazia */ }
+    }
+}
+function observarSessao(carregado, sessionId, opcoes = {}) {
+    const { thread, sessao: registrada } = (0, session_events_1.resolverSessao)(carregado.raiz, sessionId);
+    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');
+    const now = opcoes.agoraMs ?? Date.now();
+    if (!Number.isFinite(now))
+        throw new Error('relógio inválido');
+    const dir = (0, thread_1.dirThread)(carregado.raiz, thread.id);
+    const chave = (0, node_crypto_1.createHash)('sha256').update(sessionId + '|' + sessao.despachadaEm).digest('hex');
+    const base = { sessionId, thread: thread.id, concluido: false, bytesLidos: 0 };
+    const pasta = path.join(dir, 'sensores', chave);
+    // Processo destacado não recria a thread de um projeto apagado: a pasta de sensores nasce
+    // sem `recursive`, só dentro de uma thread presente, e a ausência encerra a observação.
+    const removida = { ...base, encerrado: true, espera: session_watcher_claude_1.THREAD_REMOVIDA };
+    // GO-FIX 3 (achado 1): a thread pode sumir entre a checagem e a criação. O que esta observação
+    // criou ou gravou numa thread que sumiu é desfeito, para um `rm -rf` concorrente não esbarrar
+    // em `sensores/` recriado nem deixar cursor órfão.
+    const criadas = [];
+    const desfazer = () => { desfazerNaThreadRemovida(pasta, criadas); return removida; };
+    try {
+        if (!(0, ledger_1.threadPresente)(dir))
+            return removida;
+        for (const nivel of [path.dirname(pasta), pasta]) {
+            try {
+                fs.mkdirSync(nivel);
+                criadas.push(nivel);
+            }
+            catch (e) {
+                if (e.code !== 'EEXIST')
+                    throw e;
+            }
+        }
+        if (!(0, ledger_1.threadPresente)(dir))
+            return desfazer();
+        if (sessao.runtime === 'claude-bg') {
+            const r = comLockWatcher(pasta, () => (0, session_watcher_claude_1.observarClaudeSobLock)({ raiz: carregado.raiz,
+                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, () => {
+            const eventos = (0, ledger_1.lerLedger)(dir), resultadoId = `codex:${chave}`;
+            const pronto = eventos.find(e => e.tipo === 'phase_result' && e.sensorResultId === resultadoId);
+            if (pronto)
+                return { ...base, concluido: true, classificacao: String(pronto.classificacao) };
+            const registro = eventos.filter(e => e.tipo === 'session_sensor_registered' &&
+                e.sessionId === sessionId && e.despachoEm === sessao.despachadaEm).at(-1);
+            if (registro)
+                conferirRegistro(dir, registro);
+            // I-33 (D4): o rollout mora no CODEX_HOME do perfil que despachou, nunca no do processo.
+            const perfil = (0, runtime_profiles_1.perfilDoRegistro)(eventos, sessao);
+            // Fonte do controller validada ANTES de ler rollout ou escrever cursor.
+            let fonteControlador = null, snapshot = null;
+            let cwdDespacho;
+            if (registro?.controlador) {
+                const despacho = eventos.filter(e => e.tipo === 'phase_dispatch' && e.sessionId === sessionId).at(-1);
+                if (despacho?.controlador !== undefined && despacho.controlador !== registro.controlador)
+                    throw new Error('controlador registrado divergente do despacho');
+                const cwd = (despacho?.cwd ?? registro.cwd);
+                if (!cwd)
+                    throw new Error('despacho do controller sem cwd registrado');
+                cwdDespacho = cwd;
+                fonteControlador = (0, codex_controller_sensor_1.registrarFonteController)(registro.controlador, {
+                    dirSessoes: path.join(dir, 'sessoes'), sessionId, cwd, despachoEm: sessao.despachadaEm, agoraMs: now,
+                    fixacao: path.join(dir, 'sessoes', `watcher-source-${chave}.json`),
+                    vinculo: { thread: thread.id, fase: sessao.fase, promptSha256: sessao.promptSha256 }
+                });
+                snapshot = (0, codex_controller_sensor_1.lerSnapshotController)(fonteControlador, { agoraMs: now });
+            }
+            const file = path.join(pasta, 'cursor.json');
+            const cursor = lerJson(file) ?? { schema: 'ork.session-cursor/v1', sessionId,
+                despachoEm: sessao.despachadaEm, crescimentoEm: Date.parse(sessao.despachadaEm), heartbeatEm: 0, fontes: {} };
+            if (cursor.schema !== 'ork.session-cursor/v1' || cursor.sessionId !== sessionId || cursor.despachoEm !== sessao.despachadaEm)
+                throw new Error('cursor de outra sessão/despacho');
+            // Cursor anterior media bytes, nao progresso: migracao conservadora desde o despacho.
+            cursor.progressoEm ??= Date.parse(sessao.despachadaEm);
+            // Transporte do controller não admite descoberta nem override de rollout.
+            const fontes = { stream: registro?.logPath, rollout: snapshot ? snapshot.rollout
+                    : opcoes.rollout === undefined ? (0, codex_1.acharRollout)(sessionId, 3, (0, codex_1.casaDoCodex)(perfil)) : opcoes.rollout };
+            let bytesLidos = 0, temMais = false, cresceu = false;
+            for (const [nome, fonte] of Object.entries(fontes)) {
+                if (!fonte || !fs.existsSync(fonte))
+                    continue;
+                let leitura;
+                try {
+                    leitura = lerFonte(fonte, cursor.fontes[nome], now, sessionId, nome === 'rollout' ? fonteControlador ?? undefined : undefined);
+                }
+                catch (e) {
+                    if (nome !== 'rollout' || e.message !== 'log/rollout pertence a outra sessão')
+                        throw e;
+                    delete cursor.fontes[nome];
+                    if (!eventos.some(e => e.tipo === 'session_watcher_source_rejected' && e.sessionId === sessionId)) {
+                        (0, ledger_1.registrar)(dir, thread.id, 'session_watcher_source_rejected', { sessionId, despachoEm: sessao.despachadaEm,
+                            fase: sessao.fase, fonte: nome, motivo: 'identidade de sessão divergente' });
+                    }
+                    continue;
+                }
+                cursor.fontes[nome] = leitura.cursor;
+                bytesLidos += leitura.bytes;
+                temMais ||= leitura.temMais;
+                if (leitura.cresceu) {
+                    cresceu = true;
+                    cursor.crescimentoEm = Math.max(cursor.crescimentoEm, leitura.quando);
+                    cursor.progressoEm = Math.max(cursor.progressoEm, leitura.quando);
+                }
+            }
+            // 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;
+            const recibo = registro?.reciboPath ? lerJson(registro.reciboPath) : null;
+            if (recibo && (!processo || recibo.schema !== 'ork.codex-process/v1' || recibo.iniciadoEm !== processo.iniciadoEm ||
+                JSON.stringify(recibo.filho) !== JSON.stringify(processo.filho) ||
+                !Number.isFinite(Date.parse(recibo.terminadoEm)) || Date.parse(recibo.terminadoEm) > now ||
+                !Number.isFinite(recibo.duracaoMs) || recibo.duracaoMs < 0 ||
+                (recibo.exitCode !== null && (!Number.isInteger(recibo.exitCode) || recibo.exitCode < 0)) ||
+                (recibo.signal !== null && typeof recibo.signal !== 'string')))
+                throw new Error('recibo de processo inválido');
+            // Fechamento normalizado: recibo do supervisor OU close real do controller, nunca ambos.
+            const fechamento = snapshot?.fechamento
+                ? { exitCode: snapshot.fechamento.exitCode, signal: snapshot.fechamento.signal,
+                    duracaoMs: snapshot.fechamento.duracaoMs, erro: null, fonte: 'controller.close' }
+                : recibo ? { exitCode: recibo.exitCode, signal: recibo.signal, duracaoMs: recibo.duracaoMs,
+                    erro: recibo.erro, fonte: 'supervisor.close' } : null;
+            const supervisionado = !!registro?.processoPath || !!snapshot;
+            // Espera nativa autenticada e viva não é silêncio: não conta prazo nem termina o turno.
+            const esperaHumana = snapshot?.esperaHumana ?? false;
+            const estado = fechamento ? 'ausente' : snapshot ? snapshot.estadoRuntime : (0, codex_runner_1.estadoProcesso)(processo?.filho ?? null);
+            const terminais = Object.entries(cursor.fontes).filter(([, f]) => f.terminal)
+                .map(([nome, f]) => ({ nome, terminal: f.terminal }));
+            const ordem = { gate_blocked: 0, 'human.pending': 1, fase_concluida: 2 };
+            terminais.sort((a, b) => {
+                const x = a.terminal, y = b.terminal;
+                // Observação de leitura não é timestamp do evento. Contagem só desempata
+                // fontes sem timestamps comparáveis; severidade vale no mesmo turno.
+                const tempo = x.timestampFonte === 'evento' && y.timestampFonte === 'evento'
+                    ? Date.parse(y.timestamp) - Date.parse(x.timestamp) : 0;
+                return tempo || (y.numeroTurno ?? 0) - (x.numeroTurno ?? 0) ||
+                    ordem[x.classificacao] - ordem[y.classificacao] || a.nome.localeCompare(b.nome);
+            });
+            let terminal = terminais[0]?.terminal;
+            const fontesAtuais = Object.values(cursor.fontes);
+            const aberto = fontesAtuais.some(f => {
+                if (!f.parser.turnoAberto)
+                    return false;
+                if (!terminal)
+                    return true;
+                if (f.parser.turnoIniciadoEm && terminal.timestampFonte === 'evento') {
+                    return Date.parse(f.parser.turnoIniciadoEm) > Date.parse(terminal.timestamp);
+                }
+                // Um terminal confirmado cobre a fonte atrasada ainda aberta no mesmo turno.
+                return f.parser.turnos > (terminal.numeroTurno ?? 0);
+            });
+            const parcial = fontesAtuais.some(f => f.parcial);
+            const backlog = fontesAtuais.some(f => f.tamanho > f.offset && !f.parcial);
+            // Suspensao medida entre observacoes autenticadas; persiste no cursor para restart.
+            if (esperaHumana)
+                cursor.esperaDesde ??= now;
+            else if (cursor.esperaDesde !== undefined) {
+                cursor.progressoEm += Math.max(0, now - Math.max(cursor.esperaDesde, cursor.progressoEm));
+                delete cursor.esperaDesde;
+            }
+            const estavel = !esperaHumana && now - cursor.progressoEm >= exports.LIMITE_MORTE_MS;
+            const semCloseNoLimite = supervisionado && !fechamento && estavel;
+            const invalido = fontesAtuais.some(f => f.parser.invalido);
+            // Conclusão nativa é medida em todo terminal, independente da política de retry:
+            // bloqueio sem retry preserva o motivo, mas não prova que o turno do runtime terminou.
+            const provaNativa = snapshot && terminal
+                ? semProvaNativa(snapshot, terminal, terminais[0]?.nome, fechamento, sessionId, cwdDespacho)
+                : 'terminal nativo do controller ausente';
+            // Parecer negativo também exige conclusão nativa inteira: texto claims.failed de
+            // turno interrompido não pode virar rejeição autenticada de um objetivo.
+            const semProva = snapshot && terminal && terminal.classificacao !== 'human.pending' && !bloqueioPreservado(terminal)
+                ? provaNativa : null;
+            const descorrelacionado = !!semProva;
+            const incompleto = semCloseNoLimite && (!!terminal || estado !== 'ausente' || aberto || parcial || invalido) || !backlog && (((parcial || aberto || invalido || descorrelacionado || !terminal) && !!fechamento) ||
+                (estavel && (parcial || (aberto && estado === 'ausente') ||
+                    (supervisionado && estado === 'desconhecido'))));
+            const morte = estado === 'ausente' && estavel && !temMais;
+            // Fechamento supervisionado precisa existir antes de associar o código de saída ao turno.
+            const podeTerminar = !esperaHumana && (incompleto || (!temMais && !aberto &&
+                ((terminal && (fechamento || !supervisionado)) || morte)));
+            const conta = falhaDeContaDoTerminal(terminal, !invalido && !aberto, snapshot, now);
+            (0, codex_runner_1.gravarAtomico)(file, cursor);
+            return (0, session_events_1.comLockDeSessao)(dir, () => {
+                const atuais = (0, ledger_1.lerLedger)(dir);
+                if (cresceu && cursor.crescimentoEm > cursor.heartbeatEm) {
+                    const heartbeatId = `${resultadoId}:heartbeat:${cursor.crescimentoEm}`;
+                    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,
+                        });
+                    cursor.heartbeatEm = cursor.crescimentoEm;
+                    (0, codex_runner_1.gravarAtomico)(file, cursor);
+                }
+                if (!podeTerminar)
+                    return { ...base, bytesLidos };
+                const semTerminal = !terminal;
+                // Fato registrado para a autoridade de revisão: `null` só com terminal nativo correlacionado.
+                const conclusaoNativa = incompleto || invalido || aberto || descorrelacionado
+                    ? provaNativa ?? 'observação incompleta ou inválida' : provaNativa;
+                if (incompleto || invalido || aberto || descorrelacionado)
+                    terminal = { classificacao: 'gate_blocked', motivo: 'runtime.unavailable',
+                        timestamp: new Date(now).toISOString(), turnId: null, fonte: semProva ?? 'observação incompleta ou inválida',
+                        tokens: new codex_events_1.ParserCodex().estado.tokens, duracaoMs: null };
+                if (!terminal)
+                    terminal = { classificacao: 'gate_blocked', motivo: 'runtime.silencio',
+                        timestamp: new Date(now).toISOString(), turnId: null, fonte: 'processo ausente e arquivos estáveis',
+                        tokens: new codex_events_1.ParserCodex().estado.tokens, duracaoMs: null };
+                if (fechamento && (fechamento.exitCode !== 0 || fechamento.signal || fechamento.erro) &&
+                    terminal.classificacao !== 'human.pending' && !bloqueioPreservado(terminal)) {
+                    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.
+                if (conta)
+                    terminal = { ...terminal, classificacao: 'gate_blocked', motivo: conta.falha.motivo, falhaDeConta: conta.falha,
+                        fonte: `${conta.fonte}: ${conta.falha.motivo} (${conta.falha.trecho})` };
+                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,
+                    turnId: terminal.turnId, numeroTurno: terminal.numeroTurno ?? null,
+                    tokens: terminal.tokens, exitCode: fechamento?.exitCode ?? null, exitCodeFonte: fechamento?.fonte ?? 'unavailable',
+                    signal: fechamento?.signal ?? null, duracaoMs: fechamento?.duracaoMs ?? terminal.duracaoMs,
+                    duracaoFonte: fechamento?.fonte ?? (terminal.duracaoMs === null ? 'unavailable' : terminal.fonte),
+                    ok: terminal.classificacao === 'fase_concluida' && fechamento?.exitCode === 0,
+                    conclusaoNativa: conclusaoNativa === null,
+                    conclusaoNativaAusente: conclusaoNativa,
+                    estado: terminal.classificacao === 'fase_concluida' ? 'concluida' : 'bloqueada',
+                    observadoEm: terminal.timestamp, gate: 'phase.dispatch', origem: 'sessions.watch',
+                    morteLatenciaMs: morte ? now - cursor.progressoEm : null, ...(perfil ? { perfil } : {}),
+                    ...(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);
+                    }
+                    catch { /* store ocupado ou invalido: o retry marca de novo pelo gate tipado */ }
+                }
+                if (!atuais.some(e => e.tipo === tipo && e.sensorResultId === resultadoId))
+                    (0, ledger_1.registrar)(dir, thread.id, tipo, dados);
+                if (terminal.classificacao !== 'fase_concluida' && tipo !== 'gate_blocked' &&
+                    !atuais.some(e => e.tipo === 'gate_blocked' && e.sensorResultId === resultadoId))
+                    (0, ledger_1.registrar)(dir, thread.id, 'gate_blocked', dados);
+                if (!atuais.some(e => e.tipo === 'phase_result' && e.sensorResultId === resultadoId))
+                    (0, ledger_1.registrar)(dir, thread.id, 'phase_result', dados);
+                return { ...base, bytesLidos, concluido: true, classificacao: terminal.classificacao };
+            });
+        }) ?? { ...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) {
+    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);
+    const eventos = (0, ledger_1.lerLedger)(dir);
+    const registro = fonte ?? eventos.filter(e => e.tipo === 'session_sensor_registered' &&
+        e.sessionId === sessionId && e.despachoEm === sessao.despachadaEm).at(-1);
+    if (!registro)
+        throw new Error('fonte de sensor ausente');
+    conferirRegistro(dir, registro);
+    // 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) {
+        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;
+    }
+    if (registro.controlador) {
+        const despacho = eventos.filter(e => e.tipo === 'phase_dispatch' && e.sessionId === sessionId).at(-1);
+        if (despacho?.controlador !== undefined && despacho.controlador !== registro.controlador)
+            throw new Error('controlador registrado divergente do despacho');
+        const cwd = (despacho?.cwd ?? registro.cwd);
+        if (!cwd)
+            throw new Error('despacho do controller sem cwd registrado');
+        const chave = (0, node_crypto_1.createHash)('sha256').update(sessionId + '|' + sessao.despachadaEm).digest('hex');
+        const fixada = (0, codex_controller_sensor_1.registrarFonteController)(registro.controlador, { dirSessoes: path.join(dir, 'sessoes'),
+            fixacao: path.join(dir, 'sessoes', `watcher-source-${chave}.json`),
+            sessionId, cwd, despachoEm: sessao.despachadaEm,
+            vinculo: { thread: thread.id, fase: sessao.fase, promptSha256: sessao.promptSha256 } });
+        (0, codex_controller_sensor_1.lerSnapshotController)(fixada);
+    }
+}
+function iniciarWatcher(raiz, sessionId) {
+    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);
+    // 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);
+    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;
+    if (identidadeAnterior && anterior?.pid === identidadeAnterior.pid && (0, codex_runner_1.estadoProcesso)(identidadeAnterior) === 'vivo')
+        return identidadeAnterior.pid;
+    const token = (0, node_crypto_1.randomUUID)();
+    const readyPath = path.join(dir, `watcher-${sessionId}-${token}.ready.json`);
+    const ackPath = readyPath + '.ack';
+    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], {
+            cwd: raiz, detached: true, stdio: ['ignore', 'ignore', err],
+        });
+    }
+    finally {
+        fs.closeSync(err);
+    }
+    let erroRegistrado = false;
+    const falha = () => {
+        if (erroRegistrado)
+            return;
+        erroRegistrado = true;
+        (0, ledger_1.registrar)(dir, thread.id, 'session_watcher_error', { sessionId, despachoEm: sessao.despachadaEm,
+            fase: sessao.fase, motivo: 'runtime.unavailable', erro: 'falha ao confirmar prontidao do watcher',
+            origem: 'sessions.watch' });
+    };
+    child.on('error', falha);
+    child.unref();
+    const identidade = child.pid ? (0, codex_runner_1.identidadeProcesso)(child.pid) : null;
+    try {
+        if (!identidade)
+            throw new Error('watcher sem identidade de processo');
+        const deadline = Date.now() + 5000;
+        const pausa = new Int32Array(new SharedArrayBuffer(4));
+        while (Date.now() < deadline) {
+            const ready = lerJson(readyPath);
+            if (ready && ready.token === token && ready.sessionId === sessionId && ready.despachoEm === sessao.despachadaEm &&
+                JSON.stringify(ready.identidade) === JSON.stringify(identidade) && (0, codex_runner_1.estadoProcesso)(identidade) === 'vivo') {
+                (0, ledger_1.registrar)(dir, thread.id, 'session_watcher_started', { fase: sessao.fase, sessionId,
+                    despachoEm: sessao.despachadaEm, pid: identidade.pid, identidade, readyPath, token });
+                (0, codex_runner_1.gravarAtomico)(ackPath, { token });
+                return identidade.pid;
+            }
+            if ((0, codex_runner_1.estadoProcesso)(identidade) === 'ausente')
+                break;
+            Atomics.wait(pausa, 0, 0, 10);
+        }
+        throw new Error('watcher sem prontidao confirmada');
+    }
+    catch (e) {
+        falha();
+        // Encerrar apenas o filho cuja identidade continua sendo a capturada no spawn.
+        if (identidade && (0, codex_runner_1.estadoProcesso)(identidade) === 'vivo')
+            child.kill('SIGTERM');
+        throw e;
+    }
+}
+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 dir = (0, thread_1.dirThread)(carregado.raiz, thread.id);
+    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);
+            if (atual.status !== 'aberta' || atual.sessoes.at(-1)?.sessionId !== sessionId)
+                return;
+            const r = observarSessao(carregado, sessionId);
+            if (r.concluido || r.encerrado)
+                return;
+        }
+        catch (e) {
+            if (!(0, ledger_1.threadPresente)(dir))
+                return;
+            if (!/ocupad/.test(e.message))
+                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));
+    }
+}
+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');
+        process.exitCode = 1;
+    });