@orkastery/cli 0.4.3 → 0.5.1

package/dist/parado-no-condutor.js

@@ -0,0 +1,933 @@
+"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.LIMITE_DE_RECENTES = exports.LIMITE_DE_PRS = exports.VALIDADE_DO_RETRATO_MIN = exports.LIMIAR_PARADO_NO_CONDUTOR_MIN = exports.CONTRATO_PRS = void 0;
+exports.nomeDeCheck = nomeDeCheck;
+exports.repositorioDoRemoto = repositorioDoRemoto;
+exports.lerPrsDaForja = lerPrsDaForja;
+exports.gravarRetratoDePrs = gravarRetratoDePrs;
+exports.lerRetratoDePrs = lerRetratoDePrs;
+exports.perguntaAberta = perguntaAberta;
+exports.fimDoTurno = fimDoTurno;
+exports.pendenciaDoDono = pendenciaDoDono;
+exports.esperaDoCondutor = esperaDoCondutor;
+exports.sessaoSemPergunta = sessaoSemPergunta;
+exports.entregasDoProjeto = entregasDoProjeto;
+/**
+ * RM-037 (fatia 4): o trabalho parado no condutor.
+ *
+ * Em 01/10/2026 o condutor parou duas vezes e nada no produto percebeu. De madrugada, tres threads
+ * terminaram com o verify verde e ficaram 15 h sem push e sem PR; de dia, PRs ficaram horas com os
+ * checks verdes e sem merge, e um PR com o check vermelho ficou 4h38 sem fase nenhuma. O pulse batia de
+ * 15 em 15 min e so dizia "Esperando voce": o `human.pending` que o observador grava quando a sessao
+ * claude-bg encerra o turno em `blocked` contava como pergunta do dono, e nao havia pergunta nenhuma
+ * (12 desses resultados seguiram ate o `ship_done` sem um `human_gate`).
+ *
+ * Aqui mora, num lugar so, o que e do condutor depois da entrega:
+ *
+ *  - quem e do condutor (`esperaDoCondutor`): o fim de turno num bloco sem pausa ao fim, sem pergunta
+ *    estruturada aberta. Pausa prevista do modo, escalacao tipada, `hitl_requested` aberto (inclusive
+ *    vencido que espera), prompt de permissao do hook e menu na tela continuam do dono;
+ *  - o estado da entrega de cada thread aberta: o git local (a ponta da branch, a copia do remoto que o
+ *    push desta maquina atualiza e a base) e os PRs da forja, lidos pelo `gh` e guardados como retrato
+ *    `ork.prs-abertos/v1`;
+ *  - os casos, cada um com o desde e o proximo passo, alem do limiar. O que sai do dono volta sempre
+ *    como linha do condutor (CHECK da fatia 4, rodada 1).
+ *
+ * O pulse le a forja so quando alguma thread tem branch publicada; o status do roadmap le o retrato e
+ * nunca a rede. Falha, lista cortada e retrato velho sao "PR nao lido", nunca "sem PR".
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const conducao_1 = require("./conducao");
+const estado_thread_1 = require("./estado-thread");
+const forja_1 = require("./forja");
+const hitl_1 = require("./hitl");
+const hitl_contract_1 = require("./hitl-contract");
+const hitl_classificacao_1 = require("./hitl-classificacao");
+const hitl_gates_1 = require("./hitl-gates");
+const ledger_1 = require("./ledger");
+const modos_1 = require("./modos");
+const ocupacao_1 = require("./ocupacao");
+const session_watcher_claude_1 = require("./session-watcher-claude");
+const thread_1 = require("./thread");
+const util_1 = require("./util");
+const worktree_1 = require("./worktree");
+exports.CONTRATO_PRS = 'ork.prs-abertos/v1';
+/** D4: duas batidas do pulse. Abaixo disto o condutor pode estar agindo. */
+exports.LIMIAR_PARADO_NO_CONDUTOR_MIN = 30;
+/** O retrato de PRs vale por uma hora para quem nao le a rede (o status do roadmap); depois, "PR nao lido". */
+exports.VALIDADE_DO_RETRATO_MIN = 60;
+/** Quantos PRs ABERTOS a leitura pede. Lista cheia e `parcial`: o PR que nao veio nunca vira "sem PR". */
+exports.LIMITE_DE_PRS = 200;
+/** Quantos PRs recentes (de qualquer estado) a segunda leitura pede: so para achar o mesclado e o fechado. */
+exports.LIMITE_DE_RECENTES = 100;
+/** Retrato com data mais a frente do relogio do que isto nao vale (relogio adiantado ou arquivo mexido). */
+const FOLGA_DO_RELOGIO_MIN = 5;
+const ARQUIVO_DOS_PRS = 'prs.json';
+const PRAZO_DO_GH_MS = 30000;
+/** A leitura inteira da forja numa batida: cabe com folga nos 240 s que a varredura da ao subprocesso do pulse. */
+const ORCAMENTO_DA_LEITURA_MS = 60000;
+const CAMPOS_DOS_RECENTES = 'number,state,headRefName,headRefOid,baseRefName,isDraft,isCrossRepository,url,createdAt,mergedAt';
+const CAMPOS_DO_GH = `${CAMPOS_DOS_RECENTES},statusCheckRollup`;
+/** Quantas branches candidatas a "sem PR" sao conferidas uma a uma por batida; o resto fica "PR nao lido". */
+const LIMITE_DE_CANDIDATAS = 10;
+/** A conferencia de uma candidata so comeca com este tempo de sobra no orcamento; com menos, a branch fica sem conferir. */
+const MINIMO_DA_CONFERENCIA_MS = 5000;
+/** As fases que o ciclo despacha antes da entrega: depois de um bloco que para nelas, o passo e despachar, nao publicar. */
+const FASES_ANTES_DA_ENTREGA = ['GOAL', 'PLAN', 'GO', 'CHECK'];
+/** Os modos em que a #TAG ja autoriza o push (`autorizacaoDePush`, `core/src/ship.ts`). */
+const MODOS_COM_PUSH_AUTORIZADO = ['auto', 'maestro'];
+/** O ambiente do `gh`: sem cor, sem prompt e sem host ou repositorio herdados (o host vai no `--repo`). */
+function ambienteDoGh() {
+    const env = { ...process.env, GH_PROMPT_DISABLED: '1', NO_COLOR: '1', CLICOLOR: '0', CLICOLOR_FORCE: '0' };
+    delete env.GH_HOST;
+    delete env.GH_REPO;
+    delete env.GH_FORCE_TTY;
+    return env;
+}
+const ghPadrao = (args, timeoutMs) => {
+    const r = (0, node_child_process_1.spawnSync)('gh', [...args], { encoding: 'utf8', timeout: timeoutMs, maxBuffer: 16 * 1024 * 1024, env: ambienteDoGh() });
+    return { status: r.status, stdout: r.stdout ?? '', stderr: r.error ? r.error.message : (r.stderr ?? '') };
+};
+/** Git local sem rede escondida: clone parcial nunca busca objeto durante uma leitura daqui. */
+const git = (raiz, args) => (0, util_1.exec)('git', args, raiz, 60000, { ...process.env, GIT_NO_LAZY_FETCH: '1' });
+const SHA = /^[0-9a-f]{40}$/;
+const BRANCH = /^[A-Za-z0-9._/-]{1,200}$/;
+const REPOSITORIO = /^[A-Za-z0-9_.-]{1,100}\/[A-Za-z0-9_.-]{1,100}$/;
+/** Texto curto vindo de fora: sem controle, num teto. */
+function curto(v, teto = 120) {
+    if (typeof v !== 'string')
+        return null;
+    const limpo = Array.from(v.replace(/\p{Cc}/gu, ' ').replace(/\s+/g, ' ').trim()).slice(0, teto).join('');
+    return limpo || null;
+}
+/**
+ * O nome de um check vem do GitHub e e o unico texto livre da forja que chega ao dono (no proximo passo).
+ * Fica so letra, numero e pontuacao simples: nada de controle, de formatacao invisivel, de quebra de
+ * linha, de `:` (diretiva de canal) nem de `$` (padrao de substituicao).
+ */
+function nomeDeCheck(v) {
+    if (typeof v !== 'string')
+        return null;
+    const limpo = v.replace(/[^\p{L}\p{N} ()[\]._,+/-]+/gu, ' ').replace(/\s+/g, ' ').trim();
+    return limpo ? Array.from(limpo).slice(0, 80).join('').trim() : null;
+}
+/** Instante ISO de fora. O GitHub devolve o ano 1 para o que ainda nao aconteceu. */
+function instante(v) {
+    if (typeof v !== 'string')
+        return null;
+    const ms = Date.parse(v);
+    return Number.isFinite(ms) && new Date(ms).getUTCFullYear() >= 2000 ? new Date(ms).toISOString() : null;
+}
+/**
+ * Um check do rollup, com a chave que diz quando ele se repete (o tipo, o workflow e o nome cru, como o `gh
+ * pr checks`: dois checks diferentes com o mesmo nome limpo nunca se fundem) e o inicio que decide o mais novo.
+ */
+function checkDaForja(c) {
+    if (!c || typeof c !== 'object')
+        return null;
+    const o = c;
+    const nome = nomeDeCheck(o.name) ?? nomeDeCheck(o.context);
+    if (!nome)
+        return null;
+    // O run do Actions separa o mesmo job disparado por dois eventos; a reexecucao fica no mesmo run.
+    const run = /\/actions\/runs\/(\d+)/.exec(String(o.detailsUrl ?? o.targetUrl ?? ''))?.[1] ?? '';
+    const chave = JSON.stringify([String(o.__typename ?? ''), String(o.workflowName ?? '').slice(0, 200),
+        String(o.name ?? o.context ?? '').slice(0, 200), run]);
+    let situacao;
+    if (o.__typename === 'StatusContext' || (o.status === undefined && typeof o.state === 'string')) {
+        const s = String(o.state ?? '').toUpperCase();
+        situacao = s === 'SUCCESS' ? 'verde' : s === 'FAILURE' || s === 'ERROR' ? 'vermelho' : 'pendente';
+    }
+    else {
+        const status = String(o.status ?? '').toUpperCase(), conclusao = String(o.conclusion ?? '').toUpperCase();
+        situacao = status !== 'COMPLETED' ? 'pendente' : ['SUCCESS', 'NEUTRAL', 'SKIPPED'].includes(conclusao) ? 'verde' : 'vermelho';
+    }
+    const concluidoEm = situacao === 'pendente' ? null : instante(o.completedAt) ?? instante(o.startedAt);
+    return { check: { nome, situacao, concluidoEm }, chave, inicio: instante(o.startedAt) ?? instante(o.completedAt) ?? '' };
+}
+/**
+ * Um PR da resposta do `gh`, ou `null` quando nao e de thread nenhuma daqui (fork, outra base, branch que
+ * nao e nome de branch de thread). Formato errado lanca: a leitura inteira vira "nao lido".
+ */
+function prDaForja(bruto, base) {
+    if (!bruto || typeof bruto !== 'object')
+        throw new Error('PR fora do formato');
+    const p = bruto;
+    const numero = p.number, head = p.headRefOid;
+    const estado = { OPEN: 'aberto', MERGED: 'mesclado', CLOSED: 'fechado' }[String(p.state)];
+    if (!Number.isSafeInteger(numero) || numero < 1 || typeof head !== 'string' || !SHA.test(head) || !estado ||
+        typeof p.isDraft !== 'boolean')
+        throw new Error('PR fora do formato');
+    if (p.isCrossRepository === true || (typeof p.baseRefName === 'string' && p.baseRefName !== base) ||
+        typeof p.headRefName !== 'string' || !BRANCH.test(p.headRefName))
+        return null;
+    const rollup = p.statusCheckRollup;
+    if (rollup !== null && rollup !== undefined && !Array.isArray(rollup))
+        throw new Error('checks fora do formato');
+    const porChave = new Map();
+    if (estado === 'aberto') {
+        for (const [i, c] of (rollup ?? []).entries()) {
+            // Check ilegivel nunca vira verde: entra como pendente, e o PR nao sai como "esperando merge".
+            const lido = checkDaForja(c) ?? { check: { nome: 'check ilegivel', situacao: 'pendente', concluidoEm: null },
+                chave: `ilegivel:${i}`, inicio: '' };
+            // O rollup repete o check reexecutado: vale o mais novo da mesma chave, como no `gh pr checks`.
+            const atual = porChave.get(lido.chave);
+            if (!atual || lido.inicio > atual.inicio)
+                porChave.set(lido.chave, lido);
+        }
+    }
+    const url = typeof p.url === 'string' && /^https:\/\/[^\s]+$/.test(p.url) ? curto(p.url, 300) : null;
+    return { numero: numero, branch: p.headRefName, head, estado, rascunho: p.isDraft, url,
+        criadoEm: instante(p.createdAt), mescladoEm: instante(p.mergedAt), checks: [...porChave.values()].map((x) => x.check) };
+}
+/** O repositorio `dono/nome` do remoto, so quando ele e do github.com (o host ancorado, nao so citado no caminho). */
+function repositorioDoRemoto(raiz, remoto) {
+    const url = git(raiz, ['remote', 'get-url', remoto]);
+    const forja = url.ok ? (0, forja_1.identidadeDaForja)(url.stdout.trim()) : null;
+    return forja && forja.tipo === 'github' && forja.host === 'github.com' && REPOSITORIO.test(forja.repo) ? forja.repo : null;
+}
+/**
+ * Le os PRs da base do repositorio do remoto em duas chamadas: os abertos (ate `LIMITE_DE_PRS`; e so a
+ * lista deles que pode dizer "sem PR") e os recentes de qualquer estado (para achar o mesclado e o fechado).
+ * O `gh` usa a autenticacao dele; nenhum token passa por aqui. Remoto que nao e do github.com nao chama nada.
+ */
+function lerPrsDaForja(carregado, opcoes = {}) {
+    const lidoEm = opcoes.quando ?? new Date().toISOString();
+    const remoto = opcoes.remoto ?? carregado.manifesto.fabrica.remoto;
+    const base = carregado.manifesto.worktree.base_branch;
+    const repositorio = repositorioDoRemoto(carregado.raiz, remoto);
+    if (!repositorio)
+        return { ok: false, lidoEm, erro: `o remoto ${remoto} não é um repositório do github.com` };
+    const orcamento = opcoes.orcamentoMs ?? ORCAMENTO_DA_LEITURA_MS, fimDaLeitura = Date.now() + orcamento;
+    const resta = () => fimDaLeitura - Date.now();
+    const pedir = (args) => {
+        if (resta() <= 0)
+            return `gh pr list: orçamento de ${Math.round(orcamento / 1000)} s da leitura esgotado`;
+        const r = (opcoes.executor ?? ghPadrao)(['pr', 'list', `--repo=github.com/${repositorio}`, `--base=${base}`, ...args], Math.min(PRAZO_DO_GH_MS, resta()));
+        if (r.status !== 0) {
+            const detalhe = curto((0, hitl_1.redigirSegredos)(r.stderr || r.stdout || ''), 160) ?? 'sem detalhe';
+            return `gh pr list falhou (${r.status === null ? 'sem código de saída' : `código ${r.status}`}): ${detalhe}`;
+        }
+        try {
+            const lista = JSON.parse(r.stdout);
+            if (!Array.isArray(lista))
+                throw new Error('a resposta não é uma lista');
+            return lista;
+        }
+        catch (e) {
+            return `resposta do gh pr list fora do formato: ${curto((0, hitl_1.redigirSegredos)(e.message), 120) ?? 'sem detalhe'}`;
+        }
+    };
+    try {
+        const porNumero = new Map();
+        const juntar = (lista, comChecks) => {
+            for (const bruto of lista) {
+                const pr = prDaForja(bruto, base);
+                if (!pr || porNumero.has(pr.numero))
+                    continue;
+                // S-b do CHECK (rodada 3): a leitura sem rollup nunca diz que o aberto nao tem checks.
+                if (!comChecks && pr.estado === 'aberto')
+                    pr.checks = [{ nome: 'checks não lidos', situacao: 'pendente', concluidoEm: null }];
+                porNumero.set(pr.numero, pr);
+            }
+        };
+        const abertos = pedir(['--state=open', `--limit=${exports.LIMITE_DE_PRS}`, `--json=${CAMPOS_DO_GH}`]);
+        if (typeof abertos === 'string')
+            return { ok: false, lidoEm, erro: abertos };
+        juntar(abertos, true);
+        const recentes = pedir(['--state=all', `--limit=${exports.LIMITE_DE_RECENTES}`, `--json=${CAMPOS_DOS_RECENTES}`]);
+        if (typeof recentes === 'string')
+            return { ok: false, lidoEm, erro: recentes };
+        juntar(recentes, false);
+        // R1 do CHECK (rodada 3): antes de dizer "sem PR", a branch candidata e conferida sozinha (o mesclado velho
+        // fica fora dos recentes). Acima do teto da batida, a branch fica sem conferir, e isso e "PR nao lido".
+        const achadas = new Set([...porNumero.values()].map((p) => p.branch));
+        const faltam = [...new Set(opcoes.candidatas ?? [])].filter((b) => BRANCH.test(b) && !achadas.has(b));
+        const semConferir = [];
+        for (const [i, branch] of faltam.entries()) {
+            // Acima do teto da batida, sem tempo para a conferencia inteira ou com ela falhando, a candidata fica sem conferir
+            // ("PR nao lido") e o que ja foi lido vale (sugestao da seguranca na rodada 4 do CHECK).
+            if (i >= LIMITE_DE_CANDIDATAS || resta() < MINIMO_DA_CONFERENCIA_MS) {
+                semConferir.push(branch);
+                continue;
+            }
+            const daBranch = pedir(['--state=all', `--head=${branch}`, '--limit=5', `--json=${CAMPOS_DOS_RECENTES}`]);
+            try {
+                if (typeof daBranch === 'string')
+                    throw new Error(daBranch);
+                juntar(daBranch, false);
+            }
+            catch {
+                semConferir.push(branch);
+            }
+        }
+        return { ok: true, retrato: { contrato: exports.CONTRATO_PRS, lidoEm, repositorio, base, parcial: abertos.length >= exports.LIMITE_DE_PRS,
+                ...(semConferir.length ? { semConferir } : {}), prs: [...porNumero.values()] } };
+    }
+    catch (e) {
+        return { ok: false, lidoEm, erro: `resposta do gh pr list fora do formato: ${curto((0, hitl_1.redigirSegredos)(e.message), 120) ?? 'sem detalhe'}` };
+    }
+}
+const dirDoMonitor = (raiz) => path.join((0, estado_thread_1.raizDoEstado)(raiz), '.orkastery', 'monitor');
+/** Grava o retrato de uma leitura que deu certo: arquivo novo exclusivo, so do dono, renomeado por cima. */
+function gravarRetratoDePrs(raiz, retrato) {
+    const dir = dirDoMonitor(raiz);
+    fs.mkdirSync(dir, { recursive: true });
+    const arquivo = path.join(dir, ARQUIVO_DOS_PRS), tmp = `${arquivo}.${process.pid}.${Date.now()}.tmp`;
+    try {
+        fs.writeFileSync(tmp, JSON.stringify(retrato, null, 2) + '\n', { mode: 0o600, flag: 'wx' });
+        fs.renameSync(tmp, arquivo);
+    }
+    catch (e) {
+        try {
+            fs.unlinkSync(tmp);
+        }
+        catch { /* ja saiu */ }
+        throw e;
+    }
+}
+/** O ultimo retrato gravado pelo pulse, conferido campo a campo e com os nomes de check limpos de novo. */
+function lerRetratoDePrs(raiz) {
+    try {
+        const r = JSON.parse(fs.readFileSync(path.join(dirDoMonitor(raiz), ARQUIVO_DOS_PRS), 'utf8'));
+        const lidoEm = instante(r.lidoEm);
+        if (r.contrato !== exports.CONTRATO_PRS || !lidoEm || typeof r.repositorio !== 'string' || !REPOSITORIO.test(r.repositorio) ||
+            typeof r.base !== 'string' || typeof r.parcial !== 'boolean' || !Array.isArray(r.prs) ||
+            (r.semConferir !== undefined && !(Array.isArray(r.semConferir) && r.semConferir.every((b) => typeof b === 'string' && BRANCH.test(b)))))
+            return null;
+        const opcional = (v) => (v === null || v === undefined ? null : instante(v) ?? undefined);
+        const prs = [];
+        for (const bruto of r.prs) {
+            const p = (bruto ?? {});
+            const estado = p.estado;
+            const criadoEm = opcional(p.criadoEm), mescladoEm = opcional(p.mescladoEm);
+            if (!Number.isSafeInteger(p.numero) || p.numero < 1 || typeof p.branch !== 'string' || !BRANCH.test(p.branch) ||
+                typeof p.head !== 'string' || !SHA.test(p.head) || !['aberto', 'mesclado', 'fechado'].includes(estado) ||
+                typeof p.rascunho !== 'boolean' || !Array.isArray(p.checks) || criadoEm === undefined || mescladoEm === undefined)
+                return null;
+            const checks = [];
+            for (const c of p.checks) {
+                const k = (c ?? {});
+                const nome = nomeDeCheck(k.nome), concluidoEm = opcional(k.concluidoEm);
+                if (!nome || !['verde', 'vermelho', 'pendente'].includes(String(k.situacao)) || concluidoEm === undefined)
+                    return null;
+                checks.push({ nome, situacao: k.situacao, concluidoEm });
+            }
+            prs.push({ numero: p.numero, branch: p.branch, head: p.head, estado, rascunho: p.rascunho,
+                url: typeof p.url === 'string' && /^https:\/\/[^\s]+$/.test(p.url) ? curto(p.url, 300) : null, criadoEm, mescladoEm, checks });
+        }
+        return { contrato: exports.CONTRATO_PRS, lidoEm, repositorio: r.repositorio, base: r.base, parcial: r.parcial,
+            ...(Array.isArray(r.semConferir) && r.semConferir.length ? { semConferir: r.semConferir } : {}), prs };
+    }
+    catch {
+        return null;
+    }
+}
+// ---------------------------------------------------------------------------
+// Quem e do condutor (D6).
+// ---------------------------------------------------------------------------
+const RESPOSTAS_HITL = ['human_gate', 'session_answered'];
+/**
+ * Pergunta estruturada ainda pendente desde `desde`: pedido sem resposta que, vencido, espera ou escala
+ * (so o "seguir a recomendada" resolve sozinho). Decisao informada (`decidido`) nao e pergunta. Pedido
+ * ilegivel conta como pendente: na duvida, a vez e do dono.
+ */
+function perguntaAberta(eventos, desde, quando) {
+    const inicio = Date.parse(desde);
+    const respondidos = new Set(eventos.filter((e) => RESPOSTAS_HITL.includes(e.tipo)).map((e) => String(e.pedidoId)));
+    // O pedido novo para o mesmo alvo substitui o velho: so o mais novo de cada sessao ou gate conta.
+    const porAlvo = new Map();
+    for (const e of eventos) {
+        if (e.tipo !== 'hitl_requested' || Date.parse(e.ts) < inicio)
+            continue;
+        const pedido = e.pedido;
+        if (!pedido || typeof pedido !== 'object') {
+            porAlvo.set(`ilegivel:${String(e.eventId)}`, null);
+            continue;
+        }
+        if (pedido.classe === 'decidido')
+            continue;
+        let alvo;
+        try {
+            alvo = (0, hitl_contract_1.alvoDoPedido)(pedido);
+        }
+        catch {
+            alvo = undefined;
+        }
+        porAlvo.set(alvo ? JSON.stringify(alvo) : `pedido:${String(pedido.id)}`, pedido);
+    }
+    return [...porAlvo.values()].some((pedido) => {
+        if (!pedido)
+            return true;
+        if (respondidos.has(String(pedido.id)))
+            return false;
+        try {
+            return (0, hitl_contract_1.estadoDoPedido)(pedido, quando) !== 'seguir-recomendada';
+        }
+        catch {
+            return true;
+        }
+    });
+}
+/** O carimbo que o radar grava (`ork sessions hitl --registrar`): a leitura da tela, nao um evento da sessao. */
+const doRadar = (e) => e.tipo === 'sessao_bloqueada' && e.fonte === 'ork sessions hitl --registrar';
+/**
+ * B1 do CHECK (rodada 5): o SHIP que o observador viu terminar em `done`, com o Stop, sem o `ship_done` no
+ * intervalo do despacho. A prova do ork no SHIP e so o `ship_done` (`provaDoOrk`): o que falta e mergear o PR
+ * ou registrar a entrega, e isso e do condutor, como o fim de turno em `blocked`. Dos 4 `human.pending` do SHIP
+ * nos ledgers de 30/09, 2 tem este formato (ork-rm037noite e ork-pacotedeexpe). O CHECK em `done` sem o veredito
+ * e outra coisa, e continua com o dono (A3 da rodada 5, pendente).
+ */
+function shipSemRegistro(e) {
+    const { ok: provou } = (e.provaOrk ?? {});
+    return e.motivo === 'human.pending' && e.origem === 'sessions.watch' && e.fase === 'SHIP' && e.estadoNativo === 'done' &&
+        !!e.stop && provou === false;
+}
+/**
+ * O bloqueio que pede o dono: o prompt de permissao do hook e o que o radar leu com pergunta na tela. O
+ * carimbo do radar no fim de turno (`blocked` lido sem menu nem pergunta) nao e prompt nenhum.
+ */
+function bloqueioDoDono(e) {
+    return e.tipo === 'sessao_bloqueada' && !(doRadar(e) && e.tipoDeHitl === 'hitl.desconhecido' && !String(e.pergunta ?? '').trim());
+}
+/**
+ * O ultimo entre bloqueio do dono, destravamento e Stop da sessao, desde o despacho, e bloqueio? R4-1 do CHECK
+ * (rodada 4): o carimbo do radar depois de um Stop, sem atividade da sessao no meio, e a leitura da mensagem
+ * final (a lista numerada vira "hitl.pergunta"; a palavra "token", "hitl.credencial") e nao conta. O prompt do
+ * hook conta sempre.
+ */
+function bloqueioPendente(eventos, sessionId, desde) {
+    const inicio = Date.parse(desde);
+    let pendente = false, turnoEncerrado = false;
+    for (const e of eventos) {
+        if (e.sessionId !== sessionId || Date.parse(e.ts) < inicio)
+            continue;
+        if (e.tipo === 'runtime_stop') {
+            pendente = false;
+            turnoEncerrado = true;
+        }
+        else if (e.tipo === 'sessao_destravada')
+            pendente = false;
+        else if (doRadar(e)) {
+            if (bloqueioDoDono(e) && !turnoEncerrado)
+                pendente = true;
+        }
+        else if (atividadeDaSessao(e)) {
+            turnoEncerrado = false;
+            if (e.tipo === 'sessao_bloqueada')
+                pendente = true;
+        }
+    }
+    return pendente;
+}
+/** O ultimo despacho de fase da thread, quando ha um. */
+function ultimoDespacho(eventos) {
+    for (let i = eventos.length - 1; i >= 0; i--)
+        if (eventos[i].tipo === 'phase_dispatch')
+            return eventos[i];
+    return null;
+}
+const texto = (v) => (typeof v === 'string' && v ? v : null);
+/**
+ * Atividade da sessao que supera um fim de turno: heartbeat (fora a notificacao de ociosidade), commit, Stop
+ * novo e prompt de permissao do hook. O carimbo do radar nao e atividade: so registra o `blocked` que ja
+ * estava la, mesmo quando a tela traz lista ou palavra-chave (R4-1 do CHECK, rodada 4).
+ */
+function atividadeDaSessao(e) {
+    if (e.tipo === 'runtime_event')
+        return !(e.sensor === 'notification' && e.notificationType === 'idle_prompt');
+    return e.tipo === 'commit' || e.tipo === 'runtime_stop' || (e.tipo === 'sessao_bloqueada' && !doRadar(e));
+}
+function fimDoTurno(eventos, despacho) {
+    const i = eventos.lastIndexOf(despacho);
+    const depois = eventos.slice(i + 1);
+    const sid = texto(despacho.sessionId);
+    const daSessao = (e) => !sid || !e.sessionId || e.sessionId === sid;
+    const resultado = [...depois].reverse().find((e) => e.tipo === 'phase_result' && daSessao(e));
+    let concluida = false;
+    if (resultado) {
+        const fase = texto(resultado.fase);
+        // O resultado legado (sem classificacao, `ok: true`) tambem e fase concluida.
+        concluida = resultado.ok !== false && (resultado.classificacao === 'fase_concluida' ||
+            (resultado.classificacao === undefined && resultado.ok === true));
+        // A1 (rodada 3) e R4-2 (rodada 4) do CHECK: o dono pode ter respondido na tela e a sessao voltado a trabalhar,
+        // depois da fase concluida ou da espera do observador. So vale o fim de turno sem atividade depois; com
+        // atividade, decide o Stop correlacionado mais novo, abaixo.
+        const retomou = !!sid && eventos.slice(eventos.lastIndexOf(resultado) + 1).some((e) => e.sessionId === sid && atividadeDaSessao(e));
+        if (concluida) {
+            if (!retomou)
+                return { em: resultado.ts, tipo: 'concluida', sessionId: sid, fase, comProva: true };
+        }
+        else if (resultado.motivo === 'human.pending' && despacho.pausaAoFim === true) {
+            // S-a do CHECK (rodada 3): no bloco com pausa ao fim, todo `human.pending` do resultado e a fase entregue ao dono.
+            return { em: resultado.ts, tipo: 'pausa-do-bloco', sessionId: sid, fase, comProva: true };
+        }
+        else if (resultado.motivo === 'human.pending' && resultado.stop && (resultado.estadoNativo === 'blocked' || shipSemRegistro(resultado))) {
+            if (!retomou) {
+                const { ts: doStop } = resultado.stop;
+                const { ok: provou } = (resultado.provaOrk ?? {});
+                return { em: instante(doStop) ?? resultado.ts, tipo: 'espera-do-observador', sessionId: sid, fase,
+                    comProva: typeof provou === 'boolean' ? provou : null };
+            }
+        }
+        else
+            return { em: resultado.ts, tipo: 'outro', sessionId: sid, fase, comProva: null };
+    }
+    if (sid) {
+        const ultimoStop = [...depois].reverse().find((e) => e.tipo === 'runtime_stop' && e.sessionId === sid && e.sensor === 'stop');
+        const despachadaEm = texto(ultimoStop?.despachoEm);
+        if (ultimoStop && despachadaEm) {
+            const stop = (0, session_watcher_claude_1.stopCorrelacionado)(eventos, { sessionId: sid, fase: String(ultimoStop.fase), despachadaEm });
+            // Com resultado anterior e sessao retomada, so o Stop depois do resultado encerra o turno novo. A fase que
+            // ja tinha concluido continua concluida; o turno novo acabou neste Stop.
+            if (stop && (!resultado || Date.parse(stop.ts) > Date.parse(resultado.ts))) {
+                return concluida ? { em: stop.ts, tipo: 'concluida', sessionId: sid, fase: texto(resultado?.fase) ?? texto(stop.fase), comProva: true }
+                    : { em: stop.ts, tipo: 'stop-sem-resultado', sessionId: sid, fase: texto(stop.fase), comProva: null };
+            }
+        }
+    }
+    return null;
+}
+/**
+ * O que ainda espera o dono depois do ultimo despacho, quando espera: a pausa prevista do bloco sem
+ * aprovacao humana, a thread pausada, a pergunta pendente, o prompt de permissao e a escalacao tipada
+ * dele, cada um com as regras de destravar do monitor. Nada disso e do condutor (P3).
+ */
+function pendenciaDoDono(t, eventos, quando) {
+    if (t.status === 'pausada')
+        return 'thread pausada';
+    const despacho = ultimoDespacho(eventos);
+    if (!despacho)
+        return null;
+    const depois = eventos.slice(eventos.lastIndexOf(despacho) + 1);
+    if (despacho.pausaAoFim === true && !depois.some(ocupacao_1.ehAprovacaoHumana))
+        return 'pausa prevista ao fim do bloco';
+    if (perguntaAberta(eventos, despacho.ts, quando))
+        return 'pergunta aberta';
+    const sid = texto(despacho.sessionId);
+    if (sid && bloqueioPendente(eventos, sid, despacho.ts))
+        return 'prompt de permissão pendente';
+    // Aviso da rodada 6 do CHECK: o gate do observador so muda de dono com o fim de turno provado. A sessao que voltou a
+    // trabalhar depois do resultado, sem Stop novo, segue do dono, e a thread nao sai tambem como linha do condutor.
+    const fim = fimDoTurno(eventos, despacho);
+    const turnoEncerrado = !!fim && fim.tipo !== 'outro';
+    for (let k = 0; k < depois.length; k++) {
+        const e = depois[k];
+        if (e.tipo !== 'gate_blocked')
+            continue;
+        const motivo = String(e.motivo ?? '');
+        // O fim de turno que o observador viu em `blocked`, e o SHIP em `done` sem o `ship_done` (B1 da rodada 5), nao sao
+        // escalacao: sao justamente o que muda de dono.
+        if (turnoEncerrado && motivo === 'human.pending' && e.origem === 'sessions.watch' &&
+            (e.estadoNativo === 'blocked' || shipSemRegistro(e)))
+            continue;
+        const doDono = motivo === 'human.pending' ||
+            (hitl_gates_1.MOTIVOS_DE_ESCALACAO_HUMANA.includes(motivo) && (0, hitl_classificacao_1.quemDecide)(motivo) === 'dono');
+        const resolvido = depois.slice(k + 1).some((p) => ocupacao_1.EVENTOS_QUE_DESTRAVAM.includes(p.tipo) || (0, ocupacao_1.ehAprovacaoHumana)(p));
+        if (doDono && !resolvido)
+            return `escalação ${motivo}`;
+    }
+    return null;
+}
+function esperaDoCondutor(t, eventos, quando) {
+    if (t.status === 'fechada')
+        return null;
+    const despacho = ultimoDespacho(eventos);
+    if (!despacho || despacho.pausaAoFim !== false)
+        return null;
+    const fim = fimDoTurno(eventos, despacho);
+    if (!fim || fim.tipo === 'outro' || fim.tipo === 'pausa-do-bloco' || pendenciaDoDono(t, eventos, quando))
+        return null;
+    return { thread: t.id, fase: fim.fase, sessionId: fim.sessionId, fimDoTurnoEm: fim.em, tipo: fim.tipo, comProva: fim.comProva };
+}
+/**
+ * Sessao `blocked` do radar de quem o turno acabou sem pergunta: claude-bg com a tela lida, sem menu, sem
+ * pergunta e sem palavra de credencial ou permissao. Sessao nativa (Codex) em `blocked` e pergunta
+ * estruturada, e tela nao lida (orcamento) nao prova nada: as duas continuam do dono.
+ */
+function sessaoSemPergunta(s) {
+    return s.classe === 'hitl' && s.jobVivo === true && s.kind !== 'codex-controller' && s.tipoDeHitl === 'hitl.desconhecido' &&
+        s.alternativas.length === 0 && !s.pergunta?.trim() && !!s.thread?.id;
+}
+const minutosDesde = (desde, quando) => Math.max(0, Math.floor((Date.parse(quando) - Date.parse(desde)) / 60000));
+const curtoDaSessao = (sid) => (sid ?? '').slice(0, 8);
+/** Os refs locais de uma vez: `refs/heads/...` e a copia do remoto, sem rede. */
+function refsLocais(raiz, remoto) {
+    const r = git(raiz, ['for-each-ref', '--format=%(refname)%09%(objectname)', 'refs/heads/', `refs/remotes/${remoto}/`]);
+    const mapa = new Map();
+    if (!r.ok)
+        return mapa;
+    for (const linha of r.stdout.split('\n')) {
+        const [ref, sha] = linha.split('\t');
+        if (ref && sha && SHA.test(sha))
+            mapa.set(ref, sha);
+    }
+    return mapa;
+}
+/** Os merges `ship(<thread>)` da base numa leitura so, do mais novo para o mais velho (fica o mais novo). */
+function mergesNaBase(raiz, baseRef) {
+    const mapa = new Map();
+    if (!baseRef)
+        return mapa;
+    // Regex basica do git: o `(` e literal. A ref vem qualificada do `for-each-ref`.
+    const r = git(raiz, ['log', baseRef, '--first-parent', '--format=%H%x09%cI%x09%s', '--grep=^ship(']);
+    if (!r.ok)
+        return mapa;
+    for (const linha of r.stdout.split('\n')) {
+        const [sha, em, assunto] = linha.split('\t');
+        const m = /^ship\(([A-Za-z0-9._-]+)\)/.exec(assunto ?? '');
+        if (m && sha && SHA.test(sha) && !mapa.has(m[1]))
+            mapa.set(m[1], { sha, em: instante(em) });
+    }
+    return mapa;
+}
+/** Situacao dos checks de um PR aberto e o instante que conta para cada uma. */
+function situacaoDoPr(pr) {
+    const maisNovo = (cs) => cs.map((c) => c.concluidoEm).filter((x) => !!x).sort().at(-1) ?? null;
+    const vermelhos = pr.checks.filter((c) => c.situacao === 'vermelho');
+    if (vermelhos.length) {
+        const ultimo = [...vermelhos].sort((a, b) => String(a.concluidoEm).localeCompare(String(b.concluidoEm))).at(-1);
+        return { situacao: 'vermelho', desdeEm: maisNovo(vermelhos) ?? pr.criadoEm, vermelho: ultimo.nome, semChecks: false };
+    }
+    if (!pr.checks.length)
+        return { situacao: 'pendente', desdeEm: pr.criadoEm, vermelho: null, semChecks: true };
+    if (pr.checks.some((c) => c.situacao === 'pendente'))
+        return { situacao: 'pendente', desdeEm: null, vermelho: null, semChecks: false };
+    return { situacao: 'verde', desdeEm: maisNovo(pr.checks) ?? pr.criadoEm, vermelho: null, semChecks: false };
+}
+/** Os PRs da branch no retrato: o aberto mais novo; o mesclado na ponta atual; o fechado mais novo. */
+function prsDaBranch(retrato, branch, cabeca) {
+    const daBranch = retrato && branch ? retrato.prs.filter((p) => p.branch === branch).sort((a, b) => b.numero - a.numero) : [];
+    return {
+        aberto: daBranch.find((p) => p.estado === 'aberto') ?? null,
+        // Commit novo depois do merge e entrega nova, que ainda nao tem PR.
+        mesclado: daBranch.find((p) => p.estado === 'mesclado' && p.head === cabeca) ?? null,
+        fechado: daBranch.find((p) => p.estado === 'fechado') ?? null,
+        achado: daBranch.length > 0,
+    };
+}
+const houveDespachoDepois = (eventos, desde) => eventos.some((e) => e.tipo === 'phase_dispatch' && Date.parse(e.ts) > Date.parse(desde));
+/**
+ * A fase que vem depois do que o despacho rodou, quando o ciclo da thread tem uma. No #Auto uma sessao roda o
+ * bloco inteiro; nos outros modos o condutor despacha fase a fase dentro do bloco (#Maestro: GOAL e depois
+ * PLAN, as duas com o bloco GOAL-PLAN), e pular uma fase pularia a pausa do dono que mora nela.
+ */
+function faseSeguinte(t, despacho) {
+    if (!despacho)
+        return null;
+    const fases = t.fases ?? [];
+    const bloco = typeof despacho.bloco === 'string' && despacho.bloco ? despacho.bloco.split('-') : [];
+    const rodou = t.modo === 'auto' && bloco.length ? bloco.at(-1) : String(despacho.fase ?? '');
+    const i = fases.indexOf(rodou);
+    return i >= 0 && i + 1 < fases.length ? fases[i + 1] : null;
+}
+/** A linha das sessoes que sobraram de uma thread: uma linha, com todas elas. */
+function passoDasSobras(ids, fechada) {
+    const onde = fechada ? 'da thread fechada' : 'de um despacho anterior';
+    return ids.length === 1
+        ? `encerrar a sessão ${ids[0]}, que sobrou ${onde} (ork sessions stop ${ids[0]})`
+        : `encerrar as sessões ${ids.join(' e ')}, que sobraram ${onde} (${ids.map((id) => `ork sessions stop ${id}`).join('; ')})`;
+}
+/**
+ * O estado da entrega de cada thread aberta deste checkout e o que esta parado no condutor (D5), mais as
+ * sessoes `blocked` sem pergunta que sobraram. O que o predicado tira do dono volta sempre como linha.
+ */
+function entregasDoProjeto(carregado, opcoes) {
+    const raiz = carregado.raiz, quando = opcoes.quando, limiar = opcoes.limiarMin ?? exports.LIMIAR_PARADO_NO_CONDUTOR_MIN;
+    const remoto = carregado.manifesto.fabrica.remoto, baseBranch = carregado.manifesto.worktree.base_branch;
+    const refs = refsLocais(raiz, remoto);
+    // A copia do remoto vem primeiro: a base local desta maquina pode estar parada (o merge e pelo GitHub).
+    const baseRef = [`refs/remotes/${remoto}/${baseBranch}`, `refs/heads/${baseBranch}`].find((r) => refs.has(r)) ?? null;
+    const merges = mergesNaBase(raiz, baseRef);
+    const sessoes = opcoes.sessoes ?? [];
+    const threads = [];
+    for (const id of (0, thread_1.listarIds)(raiz)) {
+        try {
+            threads.push((0, thread_1.lerThread)(raiz, id));
+        }
+        catch { /* thread ilegivel fica de fora */ }
+    }
+    const fatos = threads.filter((t) => t.status !== 'fechada').map((t) => {
+        let eventos = [];
+        try {
+            eventos = (0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, t.id));
+        }
+        catch { /* ledger ilegivel: sem fato, sem caso */ }
+        const branch = (0, worktree_1.branchDaWorktree)(t);
+        const cabeca = refs.get(`refs/heads/${branch}`) ?? null;
+        const remota = refs.get(`refs/remotes/${remoto}/${branch}`) ?? null;
+        const comProduto = !!cabeca && !!baseRef && Number(git(raiz, ['rev-list', '--count', `${baseRef}..${cabeca}`]).stdout.trim()) > 0;
+        // `merge-base --is-ancestor`: 0 contem, 1 nao contem; outro codigo e git sem resposta, que nunca vira "sem push".
+        const contem = remota && cabeca && remota !== cabeca ? git(raiz, ['merge-base', '--is-ancestor', cabeca, remota]).code : null;
+        const publicada = !cabeca ? null : !remota ? false : remota === cabeca || contem === 0 ? true : contem === 1 ? false : null;
+        const ships = eventos.filter((e) => e.tipo === 'ship_done'), merge = merges.get(t.id) ?? null;
+        // R4-4 do CHECK (rodada 4): o `ship_done` cobre a entrega do mesmo head (`shaDe`) ou do mesmo merge; a entrega
+        // nova depois dele ainda nao foi registrada. O legado sem o sha cobre tudo, como antes.
+        const cobre = (campo, sha) => ships.some((e) => typeof e[campo] !== 'string' || !SHA.test(e[campo]) || e[campo] === sha);
+        return { t, eventos, branch: cabeca ? branch : null, cabeca, comProduto, publicada, temRemota: !!remota,
+            shipNoLedger: ships.length > 0, entregueNaPonta: cabeca ? cobre('shaDe', cabeca) : ships.length > 0,
+            mergeRegistrado: !!merge && cobre('mergeSha', merge.sha), merge };
+    });
+    // D2: a forja so e lida quando alguma thread tem o que mostrar la: produto numa branch que ja foi ao remoto
+    // (inteira, ou com commit novo ainda sem push, que pode ter PR aberto).
+    let prs = null;
+    const candidatas = fatos.filter((f) => f.comProduto && f.temRemota && f.branch).map((f) => f.branch);
+    if (opcoes.lerPrs && candidatas.length)
+        prs = opcoes.lerPrs(candidatas);
+    // O retrato so vale do repositorio e da base de agora, e lido ha menos de `VALIDADE_DO_RETRATO_MIN`.
+    let retrato = null, semRetrato = prs && !prs.ok ? prs.erro : 'sem leitura dos PRs';
+    if (prs?.ok) {
+        const r = prs.retrato;
+        if (r.base !== baseBranch || r.repositorio !== repositorioDoRemoto(raiz, remoto))
+            semRetrato = 'retrato de PRs de outro repositório ou base';
+        else if (minutosDesde(r.lidoEm, quando) > exports.VALIDADE_DO_RETRATO_MIN)
+            semRetrato = 'retrato de PRs velho';
+        else if (Date.parse(r.lidoEm) - Date.parse(quando) > FOLGA_DO_RELOGIO_MIN * 60000)
+            semRetrato = 'retrato de PRs com data no futuro';
+        else
+            retrato = r;
+    }
+    const estados = [], parados = [];
+    const doCondutor = { gates: new Set(), sessoes: new Set(), turnosEncerrados: new Set() };
+    for (const f of fatos) {
+        const { t, eventos } = f;
+        const despacho = ultimoDespacho(eventos);
+        const fim = despacho ? fimDoTurno(eventos, despacho) : null;
+        const terminou = !!fim && fim.tipo !== 'outro';
+        const fimEm = terminou ? fim.em : null;
+        // A1 do CHECK (rodada 3): o fim de turno vem do ledger (Stop sem atividade depois); a tela da sessao depois
+        // dele e a mensagem final, e a lista numerada nela nao e menu. Sessao retomada nao tem fim de turno.
+        const espera = esperaDoCondutor(t, eventos, quando);
+        if (espera) {
+            doCondutor.gates.add(`${t.id}|${espera.fase ?? t.faseAtual}`);
+            if (espera.sessionId) {
+                doCondutor.sessoes.add(espera.sessionId);
+                doCondutor.turnosEncerrados.add(espera.sessionId);
+            }
+        }
+        const conducao = (0, conducao_1.conducaoDaThread)(raiz, t.id, { agora: new Date(quando) });
+        // P7: a sessao que ja encerrou o turno nao conduz mais nada, mesmo com o lease de pe.
+        const conduzidaAgora = !!conducao && !(conducao.dono.tipo === 'sessao' && terminou && conducao.dono.sessionId === fim.sessionId);
+        const doDono = pendenciaDoDono(t, eventos, quando);
+        // A2 do CHECK (rodada 3): depois do veredito do dono, o tempo do condutor conta a partir dele.
+        const aprovacao = despacho ? eventos.slice(eventos.lastIndexOf(despacho) + 1).filter(ocupacao_1.ehAprovacaoHumana).at(-1) : undefined;
+        // A2 do CHECK: a leitura dos PRs so vale depois do fim do turno; antes dele, o turno pode ter mudado o PR.
+        const prLido = retrato && (!fimEm || Date.parse(retrato.lidoEm) >= Date.parse(fimEm)) ? retrato : null;
+        const daBranch = prsDaBranch(prLido, f.branch, f.cabeca);
+        const aberto = daBranch.aberto, s = aberto ? situacaoDoPr(aberto) : null;
+        // S1 do CHECK (rodada 2): o head do PR aberto e a ponta local: ja esta no GitHub, mesmo com a ref de rastreio velha.
+        const publicada = f.publicada === false && aberto?.head === f.cabeca ? true : f.publicada;
+        const precisaDePr = f.comProduto && publicada === true;
+        const cortado = !!prLido && !daBranch.achado && (prLido.parcial || !!f.branch && !!prLido.semConferir?.includes(f.branch));
+        const usouPr = !!prLido && precisaDePr && !cortado;
+        const prNaoLido = !precisaDePr || usouPr ? null : !retrato ? semRetrato : !prLido ? 'retrato de PRs anterior ao fim do turno'
+            : prLido.parcial ? `lista de PRs abertos cortada nos ${exports.LIMITE_DE_PRS} mais novos` : 'branch sem conferir nesta batida';
+        const proxima = faseSeguinte(t, despacho);
+        const antesDaEntrega = !!proxima && FASES_ANTES_DA_ENTREGA.includes(proxima);
+        const despachar = `despachar a fase ${proxima} (ork phase run ${t.id} ${proxima} --prompt "<pedido da fase>")`;
+        const prSabido = !!prLido && !cortado;
+        const autorizacao = MODOS_COM_PUSH_AUTORIZADO.includes(t.modo) ? '' : `, com a autorização de push do dono (${(0, modos_1.tagDoModo)(t.modo)})`;
+        // B2 do CHECK: depois de uma fase que terminou, o PR parado volta a ser do condutor, mesmo com despacho no meio.
+        const valeDesde = (instanteDoPr) => !houveDespachoDepois(eventos, instanteDoPr) ||
+            (!!fimEm && Date.parse(fimEm) >= Date.parse(instanteDoPr));
+        const maisTarde = (a, b) => (b && Date.parse(b) > Date.parse(a) ? b : a);
+        const { ts: aprovadaEm } = aprovacao ?? { ts: null };
+        const fimOuVeredito = fimEm ? maisTarde(fimEm, aprovadaEm) : null;
+        let caso = null, desde = null, passo = '', peloGit = false;
+        const evidencia = [];
+        if (!conduzidaAgora && !doDono) {
+            if (f.comProduto && publicada === false && terminou) {
+                desde = fimOuVeredito;
+                if (antesDaEntrega && !aberto) {
+                    caso = 'fase-seguinte';
+                    passo = despachar;
+                }
+                else {
+                    caso = 'sem-push';
+                    // N2 da seguranca (rodada 2): branch que ja foi ao remoto pode ter PR; sem a leitura, nunca "abrir o PR". A4 da
+                    // rodada 5: publicar e abrir o PR pedem a mesma autorizacao de push que o merge.
+                    passo = (aberto ? `publicar os commits novos da branch ${f.branch} no PR #${aberto.numero}`
+                        : f.temRemota && !prSabido ? `publicar os commits novos da branch ${f.branch} (PR não lido)`
+                            : `publicar a branch ${f.branch} e abrir o PR`) + autorizacao;
+                }
+                evidencia.push(`refs/heads/${f.branch} tem commit fora de refs/remotes/${remoto}/${f.branch}`);
+            }
+            else if (aberto && s?.situacao === 'vermelho' && s.desdeEm && valeDesde(s.desdeEm)) {
+                caso = 'pr-vermelho';
+                desde = maisTarde(s.desdeEm, fimOuVeredito);
+                passo = `corrigir o check ${s.vermelho} vermelho do PR #${aberto.numero} e despachar a correção`;
+                evidencia.push(`gh pr list: PR #${aberto.numero} com o check ${s.vermelho} vermelho`);
+            }
+            else if (aberto && s && (s.situacao === 'verde' || s.semChecks) && s.desdeEm && valeDesde(s.desdeEm)) {
+                caso = 'pr-verde';
+                desde = maisTarde(s.desdeEm, fimOuVeredito);
+                passo = `${aberto.rascunho ? `tirar o PR #${aberto.numero} do rascunho e mergear` : `mergear o PR #${aberto.numero}`}` +
+                    `${s.semChecks ? ', que não tem checks' : ''}${autorizacao}`;
+                evidencia.push(s.semChecks ? `gh pr list: PR #${aberto.numero} sem checks e sem merge`
+                    : `gh pr list: PR #${aberto.numero} com ${aberto.checks.length} check(s) verde(s) e sem merge`);
+            }
+            else if (!aberto && !f.comProduto && f.merge && !f.mergeRegistrado) {
+                caso = 'sem-registro';
+                desde = f.merge.em ?? fimEm;
+                peloGit = true;
+                passo = `registrar a entrega do merge ${f.merge.sha.slice(0, 7)} (ork ship registrar-pr ${t.id})`;
+                evidencia.push(`git log: merge ship(${t.id}) ${f.merge.sha.slice(0, 7)} na base, sem ship_done no ledger`);
+            }
+            else if (!aberto && daBranch.mesclado && !f.entregueNaPonta && (daBranch.mesclado.mescladoEm ?? fimEm)) {
+                // N4 do CHECK (rodada 2): PR mesclado sem o assunto ship(<thread>); o `registrar-pr` nao o acha sozinho. Com o
+                // merge ship(<thread>) ainda sem registro na base (squash), o `registrar-pr` acha.
+                caso = 'sem-registro';
+                desde = daBranch.mesclado.mescladoEm ?? fimEm;
+                passo = f.merge && !f.mergeRegistrado ? `registrar a entrega do merge ${f.merge.sha.slice(0, 7)} (ork ship registrar-pr ${t.id})`
+                    : `conferir a entrega do PR #${daBranch.mesclado.numero}, mesclado sem o assunto ship(${t.id}), e registrar o ship_done`;
+                evidencia.push(`gh pr list: PR #${daBranch.mesclado.numero} mesclado na ponta da branch, sem ship_done no ledger`);
+            }
+            else if (!aberto && !daBranch.mesclado && precisaDePr && terminou && usouPr && !f.entregueNaPonta) {
+                desde = fimOuVeredito;
+                if (antesDaEntrega) {
+                    caso = 'fase-seguinte';
+                    passo = despachar;
+                }
+                else {
+                    caso = 'sem-pr';
+                    passo = (daBranch.fechado ? `abrir de novo o PR da branch ${f.branch} (o PR #${daBranch.fechado.numero} foi fechado sem merge)`
+                        : `abrir o PR da branch ${f.branch}`) + autorizacao;
+                }
+                evidencia.push(`refs/remotes/${remoto}/${f.branch} contém a ponta`, daBranch.fechado ? `gh pr list: PR #${daBranch.fechado.numero} fechado sem merge` : `gh pr list: nenhum PR de ${f.branch}`);
+            }
+            else if (terminou && despacho?.pausaAoFim === true && aprovadaEm && proxima && FASES_ANTES_DA_ENTREGA.includes(proxima)) {
+                // S-e do CHECK (rodada 3): o dono aprovou a pausa e a fase seguinte nao foi despachada. Rodada 5: vale para
+                // qualquer fim de turno do bloco com pausa ao fim, porque no Codex a fase boa chega como `fase_concluida`.
+                caso = 'fase-seguinte';
+                desde = aprovadaEm;
+                passo = despachar;
+                evidencia.push('ledger: veredito do dono na pausa prevista, sem despacho depois');
+            }
+            else if (espera) {
+                // O que sai do dono volta sempre: sem caso de entrega, a linha diz o que a thread pede agora.
+                desde = espera.fimDoTurnoEm;
+                const id = curtoDaSessao(espera.sessionId);
+                if (antesDaEntrega && !f.entregueNaPonta && espera.comProva !== false) {
+                    caso = 'fase-seguinte';
+                    passo = despachar;
+                }
+                else {
+                    caso = 'sessao-sem-pergunta';
+                    passo = f.shipNoLedger && !f.comProduto ? `fechar o MASTER da thread (ork master ${t.id})`
+                        : aberto ? `acompanhar os checks do PR #${aberto.numero}, que seguem em andamento`
+                            : precisaDePr && !usouPr ? `conferir o PR da branch ${f.branch} (PR não lido) e seguir`
+                                : `ler o fim da sessão ${id} (ork sessions logs ${id}) e seguir a thread`;
+                }
+            }
+        }
+        if (caso && fim && fim.tipo !== 'outro')
+            evidencia.push(`fim do turno: ${fim.tipo}`);
+        const paradoHaMin = desde ? minutosDesde(desde, quando) : 0;
+        const dependeDoPr = caso === 'pr-verde' || caso === 'pr-vermelho' || caso === 'sem-pr' || (caso === 'sem-push' && !!aberto) ||
+            (caso === 'sem-registro' && !peloGit);
+        const parado = caso && desde && paradoHaMin >= limiar ? {
+            thread: t.id, caso, desdeEm: desde, paradoHaMin, proximoPasso: passo, evidencia, branch: f.branch, pr: aberto?.numero ?? null,
+            sessionId: espera?.sessionId ?? fim?.sessionId ?? null, prLidoEm: dependeDoPr && prLido ? prLido.lidoEm : null,
+        } : null;
+        if (parado)
+            parados.push(parado);
+        const prDaEntrega = aberto ? { numero: aberto.numero, estado: 'aberto', situacao: s?.situacao ?? null,
+            checkVermelho: s?.vermelho ?? null, rascunho: aberto.rascunho }
+            : daBranch.mesclado && !f.entregueNaPonta ? { numero: daBranch.mesclado.numero, estado: 'mesclado', situacao: null, checkVermelho: null, rascunho: false }
+                : null;
+        const registrar = `ork ship registrar-pr ${t.id}`;
+        const resumo = aberto ? (s?.situacao === 'vermelho' ? `PR #${aberto.numero} aberto com o check ${s.vermelho} vermelho`
+            : s?.semChecks ? `PR #${aberto.numero} aberto, sem checks, esperando o merge`
+                : s?.situacao === 'verde' ? (aberto.rascunho ? `PR #${aberto.numero} em rascunho, com os checks verdes`
+                    : `PR #${aberto.numero} com os checks verdes, esperando o merge`)
+                    : `PR #${aberto.numero} aberto, checks em andamento`)
+            : f.comProduto && publicada === false ? 'branch com commits sem push'
+                : daBranch.mesclado && !f.entregueNaPonta ? (f.merge && !f.mergeRegistrado ? `PR #${daBranch.mesclado.numero} mesclado, falta registrar a entrega (${registrar})`
+                    : `PR #${daBranch.mesclado.numero} mesclado sem o assunto ship(${t.id}), falta registrar a entrega`)
+                    : !f.comProduto && f.merge && !f.mergeRegistrado ? `merge ${f.merge.sha.slice(0, 7)} na base, falta registrar a entrega (${registrar})`
+                        : precisaDePr ? (!usouPr ? 'branch publicada, PR não lido'
+                            : daBranch.fechado ? `branch publicada, PR #${daBranch.fechado.numero} fechado sem merge` : 'branch publicada sem PR')
+                            : null;
+        estados.push({ thread: t.id, branch: f.branch, comProduto: f.comProduto, publicada, pr: prDaEntrega,
+            prLidoEm: prLido && (usouPr || aberto) ? prLido.lidoEm : null, prNaoLido, conduzidaAgora, espera, parado, resumo });
+    }
+    // As sessoes `blocked` sem pergunta que sobraram: de thread fechada, ou de despacho antigo de thread aberta.
+    // A do despacho corrente fica com o predicado do ledger (`esperaDoCondutor`). Sem o carimbo do radar nao
+    // ha desde, e a sessao segue com o dono.
+    const sobras = new Map();
+    for (const s of sessoes) {
+        if (!sessaoSemPergunta(s))
+            continue;
+        const t = threads.find((x) => x.id === s.thread.id);
+        const { bloqueadaDesdeEm: carimbo } = s;
+        const desde = instante(carimbo);
+        if (!t || !desde)
+            continue;
+        if (t.status !== 'fechada') {
+            let eventos = [];
+            try {
+                eventos = (0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, t.id));
+            }
+            catch {
+                continue;
+            }
+            const despachos = eventos.filter((e) => e.tipo === 'phase_dispatch');
+            const antiga = texto(despachos.at(-1)?.sessionId) !== s.sessionId && despachos.some((e) => e.sessionId === s.sessionId);
+            if (!antiga || pendenciaDoDono(t, eventos, quando))
+                continue;
+        }
+        const atual = sobras.get(t.id) ?? { ids: [], sessoes: [], desde, fechada: t.status === 'fechada' };
+        atual.ids.push(curtoDaSessao(s.sessionId));
+        atual.sessoes.push(s.sessionId);
+        if (Date.parse(desde) < Date.parse(atual.desde))
+            atual.desde = desde;
+        sobras.set(t.id, atual);
+    }
+    for (const [thread, x] of sobras) {
+        for (const sid of x.sessoes)
+            doCondutor.sessoes.add(sid);
+        // A thread que ja tem a linha dela nao ganha outra: uma linha por thread.
+        if (parados.some((p) => p.thread === thread) || minutosDesde(x.desde, quando) < limiar)
+            continue;
+        parados.push({ thread, caso: 'sessao-sem-pergunta', desdeEm: x.desde, paradoHaMin: minutosDesde(x.desde, quando),
+            proximoPasso: passoDasSobras(x.ids, x.fechada), evidencia: ['radar: sessão blocked com a tela lida, sem menu nem pergunta'],
+            branch: null, pr: null, sessionId: x.sessoes[0], prLidoEm: null });
+    }
+    parados.sort((a, b) => a.desdeEm.localeCompare(b.desdeEm) || a.thread.localeCompare(b.thread));
+    return { estados, parados, doCondutor, prs };
+}