@orkastery/cli 0.5.6 → 0.6.1

package/dist/noctum-reconciliacao.js

@@ -0,0 +1,594 @@
+"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.lerRemotoPadrao = exports.ultimaReservaDoArco = exports.reservaQueLancou = exports.listagemCompleta = void 0;
+exports.provaDaSessao = provaDaSessao;
+exports.retomadaPendente = retomadaPendente;
+exports.faseDaRetomada = faseDaRetomada;
+exports.decidirReservas = decidirReservas;
+exports.decidirSessoes = decidirSessoes;
+exports.paradaPorAmbiente = paradaPorAmbiente;
+exports.recusaDeAmbiente = recusaDeAmbiente;
+exports.decidirPedidos = decidirPedidos;
+exports.registrarEfeitoIncerto = registrarEfeitoIncerto;
+exports.reconciliarEfeito = reconciliarEfeito;
+exports.efeitosAbertos = efeitosAbertos;
+/**
+ * RM-058, fatia N4 (D7 a D12, D15 e D16 da ork-rm058n4): a reconciliação do que ficou no meio.
+ *
+ * Aqui só se DECIDE, com a prova de cada decisão; quem grava é o vigia (`noctum-vigia.ts`), sob as travas dele. Toda
+ * decisão relê o disco (o log do arco, a supervisão e o ledger das threads) e a leitura do runtime que o vigia passa:
+ *
+ * - a reserva pendente de um passo morto no meio (D7): a prova no ledger decide entre concluída (o despacho com a
+ *   correlação do arco veio), devolvida (nada foi lançado: nenhum prompt gravado com a correlação depois da reserva) e
+ *   incerta (o runtime pode ter aberto a sessão); a incerta só se resolve pelo runtime e, sem prova, fica contada e o
+ *   trabalho é isolado depois da carência;
+ * - a sessão sem resultado (D10 a D12): morta pelo runtime, ou parada pelo controle dele com confirmação, vira
+ *   `sessao_morta` no ledger da thread (o que solta condução e vaga) e uma retomada autorizada, que o passo da N2 despacha
+ *   com a conferência do envelope e a reserva (D8); a fase é a seguinte à prova mais adiantada que a sessão deixou (D9);
+ * - o despacho de fora do arco numa thread dele isola o trabalho (D16), e a recusa de ambiente repetida para o arco (D15).
+ *
+ * "Pouca saída, sozinha, não prova travamento": só evento de produto conta como avanço, heartbeat não; e parar uma sessão
+ * exige o prazo vencido, o runtime dizendo o estado e a confirmação depois.
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const conducao_sentinela_1 = require("./conducao-sentinela");
+const horario_1 = require("./horario");
+const ledger_1 = require("./ledger");
+const noctum_envelope_1 = require("./noctum-envelope");
+const noctum_supervisao_1 = require("./noctum-supervisao");
+const parado_no_condutor_1 = require("./parado-no-condutor");
+const ratelimit_1 = require("./ratelimit");
+const thread_1 = require("./thread");
+const util_1 = require("./util");
+const TERMINAIS = ['done', 'completed', 'exited', 'stopped', 'failed'];
+/** O runtime mostra a sessão trabalhando agora (o claude-bg diz `running` ou `busy`; o watcher, `working`). */
+const TRABALHANDO = ['running', 'busy', 'working'];
+const estadoDe = (s) => String(s.state ?? s.status ?? '').trim().toLowerCase();
+const texto = (v) => typeof v === 'string' && v ? v : null;
+/**
+ * A listagem que prova ausência: todas as fontes lidas, nenhuma ausente (B6 do CHECK: sem o `claude` no PATH, a fonte
+ * diz `ausente` e não lista nada, o que não prova que não há sessão).
+ */
+const listagemCompleta = (leitura) => leitura.fontes.every(f => f.ok && !f.ausente);
+exports.listagemCompleta = listagemCompleta;
+/**
+ * D10: a prova do runtime. Vista com estado terminal ou fantasma (sem processo), morta; vista em outro estado, viva.
+ * Ausente, só o claude-bg prova a morte, e só com a listagem completa (`--all`, todas as fontes lidas e nenhuma ausente),
+ * a conta da sessão entre as consultadas e a sessão despachada pelo menos `ausenciaMinimaMs` antes da leitura (B3: a
+ * sessão que nasceu durante a leitura ainda não aparece nela). O codex lista só rollouts recentes: ausência lá não prova.
+ */
+function provaDaSessao(leitura, sessionId, conta, runtime, despachadaEm, ausenciaMinimaMs = 0) {
+    const vista = leitura.sessoes.find(s => s.sessionId === sessionId);
+    if (vista) {
+        if (vista.fantasma)
+            return { estado: 'morta', detalhe: `o runtime ${runtime} lista a sessão sem processo (fantasma)` };
+        const estado = estadoDe(vista);
+        if (TERMINAIS.includes(estado))
+            return { estado: 'morta', detalhe: `o runtime ${runtime} lista a sessão em ${estado}` };
+        return { estado: 'viva', trabalhando: TRABALHANDO.includes(estado), detalhe: `o runtime ${runtime} lista a sessão em ${estado || 'estado sem nome'}` };
+    }
+    const completa = (0, exports.listagemCompleta)(leitura);
+    const consultada = leitura.contas.some(c => c.runtime === runtime && (c.perfil?.id ?? null) === conta);
+    const lidaEm = Date.parse(leitura.lidaEm ?? '');
+    const recente = despachadaEm !== undefined && (!Number.isFinite(lidaEm) || lidaEm - Date.parse(despachadaEm) < ausenciaMinimaMs);
+    if (runtime === 'claude-bg' && completa && consultada && !recente) {
+        return { estado: 'morta', detalhe: `a listagem completa do claude-bg na conta ${conta ?? 'do processo'} não tem a sessão` };
+    }
+    return { estado: 'desconhecida', detalhe: !completa ? 'o runtime não respondeu em todas as contas, ou o claude não está no PATH'
+            : runtime !== 'claude-bg' ? `ausência no ${runtime} não prova o fim da sessão`
+                : !consultada ? `a conta ${conta ?? 'do processo'} não foi consultada`
+                    : 'a sessão foi despachada há pouco e a listagem pode ainda não a ter' };
+}
+/**
+ * As sessões da thread no runtime que podem ser do lançamento: pelo nome do despacho (o slug), ou pela pasta da worktree
+ * com o início depois da reserva (A3 do CHECK: uma sessão antiga da mesma worktree não é deste lançamento).
+ */
+function sessoesDaThread(leitura, t, slug, desde) {
+    const pasta = t.worktree ? path.resolve(t.worktree) : null;
+    const inicio = (s) => typeof s.startedAt === 'number' ? (s.startedAt < 1e12 ? s.startedAt * 1000 : s.startedAt) : NaN;
+    return leitura.sessoes.filter(s => (slug && s.name === slug) ||
+        (pasta && s.cwd && path.resolve(s.cwd) === pasta && inicio(s) >= desde - 60_000));
+}
+/**
+ * A reserva que lançou: concluída ou pendente, ou devolvida pela reconciliação sem sessão depois do prompt gravado (NA2 da
+ * rodada 2: o runtime foi chamado e não abriu nada). A recusa de antes do lançamento e a devolução sem lançamento não.
+ */
+const reservaQueLancou = (d) => d.desfecho !== 'recusado' || (d.motivo ?? '').startsWith('noctum.reconciliacao.sem-sessao');
+exports.reservaQueLancou = reservaQueLancou;
+/**
+ * B1 do CHECK: a retomada autorizada que nenhuma reserva do arco atendeu ainda (a mais nova do trabalho). Uma reserva do
+ * trabalho depois da autorização que lançou a atende, tenha o lançamento dado certo ou não; só a recusa de antes do
+ * lançamento (nada abriu) deixa a autorização de pé. Assim cada tentativa conta no teto. O "depois" é a ordem do log do
+ * arco (NA1 da rodada 2: o `seq` de reserva gravado na autorização), e não o relógio de dois processos; a linha sem ele
+ * fica com o instante.
+ */
+function retomadaPendente(sup, estado, trabalho) {
+    const r = sup.retomadas.filter(x => x.trabalho === trabalho).at(-1);
+    if (!r)
+        return null;
+    const depois = (d) => r.aposReserva !== null ? d.seq > r.aposReserva : Date.parse(d.reservadoEm) >= Date.parse(r.em);
+    const atendida = estado.despachos.some(d => d.trabalho === trabalho && (0, exports.reservaQueLancou)(d) && depois(d));
+    return atendida ? null : r;
+}
+/** O último `seq` de reserva do arco: o que a autorização grava para ser atendida só pelas reservas de depois dela. */
+const ultimaReservaDoArco = (estado) => Math.max(0, ...estado.despachos.map(d => d.seq));
+exports.ultimaReservaDoArco = ultimaReservaDoArco;
+const depoisDe = (e, desde) => Date.parse(e.ts) >= desde;
+const perfilDe = (e) => {
+    const p = e?.perfil;
+    if (typeof p === 'string')
+        return p;
+    return p && typeof p === 'object' && typeof p.id === 'string' ? p.id : null;
+};
+// ---------------------------------------------------------------------------
+// D9: a fase da retomada.
+// ---------------------------------------------------------------------------
+/** O artefato de cada fase que tem um, na pasta `docs/` da thread (a mesma regra da Sentinela). */
+const ARTEFATO_DA_FASE = { GOAL: 'goal.md', PLAN: 'plan.md', CHECK: 'check.md' };
+const FASES_DA_ENTREGA = ['SHIP', 'MASTER'];
+/** Eventos de produto: o que só uma sessão que trabalha deixa. Heartbeat não é avanço. */
+const EVENTOS_DE_AVANCO = ['mcp_git_committed', 'commit', 'claim_added', 'verify_run', 'baseline_recorded', 'autonomous_decision',
+    'phase_result', 'hitl_requested', 'ship_started', 'ship_done', 'ship_blocked', 'go_fix_opened', 'check_reverify', 'artifact_delivered'];
+/**
+ * A fase da retomada (D9): a seguinte à prova mais adiantada que a sessão deixou depois do despacho (o artefato da fase
+ * gravado depois dele, ou o `ship_done`), ou a própria fase do despacho sem prova. Diferente da Sentinela, que lê um turno
+ * concluído, aqui o turno não concluiu: produto na branch prova o PLAN (o GO começou), mas não prova o GO; só o
+ * `check.md` depois dele prova. `null` quando a seguinte é SHIP ou MASTER: a entrega é da N5, e o arco não a retoma.
+ */
+function faseDaRetomada(raiz, t, eventos, fase, despachoEm) {
+    const desde = Date.parse(despachoEm);
+    const i = t.fases.indexOf(fase);
+    if (i < 0)
+        return null;
+    const comProduto = eventos.some(e => (e.tipo === 'mcp_git_committed' || e.tipo === 'commit') && depoisDe(e, desde));
+    const feita = (f) => {
+        const artefato = ARTEFATO_DA_FASE[f];
+        if (artefato) {
+            const st = fs.statSync(path.join((0, thread_1.dirThread)(raiz, t.id), 'docs', artefato), { throwIfNoEntry: false });
+            if (st && st.mtimeMs >= desde)
+                return true;
+        }
+        if (f === 'PLAN' && comProduto)
+            return true;
+        return f === 'SHIP' && eventos.some(e => e.tipo === 'ship_done' && depoisDe(e, desde));
+    };
+    let maisAdiantada = -1;
+    for (let k = i; k < t.fases.length; k++)
+        if (feita(t.fases[k]))
+            maisAdiantada = k;
+    const proxima = maisAdiantada >= 0 ? t.fases[maisAdiantada + 1] ?? null : fase;
+    return proxima && !FASES_DA_ENTREGA.includes(proxima) ? proxima : null;
+}
+/**
+ * D7: o que fazer com cada reserva pendente. Só vale com a trava de despacho na mão de quem chama (nenhum passo no meio).
+ * Os eventos que contam são os da thread depois da reserva e antes da reserva seguinte do mesmo trabalho.
+ */
+function decidirReservas(raiz, arco, conteudo, estado, leitura, parametros, quando) {
+    const correlacao = (0, noctum_supervisao_1.correlacaoDoArco)(arco);
+    const threads = (0, noctum_supervisao_1.threadsDoArco)(raiz, conteudo, estado);
+    let ilegivel = false;
+    for (const id of (0, thread_1.listarIds)(raiz)) {
+        try {
+            (0, thread_1.lerThread)(raiz, id);
+        }
+        catch {
+            ilegivel = true;
+            break;
+        }
+    }
+    const decisoes = [];
+    for (const d of estado.despachos.filter(x => x.desfecho === 'pendente')) {
+        const base = { seq: d.seq, trabalho: d.trabalho, sessionId: null, idempotente: false, motivo: null, morta: null, isolamento: null };
+        const desde = Date.parse(d.reservadoEm);
+        const vencida = Date.parse(quando) - desde >= parametros.carenciaDaReservaMs;
+        const thread = d.thread ?? threads.get(d.trabalho) ?? null;
+        if (!thread) {
+            // Sem thread do trabalho de pedido: o passo morreu antes de abrir. Com thread ilegível no projeto, ela pode ser a dele.
+            decisoes.push(ilegivel
+                ? { ...base, thread: null, acao: 'aguardar', prova: 'há thread ilegível no projeto, e ela pode ser a do trabalho: sem prova de que nada foi lançado' }
+                : { ...base, thread: null, acao: 'devolver', motivo: 'noctum.reconciliacao.sem-lancamento: nenhuma thread do trabalho existe depois da reserva',
+                    prova: 'nenhuma thread casa com o item e o sha256 do pedido' });
+            continue;
+        }
+        let eventos, t;
+        try {
+            t = (0, thread_1.lerThread)(raiz, thread);
+            eventos = (0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, thread));
+        }
+        catch {
+            decisoes.push({ ...base, thread, acao: 'aguardar', prova: `a thread ${thread} não pôde ser lida` });
+            continue;
+        }
+        // A janela desta reserva: até a reserva seguinte do mesmo trabalho, se houver.
+        const proxima = estado.despachos.filter(x => x.trabalho === d.trabalho && x.seq > d.seq).map(x => Date.parse(x.reservadoEm))[0] ?? Infinity;
+        const janela = eventos.filter(e => depoisDe(e, desde) && Date.parse(e.ts) < proxima);
+        const doArco = (e) => e.correlacao === correlacao && e.fase === d.fase;
+        const despacho = janela.find(e => e.tipo === 'phase_dispatch' && doArco(e));
+        if (despacho) {
+            decisoes.push({ ...base, thread, acao: 'concluir', sessionId: texto(despacho.sessionId),
+                prova: `${thread}: phase_dispatch ${String(despacho.eventId ?? '')} com a correlação do arco depois da reserva` });
+            continue;
+        }
+        const idempotente = janela.find(e => e.tipo === 'despacho_idempotente' && e.fase === d.fase);
+        if (idempotente) {
+            decisoes.push({ ...base, thread, acao: 'concluir', sessionId: texto(idempotente.sessionId), idempotente: true,
+                prova: `${thread}: despacho_idempotente ${String(idempotente.eventId ?? '')} depois da reserva` });
+            continue;
+        }
+        const prompt = janela.find(e => e.tipo === 'phase_prompt_recorded' && doArco(e));
+        const falha = janela.filter(e => e.tipo === 'phase_dispatch_failed' && doArco(e)).at(-1);
+        if (!prompt && !falha) {
+            // O prompt vai ao disco e ao ledger antes do adaptador (RM-063, F3): sem ele, o runtime não foi chamado.
+            decisoes.push({ ...base, thread, acao: 'devolver',
+                motivo: 'noctum.reconciliacao.sem-lancamento: nenhum phase_prompt_recorded do arco depois da reserva',
+                prova: `${thread}: nenhum prompt gravado com a correlação do arco depois da reserva` });
+            continue;
+        }
+        const conta = perfilDe(falha) ?? perfilDe(prompt) ?? d.conta;
+        const runtime = texto(falha?.runtime) ?? texto(prompt?.runtime) ?? d.runtime;
+        const idDaFalha = texto(falha?.sessionId);
+        if (idDaFalha) {
+            const p = provaDaSessao(leitura, idDaFalha, conta, runtime, falha.ts, parametros.ausenciaMinimaMs);
+            if (p.estado === 'viva') {
+                decisoes.push({ ...base, thread, acao: 'concluir', sessionId: idDaFalha, prova: `a sessão ${idDaFalha} dita na falha está viva: ${p.detalhe}` });
+            }
+            else if (p.estado === 'morta') {
+                decisoes.push({ ...base, thread, acao: 'concluir', sessionId: idDaFalha, morta: { sessionId: idDaFalha, fase: d.fase, runtime, perfil: conta },
+                    prova: `a sessão ${idDaFalha} dita na falha acabou: ${p.detalhe}` });
+            }
+            else {
+                decisoes.push({ ...base, thread, acao: vencida ? 'isolar' : 'aguardar',
+                    isolamento: vencida ? { motivo: 'reserva-incerta', detalhe: `a sessão ${idDaFalha} pode estar aberta e o runtime não prova: ${p.detalhe}` } : null,
+                    prova: `sessão ${idDaFalha} sem prova do runtime: ${p.detalhe}` });
+            }
+            continue;
+        }
+        // Prompt gravado sem despacho nem id: o runtime pode ter aberto a sessão sem que o núcleo soubesse dela.
+        const achadas = sessoesDaThread(leitura, t, texto(prompt?.slug) ?? texto(falha?.slug), desde);
+        const viva = achadas.find(s => !s.fantasma && !TERMINAIS.includes(estadoDe(s)));
+        if (viva) {
+            decisoes.push({ ...base, thread, acao: 'concluir', sessionId: viva.sessionId,
+                isolamento: { motivo: 'sessao-fora-do-registro', detalhe: `a sessão ${viva.sessionId} trabalha na thread sem o registro do núcleo; o arco não despacha por cima` },
+                prova: `o runtime lista a sessão ${viva.sessionId} na thread ${thread} (${estadoDe(viva) || 'estado sem nome'})` });
+            continue;
+        }
+        if (achadas.length) {
+            const morta = achadas[0];
+            decisoes.push({ ...base, thread, acao: 'concluir', sessionId: morta.sessionId,
+                morta: { sessionId: morta.sessionId, fase: d.fase, runtime, perfil: conta }, prova: `a sessão ${morta.sessionId} da thread acabou no runtime` });
+            continue;
+        }
+        const completa = (0, exports.listagemCompleta)(leitura) && leitura.contas.some(c => c.runtime === runtime && (c.perfil?.id ?? null) === conta);
+        if (runtime === 'claude-bg' && completa && vencida) {
+            decisoes.push({ ...base, thread, acao: 'devolver',
+                motivo: 'noctum.reconciliacao.sem-sessao: a listagem completa do claude-bg não tem sessão da thread depois da carência',
+                prova: `nenhuma sessão da thread ${thread} na conta ${conta} depois de ${Math.round(parametros.carenciaDaReservaMs / 60000)} min` });
+            continue;
+        }
+        decisoes.push({ ...base, thread, acao: vencida ? 'isolar' : 'aguardar',
+            isolamento: vencida ? { motivo: 'reserva-incerta', detalhe: 'o lançamento ficou incerto e o runtime não prova nada: a reserva segue contada' } : null,
+            prova: completa ? 'ainda na carência da reserva' : 'o runtime não prova a ausência da sessão (fonte sem leitura, conta não consultada ou codex)' });
+    }
+    return decisoes;
+}
+/** Atividade da própria sessão depois do despacho: o que mostra que o turno começou. */
+const ATIVIDADE = ['runtime_event', 'runtime_heartbeat', 'commit', 'runtime_stop', 'runtime_subagent_stop', 'sessao_destravada', 'phase_result'];
+/** O último instante de avanço da thread desde o despacho: evento de produto no ledger ou artefato de fase gravado. */
+function ultimoAvanco(raiz, thread, eventos, desde) {
+    let ultimo = desde;
+    for (const e of eventos)
+        if (EVENTOS_DE_AVANCO.includes(e.tipo) && Date.parse(e.ts) > ultimo)
+            ultimo = Date.parse(e.ts);
+    for (const arquivo of Object.values(ARTEFATO_DA_FASE)) {
+        const st = fs.statSync(path.join((0, thread_1.dirThread)(raiz, thread), 'docs', arquivo), { throwIfNoEntry: false });
+        if (st && st.mtimeMs > ultimo)
+            ultimo = st.mtimeMs;
+    }
+    return ultimo;
+}
+/** A recusa do núcleo ou do runtime (o portão, a conta), e não a do próprio arco (`noctum.*`) nem a baseline pendente. */
+const recusaDoNucleo = (motivo) => !!motivo && !motivo.startsWith('noctum.') && motivo !== 'baseline.pendente';
+/**
+ * D10 a D12 e D16: o que fazer em cada thread do arco. Despacho de fora isola, mesmo com retomada pendente (NB1 da rodada
+ * 2). A recusa do núcleo depois do último lançamento numa thread já despachada (o portão: a árvore, a policy, a
+ * autoconferência, o contexto, a conta) vira a retomada da fase recusada (NA3 da rodada 2): a Sentinela a pede, e a fila
+ * da N2 não a despacha sozinha. O último lançamento do arco na thread (o `phase_dispatch`, ou a falha do despacho, B2 do
+ * CHECK) decide o resto: a falha que disse o id põe essa sessão sob vigia, como um despacho; a falha sem id numa thread já
+ * despachada vira a retomada da mesma fase (a conta que falhou já está fora). A sessão morta sem resultado (depois da
+ * carência desde a última atividade dela, B5), o fim de turno sem resultado depois da carência, a sessão sem avanço e a
+ * sem primeiro turno viram retomada (com a parada pelo runtime antes, quando a sessão está viva), até o teto; no teto,
+ * isolamento. Trabalho isolado, entregue, fechado, esperando o dono, com reserva pendente ou com retomada autorizada e
+ * ainda não atendida (B1) fica de fora.
+ */
+function decidirSessoes(raiz, arco, conteudo, estado, sup, leitura, quando, ordensCanceladas = new Set()) {
+    const parametros = sup.parametros;
+    if (!parametros)
+        return [];
+    const agora = Date.parse(quando);
+    const correlacao = (0, noctum_supervisao_1.correlacaoDoArco)(arco);
+    const autorizadoEm = Date.parse(estado.autorizadoPor?.recebidoEm ?? conteudo.janela.inicio);
+    const pendentes = new Set(estado.despachos.filter((d) => d.desfecho === 'pendente').map(d => d.trabalho));
+    const decisoes = [];
+    const aposReserva = (0, exports.ultimaReservaDoArco)(estado);
+    for (const [trabalho, thread] of (0, noctum_supervisao_1.threadsDoArco)(raiz, conteudo, estado)) {
+        // A sessão da ordem cancelada na rede é encerrada pelo vigia, mas nunca autorizada a retomar nesta máquina.
+        if (ordensCanceladas.has(trabalho))
+            continue;
+        if (sup.isolados.has(trabalho) || pendentes.has(trabalho))
+            continue;
+        let t, eventos;
+        try {
+            t = (0, thread_1.lerThread)(raiz, thread);
+            eventos = (0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, thread));
+        }
+        catch {
+            continue;
+        }
+        if (t.status === 'fechada' || eventos.some(e => e.tipo === 'ship_done'))
+            continue;
+        // D16: um despacho de fora do arco, depois da autorização, isola o trabalho.
+        const deFora = eventos.find(e => e.tipo === 'phase_dispatch' && Date.parse(e.ts) >= autorizadoEm && e.correlacao !== correlacao);
+        if (deFora) {
+            decisoes.push({ acao: 'isolar', trabalho, thread, motivo: 'condutor-externo', parar: null,
+                detalhe: `a thread ${thread} recebeu despacho de fora do arco (${String(deFora.fase)}, canal ${String(deFora.canal ?? 'desconhecido')}, ` +
+                    `origem ${String(deFora.origem ?? 'desconhecida')}): o arco não conduz junto com outro condutor` });
+            continue;
+        }
+        if ((0, parado_no_condutor_1.pendenciaDoDono)(t, eventos, quando) || retomadaPendente(sup, estado, trabalho))
+            continue;
+        const retomar = (fase, motivo, sessao, prova, viva) => {
+            const parar = sessao && viva ? { ...sessao, thread } : null;
+            const morta = sessao && !viva ? { sessionId: sessao.sessionId, fase: (fase ?? 'GOAL'), runtime: sessao.runtime, perfil: sessao.perfil } : null;
+            if (!fase)
+                return { acao: 'aguardar', trabalho, thread, detalhe: `${prova}; a fase seguinte é da entrega (N5)` };
+            const feitas = (0, noctum_supervisao_1.retomadasDe)(sup, trabalho, fase);
+            const semTurno = motivo === 'sem-primeiro-turno'
+                ? sup.retomadas.filter(r => r.trabalho === trabalho && r.motivo === 'sem-primeiro-turno').length : 0;
+            if (motivo === 'sem-primeiro-turno' && semTurno >= parametros.retomadasSemPrimeiroTurno) {
+                return { acao: 'isolar', trabalho, thread, motivo: 'sem-primeiro-turno', parar,
+                    detalhe: `${prova}; a sessão não começou o turno ${semTurno + 1} vez(es): a causa costuma ser de ambiente (diálogo de servidor MCP novo, ` +
+                        'credencial) e o dono resolve' };
+            }
+            if (feitas >= parametros.tetoDeRetomadas) {
+                return { acao: 'isolar', trabalho, thread, motivo: 'retomadas-esgotadas', parar,
+                    detalhe: `${prova}; ${feitas} retomada(s) da fase ${fase} já autorizadas, e o teto é ${parametros.tetoDeRetomadas}` };
+            }
+            return { acao: 'retomar', trabalho, thread, fase, tentativa: feitas + 1, motivo, sessao: sessao?.sessionId ?? null, aposReserva, parar, morta, prova };
+        };
+        // NA3 da rodada 2: a última reserva do trabalho recusada pelo núcleo, com o bloqueio do despacho no ledger depois do
+        // último despacho, numa thread já despachada. A retomada é contada; a recusa repetida isola no teto (B4) e a de ambiente
+        // da máquina para o arco (D15); a que passa (a conta, a vaga, a condução) se repete na cadência do arco.
+        const ultimaReserva = estado.despachos.filter(x => x.trabalho === trabalho).sort((a, b) => b.seq - a.seq)[0];
+        const bloqueio = (0, conducao_sentinela_1.bloqueioDepoisDoDespacho)(eventos);
+        // NA3b da rodada 3: qualquer despacho vale (a thread que o dono despachou antes do arco também), como na B2.
+        if (ultimaReserva?.desfecho === 'recusado' && recusaDoNucleo(ultimaReserva.motivo) && bloqueio?.deDespacho &&
+            eventos.some(e => e.tipo === 'phase_dispatch')) {
+            decisoes.push(retomar(ultimaReserva.fase, 'despacho-falho', null, `o despacho do ${ultimaReserva.fase} foi recusado pelo núcleo (${ultimaReserva.motivo}) depois do último lançamento`, false));
+            continue;
+        }
+        // B2 do CHECK: o último lançamento do arco, despacho ou falha do despacho.
+        const lancamentos = eventos.filter(e => (e.tipo === 'phase_dispatch' || e.tipo === 'phase_dispatch_failed') && e.correlacao === correlacao);
+        const d = lancamentos.at(-1);
+        if (!d)
+            continue;
+        const fase = (texto(d.fase) ?? t.faseAtual);
+        const runtime = texto(d.runtime) ?? 'claude-bg', conta = perfilDe(d);
+        const sid = texto(d.sessionId);
+        if (!sid) {
+            // A falha sem id não abriu nada (a conta, o limite de uso) ou já foi reconciliada como sem lançamento. Na thread que
+            // nunca teve despacho a fila da N2 a despacha de novo; na já despachada, a Sentinela pede retomar, e quem autoriza é aqui.
+            if (d.tipo !== 'phase_dispatch_failed' || !eventos.some(e => e.tipo === 'phase_dispatch'))
+                continue;
+            decisoes.push(retomar(fase, 'despacho-falho', null, `o despacho do ${fase} falhou sem abrir sessão: ${String(d.erro ?? 'sem detalhe').slice(0, 160)}`, false));
+            continue;
+        }
+        const desde = Date.parse(d.ts);
+        const sessao = { sessionId: sid, runtime, perfil: conta };
+        const fim = eventos.some(e => e.tipo === 'sessao_morta' && e.sessionId === sid && Date.parse(e.ts) >= desde);
+        // A espera do condutor é a do último `phase_dispatch`: vale só quando ele é o último lançamento.
+        const espera = d.tipo === 'phase_dispatch' ? (0, parado_no_condutor_1.esperaDoCondutor)(t, eventos, quando) : null;
+        if (espera?.tipo === 'concluida' || eventos.some(e => e.tipo === 'phase_result' && e.sessionId === sid && Date.parse(e.ts) >= desde &&
+            (e.classificacao === 'fase_concluida' || (e.classificacao === undefined && e.ok === true))))
+            continue;
+        const p = provaDaSessao(leitura, sid, conta, runtime, d.ts, parametros.ausenciaMinimaMs);
+        // A última atividade da própria sessão (ou o lançamento): a carência conta dela.
+        const ultimaAtividade = Math.max(desde, ...eventos.filter(e => e.sessionId === sid).map(e => Date.parse(e.ts)).filter(Number.isFinite));
+        if (fim || p.estado === 'morta') {
+            // B5 do CHECK: o estado `done` vem antes do resultado que o observador grava; sem `sessao_morta` provada antes, a
+            // morte só vira retomada depois da carência desde a última atividade da sessão.
+            if (!fim && agora - ultimaAtividade < parametros.carenciaMs) {
+                decisoes.push({ acao: 'aguardar', trabalho, thread, detalhe: `a sessão ${sid} acabou há pouco (${p.detalhe}): o resultado da fase pode ainda chegar` });
+                continue;
+            }
+            decisoes.push(retomar(faseDaRetomada(raiz, t, eventos, fase, d.ts), d.tipo === 'phase_dispatch_failed' ? 'despacho-falho' : 'sessao-morta', fim ? null : sessao, fim ? `a sessão ${sid} já tem sessao_morta no ledger` : `a sessão ${sid} acabou sem resultado: ${p.detalhe}`, false));
+            continue;
+        }
+        if (p.estado === 'desconhecida') {
+            decisoes.push({ acao: 'aguardar', trabalho, thread, detalhe: `a sessão ${sid} sem prova do runtime: ${p.detalhe}` });
+            continue;
+        }
+        const trabalhando = p.estado === 'viva' && p.trabalhando;
+        // D11: o fim de turno sem resultado (o Stop sem `phase_result`, ou o fim de turno que o observador viu com a sessão
+        // parada), depois da carência e com a sessão sem trabalhar no runtime; a que voltou a trabalhar segue.
+        if (espera?.tipo === 'stop-sem-resultado' || espera?.tipo === 'espera-do-observador') {
+            if (agora - Date.parse(espera.fimDoTurnoEm) >= parametros.carenciaMs && !trabalhando) {
+                decisoes.push(retomar(faseDaRetomada(raiz, t, eventos, fase, d.ts), 'fim-de-turno-sem-resultado', sessao, `o turno da sessão ${sid} acabou sem resultado em ${(0, horario_1.formatarDataHora)(espera.fimDoTurnoEm)} e ela não trabalha: ${p.detalhe}`, true));
+            }
+            continue;
+        }
+        // O CHECK sem veredito é do passo da N2 (a Sentinela pede o CHECK de novo).
+        if (espera)
+            continue;
+        // D12: no turno, a sessão viva (trabalhando ou parada num diálogo antes de começar) é presa sem nenhuma atividade desde o
+        // despacho além do prazo do primeiro turno, ou sem evento de produto além do prazo da fase.
+        const ativa = eventos.some(e => Date.parse(e.ts) > desde && ((ATIVIDADE.includes(e.tipo) && e.sessionId === sid) || EVENTOS_DE_AVANCO.includes(e.tipo)));
+        if (!ativa && agora - desde >= parametros.primeiroTurnoMs) {
+            decisoes.push(retomar(fase, 'sem-primeiro-turno', sessao, `a sessão ${sid} não deu sinal nenhum em ${Math.round((agora - desde) / 60000)} min depois do despacho (${p.detalhe})`, true));
+            continue;
+        }
+        const parado = agora - ultimoAvanco(raiz, thread, eventos, desde);
+        if (ativa && parado >= parametros.semAvancoMs) {
+            decisoes.push(retomar(faseDaRetomada(raiz, t, eventos, fase, d.ts), 'sem-avanco', sessao, `a sessão ${sid} segue sem evento de produto há ${Math.round(parado / 60000)} min (prazo ${Math.round(parametros.semAvancoMs / 60000)} min; ${p.detalhe})`, true));
+        }
+    }
+    return decisoes;
+}
+/** D15: as recusas de ambiente seguidas desde o último despacho concluído do arco, e se elas param o arco. */
+function paradaPorAmbiente(sup, estado) {
+    const parametros = sup.parametros;
+    if (!parametros)
+        return null;
+    const ultimo = Math.max(...estado.despachos.filter(d => d.desfecho === 'concluido' && d.concluidoEm).map(d => Date.parse(d.concluidoEm)), -Infinity);
+    const seguidas = sup.recusasDeAmbiente.filter(r => Date.parse(r.em) > ultimo);
+    if (seguidas.length < parametros.recusasDeAmbienteQueParam)
+        return null;
+    return { motivo: 'ambiente-do-despacho', detalhe: `${seguidas.length} despachos seguidos recusados pelo ambiente de quem despacha ` +
+            `(${seguidas.at(-1).detalhe.slice(0, 160)}): o dono confere o ambiente (o node no PATH, a instalação do MCP) antes de outro arco` };
+}
+/**
+ * A recusa do núcleo que vem do ambiente da máquina de quem despacha, e não do trabalho: o MCP divergente com outro `node`
+ * no PATH, a instalação do MCP, o projeto sem o perfil do instalador. Os erros de contexto da thread (o escopo, a worktree,
+ * a identidade) contam como recusa do trabalho, que isola no teto (RA2 da rodada 3).
+ */
+function recusaDeAmbiente(detalhe) {
+    return /runtime\.context\.(conflict|installation|missing)/.test(detalhe);
+}
+/**
+ * D17: o pedido aguardando na fila durável que é do arco (a correlação dele) nunca é redespachado pelo `ork retry resume`.
+ * A retomada da fase sai pelo passo do arco, autorizada como qualquer despacho que falhou sem abrir sessão (B2 do CHECK,
+ * `decidirSessoes`), com a conta do limite de uso fora até o `liberaEm`. Aqui o pedido só sai da fila: depois de um
+ * despacho do arco na thread, como retomado; com o arco encerrado, com o motivo (retomar exige o dono).
+ */
+function decidirPedidos(raiz, arco, estado) {
+    const correlacao = (0, noctum_supervisao_1.correlacaoDoArco)(arco);
+    const ultimos = new Map();
+    for (const p of (0, ratelimit_1.lerFilaDeRetomada)(raiz))
+        ultimos.set(p.id, p);
+    const encerrado = estado.situacao === 'revogado' || estado.situacao === 'expirado';
+    const decisoes = [];
+    for (const p of ultimos.values()) {
+        if (p.estado !== 'aguardando' || p.correlacao !== correlacao)
+            continue;
+        if (encerrado) {
+            decisoes.push({ acao: 'cancelar', pedido: p.id, thread: p.thread,
+                motivo: `o arco ${arco} terminou (${estado.situacao}): retomar a fase ${p.fase} da thread ${p.thread} exige o dono` });
+            continue;
+        }
+        let eventos;
+        try {
+            eventos = (0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, p.thread));
+        }
+        catch {
+            continue;
+        }
+        const retomado = eventos.find(e => e.tipo === 'phase_dispatch' && e.correlacao === correlacao && Date.parse(e.ts) > Date.parse(p.criadoEm));
+        if (retomado) {
+            decisoes.push({ acao: 'cancelar', pedido: p.id, thread: p.thread,
+                motivo: `retomado pelo arco ${arco} no despacho ${String(retomado.eventId ?? (0, horario_1.formatarDataHora)(retomado.ts))} (${String(retomado.fase)})` });
+        }
+    }
+    return decisoes;
+}
+/**
+ * O remoto que o `git ls-remote` aceita do log: nome ou endereço sem espaço, que nunca começa com `-` (senão viraria opção
+ * do git, como `--upload-pack`).
+ */
+const REMOTO_SEGURO = /^[A-Za-z0-9_][A-Za-z0-9._/:@~+-]{0,299}$/;
+/** O `git ls-remote` da branch exata, com prazo e sem pedir credencial no terminal. */
+const lerRemotoPadrao = (remoto, branch, cwd) => {
+    if (!REMOTO_SEGURO.test(remoto) || (0, noctum_envelope_1.nomeDaBranch)(branch) === undefined)
+        return { ok: false, detalhe: 'remoto ou branch fora do formato seguro' };
+    const r = (0, util_1.exec)('git', ['ls-remote', '--heads', remoto, `refs/heads/${branch}`], cwd, 30_000, { ...process.env, GIT_TERMINAL_PROMPT: '0' });
+    if (!r.ok)
+        return { ok: false, detalhe: `git ls-remote saiu ${r.code}: ${(r.stderr.trim().split('\n')[0] ?? '').slice(0, 160)}` };
+    const linha = r.stdout.split('\n').find(l => l.endsWith(`\trefs/heads/${branch}`));
+    const sha = linha?.split('\t')[0] ?? null;
+    return { ok: true, sha: sha && /^[0-9a-f]{40}$/.test(sha) ? sha : null };
+};
+exports.lerRemotoPadrao = lerRemotoPadrao;
+const chaveDoEfeito = (e) => JSON.stringify([e.acao, e.repositorio, e.remoto, e.branch, e.sha, e.trabalho]);
+/** D18: registra o efeito de resultado incerto (o push que estourou o prazo ou caiu sem resposta) e devolve o id dele. */
+function registrarEfeitoIncerto(carregado, arco, efeito, quando = new Date().toISOString()) {
+    if (!/^[0-9a-f]{40}$/.test(efeito.sha) || (0, noctum_envelope_1.nomeDaBranch)(efeito.branch) === undefined || !REMOTO_SEGURO.test(efeito.remoto)) {
+        throw new noctum_supervisao_1.RecusaDaSupervisao('noctum.supervisao.invalida', 'efeito incerto exige o sha completo, a branch e o remoto, no formato seguro');
+    }
+    const id = 'E-' + (0, node_crypto_1.createHash)('sha256').update(JSON.stringify([arco, chaveDoEfeito(efeito), quando])).digest('hex').slice(0, 12);
+    (0, noctum_supervisao_1.gravarNaSupervisao)(carregado, arco, [{ tipo: 'efeito_incerto', id, efeito: { ...efeito, detalhe: efeito.detalhe.slice(0, 200) } }], quando);
+    return id;
+}
+/**
+ * D18: o remoto decide o efeito incerto, e o desfecho vai ao log. Igual ao sha: confirmado, e nunca se repete. Branch
+ * ausente: a repetição é permitida enquanto os efeitos do mesmo push não passam do teto, e quem repete confere o envelope
+ * de novo; no teto, o trabalho é isolado. Outro sha na branch: divergente, isolado (alguém escreveu ali). Sem leitura:
+ * lacuna, lida de novo no tique seguinte, e isolada no teto. Desfecho final não é relido.
+ */
+function reconciliarEfeito(carregado, arco, id, opcoes = {}) {
+    const quando = opcoes.quando ?? new Date().toISOString();
+    const sup = (0, noctum_supervisao_1.lerSupervisao)(carregado.raiz, arco);
+    const ef = sup.efeitos.get(id);
+    if (!ef)
+        throw new noctum_supervisao_1.RecusaDaSupervisao('noctum.supervisao.invalida', `efeito ${id} sem registro neste arco`);
+    const teto = sup.parametros?.leiturasDoEfeito ?? 2;
+    const ultimo = ef.desfechos.at(-1);
+    if (ultimo && ultimo.desfecho !== 'sem-leitura') {
+        return { id, desfecho: ultimo.desfecho, podeRepetir: false, isolado: sup.isolados.has(ef.efeito.trabalho), prova: ultimo.prova };
+    }
+    const r = (opcoes.lerRemoto ?? exports.lerRemotoPadrao)(ef.efeito.remoto, ef.efeito.branch, opcoes.cwd ?? carregado.raiz);
+    const desfecho = !r.ok ? 'sem-leitura' : r.sha === ef.efeito.sha ? 'confirmado' : r.sha === null ? 'ausente' : 'divergente';
+    const prova = !r.ok ? r.detalhe : r.sha === null ? `a branch ${ef.efeito.branch} não existe no remoto ${ef.efeito.remoto}`
+        : `o remoto ${ef.efeito.remoto} tem ${r.sha} na branch ${ef.efeito.branch}`;
+    // As tentativas do mesmo push (a mesma chave) contam juntas: um efeito novo não zera o teto.
+    const mesmas = [...sup.efeitos.values()].filter(x => chaveDoEfeito(x.efeito) === chaveDoEfeito(ef.efeito)).length;
+    const leituras = ef.desfechos.filter(d => d.desfecho === 'sem-leitura').length + 1;
+    const podeRepetir = desfecho === 'ausente' && mesmas < teto;
+    const motivo = desfecho === 'divergente' ? 'efeito-divergente' : desfecho === 'sem-leitura' && leituras >= teto ? 'efeito-sem-leitura'
+        : desfecho === 'ausente' && !podeRepetir ? 'efeito-esgotado' : null;
+    const linhas = [{ tipo: 'efeito_reconciliado', id, desfecho, prova: prova.slice(0, 300) }];
+    if (motivo)
+        linhas.push({ tipo: 'isolado', trabalho: ef.efeito.trabalho, thread: ef.efeito.thread, motivo,
+            detalhe: `${ef.efeito.acao} de ${ef.efeito.sha.slice(0, 12)} em ${ef.efeito.branch}: ${prova}`.slice(0, 300) });
+    (0, noctum_supervisao_1.gravarNaSupervisao)(carregado, arco, linhas, quando);
+    return { id, desfecho, podeRepetir, isolado: motivo !== null || sup.isolados.has(ef.efeito.trabalho), prova };
+}
+/** Os efeitos incertos ainda sem desfecho final: o vigia os relê a cada tique. */
+function efeitosAbertos(sup) {
+    return [...sup.efeitos.values()].filter(e => {
+        const ultimo = e.desfechos.at(-1);
+        return (!ultimo || ultimo.desfecho === 'sem-leitura') && !sup.isolados.has(e.efeito.trabalho);
+    }).map(e => e.id);
+}