@orkastery/cli 0.5.3 → 0.6.0

package/dist/conducao-batida.js

@@ -0,0 +1,759 @@
+"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.ESPERA_LONGA_MS = exports.VALIDADE_DO_RETRATO_MS = exports.ARQUIVO_DA_BATIDA = exports.CONTRATO_DA_BATIDA = void 0;
+exports.passosDaBatida = passosDaBatida;
+exports.lerPrsAbertos = lerPrsAbertos;
+exports.lerChecksObrigatorios = lerChecksObrigatorios;
+exports.assuntoDoMerge = assuntoDoMerge;
+exports.comandoDoMerge = comandoDoMerge;
+exports.avaliarPr = avaliarPr;
+exports.alinhamentoDaBranch = alinhamentoDaBranch;
+exports.conduzirBatida = conduzirBatida;
+exports.lerRetratoDaBatida = lerRetratoDaBatida;
+exports.baterConducao = baterConducao;
+exports.pendentesDaUltimaBatida = pendentesDaUltimaBatida;
+exports.textoDaBatida = textoDaBatida;
+/**
+ * RM-063 (F7): a batida da conducao, o passo deterministico que a varredura chama para avancar as threads dentro da
+ * autorizacao duravel do dono (`ork conducao batida`).
+ *
+ * Incidente de 12 e 13/10/2026: os PRs #153 e #154 ficaram prontos, com os checks verdes, e esperaram de 5 a 6 horas pelo
+ * condutor, que era uma sessao interativa (P6 da pagina da RM-063: acabou a conversa, acabou a conducao). A batida faz,
+ * a cada rodada do cron e no `#OrkRetomar` do canal, o que o condutor fazia, e so o que o dono autorizou:
+ *
+ *  - `merge`: o PR aberto de branch `ork/*` de uma thread #Auto ou #Maestro, com todos os checks obrigatorios verdes e o
+ *    PR limpo (`mergeStateStatus` CLEAN), entra na base por `gh pr merge --merge --match-head-commit`, com o assunto
+ *    `ship(<thread>): ...` que o registro da entrega procura; o merge e provado na copia da base. O PR que ficou para
+ *    tras, ou em conflito so no CHANGELOG, ganha o merge da base na branch (`atualizar-branch.ts`) e espera o CI de novo;
+ *    conflito em codigo vira item do dono;
+ *  - `registrar`, `master` e `limpar`: os da varredura da F5 (`varredura-acoes.ts`), na mesma rodada, depois do merge;
+ *  - `despachar`: a fase seguinte que o nucleo calcula (`passosDoCondutor`, o mesmo passo da Sentinela), so com o pedido
+ *    guardado na criacao da thread, e a retomada pelo retry com o prompt gravado (F3) quando o plano e automatico. A
+ *    fase que precisa de LLM sai como sessao de fundo pelo `ork phase run`, nunca por cron LLM. Com a Sentinela ligada
+ *    nesta maquina, o despacho comum e dela; a retomada por cota continua na batida da maquina.
+ *
+ * Nada aqui faz tag nem publicacao. Autorizacao ausente, vencida, de outra maquina ou sem a acao, check pendente ou
+ * vermelho, PR em rascunho e trabalho na thread recusam com motivo tipado, e cada recusa vira item da fila do pulse
+ * pelo retrato da ultima batida (`.orkastery/monitor/conducao-batida.json`). Cada acao feita ou recusada vai ao ledger
+ * da thread como `varredura_acao`, com a autorizacao que a permitiu.
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const autorizacao_duravel_1 = require("./autorizacao-duravel");
+const atualizar_branch_1 = require("./atualizar-branch");
+const conducao_1 = require("./conducao");
+const conducao_sentinela_1 = require("./conducao-sentinela");
+const entrega_pr_1 = require("./entrega-pr");
+const estado_thread_1 = require("./estado-thread");
+const ledger_1 = require("./ledger");
+const locale_1 = require("./locale");
+const maquina_1 = require("./maquina");
+const monitor_lock_1 = require("./monitor-lock");
+const doctor_pulse_cron_1 = require("./doctor-pulse-cron");
+const parado_no_condutor_1 = require("./parado-no-condutor");
+const ship_publicar_1 = require("./ship-publicar");
+const phase_1 = require("./phase");
+const retry_1 = require("./retry");
+const thread_1 = require("./thread");
+const util_1 = require("./util");
+const varredura_acoes_1 = require("./varredura-acoes");
+const worktree_1 = require("./worktree");
+const session_watcher_1 = require("./session-watcher");
+const noctum_guarda_1 = require("./noctum-guarda");
+exports.CONTRATO_DA_BATIDA = 'ork.conducao-batida/v1';
+exports.ARQUIVO_DA_BATIDA = 'conducao-batida.json';
+/** O retrato da ultima batida vale para o pulse por tres batidas do template (`*\/15`); depois, nada se afirma dele. */
+exports.VALIDADE_DO_RETRATO_MS = 45 * 60 * 1000;
+/** A espera da batida (check pendente, estado do merge desconhecido) que passa disto vira item do dono. */
+exports.ESPERA_LONGA_MS = 2 * 60 * 60 * 1000;
+/** Os modos em que a #TAG ja autoriza o push (`MODOS_QUE_AUTORIZAM_PUSH`, `ship.ts`): so neles a batida mescla e despacha. */
+const MODOS_QUE_ANDAM_SOZINHOS = ['auto', 'maestro'];
+const PRAZO_DO_GH_MS = 30000;
+const CAMPOS_DO_PR = 'number,title,headRefName,headRefOid,baseRefName,isDraft,isCrossRepository,mergeable,mergeStateStatus,url';
+/**
+ * RM-064 T5: a Sentinela pode conduzir fases, mas a conta dela também pode esgotar. A reação ao sinal tipado de cota
+ * pertence à batida da máquina; todo o resto continua cedido, evitando dois condutores gerais concorrentes.
+ */
+function passosDaBatida(passos, sentinela) {
+    if (!sentinela)
+        return [...passos];
+    return passos.filter((p) => p.acao === 'retomar' && p.bloqueio?.motivo === 'runtime.quota-exhausted');
+}
+// ---------------------------------------------------------------------------
+// A forja: os PRs abertos e os checks obrigatorios.
+// ---------------------------------------------------------------------------
+const texto = (v) => (typeof v === 'string' ? v : '');
+/** Os PRs abertos da base, so do mesmo repositorio. */
+function lerPrsAbertos(executor, forja, base) {
+    const r = executor(['pr', 'list', `--repo=${forja.host}/${forja.repositorio}`, `--base=${base}`, '--state=open', '--limit=100',
+        `--json=${CAMPOS_DO_PR}`], PRAZO_DO_GH_MS);
+    if (r.status !== 0)
+        return { ok: false, erro: `gh pr list saiu ${r.status ?? 'sem código'}: ${r.stderr.trim().split('\n')[0]?.slice(0, 160) ?? ''}` };
+    let bruto;
+    try {
+        bruto = JSON.parse(r.stdout);
+    }
+    catch {
+        return { ok: false, erro: 'gh pr list respondeu JSON inválido' };
+    }
+    if (!Array.isArray(bruto))
+        return { ok: false, erro: 'gh pr list não respondeu uma lista' };
+    const prs = [];
+    for (const x of bruto) {
+        if (!x || typeof x !== 'object' || x.isCrossRepository === true || !Number.isInteger(x.number))
+            continue;
+        if (!/^[0-9a-f]{40}$/.test(texto(x.headRefOid)))
+            continue;
+        prs.push({ numero: x.number, titulo: texto(x.title).slice(0, 240), branch: texto(x.headRefName), head: texto(x.headRefOid),
+            base: texto(x.baseRefName), rascunho: x.isDraft === true, mergeable: texto(x.mergeable) || 'UNKNOWN',
+            estado: texto(x.mergeStateStatus) || 'UNKNOWN', url: texto(x.url) || null });
+    }
+    return { ok: true, prs };
+}
+/** Os checks obrigatorios do PR. Sem nenhum obrigatorio na base, a lista vem vazia (e o merge fica com o dono). */
+function lerChecksObrigatorios(executor, forja, numero) {
+    const r = executor(['pr', 'checks', String(numero), `--repo=${forja.host}/${forja.repositorio}`, '--required', '--json=name,bucket,state'], PRAZO_DO_GH_MS);
+    // O `gh pr checks` sai 8 com check pendente e 1 com check falho: o JSON vem nos dois casos.
+    try {
+        const lido = JSON.parse(r.stdout);
+        if (Array.isArray(lido)) {
+            return { ok: true, checks: lido.map((c) => ({ nome: texto(c.name), bucket: texto(c.bucket) })) };
+        }
+    }
+    catch { /* sem JSON: a base sem check obrigatorio, ou falha do gh */ }
+    if (/no required checks/i.test(`${r.stderr}\n${r.stdout}`))
+        return { ok: true, checks: [] };
+    return { ok: false, erro: `gh pr checks --required saiu ${r.status ?? 'sem código'}: ${(r.stderr || r.stdout).trim().split('\n')[0]?.slice(0, 160) ?? ''}` };
+}
+/** O assunto do merge: o `ship(<thread>)` que o registro da entrega e a varredura procuram na base. */
+function assuntoDoMerge(thread, pr) {
+    const titulo = pr.titulo.trim();
+    const comPrefixo = titulo.startsWith(`ship(${thread})`) ? titulo : `ship(${thread}): ${titulo || `entrega do PR #${pr.numero}`}`;
+    return `${comPrefixo} (#${pr.numero})`;
+}
+/** O comando do merge que o dono roda (e que a batida roda com a autorizacao). */
+function comandoDoMerge(forja, thread, pr) {
+    // O titulo do PR vem do agente que o abriu: entre aspas simples, `$(...)` e crase colados no terminal nao rodam.
+    return `gh pr merge ${pr.numero} --repo ${forja.host}/${forja.repositorio} --merge --match-head-commit ${pr.head} ` +
+        `--subject ${(0, doctor_pulse_cron_1.citarNoShell)(assuntoDoMerge(thread, pr))}`;
+}
+/**
+ * O estado do merge, puro: o que o PR precisa antes de entrar. `pronto` so com os checks obrigatorios todos verdes (ou
+ * pulados) e o PR limpo; `atualizar` quando a branch ficou para tras ou conflita (o merge da base resolve, ou diz o
+ * conflito em codigo); o resto e espera da batida ou bloqueio do dono.
+ */
+function avaliarPr(pr, checks) {
+    if (pr.rascunho || pr.estado === 'DRAFT')
+        return { estado: 'dono', motivo: 'pr-rascunho', detalhe: `o PR #${pr.numero} está em rascunho` };
+    if (pr.mergeable === 'CONFLICTING' || pr.estado === 'DIRTY' || pr.estado === 'BEHIND')
+        return { estado: 'atualizar' };
+    const vermelhos = checks.filter((c) => c.bucket === 'fail' || c.bucket === 'cancel');
+    if (vermelhos.length) {
+        return { estado: 'dono', motivo: 'checks-vermelhos', detalhe: `check obrigatório vermelho: ${vermelhos.map((c) => c.nome).join(', ').slice(0, 200)}` };
+    }
+    const pendentes = checks.filter((c) => c.bucket === 'pending' || !['pass', 'skipping'].includes(c.bucket));
+    if (pendentes.length) {
+        return { estado: 'espera', motivo: 'checks-pendentes', detalhe: `${pendentes.length} de ${checks.length} check(s) obrigatório(s) pendente(s)` };
+    }
+    if (!checks.length) {
+        return { estado: 'dono', motivo: 'sem-checks-obrigatorios', detalhe: 'a base não exige check nenhum: o merge sem check obrigatório verde fica com o dono' };
+    }
+    if (pr.estado === 'CLEAN' || pr.estado === 'HAS_HOOKS')
+        return { estado: 'pronto' };
+    if (pr.estado === 'BLOCKED')
+        return { estado: 'dono', motivo: 'pr-bloqueado', detalhe: 'o GitHub bloqueia o merge com os checks obrigatórios verdes' };
+    if (pr.estado === 'UNSTABLE')
+        return { estado: 'dono', motivo: 'pr-instavel', detalhe: 'há check não obrigatório vermelho' };
+    return { estado: 'espera', motivo: 'estado-desconhecido', detalhe: `o GitHub ainda não calculou o estado do merge (${pr.estado})` };
+}
+// ---------------------------------------------------------------------------
+// O registro de cada acao no ledger da thread.
+// ---------------------------------------------------------------------------
+/** As recusas de uma tentativa da batida: so elas (e o que ela fez) vao ao ledger; sem autorizacao ou com bloqueio, so a fila. */
+const TENTATIVAS_RECUSADAS = ['merge-recusado', 'atualizacao-recusada', 'despacho-recusado', 'retomada-recusada',
+    'conflito-em-codigo', 'merge-sem-prova'];
+function registrarAcao(raiz, item, leitura) {
+    // O `gh pr merge` que respondeu sem a prova na base (fila de merge, merge automatico) e uma tentativa: vai ao ledger.
+    if (item.resultado !== 'feita' && !TENTATIVAS_RECUSADAS.includes(item.motivo ?? ''))
+        return;
+    const referencia = (0, autorizacao_duravel_1.referenciaDaAutorizacao)(leitura);
+    const resultado = item.resultado === 'feita' ? 'feita' : 'recusada';
+    const detalhe = item.detalhe.slice(0, 400);
+    let anterior;
+    try {
+        anterior = [...(0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, item.thread))].reverse()
+            .find((e) => e.tipo === ledger_1.TIPOS_DE_EVENTO.acaoDaVarredura && e.acao === item.acao);
+    }
+    catch { /* sem ledger, a linha vai */ }
+    // A mesma recusa da rodada anterior nao vira linha nova a cada batida.
+    if (resultado === 'recusada' && anterior?.resultado === 'recusada' && anterior.detalhe === detalhe && anterior.motivo === item.motivo)
+        return;
+    try {
+        (0, ledger_1.registrar)((0, thread_1.dirThread)(raiz, item.thread), item.thread, ledger_1.TIPOS_DE_EVENTO.acaoDaVarredura, {
+            fase: item.fase, acao: item.acao, resultado, motivo: item.motivo, detalhe, comando: item.comando, origem: 'conducao.batida',
+            ...(item.pr ? { pr: item.pr } : {}), autorizacao: referencia,
+            quemDecidiu: referencia ? `batida da condução do ork, pela autorização durável de ${String(referencia.por)}` : null,
+            evidencia: item.evidencia,
+        });
+    }
+    catch { /* a acao vale; o ledger e o rastro */ }
+}
+// ---------------------------------------------------------------------------
+// As acoes.
+// ---------------------------------------------------------------------------
+const andaSozinha = (t) => MODOS_QUE_ANDAM_SOZINHOS.includes(t.modo);
+/** O motivo da autorizacao que impede a acao, ou `null` quando ela esta autorizada. */
+function semAutorizacao(leitura, acao) {
+    if (!leitura.valida)
+        return leitura.motivo;
+    return (0, autorizacao_duravel_1.autorizada)(leitura, acao) ? null : 'acao-fora-da-autorizacao';
+}
+function threadsAbertas(raiz) {
+    const saida = [];
+    for (const id of (0, thread_1.listarIds)(raiz)) {
+        try {
+            const t = (0, thread_1.lerThread)(raiz, id);
+            if (t.status !== 'fechada')
+                saida.push(t);
+        }
+        catch { /* thread ilegivel fica de fora */ }
+    }
+    return saida;
+}
+/**
+ * A branch local da thread contra o head do PR. `igual`; `atras` (o PR tem commits que a local nao tem: o "Update branch"
+ * do GitHub ou um push de outra maquina); `merges-da-base` (a local so tem, alem do PR, merges da base, como os que a
+ * batida faz e ainda nao empurrou); `fora-do-pr` (a local tem trabalho que o PR nao tem: o merge levaria a entrega sem
+ * ele, e a atualizacao o empurraria sem CHECK); `sem-resposta` (o git nao respondeu, ou o head do PR nao chegou aqui).
+ */
+function alinhamentoDaBranch(raiz, remoto, branch, head, baseRef) {
+    const local = (0, util_1.exec)('git', ['rev-parse', '--verify', '-q', `refs/heads/${branch}^{commit}`], raiz, 30000);
+    if (!local.ok)
+        return { estado: 'igual', fora: 0 };
+    if (local.stdout.trim() === head)
+        return { estado: 'igual', fora: 0 };
+    if (!(0, util_1.exec)('git', ['cat-file', '-e', `${head}^{commit}`], raiz, 30000).ok) {
+        const env = { ...process.env, GIT_TERMINAL_PROMPT: '0', GIT_SSH_COMMAND: process.env.GIT_SSH_COMMAND ?? 'ssh -o BatchMode=yes' };
+        (0, util_1.exec)('git', ['fetch', '-q', '--no-tags', '--', remoto, `+refs/heads/${branch}:refs/remotes/${remoto}/${branch}`], raiz, 60000, env);
+        if (!(0, util_1.exec)('git', ['cat-file', '-e', `${head}^{commit}`], raiz, 30000).ok)
+            return { estado: 'sem-resposta', fora: 0 };
+    }
+    // So o que a local tem alem do PR e da base: os commits que o merge da base trouxe sao da base, nao trabalho da thread.
+    const r = (0, util_1.exec)('git', ['rev-list', '--parents', `${head}..refs/heads/${branch}`, '--not', baseRef], raiz, 30000);
+    if (!r.ok)
+        return { estado: 'sem-resposta', fora: 0 };
+    const fora = r.stdout.split('\n').map((l) => l.trim().split(/\s+/)).filter((l) => l[0]);
+    if (!fora.length)
+        return { estado: 'atras', fora: 0 };
+    const daBase = (c) => c.length === 3 && (0, util_1.exec)('git', ['merge-base', '--is-ancestor', c[2], baseRef], raiz, 30000).ok;
+    return fora.every(daBase) ? { estado: 'merges-da-base', fora: fora.length } : { estado: 'fora-do-pr', fora: fora.filter((c) => !daBase(c)).length };
+}
+function anotar(ctx, item) {
+    (item.resultado === 'feita' ? ctx.feitas : ctx.pendentes).push(item);
+    registrarAcao(ctx.raiz, item, ctx.leitura);
+}
+/** O merge dos PRs prontos (e a atualizacao dos que ficaram para tras), thread por thread. */
+function mesclarProntos(ctx, threads, opcoes) {
+    const { carregado, raiz } = ctx;
+    const remoto = carregado.manifesto.fabrica.remoto, base = carregado.manifesto.worktree.base_branch;
+    const candidatas = threads.filter((t) => andaSozinha(t) && (0, worktree_1.branchDaWorktree)(t).startsWith('ork/'));
+    if (!candidatas.length)
+        return null;
+    const forja = opcoes.forja === undefined ? (0, parado_no_condutor_1.githubDoRemoto)(raiz, remoto) : opcoes.forja;
+    if (!forja)
+        return { ok: false, detalhe: `o remoto ${remoto} não é um GitHub que o gh lê: o merge fica com o dono` };
+    const executor = opcoes.executorGh ?? parado_no_condutor_1.ghPadrao;
+    const lidos = lerPrsAbertos(executor, forja, base);
+    if (!lidos.ok)
+        return { ok: false, detalhe: lidos.erro };
+    for (const t of candidatas) {
+        const branch = (0, worktree_1.branchDaWorktree)(t);
+        const pr = lidos.prs.filter((p) => p.branch === branch && p.base === base).sort((a, b) => b.numero - a.numero)[0];
+        if (!pr)
+            continue;
+        const item = (resultado, motivo, detalhe, oQue, comando) => ({
+            acao: 'merge', thread: t.id, fase: t.faseAtual, resultado, motivo, detalhe,
+            oQue: oQue ?? (0, locale_1.textoDoCatalogo)((m) => m.pulse.varredura.oQue.merge(pr.numero, branch, `${remoto}/${base}`)),
+            comando: comando ?? comandoDoMerge(forja, t.id, pr), evidencia: `gh pr view ${pr.numero}: ${pr.estado}, mergeable ${pr.mergeable}`,
+            desdeEm: null, pr: pr.numero
+        });
+        let eventos = [];
+        try {
+            eventos = (0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, t.id));
+        }
+        catch {
+            eventos = [];
+        }
+        // RM-058, integracao (T1.2, D3 e D4): o PR da thread que um arco #Noctum segura ou retem nao e mesclado nem atualizado
+        // por aqui: a entrega e do passo da entrega do arco. O pulo fica no retrato, como as esperas, e nao no ledger da thread.
+        const arco = (0, noctum_guarda_1.arcoDoPasso)(raiz, ctx.arcos, t.id, eventos);
+        if (arco) {
+            anotar(ctx, item('espera', arco.motivo, arco.detalhe));
+            continue;
+        }
+        const checks = lerChecksObrigatorios(executor, forja, pr.numero);
+        if (!checks.ok) {
+            anotar(ctx, item('espera', 'estado-desconhecido', checks.erro));
+            continue;
+        }
+        const avaliacao = avaliarPr(pr, checks.checks);
+        if (avaliacao.estado === 'espera') {
+            anotar(ctx, item('espera', avaliacao.motivo, avaliacao.detalhe));
+            continue;
+        }
+        if (avaliacao.estado === 'dono') {
+            anotar(ctx, item('dono', avaliacao.motivo, avaliacao.detalhe));
+            continue;
+        }
+        // Pronto ou para atualizar: primeiro o estado (quem trabalha na thread, o que espera o dono, a branch local e o
+        // CHECK), e so depois a autorizacao: o dono so recebe "pronto" do PR que esta pronto de verdade.
+        const atualizar = avaliacao.estado === 'atualizar';
+        const oQue = atualizar ? (0, locale_1.textoDoCatalogo)((m) => m.pulse.varredura.oQue.atualizar(pr.numero, branch, `${remoto}/${base}`)) : undefined;
+        const comando = atualizar ? `ork conducao atualizar ${t.id} --enviar` : undefined;
+        const trabalho = (0, varredura_acoes_1.trabalhoNaWorktree)(raiz, t, ctx.quando, ctx.vivas);
+        if (trabalho) {
+            anotar(ctx, item('dono', trabalho.motivo, trabalho.texto, oQue, `ork thread status ${t.id}`));
+            continue;
+        }
+        const doDono = (0, parado_no_condutor_1.pendenciaDoDono)(t, eventos, ctx.quando);
+        if (doDono) {
+            anotar(ctx, item('dono', 'pendencia-do-dono', doDono, oQue, `ork thread status ${t.id}`));
+            continue;
+        }
+        // A branch local nao pode ter trabalho que o PR nao tem: o merge o deixaria de fora, e a atualizacao o empurraria
+        // para o PR sem CHECK. Os merges da base que a batida fez e nao empurrou nao contam.
+        const alinhada = alinhamentoDaBranch(raiz, remoto, branch, pr.head, `refs/remotes/${remoto}/${base}`);
+        if (alinhada.estado === 'fora-do-pr' || alinhada.estado === 'sem-resposta') {
+            anotar(ctx, item('dono', alinhada.estado === 'sem-resposta' ? 'git-sem-resposta' : 'branch-nao-publicada', alinhada.estado === 'sem-resposta'
+                ? 'o git não respondeu sobre a branch' : `a branch local tem ${alinhada.fora} commit(s) que o PR #${pr.numero} não tem`, oQue, `ork thread status ${t.id}`));
+            continue;
+        }
+        // O merge so leva o que passou pelo CHECK: o veredito PASSOU gravado depois do ultimo commit de produto do PR.
+        if (!atualizar) {
+            const check = (0, ship_publicar_1.conferirCheck)(raiz, t, `refs/remotes/${remoto}/${base}`, pr.head);
+            if (check.etapa.estado !== 'feita' && check.etapa.estado !== 'nao-se-aplica') {
+                anotar(ctx, item('dono', 'check-pendente', check.etapa.texto, undefined, `ork thread status ${t.id}`));
+                continue;
+            }
+        }
+        const fora = semAutorizacao(ctx.leitura, 'merge');
+        if (fora) {
+            anotar(ctx, item('dono', fora, atualizar ? `o PR #${pr.numero} precisa da base (${pr.estado})` : `o PR #${pr.numero} está pronto`, oQue, comando));
+            continue;
+        }
+        if (atualizar) {
+            anotar(ctx, atualizacaoDoPr(ctx, t, pr, oQue, comando, alinhada.estado === 'atras' ? pr.head : null));
+            continue;
+        }
+        const r = executor(['pr', 'merge', String(pr.numero), `--repo=${forja.host}/${forja.repositorio}`, '--merge',
+            '--match-head-commit', pr.head, '--subject', assuntoDoMerge(t.id, pr)], 120000);
+        if (r.status !== 0) {
+            anotar(ctx, item('dono', 'merge-recusado', `gh pr merge saiu ${r.status ?? 'sem código'}: ${(r.stderr || r.stdout).trim().split('\n')[0]?.slice(0, 200) ?? ''}`));
+            continue;
+        }
+        // A prova: o merge `ship(<thread>)` com o head do PR como segundo pai, na copia da base trazida agora.
+        (0, varredura_acoes_1.buscarBase)(carregado);
+        const merge = (0, entrega_pr_1.mergeDaEntrega)(raiz, t.id, remoto, base);
+        if (!merge || merge.headSha !== pr.head) {
+            anotar(ctx, item('espera', 'merge-sem-prova', `gh pr merge respondeu, mas ${remoto}/${base} ainda não tem o merge ship(${t.id}) do head ` +
+                `${pr.head.slice(0, 8)} (fila de merge ou merge automático)`));
+            continue;
+        }
+        anotar(ctx, { ...item('feita', null, `PR #${pr.numero} mesclado em ${remoto}/${base}: ${merge.mergeSha.slice(0, 8)}`),
+            evidencia: `git log ${remoto}/${base}: merge ship(${t.id}) ${merge.mergeSha.slice(0, 8)} com o head ${pr.head.slice(0, 8)}` });
+    }
+    return { ok: true, detalhe: `${lidos.prs.length} PR(s) aberto(s) lidos em ${forja.host}/${forja.repositorio}` };
+}
+/** O PR para tras ou em conflito: o merge da base na branch, com o CHANGELOG reconciliado, e a branch empurrada. */
+function atualizacaoDoPr(ctx, t, pr, oQue, comando, alinharCom) {
+    const base = { acao: 'merge', thread: t.id, fase: t.faseAtual, oQue, comando,
+        evidencia: `gh pr view ${pr.numero}: ${pr.estado}, mergeable ${pr.mergeable}`, desdeEm: null, pr: pr.numero };
+    let r;
+    try {
+        r = (0, atualizar_branch_1.atualizarBranchDaThread)(ctx.carregado, t.id, { buscar: false, enviar: true, canal: ctx.canal, correlacao: ctx.correlacao,
+            ...(alinharCom ? { alinharCom } : {}) });
+    }
+    catch (e) {
+        return { ...base, resultado: 'dono', motivo: 'atualizacao-recusada', detalhe: e.message.slice(0, 300) };
+    }
+    switch (r.acao) {
+        case 'mesclada':
+            return { ...base, resultado: 'feita', motivo: 'branch-atualizada', detalhe: `${r.base} mesclada na ${r.branch} (${r.sha.slice(0, 8)})` +
+                    (r.changelog?.devolvidos ? `, ${r.changelog.devolvidos} item(ns) da thread de volta a "Não publicado"` : '') +
+                    `; o PR #${pr.numero} espera o CI do novo head` };
+        case 'ja-atualizada':
+            // O merge da base que ja estava na branch local e nao tinha chegado ao PR (push falho) foi empurrado agora.
+            if (r.enviada) {
+                return { ...base, resultado: 'feita', motivo: 'branch-atualizada', detalhe: `a ${r.branch} com ${r.base} foi empurrada (${r.sha.slice(0, 8)}); ` +
+                        `o PR #${pr.numero} espera o CI do novo head` };
+            }
+            return { ...base, resultado: 'espera', motivo: 'estado-desconhecido', detalhe: `a branch já contém ${r.base}; o GitHub ainda não recalculou o PR` };
+        case 'conflito-em-codigo':
+            return { ...base, resultado: 'dono', motivo: 'conflito-em-codigo', detalhe: `o merge de ${r.base} conflita em: ${r.arquivos.join(', ').slice(0, 200)}`,
+                comando: `ork thread status ${t.id}` };
+        default:
+            return { ...base, resultado: 'dono', motivo: r.motivo === 'conduzida' || r.motivo === 'worktree-suja' ? r.motivo : 'atualizacao-recusada',
+                detalhe: r.detalhe.slice(0, 300) };
+    }
+}
+/** O despacho da fase seguinte e a retomada pelo retry, pelo passo do nucleo. */
+function despacharPassos(ctx, passos, opcoes) {
+    const { carregado, raiz } = ctx;
+    for (const p of passos) {
+        if (p.conduzida || p.modo !== 'auto' || (p.acao !== 'despachar' && p.acao !== 'retomar'))
+            continue;
+        const fase = p.acao === 'despachar' ? p.fase : null;
+        const oQue = p.acao === 'despachar' ? (0, locale_1.textoDoCatalogo)((m) => m.pulse.varredura.oQue.despachar(String(fase)))
+            : (0, locale_1.textoDoCatalogo)((m) => m.pulse.varredura.oQue.retomar(p.faseAtual));
+        const comando = p.acao === 'despachar' ? `ork phase run ${p.thread} ${fase} --prompt "$(ork prompt render ${p.thread} ${fase})"`
+            : `ork retry run ${p.thread}`;
+        const item = (resultado, motivo, detalhe) => ({
+            acao: 'despachar', thread: p.thread, fase: fase ?? p.faseAtual, resultado, motivo, detalhe, oQue, comando,
+            evidencia: `passo do núcleo: ${p.porque}`.slice(0, 300), desdeEm: p.desdeEm, pr: null
+        });
+        // RM-058, integracao (T1.2, D3 e D4): a thread que um arco segura ou retem nao e despachada nem retomada por aqui.
+        if (p.arco) {
+            anotar(ctx, item('espera', p.arco.motivo, p.arco.detalhe));
+            continue;
+        }
+        if (p.acao === 'despachar' && !p.pedidoGuardado) {
+            anotar(ctx, item('dono', 'sem-prompt-gravado', 'a thread não tem o pedido guardado na criação: sem prompt gravado, nada sai'));
+            continue;
+        }
+        const fora = semAutorizacao(ctx.leitura, 'despachar');
+        // A retomada sem autorização não vira item: o pulse já leva o bloqueio da thread com o `ork retry run` (ou o
+        // `retry plan`), e um segundo item da mesma parada seria ruído no resumo do dono.
+        if (fora && p.acao === 'retomar')
+            continue;
+        if (fora) {
+            anotar(ctx, item('dono', fora, p.porque));
+            continue;
+        }
+        if (p.acao === 'despachar' && fase) {
+            let pedido = null;
+            try {
+                pedido = (0, thread_1.pedidoDaThread)(raiz, (0, thread_1.lerThread)(raiz, p.thread));
+            }
+            catch (e) {
+                anotar(ctx, item('dono', 'sem-prompt-gravado', e.message.slice(0, 200)));
+                continue;
+            }
+            if (!pedido) {
+                anotar(ctx, item('dono', 'sem-prompt-gravado', 'a thread não tem o pedido guardado na criação'));
+                continue;
+            }
+            const despachar = opcoes.despachar ?? despachoPeloNucleo;
+            const r = despachar(carregado, p.thread, fase, pedido.texto, ctx.canal, ctx.correlacao);
+            anotar(ctx, r.ok ? item('feita', null, `fase ${fase} despachada${r.sessionId ? ` (sessão ${r.sessionId.slice(0, 8)})` : ''}`)
+                : item('dono', 'despacho-recusado', r.detalhe));
+            continue;
+        }
+        const retomar = opcoes.retomar ?? retomadaPeloNucleo;
+        const r = retomar(carregado, p.thread);
+        // O plano que não é automático já é item do dono no pulse (o bloqueio, com o `retry plan`): a batida só o deixa.
+        if (!r.automatica)
+            continue;
+        anotar(ctx, r.ok ? item('feita', null, r.detalhe) : item('dono', 'retomada-recusada', r.detalhe));
+    }
+}
+/** O despacho pelo nucleo, como o #Noctum: o pedido guardado, o canal de quem pediu e a correlacao da batida. */
+function despachoPeloNucleo(carregado, thread, fase, prompt, canal, correlacao) {
+    try {
+        const r = (0, phase_1.rodarFase)(carregado, thread, { fase, prompt, canal, correlacao, baselinePeloDespacho: false });
+        if (r.idempotente)
+            return { ok: true, detalhe: 'o mesmo pedido já está em andamento', sessionId: r.sessionId };
+        if (r.bloqueado || !r.sessionId) {
+            return { ok: false, detalhe: (r.recusa?.texto.split('\n')[0] ?? r.erro ?? `despacho recusado (${r.motivo ?? 'sem sessão'})`).slice(0, 300),
+                sessionId: null };
+        }
+        return { ok: true, detalhe: `sessão ${r.sessionId.slice(0, 8)}`, sessionId: r.sessionId };
+    }
+    catch (e) {
+        return { ok: false, detalhe: e.message.slice(0, 300), sessionId: null };
+    }
+}
+/** A retomada pelo retry do nucleo, so com o plano automatico e sem bloqueio (a mesma regra da Sentinela). */
+function retomadaPeloNucleo(carregado, thread) {
+    try {
+        const plano = (0, retry_1.planejarRetry)(carregado, thread);
+        if (!plano.automatica || plano.bloqueio)
+            return { automatica: false, ok: false, detalhe: `o retry plan não é automático: ${plano.razao}`.slice(0, 300) };
+        const r = (0, retry_1.executarRetry)(carregado, thread);
+        return { automatica: true, ok: r.executada, detalhe: r.detalhe.slice(0, 300) };
+    }
+    catch (e) {
+        return { automatica: true, ok: false, detalhe: e.message.slice(0, 300) };
+    }
+}
+/** As acoes da varredura da F5, no formato da batida. */
+function daVarredura(v, ctx) {
+    for (const f of v.feitas) {
+        const item = { acao: f.acao, thread: f.thread, fase: null, resultado: f.resultado === 'feita' ? 'feita' : 'dono',
+            motivo: f.resultado === 'feita' ? null : 'acao-recusada', oQue: f.acao, detalhe: f.detalhe, comando: '', evidencia: '', desdeEm: null, pr: null };
+        if (item.resultado === 'feita')
+            ctx.feitas.push(item);
+    }
+    for (const p of v.pendentes) {
+        // RM-058, integracao (T1.2): a acao da thread que um arco segura espera o arco, e nao o dono.
+        if (p.motivoDoBloqueio === 'thread-do-arco') {
+            ctx.pendentes.push({ acao: p.acao, thread: p.thread, fase: p.fase, resultado: 'espera',
+                motivo: p.bloqueio?.startsWith(noctum_guarda_1.MOTIVO_DO_ARCO_ILEGIVEL) ? noctum_guarda_1.MOTIVO_DO_ARCO_ILEGIVEL : noctum_guarda_1.MOTIVO_DA_GUARDA, oQue: p.oQue,
+                detalhe: p.bloqueio ?? p.oQue, comando: `ork thread status ${p.thread}`, evidencia: p.evidencia, desdeEm: p.desdeEm, pr: null });
+            continue;
+        }
+        ctx.pendentes.push({ acao: p.acao, thread: p.thread, fase: p.fase, resultado: 'dono',
+            motivo: p.motivoDoBloqueio ?? (p.recusa ? 'acao-recusada' : semAutorizacao(ctx.leitura, p.acao)),
+            oQue: p.oQue, detalhe: p.recusa?.detalhe ?? p.bloqueio ?? p.oQue, comando: p.bloqueio ? `ork thread status ${p.thread}` : p.comando,
+            evidencia: p.evidencia, desdeEm: p.desdeEm, pr: null });
+    }
+}
+/**
+ * A batida da conducao: traz a base, mescla os PRs prontos, roda a varredura da F5 (limpar, registrar, master) e
+ * despacha a fase seguinte. Le a autorizacao uma vez; o que ela nao cobre fica pendente, com o motivo e o comando.
+ */
+function conduzirBatida(carregado, opcoes = {}) {
+    const raiz = (0, estado_thread_1.raizDoEstado)(carregado.raiz);
+    const doProjeto = { ...carregado, raiz };
+    const quando = opcoes.quando ?? new Date().toISOString();
+    const maquina = (0, maquina_1.nomeDaMaquina)();
+    const leitura = opcoes.autorizacao ?? (0, autorizacao_duravel_1.lerAutorizacao)(raiz, { projeto: carregado.manifesto.project.name, agora: new Date(quando) });
+    const busca = opcoes.buscar === false ? null : (0, varredura_acoes_1.buscarBase)(doProjeto);
+    const sessoes = (0, varredura_acoes_1.lerSessoes)(raiz, opcoes);
+    const ctx = { carregado: doProjeto, raiz, quando, leitura, vivas: sessoes.vivas, canal: opcoes.canal ?? (0, conducao_1.canalDoProcesso)(),
+        correlacao: `batida:${maquina}`, arcos: (0, noctum_guarda_1.lerArcosDaRaiz)(raiz, quando), feitas: [], pendentes: [] };
+    const threads = threadsAbertas(raiz);
+    // RM-064 T9: um watcher que falhou no despacho não pode ocultar o fim nativo da sessão.
+    // A reconciliação é local e fail-closed; a rodada seguinte deriva retomar ou pendência do dono.
+    for (const thread of threads) {
+        try {
+            (0, session_watcher_1.reconciliarSessaoSemWatcher)(doProjeto, thread.id, Date.parse(quando));
+        }
+        catch { /* o diagnóstico da observação fica no ledger; uma thread não interrompe as outras */ }
+    }
+    // 1. O merge dos PRs prontos: o que entra na base agora e registrado pela varredura nesta mesma batida.
+    const forja = mesclarProntos(ctx, threads, opcoes);
+    // 2. A varredura da F5, depois do merge e sobre a mesma leitura das sessoes.
+    const mesclou = ctx.feitas.some((f) => f.acao === 'merge' && f.motivo === null);
+    const v = (0, varredura_acoes_1.agirNaVarredura)(doProjeto, { ...opcoes, quando, autorizacao: leitura, buscar: mesclou,
+        fantasmas: () => sessoes.fantasmas, vivas: () => sessoes.vivas });
+    daVarredura(v, ctx);
+    // 3. O despacho comum: com a Sentinela ligada nesta maquina, ela conduz. Cota sempre fica com a batida.
+    let sentinela = false;
+    try {
+        sentinela = (0, conducao_sentinela_1.presencaDaSentinela)(raiz, { agora: new Date(quando), maquina })?.ativa === true;
+    }
+    catch {
+        sentinela = false;
+    }
+    let passos = [];
+    try {
+        passos = (0, conducao_sentinela_1.passosDoCondutor)(doProjeto, { quando });
+    }
+    catch {
+        passos = [];
+    }
+    despacharPassos(ctx, passosDaBatida(passos, sentinela), opcoes);
+    const a = leitura.valida ? leitura.autorizacao : null;
+    return {
+        contrato: exports.CONTRATO_DA_BATIDA, consultadoEm: quando, maquina,
+        autorizacao: { valida: leitura.valida, motivo: leitura.valida ? null : leitura.motivo, detalhe: leitura.valida ? null : leitura.detalhe,
+            por: a?.por ?? null, ate: a?.ate ?? null, pode: a ? [...a.pode] : [] },
+        busca, forja, sentinela, feitas: ctx.feitas, pendentes: ctx.pendentes,
+    };
+}
+// ---------------------------------------------------------------------------
+// O retrato da ultima batida, a trava e o registro da rodada.
+// ---------------------------------------------------------------------------
+function caminhoDoRetrato(raiz) {
+    return path.join((0, estado_thread_1.raizDoEstado)(raiz), '.orkastery', 'monitor', exports.ARQUIVO_DA_BATIDA);
+}
+function lerRetratoDaBatida(raiz) {
+    try {
+        const r = JSON.parse(fs.readFileSync(caminhoDoRetrato(raiz), 'utf8'));
+        return r && r.contrato === exports.CONTRATO_DA_BATIDA && Array.isArray(r.pendentes) && Array.isArray(r.feitas) ? r : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Sem a leitura dos PRs nesta rodada (o `gh` fora, a rede caida), os merges pendentes da rodada anterior continuam
+ * pendentes, com o `desdeEm` deles: a falha passageira nao apaga a fila do dono e nao reabre a mesma noticia depois.
+ */
+function comMergesDaRodadaAnterior(nova, anterior, raiz) {
+    if (!anterior || !nova.forja || nova.forja.ok)
+        return nova;
+    const jaTem = new Set(nova.pendentes.filter((i) => i.acao === 'merge').map((i) => i.thread));
+    const herdados = anterior.pendentes.filter((i) => i.acao === 'merge' && !jaTem.has(i.thread)).filter((i) => {
+        try {
+            return (0, thread_1.lerThread)(raiz, i.thread).status !== 'fechada';
+        }
+        catch {
+            return false;
+        }
+    });
+    return herdados.length ? { ...nova, pendentes: [...nova.pendentes, ...herdados] } : nova;
+}
+/** O `desdeEm` de cada pendente fica o da primeira batida que o viu: o resumo ao dono nao repete a mesma noticia. */
+function comDesdeEstavel(nova, anterior) {
+    const chave = (i) => [i.acao, i.thread, i.motivo, i.pr ?? ''].join('|');
+    const antes = new Map((anterior?.pendentes ?? []).map((i) => [chave(i), i.desdeEm]));
+    return { ...nova, pendentes: nova.pendentes.map((i) => ({ ...i, desdeEm: i.desdeEm ?? antes.get(chave(i)) ?? nova.consultadoEm })) };
+}
+function gravarRetrato(raiz, r) {
+    const arquivo = caminhoDoRetrato(raiz);
+    fs.mkdirSync(path.dirname(arquivo), { recursive: true });
+    const temporario = `${arquivo}.${process.pid}.${(0, node_crypto_1.randomUUID)().slice(0, 8)}.tmp`;
+    try {
+        fs.writeFileSync(temporario, JSON.stringify(r, null, 2) + '\n', { encoding: 'utf8', mode: 0o600, flag: 'wx' });
+        fs.renameSync(temporario, arquivo);
+    }
+    finally {
+        fs.rmSync(temporario, { force: true });
+    }
+}
+/**
+ * A batida inteira, como o cron e o `ork conducao batida` a rodam: uma por vez nesta maquina (a mesma trava da varredura
+ * que age, `varredura-acoes.lock`), o retrato gravado para o pulse e a linha `varredura_acoes` no `hitl.log`.
+ */
+function baterConducao(carregado, opcoes = {}) {
+    const raiz = (0, estado_thread_1.raizDoEstado)(carregado.raiz);
+    const dir = path.join(raiz, '.orkastery', 'monitor');
+    const quando = opcoes.quando ?? new Date().toISOString();
+    const log = (linha) => {
+        try {
+            fs.mkdirSync(dir, { recursive: true });
+            fs.appendFileSync(path.join(dir, 'hitl.log'), JSON.stringify({ ts: quando, tipo: 'varredura_acoes', ...linha }) + '\n', { mode: 0o600 });
+        }
+        catch { /* o log e da batida; o ledger da thread guarda cada acao */ }
+    };
+    fs.mkdirSync(dir, { recursive: true });
+    const trava = (0, monitor_lock_1.adquirirLockMonitor)(path.join(dir, 'varredura-acoes.lock'));
+    if (!trava.ok) {
+        log({ ocupada: true, detalhe: trava.detalhe });
+        return { ocupada: true, detalhe: trava.detalhe };
+    }
+    let r;
+    try {
+        const anterior = lerRetratoDaBatida(raiz);
+        r = comDesdeEstavel(comMergesDaRodadaAnterior(conduzirBatida(carregado, { ...opcoes, quando }), anterior, raiz), anterior);
+        try {
+            gravarRetrato(raiz, r);
+        }
+        catch { /* sem retrato, o pulse so nao mostra os pendentes do merge e do despacho */ }
+    }
+    catch (e) {
+        log({ erro: e.message.slice(0, 300) });
+        throw e;
+    }
+    finally {
+        trava.liberar();
+    }
+    log({ autorizacao: r.autorizacao.valida ? 'valida' : r.autorizacao.motivo, busca: r.busca, forja: r.forja, sentinela: r.sentinela,
+        feitas: r.feitas.map((f) => ({ acao: f.acao, thread: f.thread, ...(f.pr ? { pr: f.pr } : {}) })),
+        pendentes: r.pendentes.map((p) => ({ acao: p.acao, thread: p.thread, resultado: p.resultado, motivo: p.motivo })) });
+    return { ocupada: false, ...r };
+}
+/**
+ * RM-063 (F7): o que a ultima batida deixou pendente no merge e no despacho, no formato das acoes da varredura, para o
+ * pulse levar a fila. So o retrato fresco (`VALIDADE_DO_RETRATO_MS`) conta; o pendente de thread ja fechada sai.
+ */
+function pendentesDaUltimaBatida(raiz, quando) {
+    const r = lerRetratoDaBatida(raiz);
+    if (!r || !(Date.parse(quando) - Date.parse(r.consultadoEm) <= exports.VALIDADE_DO_RETRATO_MS))
+        return [];
+    const saida = [];
+    for (const i of r.pendentes) {
+        if (i.acao !== 'merge' && i.acao !== 'despachar')
+            continue;
+        // RM-058, integracao (T1.2): o pulo da thread de um arco #Noctum fica no retrato; quem diz dela ao dono e o relatorio do
+        // arco. O arco que nao se le nao tem relatorio (A6 do CHECK): o pulo dele vai a fila do dono, com o texto da guarda.
+        if (i.motivo === noctum_guarda_1.MOTIVO_DA_GUARDA)
+            continue;
+        const ilegivel = i.motivo === noctum_guarda_1.MOTIVO_DO_ARCO_ILEGIVEL;
+        try {
+            if ((0, thread_1.lerThread)((0, estado_thread_1.raizDoEstado)(raiz), i.thread).status === 'fechada')
+                continue;
+        }
+        catch {
+            continue;
+        }
+        // A espera que passa de 2 h (check obrigatorio parado, o GitHub sem o estado do merge) vira item do dono. O arco que nao
+        // se le fica com o texto da guarda mesmo depois de 2 h (N3 do CHECK 2): a espera longa diria outra causa.
+        const longa = i.resultado === 'espera' && !!i.desdeEm && Date.parse(quando) - Date.parse(i.desdeEm) > exports.ESPERA_LONGA_MS;
+        const motivo = ilegivel ? 'thread-do-arco' : longa ? 'espera-longa' : i.motivo;
+        const bloqueio = ilegivel ? i.detalhe
+            : ehBloqueio(motivo) ? (0, locale_1.textoDoCatalogo)((m) => m.pulse.varredura.bloqueios[motivo]) : null;
+        const recusa = i.motivo && /-recusad[oa]$/.test(i.motivo) ? { em: r.consultadoEm, detalhe: i.detalhe } : null;
+        saida.push({ acao: i.acao, thread: i.thread, fase: i.fase, sessionId: null, desdeEm: i.desdeEm, comando: i.comando, oQue: i.oQue,
+            evidencia: i.evidencia, bloqueio, motivoDoBloqueio: bloqueio ? motivo : null, recusa });
+    }
+    return saida;
+}
+function ehBloqueio(motivo) {
+    return !!motivo && varredura_acoes_1.MOTIVOS_DO_BLOQUEIO.includes(motivo);
+}
+/** O texto do `ork conducao batida` e da resposta ao `#OrkRetomar`: o que voltou a andar e o que ficou com o dono. */
+function textoDaBatida(r) {
+    const m = (0, locale_1.msg)().conducao.batida;
+    if (r.ocupada)
+        return m.ocupada(r.detalhe);
+    const linhas = [];
+    const a = r.autorizacao;
+    linhas.push(a.valida ? m.autorizada(a.por ?? '-', a.ate ?? '-', a.pode.join(', ')) : m.semAutorizacao(a.motivo ?? '-'));
+    if (r.sentinela)
+        linhas.push(m.sentinela);
+    if (r.forja && !r.forja.ok)
+        linhas.push(m.prs(r.forja.detalhe));
+    if (r.busca && !r.busca.ok)
+        linhas.push(m.base(r.busca.detalhe));
+    const andou = r.feitas;
+    linhas.push(andou.length ? m.voltou(andou.length) : m.nada);
+    for (const f of andou)
+        linhas.push(m.item(f.thread, f.acao, f.pr ?? null, f.detalhe));
+    const espera = r.pendentes.filter((p) => p.resultado === 'espera');
+    if (espera.length)
+        linhas.push(m.espera(espera.length));
+    for (const p of espera)
+        linhas.push(m.item(p.thread, p.acao, p.pr ?? null, p.detalhe));
+    const dono = r.pendentes.filter((p) => p.resultado === 'dono');
+    if (dono.length)
+        linhas.push(m.comVoce(dono.length));
+    for (const p of dono)
+        linhas.push(m.itemDono(p.thread, p.acao, p.pr ?? null, p.motivo ?? '-', p.detalhe, p.comando));
+    return linhas.join('\n');
+}