@orkastery/cli 0.4.3 → 0.5.0

package/dist/pulse.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.JANELA_DAS_DECISOES_MS = exports.CONTRATO_PULSE = void 0;
+exports.apresentacaoCurtaDoItem = apresentacaoCurtaDoItem;
 exports.comporPulse = comporPulse;
 exports.montarPulse = montarPulse;
 exports.textoDoPulse = textoDoPulse;
@@ -20,6 +21,7 @@ const util_1 = require("./util");
 const horario_1 = require("./horario");
 const hitl_presentation_1 = require("./hitl-presentation");
 const hitl_contract_1 = require("./hitl-contract");
+const hitl_curto_1 = require("./hitl-curto");
 const decisao_autonoma_1 = require("./decisao-autonoma");
 const docs_1 = require("./docs");
 const conducao_1 = require("./conducao");
@@ -30,6 +32,18 @@ exports.JANELA_DAS_DECISOES_MS = 7 * 24 * 60 * 60 * 1000;
 const impacto = (fase) => types_1.FASES.indexOf(fase) + 1;
 const ordenar = (a, b) => (b.paradaHaMin ?? -1) - (a.paradaHaMin ?? -1) || b.impacto - a.impacto || a.id.localeCompare(b.id);
 const minutos = (desde, quando) => desde && Number.isFinite(Date.parse(desde)) ? Math.max(0, Math.floor((Date.parse(quando) - Date.parse(desde)) / 60000)) : null;
+/**
+ * RM-048 (D1 e D4): o texto curto de uma pergunta v2 de gate e a linha com o codigo estavel.
+ * Pedido sem codigo (v1, sessao) continua com o comando de antes: nada e inventado para ele.
+ */
+function apresentacaoCurtaDoItem(pedido, desde, quando) {
+    if (!(0, hitl_contract_1.ehV2)(pedido) || pedido.classe !== 'pergunta' || pedido.alvo.tipo !== 'gate')
+        return undefined;
+    const curto = (0, hitl_curto_1.montarPedidoCurto)((0, hitl_curto_1.entradaDoPedido)(pedido, desde ?? pedido.criadoEm), { quando, responder: { tipo: 'codigo', codigo: pedido.codigo } });
+    const recomendada = pedido.alternativas.find(a => a.recomendada)?.letra ?? 'a';
+    return { textos: { telegram: (0, hitl_curto_1.textoDoPedidoCurto)(curto, 'telegram'), terminal: (0, hitl_curto_1.textoDoPedidoCurto)(curto, 'terminal') },
+        comando: `${pedido.codigo} ${recomendada}` };
+}
 function comporPulse(carregado, entrada) {
     const { radar, monitor, batch, orfas } = entrada, quando = radar.consultadoEm;
     const humanos = [], automaticas = [];
@@ -186,6 +200,13 @@ function comporPulse(carregado, entrada) {
                 item.opcoes = (0, hitl_contract_1.escolhasDoPedido)(pedido).map(o => `${(0, hitl_contract_1.chaveDaEscolha)(pedido, o.numero)}. ${o.texto}`);
                 item.recomendacao = (0, hitl_contract_1.recomendacaoDoPedido)(pedido);
                 item.comandoResposta = `/ork ${(0, hitl_contract_1.alvoDoPedido)(pedido)?.tipo === 'session' ? 'session' : 'gate'} ${pedido.thread} ${pedido.id} <resposta>`;
+                // RM-048 (D1 e D4): a pergunta v2 de gate sai pelo contrato curto, e a linha que o dono
+                // recebe e o codigo estavel ("DE6H a"), nao o identificador que muda a cada renovacao.
+                const curta = apresentacaoCurtaDoItem(pedido, item.desdeEm, quando);
+                if (curta) {
+                    item.apresentacaoCurta = curta.textos;
+                    item.comandoResposta = curta.comando;
+                }
                 // O Pulse nao e uma conexao MCP: nenhum canal mcp-local sai `disponivel` daqui.
                 item.canais = (0, hitl_presentation_1.ofertaDoPedido)(pedido);
             }

package/dist/retry.js

@@ -482,10 +482,29 @@ function escalarEsforco(base, degraus) {
  *     de provider pago enquanto a fase esperava, a retomada recusa em vez de gastar.
  */
 function redespachar(carregado, thread, fase, promptRelativo, sha, opcoes = {}) {
-    const run = () => redespacharSobLock(carregado, (0, thread_1.lerThread)(carregado.raiz, thread.id), fase, promptRelativo, sha, opcoes);
-    return opcoes.dryRun ? run() : (0, hitl_gates_1.comLockHitl)(carregado.raiz, thread.id, run);
+    const run = (retida) => redespacharSobLock(carregado, (0, thread_1.lerThread)(carregado.raiz, thread.id), fase, promptRelativo, sha, opcoes, retida);
+    if (opcoes.dryRun)
+        return run();
+    // RM-037 (defeito 1; A2, G1 e N3 do CHECK 1 e 2, B-1 e A-1r do CHECK 4): o fallback do bloco leva a
+    // retomada ao codex. O redespacho pede a baseline depois das guardas baratas, RETENDO a conducao tomada; ela
+    // e gravada aqui, fora do lock HITL, como reentrada dessa tomada, e a retomada repete uma vez com ela.
+    const r = (0, hitl_gates_1.comLockHitl)(carregado.raiz, thread.id, () => run());
+    const retida = r.retida;
+    if (!retida)
+        return r;
+    delete r.retida;
+    try {
+        (0, phase_1.garantirBaselineDoDespacho)(carregado, thread.id, { fase, prompt: '', runtime: opcoes.runtime ?? undefined,
+            model: opcoes.model ?? undefined, effort: opcoes.effort ?? undefined, ...(opcoes.canal ? { canal: opcoes.canal } : {}) }, retida.identidade);
+        return (0, hitl_gates_1.comLockHitl)(carregado.raiz, thread.id, () => run(retida));
+    }
+    finally {
+        retida.devolver();
+    }
 }
-function redespacharSobLock(carregado, thread, fase, promptRelativo, sha, opcoes = {}) {
+function redespacharSobLock(carregado, thread, fase, promptRelativo, sha, opcoes = {}, 
+/** A tomada que a primeira passada reteve para a baseline; com ela, esta e a repeticao. */
+tomadaPrevia) {
     const { raiz, manifesto } = carregado;
     const absoluto = path.isAbsolute(promptRelativo)
         ? promptRelativo
@@ -536,13 +555,24 @@ function redespacharSobLock(carregado, thread, fase, promptRelativo, sha, opcoes
     // I-36 (T6): validado o pedido, a retomada toma a conducao antes de redespachar, como o
     // `ork phase run`. A mesma fase com o mesmo prompt de quem ja conduz nao abre sessao nova;
     // outro pedido espera a vez.
-    const identidade = (0, runtime_context_1.novaIdentidadeDeDespacho)(thread.id, fase);
+    const identidade = tomadaPrevia ? { ...(0, runtime_context_1.novaIdentidadeDeDespacho)(thread.id, fase), dispatchId: tomadaPrevia.identidade }
+        : (0, runtime_context_1.novaIdentidadeDeDespacho)(thread.id, fase);
     const canal = opcoes.canal ?? (0, conducao_1.canalDoProcesso)();
     const doBlocoDaConducao = (0, setup_1.limitesDoBloco)(manifesto, (0, setup_1.lerSetup)(raiz), thread.modo, fase);
     const pedidoDeConducao = { canal, correlacao: null, operacao: 'retry.run', fase, promptSha256: sha,
         identidade: identidade.dispatchId, prazoMs: (0, phase_1.prazoDaSessao)(doBlocoDaConducao) };
     let conducao = null;
-    if (!opcoes.dryRun) {
+    if (tomadaPrevia) {
+        // R5-B1 do CHECK 5: a sucedida que o dono respondeu durante a baseline recebe o lease de volta.
+        if (!tomadaPrevia.sucessaoAindaVale()) {
+            tomadaPrevia.devolver();
+            const recusa = (0, conducao_1.recusaDeConducao)(thread.id, (0, conducao_1.conducaoDaThread)(raiz, thread.id), pedidoDeConducao);
+            (0, conducao_1.registrarRecusa)(raiz, recusa);
+            return { ...vazio, ok: false, motivo: 'conducao.em-andamento', detalhe: recusa.texto, dryRun: false };
+        }
+        conducao = tomadaPrevia;
+    }
+    else if (!opcoes.dryRun) {
         const tomada = (0, conducao_1.tomarConducao)(raiz, thread.id, pedidoDeConducao);
         if (!tomada.ok) {
             if (tomada.idempotente && tomada.atual) {
@@ -571,6 +601,17 @@ function redespacharSobLock(carregado, thread, fase, promptRelativo, sha, opcoes
             effort: opcoes.effort ?? undefined,
         }, doBloco);
         const rt = (0, runtimes_1.resolverRuntime)(runtime);
+        if (!opcoes.dryRun && (0, phase_1.baselineDoDespachoNecessaria)(carregado, thread.id, { fase, prompt: '', runtime, model, effort })) {
+            // Na primeira passada a tomada fica retida para a baseline (o `finally` nao a solta); na repeticao, o
+            // `finally` devolve o que a tomada consumiu (A-1 do CHECK 3).
+            const pendente = { ...vazio, ok: false, motivo: 'runtime.unavailable', dryRun: false,
+                detalhe: `baseline.pendente: o bloco com GO no ${runtime} precisa da baseline antes da retomada` };
+            if (!tomadaPrevia && conducao) {
+                pendente.retida = conducao;
+                conducao = null;
+            }
+            return pendente;
+        }
         // D14 (GO-FIX 2): a retomada claude-bg abre com a mesma colaboração e o mesmo contexto de
         // runtime do `ork phase run`; sem eles, o PLAN retomado saía sem negar Edit, Write e
         // NotebookEdit e sem a allowlist do núcleo. O ramo Codex não muda.
@@ -615,7 +656,8 @@ function redespacharSobLock(carregado, thread, fase, promptRelativo, sha, opcoes
             logDir: path.join((0, thread_1.dirThread)(raiz, thread.id), 'sessoes'),
             vinculo: { thread: thread.id, fase, promptSha256: sha },
             ...(perfil ? { perfil } : {}),
-            ...(runtime === 'claude-bg' ? { contextoRuntime, ...(fase === 'PLAN' ? { colaboracao: 'plan' } : {}) } : {}),
+            // RM-037 (defeito 2): o modo plano segue a mesma regra do `ork phase run`, pelo bloco.
+            ...(runtime === 'claude-bg' ? { contextoRuntime, ...((0, phase_1.modoDaSessaoDoBloco)(thread, fase).plano ? { colaboracao: 'plan' } : {}) } : {}),
             // I-36 (D4): a sessao retomada herda a identidade do despacho e o canal, como no `ork phase run`.
             ambienteExtra: (0, conducao_1.ambienteDaConducao)(identidade.dispatchId, thread.id, canal),
         });
@@ -695,8 +737,9 @@ function redespacharSobLock(carregado, thread, fase, promptRelativo, sha, opcoes
         };
     }
     finally {
-        // Retomada que nao virou sessao devolve a conducao; a que virou ja a entregou a sessao.
-        conducao?.liberar();
+        // Retomada que nao virou sessao devolve a conducao, com o que a tomada consumiu; a que virou ja a
+        // entregou a sessao, e devolver entao nao faz nada.
+        conducao?.devolver();
     }
 }
 // ---------------------------------------------------------------------------

package/dist/roadmap-reservas.js

@@ -33,14 +33,21 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.REMOTO_PADRAO = exports.BRANCH_DE_RESERVAS = exports.CONTRATO_RESERVA = void 0;
+exports.DIR_DE_FEATS = exports.CONTRATO_FEAT = exports.PRAZO_DO_FECHAMENTO_MS = exports.DIR_DE_RESERVAS = exports.REMOTO_PADRAO = exports.BRANCH_DE_RESERVAS = exports.CONTRATO_RESERVA = void 0;
+exports.redeDoFechamento = redeDoFechamento;
 exports.exigirItem = exigirItem;
 exports.quemSouEu = quemSouEu;
+exports.reservaValida = reservaValida;
 exports.reservasLocais = reservasLocais;
 exports.listarReservas = listarReservas;
+exports.maiorFeatConhecida = maiorFeatConhecida;
+exports.reservarFeat = reservarFeat;
 exports.painelEmMarkdown = painelEmMarkdown;
 exports.pegarItem = pegarItem;
 exports.soltarItem = soltarItem;
+exports.reservasOrfas = reservasOrfas;
+exports.soltarReservaDaThread = soltarReservaDaThread;
+exports.soltarReservasOrfas = soltarReservasOrfas;
 exports.textoDasReservas = textoDasReservas;
 /**
  * I-47: reservas de item do roadmap entre maquinas, como documentacao em codigo.
@@ -64,15 +71,32 @@ const os = __importStar(require("node:os"));
 const path = __importStar(require("node:path"));
 const branch_de_estado_1 = require("./branch-de-estado");
 const horario_1 = require("./horario");
+const ledger_1 = require("./ledger");
 const maquina_1 = require("./maquina");
+const thread_1 = require("./thread");
 const util_1 = require("./util");
 exports.CONTRATO_RESERVA = 'ork.roadmap-reserva/v1';
 exports.BRANCH_DE_RESERVAS = 'ork/roadmap-reservas';
 exports.REMOTO_PADRAO = 'origin';
-const DIR = 'reservas';
+/** O diretorio das reservas na branch; a leitura sem clone (RM-054) le o mesmo. */
+exports.DIR_DE_RESERVAS = 'reservas';
+const DIR = exports.DIR_DE_RESERVAS;
 const PAINEL = 'RESERVAS.md';
 const TENTATIVAS = 5;
 const ITEM = /^RM-\d{3}$/;
+/**
+ * O fechamento nao pode ficar parado na rede (achado A3 do CHECK 1): prazo curto por chamada e git
+ * sem pergunta no terminal. O ssh de quem ja o configurou vale (aviso N1 do CHECK 2): com
+ * `GIT_SSH_COMMAND`, `GIT_SSH` ou `core.sshCommand`, nada muda nele e o prazo segura a espera; sem
+ * nenhum, o ssh roda em modo lote, que usa o agente e as chaves mas nunca pergunta a senha.
+ */
+exports.PRAZO_DO_FECHAMENTO_MS = 15000;
+function redeDoFechamento(raiz) {
+    const sshProprio = !!process.env.GIT_SSH_COMMAND || !!process.env.GIT_SSH ||
+        (0, branch_de_estado_1.git)(raiz, ['config', '--get', 'core.sshCommand']).ok;
+    return { timeoutMs: exports.PRAZO_DO_FECHAMENTO_MS,
+        env: { GIT_TERMINAL_PROMPT: '0', ...(sshProprio ? {} : { GIT_SSH_COMMAND: 'ssh -o BatchMode=yes' }) } };
+}
 const PREFIXO = 'roadmap';
 /** O item precisa existir no roadmap do projeto (`docs/roadmap/RM-NNN-*.md`). */
 function exigirItem(raiz, item) {
@@ -95,14 +119,20 @@ function quemSouEu(raiz, opcoes = {}) {
     return { por, maquina: (0, maquina_1.nomeDaMaquina)(opcoes.maquina) };
 }
 /** Traz a ponta da branch de reservas. `null` quando ela ainda nao existe no remoto. */
-function buscar(raiz, remoto) {
-    return (0, branch_de_estado_1.buscarBranch)(raiz, remoto, exports.BRANCH_DE_RESERVAS, PREFIXO);
+function buscar(raiz, remoto, rede = {}) {
+    return (0, branch_de_estado_1.buscarBranch)(raiz, remoto, exports.BRANCH_DE_RESERVAS, PREFIXO, rede.timeoutMs, rede.env);
 }
 function lerDaPonta(raiz, ponta) {
     return (0, branch_de_estado_1.jsonsDaPonta)(raiz, ponta, DIR, PREFIXO)
         .filter((r) => r.contrato === exports.CONTRATO_RESERVA)
         .sort((a, b) => a.item.localeCompare(b.item));
 }
+/** RM-054: a reserva lida de fora do `ork` desta maquina (forja, outra copia) so vale inteira. */
+function reservaValida(bruto) {
+    const r = bruto;
+    return !!r && typeof r === 'object' && r.contrato === exports.CONTRATO_RESERVA && typeof r.item === 'string' && ITEM.test(r.item) &&
+        typeof r.por === 'string' && typeof r.maquina === 'string' && typeof r.desdeEm === 'string';
+}
 /** As reservas da ultima copia lida nesta maquina, sem rede (I-51: o retrato da fabrica usa). */
 function reservasLocais(raiz, remoto = exports.REMOTO_PADRAO) {
     try {
@@ -114,11 +144,73 @@ function reservasLocais(raiz, remoto = exports.REMOTO_PADRAO) {
 }
 /** `ork roadmap reservas`: quem esta com cada item, lido do remoto (ou da ultima copia, sem rede). */
 function listarReservas(raiz, opcoes = {}) {
-    const { ponta, atualizado } = buscar(raiz, opcoes.remoto ?? exports.REMOTO_PADRAO);
-    return { reservas: lerDaPonta(raiz, ponta), atualizado, ponta };
+    const { ponta, atualizado } = buscar(raiz, opcoes.remoto ?? exports.REMOTO_PADRAO, opcoes.rede);
+    return { reservas: lerDaPonta(raiz, ponta), feats: featsDaPonta(raiz, ponta), atualizado, ponta };
+}
+// ---------------------------------------------------------------------------
+// RM-037 (rm037noite, defeito 6): o numero da FEAT nova tambem e reservado.
+// ---------------------------------------------------------------------------
+/**
+ * A RM-052, a RM-026 e a RM-051 criaram a FEAT-030 cada uma, em maquinas e threads diferentes: o numero
+ * saia do `ls docs/produto` de cada branch. Agora ele sai de `ork roadmap feat`, na mesma branch de
+ * reservas e pela mesma atomicidade do item (o primeiro push vence; o segundo rele e leva o seguinte).
+ * A reserva de numero e para sempre: numero queimado nao volta, e por isso nunca colide.
+ */
+exports.CONTRATO_FEAT = 'ork.feat-reserva/v1';
+exports.DIR_DE_FEATS = 'feats';
+const NUMERO_DE_FEAT = /^FEAT-(\d{3})$/;
+const ARQUIVO_DE_FEAT = /^FEAT-(\d{3})-/;
+function featsDaPonta(raiz, ponta) {
+    return (0, branch_de_estado_1.jsonsDaPonta)(raiz, ponta, exports.DIR_DE_FEATS, PREFIXO)
+        .filter((r) => r && r.contrato === exports.CONTRATO_FEAT && typeof r.feat === 'string' && NUMERO_DE_FEAT.test(r.feat))
+        .sort((a, b) => a.feat.localeCompare(b.feat));
+}
+const numeroDaFeat = (feat) => Number(NUMERO_DE_FEAT.exec(feat)?.[1] ?? 0);
+/**
+ * O maior numero de FEAT que o projeto ja conhece: a arvore de trabalho e a ponta de toda branch local
+ * e de toda branch do remoto ja buscada (achado A6 do CHECK 1: a FEAT criada a mao numa PR aberta, ou
+ * por um `ork` antigo, tambem conta). Branch que esta maquina nunca buscou continua invisivel.
+ */
+function maiorFeatConhecida(raiz, remoto = exports.REMOTO_PADRAO) {
+    const nomes = [];
+    const dir = path.join(raiz, 'docs', 'produto');
+    if (fs.existsSync(dir))
+        nomes.push(...fs.readdirSync(dir));
+    const refs = (0, branch_de_estado_1.git)(raiz, ['for-each-ref', '--format=%(objectname)', 'refs/heads', `refs/remotes/${remoto}`]);
+    const pontas = new Set(refs.ok ? refs.stdout.split('\n').map((l) => l.trim()).filter(Boolean) : []);
+    for (const ponta of pontas) {
+        const r = (0, branch_de_estado_1.git)(raiz, ['ls-tree', '--name-only', ponta, '--', 'docs/produto/']);
+        if (r.ok)
+            nomes.push(...r.stdout.split('\n').map((n) => path.posix.basename(n)));
+    }
+    return nomes.reduce((maior, nome) => Math.max(maior, Number(ARQUIVO_DE_FEAT.exec(nome)?.[1] ?? 0)), 0);
+}
+/** `ork roadmap feat`: reserva o proximo numero de FEAT para esta maquina, por push atomico. */
+function reservarFeat(raiz, opcoes = {}) {
+    const remoto = opcoes.remoto ?? exports.REMOTO_PADRAO;
+    const eu = quemSouEu(raiz, opcoes);
+    for (let tentativa = 1; tentativa <= TENTATIVAS; tentativa++) {
+        const { ponta, atualizado } = buscar(raiz, remoto);
+        if (!atualizado)
+            throw new Error(`roadmap.sem-remoto: nao consegui ler ${exports.BRANCH_DE_RESERVAS} em ${remoto}; reservar exige rede`);
+        const feats = featsDaPonta(raiz, ponta);
+        const proximo = Math.max(maiorFeatConhecida(raiz, remoto), ...feats.map((r) => numeroDaFeat(r.feat))) + 1;
+        if (proximo > 999)
+            throw new Error('roadmap.feat: os numeros de FEAT de tres digitos acabaram');
+        const feat = `FEAT-${String(proximo).padStart(3, '0')}`;
+        const reserva = { contrato: exports.CONTRATO_FEAT, feat, por: eu.por, maquina: eu.maquina,
+            thread: opcoes.thread ?? null, nota: opcoes.nota ?? null, em: opcoes.agora ?? (0, util_1.agora)() };
+        const commit = (0, branch_de_estado_1.gravarNaBranch)(raiz, remoto, exports.BRANCH_DE_RESERVAS, ponta, [
+            { caminho: `${exports.DIR_DE_FEATS}/${feat}.json`, conteudo: JSON.stringify(reserva, null, 2) + '\n' },
+            { caminho: PAINEL, conteudo: painelEmMarkdown(lerDaPonta(raiz, ponta), [...feats, reserva]) },
+        ], `reserva: ${feat} para ${eu.por} em ${eu.maquina}${reserva.thread ? ` (thread ${reserva.thread})` : ''}`, PREFIXO);
+        if (commit)
+            return { feat, reserva, commit, tentativas: tentativa };
+    }
+    throw new Error(`roadmap.concorrencia: ${TENTATIVAS} pushes recusados seguidos; tente de novo em instantes`);
 }
 /** O `RESERVAS.md` da branch: a mesma lista, para quem abre o GitHub. */
-function painelEmMarkdown(reservas) {
+function painelEmMarkdown(reservas, feats = []) {
     const linhas = [
         '# Reservas do roadmap',
         '',
@@ -126,20 +218,24 @@ function painelEmMarkdown(reservas) {
         'não edite à mão. Antes de começar um item: `ork roadmap reservas`.',
         '',
     ];
+    const numeros = feats.length === 0 ? [] : ['', '## Números de FEAT reservados', '',
+        'O número da FEAT nova sai de `ork roadmap feat`; número reservado não volta.', '',
+        '| FEAT | Com quem | Máquina | Thread | Em |', '| --- | --- | --- | --- | --- |',
+        ...feats.map((f) => `| ${f.feat} | ${f.por} | ${f.maquina} | ${f.thread ?? 'sem thread'} | ${(0, horario_1.formatarDataHora)(f.em)} |`)];
     if (reservas.length === 0)
-        return [...linhas, 'Nenhum item reservado.', ''].join('\n');
+        return [...linhas, 'Nenhum item reservado.', ...numeros, ''].join('\n');
     linhas.push('| Item | Com quem | Máquina | Thread | Desde | Nota |', '| --- | --- | --- | --- | --- | --- |');
     for (const r of reservas) {
         linhas.push(`| ${r.item} | ${r.por} | ${r.maquina} | ${r.thread ?? '—'} | ${(0, horario_1.formatarDataHora)(r.desdeEm)} | ${r.nota ?? '—'} |`);
     }
-    return [...linhas, '', (0, horario_1.legendaDoFuso)(), ''].join('\n');
+    return [...linhas, ...numeros, '', (0, horario_1.legendaDoFuso)(), ''].join('\n');
 }
 /** Grava a reserva (ou a remocao dela) e o painel numa versao nova da branch. Recusa volta `false`. */
-function gravar(raiz, remoto, ponta, mudanca, todas, mensagem) {
+function gravar(raiz, remoto, ponta, mudanca, todas, mensagem, rede = {}) {
     return (0, branch_de_estado_1.gravarNaBranch)(raiz, remoto, exports.BRANCH_DE_RESERVAS, ponta, [
         { caminho: `${DIR}/${mudanca.item}.json`, conteudo: mudanca.reserva ? JSON.stringify(mudanca.reserva, null, 2) + '\n' : null },
-        { caminho: PAINEL, conteudo: painelEmMarkdown(todas) },
-    ], mensagem, PREFIXO);
+        { caminho: PAINEL, conteudo: painelEmMarkdown(todas, featsDaPonta(raiz, ponta)) },
+    ], mensagem, PREFIXO, rede);
 }
 function ehMinha(r, eu) {
     return r.por === eu.por && r.maquina === eu.maquina;
@@ -163,11 +259,14 @@ function pegarItem(raiz, item, opcoes = {}) {
     const remoto = opcoes.remoto ?? exports.REMOTO_PADRAO;
     const eu = quemSouEu(raiz, opcoes);
     for (let tentativa = 1; tentativa <= TENTATIVAS; tentativa++) {
-        const { ponta, atualizado } = buscar(raiz, remoto);
+        const { ponta, atualizado } = buscar(raiz, remoto, opcoes.rede);
         if (!atualizado)
             throw new Error(`roadmap.sem-remoto: nao consegui ler ${exports.BRANCH_DE_RESERVAS} em ${remoto}; reservar exige rede`);
         const todas = lerDaPonta(raiz, ponta);
         const atual = todas.find((r) => r.item === id) ?? null;
+        if (opcoes.threadEsperada !== undefined && (atual?.thread ?? null) !== opcoes.threadEsperada) {
+            return { acao: 'nada', item: id, reserva: atual, commit: null, tentativas: tentativa };
+        }
         const quando = opcoes.agora ?? (0, util_1.agora)();
         let acao = 'pegou';
         let tomadaDe;
@@ -191,7 +290,7 @@ function pegarItem(raiz, item, opcoes = {}) {
         const mensagem = acao === 'tomou'
             ? `reserva: ${id} tomada por ${eu.por} em ${eu.maquina} (de ${tomadaDe.por} em ${tomadaDe.maquina}): ${tomadaDe.motivo}`
             : `reserva: ${id} ${acao === 'renovou' ? 'renovada' : 'pega'} por ${eu.por} em ${eu.maquina}`;
-        const commit = gravar(raiz, remoto, ponta, { item: id, reserva }, novas, mensagem);
+        const commit = gravar(raiz, remoto, ponta, { item: id, reserva }, novas, mensagem, opcoes.rede);
         if (commit)
             return { acao, item: id, reserva, commit, tentativas: tentativa };
     }
@@ -203,13 +302,16 @@ function soltarItem(raiz, item, opcoes = {}) {
     const remoto = opcoes.remoto ?? exports.REMOTO_PADRAO;
     const eu = quemSouEu(raiz, opcoes);
     for (let tentativa = 1; tentativa <= TENTATIVAS; tentativa++) {
-        const { ponta, atualizado } = buscar(raiz, remoto);
+        const { ponta, atualizado } = buscar(raiz, remoto, opcoes.rede);
         if (!atualizado)
             throw new Error(`roadmap.sem-remoto: nao consegui ler ${exports.BRANCH_DE_RESERVAS} em ${remoto}; soltar exige rede`);
         const todas = lerDaPonta(raiz, ponta);
         const atual = todas.find((r) => r.item === id);
         if (!atual)
             return { acao: 'nada', item: id, reserva: null, commit: null, tentativas: tentativa };
+        if (opcoes.threadEsperada !== undefined && (atual.thread ?? null) !== opcoes.threadEsperada) {
+            return { acao: 'nada', item: id, reserva: atual, commit: null, tentativas: tentativa };
+        }
         let motivo = '';
         if (!ehMinha(atual, eu)) {
             if (!opcoes.forcar)
@@ -218,26 +320,166 @@ function soltarItem(raiz, item, opcoes = {}) {
         }
         const restantes = todas.filter((r) => r.item !== id);
         const mensagem = `reserva: ${id} solta por ${eu.por} em ${eu.maquina}${motivo}`;
-        const commit = gravar(raiz, remoto, ponta, { item: id, reserva: null }, restantes, mensagem);
+        const commit = gravar(raiz, remoto, ponta, { item: id, reserva: null }, restantes, mensagem, opcoes.rede);
         if (commit)
             return { acao: 'soltou', item: id, reserva: atual, commit, tentativas: tentativa };
     }
     throw new Error(`roadmap.concorrencia: ${TENTATIVAS} pushes recusados seguidos; tente de novo em instantes`);
 }
+function threadsLocais(raiz) {
+    const threads = [];
+    for (const id of (0, thread_1.listarIds)(raiz)) {
+        try {
+            threads.push((0, thread_1.lerThread)(raiz, id));
+        }
+        catch { /* thread ilegivel nao decide reserva */ }
+    }
+    return threads;
+}
+/** A outra thread aberta do item nesta maquina, a mais recente, que herda a reserva. */
+function sucessoraDoItem(threads, item, fora) {
+    const abertas = threads.filter((t) => t.id !== fora && t.status !== 'fechada' && t.roadmap === item)
+        .sort((a, b) => String(b.atualizadaEm ?? '').localeCompare(String(a.atualizadaEm ?? '')));
+    return abertas[0]?.id ?? null;
+}
+/**
+ * As reservas orfas: desta maquina, apontando para thread que existe aqui e esta fechada. Thread que
+ * nao existe aqui nao prova nada (pode ser de outra copia), e reserva de outra maquina so sai com
+ * `--forcar`, pelo contrato da I-47.
+ */
+function reservasOrfas(raiz, reservas, opcoes = {}) {
+    const eu = quemSouEu(raiz, opcoes);
+    const threads = threadsLocais(raiz);
+    const status = new Map(threads.map((t) => [t.id, t.status]));
+    return reservas.filter((r) => r.thread && ehMinha(r, eu) && status.get(r.thread) === 'fechada')
+        .map((reserva) => ({ reserva, sucessora: sucessoraDoItem(threads, reserva.item, reserva.thread) }));
+}
+/** Solta a reserva orfa, ou a reaponta para a sucessora, e registra no ledger da thread fechada. */
+function soltarOrfa(raiz, orfa, origem, opcoes) {
+    const thread = orfa.reserva.thread, item = orfa.reserva.item;
+    const comparando = { ...opcoes, threadEsperada: thread };
+    const r = orfa.sucessora
+        ? pegarItem(raiz, item, { ...comparando, thread: orfa.sucessora })
+        : soltarItem(raiz, item, comparando);
+    // A reserva mudou de dono no meio (ou ja tinha saido): nada foi gravado e nada vai ao ledger como soltura.
+    if (r.acao === 'nada') {
+        return { item, thread, acao: 'intocada', para: null, commit: null,
+            detalhe: `${item} mudou de dono entre a leitura e a gravacao; ficou como estava` };
+    }
+    const acao = orfa.sucessora ? 'reapontada' : 'solta';
+    const detalhe = orfa.sucessora ? `${item} passou para a thread ${orfa.sucessora}, aberta no mesmo item` : `${item} devolvido`;
+    // Sugestao 3 do CHECK 2: a soltura ja foi ao remoto; erro so no registro nao a transforma em pendencia.
+    try {
+        (0, ledger_1.registrarSeExiste)((0, thread_1.dirThread)(raiz, thread), thread, ledger_1.TIPOS_DE_EVENTO.reservaLiberada, { item, acao, para: orfa.sucessora, commit: r.commit, origem, detalhe });
+    }
+    catch { /* a reserva saiu; o resultado diz o que aconteceu */ }
+    return { item, thread, acao, para: orfa.sucessora, commit: r.commit, detalhe };
+}
+/** A pendencia vai ao ledger da thread fechada, com a correcao; o registro tambem e de melhor esforco. */
+function pendenteDaThread(raiz, thread, item, detalhe) {
+    try {
+        (0, ledger_1.registrarSeExiste)((0, thread_1.dirThread)(raiz, thread), thread, ledger_1.TIPOS_DE_EVENTO.reservaPendente, { item, detalhe, correcao: 'ork roadmap reservas --soltar-orfas' });
+    }
+    catch { /* sem ledger gravavel, o resultado ainda diz a pendencia */ }
+    return { item: item ?? '', thread, acao: 'pendente', para: null, commit: null, detalhe };
+}
+const primeiraLinha = (e) => String(e?.message ?? e).split('\n')[0].slice(0, 300);
+/**
+ * `ork thread close` e `ork master`: a thread que fecha solta a reserva do item dela, ou a passa para
+ * outra thread aberta do mesmo item nesta maquina. De melhor esforco: sem rede ou com a reserva em
+ * outra maquina, o fechamento segue e o ledger guarda a pendencia com a correcao. So vai a rede
+ * quando ha o que soltar: a thread tem item ou a ultima copia lida das reservas aponta para ela.
+ */
+function soltarReservaDaThread(raiz, threadId, opcoes = {}) {
+    let item = null;
+    try {
+        item = (0, thread_1.lerThread)(raiz, threadId).roadmap ?? null;
+    }
+    catch {
+        return [];
+    }
+    const remoto = opcoes.remoto ?? exports.REMOTO_PADRAO;
+    const naCopia = reservasLocais(raiz, remoto).find((r) => r.thread === threadId);
+    if (!item && !naCopia)
+        return [];
+    // Sugestao 1 do CHECK 2: quem passa `rede` troca o que passou, sem perder o resto do fechamento.
+    const base = redeDoFechamento(raiz);
+    const rede = { timeoutMs: opcoes.rede?.timeoutMs ?? base.timeoutMs, env: { ...base.env, ...opcoes.rede?.env } };
+    const comRede = { ...opcoes, rede };
+    const oItem = item ?? naCopia?.item ?? null;
+    let painel;
+    try {
+        painel = listarReservas(raiz, { remoto, rede });
+    }
+    catch (e) {
+        return [pendenteDaThread(raiz, threadId, oItem, primeiraLinha(e))];
+    }
+    if (!painel.atualizado) {
+        return [pendenteDaThread(raiz, threadId, oItem, `sem leitura de ${exports.BRANCH_DE_RESERVAS} em ${remoto}; a reserva fica para depois`)];
+    }
+    const dela = painel.reservas.filter((r) => r.thread === threadId);
+    let orfas;
+    // Sugestao 2 do CHECK 2: quem sou eu e as threads locais tambem podem falhar; vira pendencia, nao silencio.
+    try {
+        orfas = reservasOrfas(raiz, dela, opcoes);
+    }
+    catch (e) {
+        return dela.map((r) => pendenteDaThread(raiz, threadId, r.item, primeiraLinha(e)));
+    }
+    const saida = [];
+    // Sugestao 1 do CHECK 1: toda reserva da thread, nao so a primeira; a de outra maquina fica pendente.
+    for (const r of dela.filter((x) => !orfas.some((o) => o.reserva.item === x.item))) {
+        saida.push(pendenteDaThread(raiz, threadId, r.item, `${descrever(r)}; so quem pegou solta, ou --forcar --motivo`));
+    }
+    for (const orfa of orfas) {
+        try {
+            saida.push(soltarOrfa(raiz, orfa, 'fechamento', comRede));
+        }
+        catch (e) {
+            saida.push(pendenteDaThread(raiz, threadId, orfa.reserva.item, primeiraLinha(e)));
+        }
+    }
+    return saida;
+}
+/**
+ * `ork roadmap reservas --soltar-orfas`: a mesma regra do fechamento, para toda reserva orfa desta
+ * maquina. Uma orfa que falha vira pendencia no ledger dela e nao para as outras (sugestao 2 do CHECK 1).
+ */
+function soltarReservasOrfas(raiz, opcoes = {}) {
+    const painel = listarReservas(raiz, { remoto: opcoes.remoto, rede: opcoes.rede });
+    if (!painel.atualizado)
+        throw new Error(`roadmap.sem-remoto: nao consegui ler ${exports.BRANCH_DE_RESERVAS}; soltar exige rede`);
+    return reservasOrfas(raiz, painel.reservas, opcoes).map((orfa) => {
+        try {
+            return soltarOrfa(raiz, orfa, 'orfas', opcoes);
+        }
+        catch (e) {
+            return pendenteDaThread(raiz, orfa.reserva.thread, orfa.reserva.item, primeiraLinha(e));
+        }
+    });
+}
 /** O texto de `ork roadmap reservas` para o terminal, no fuso do dono. */
-function textoDasReservas(p) {
+function textoDasReservas(p, orfas = []) {
     const linhas = [];
     if (!p.atualizado)
         linhas.push('AVISO: sem acesso ao remoto; esta e a ultima copia lida nesta maquina.', '');
+    const feats = p.feats ?? [];
+    const numeros = feats.length === 0 ? [] : ['', `Números de FEAT reservados (${feats.length}), os últimos: ` +
+            feats.slice(-5).map((f) => `${f.feat} (${f.thread ?? f.maquina})`).join(', ') + '. O próximo sai de: ork roadmap feat'];
     if (p.reservas.length === 0) {
-        linhas.push('Nenhum item do roadmap reservado.');
+        linhas.push('Nenhum item do roadmap reservado.', ...numeros);
         return linhas.join('\n');
     }
     linhas.push('ITEM     COM QUEM            MAQUINA         THREAD             DESDE');
+    const orfaDoItem = new Map(orfas.map((o) => [o.reserva.item, o]));
     for (const r of p.reservas) {
+        const orfa = orfaDoItem.get(r.item);
+        const marca = orfa ? `  ÓRFÃ: thread fechada${orfa.sucessora ? `, passa para ${orfa.sucessora}` : ''}` : '';
         linhas.push(`${r.item.padEnd(8)} ${r.por.slice(0, 19).padEnd(19)} ${r.maquina.slice(0, 15).padEnd(15)} ` +
-            `${(r.thread ?? '-').slice(0, 18).padEnd(18)} ${(0, horario_1.formatarDataHora)(r.desdeEm)}` + (r.nota ? `  ${r.nota}` : ''));
+            `${(r.thread ?? '-').slice(0, 18).padEnd(18)} ${(0, horario_1.formatarDataHora)(r.desdeEm)}` + (r.nota ? `  ${r.nota}` : '') + marca);
     }
-    linhas.push('', (0, horario_1.legendaDoFuso)());
+    if (orfas.length > 0)
+        linhas.push('', `${orfas.length} reserva(s) órfã(s) desta máquina. Para soltar: ork roadmap reservas --soltar-orfas`);
+    linhas.push(...numeros, '', (0, horario_1.legendaDoFuso)());
     return linhas.join('\n');
 }