@orkastery/cli 0.4.2 → 0.5.0

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');
 }

package/dist/roadmap-status.js

@@ -0,0 +1,213 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TETO_DO_FECHO = exports.GRUPO_DO_CICLO = exports.GRUPOS_DO_ROADMAP = exports.CONTRATO_STATUS_DO_ROADMAP = void 0;
+exports.esperaDoDono = esperaDoDono;
+exports.fatosLocais = fatosLocais;
+exports.montarStatusDoRoadmap = montarStatusDoRoadmap;
+exports.montarStatusDeFatos = montarStatusDeFatos;
+exports.textoDoStatusDoRoadmap = textoDoStatusDoRoadmap;
+/**
+ * RM-048 (item 7, D7): o status report UNICO do roadmap, no formato aprovado pelo dono.
+ *
+ * Ate aqui cada canal escrevia o proprio relatorio de roadmap, e o dono lia uma coisa no Telegram
+ * e outra no terminal. O formato que ele aprovou (27/09 e 28/09):
+ *
+ *   titulo "Roadmap do <Projeto> (DD/MM, HH:MM)", no fuso do dono;
+ *   grupos com icones, nesta ordem: Concluidos, Disponiveis com algo em aberto, Entregue hoje,
+ *   Piloto, Em desenvolvimento, Refinamento, Proposto, Descontinuado;
+ *   um item por linha, com #HITL no que depende do dono;
+ *   fecho com "O que precisa de voce" e "O que eu faco em seguida".
+ *
+ * Tudo sai de FATO: o frontmatter do item (`ork docs`), o ledger das threads ligadas a ele e o gate
+ * que o nucleo confere sem escrever (`prepararPedidoGate`). E leitura pura: nao abre pedido, nao
+ * grava ledger, nao toca a rede. Os canais chamam `ork roadmap status` e transportam o texto.
+ *
+ * RM-054: o montador recebe FATOS de thread (`FatoDeThread`), nao so as threads deste disco. O
+ * relatorio local continua com os fatos locais; o panorama da rede soma os retratos das outras
+ * maquinas, e so ai o fecho diz entre parenteses em que maquina a thread anda.
+ */
+const docs_1 = require("./docs");
+const ledger_1 = require("./ledger");
+const thread_1 = require("./thread");
+const hitl_contract_1 = require("./hitl-contract");
+const hitl_gates_1 = require("./hitl-gates");
+const hitl_classificacao_1 = require("./hitl-classificacao");
+const horario_1 = require("./horario");
+const projeto_alvo_1 = require("./projeto-alvo");
+exports.CONTRATO_STATUS_DO_ROADMAP = 'ork.roadmap-status/v1';
+/** Os grupos, na ordem e com os icones que o dono aprovou. */
+exports.GRUPOS_DO_ROADMAP = Object.freeze([
+    { id: 'concluidos', icone: '✅', titulo: 'Concluídos' },
+    { id: 'disponiveis', icone: '🟢', titulo: 'Disponíveis com algo em aberto' },
+    { id: 'hoje', icone: '🚀', titulo: 'Entregue hoje' },
+    { id: 'piloto', icone: '🧪', titulo: 'Piloto' },
+    { id: 'desenvolvimento', icone: '🔨', titulo: 'Em desenvolvimento' },
+    { id: 'refinamento', icone: '🔍', titulo: 'Refinamento' },
+    { id: 'proposto', icone: '🆕', titulo: 'Proposto' },
+    { id: 'descontinuado', icone: '⛔', titulo: 'Descontinuado' },
+]);
+/**
+ * D7: o grupo de cada ciclo do padrao de roadmap (`docs/padroes/roadmap-de-produto.md`). Mapa
+ * TOTAL sobre os doze ciclos; ciclo fora dele cai em "Proposto" e o texto o mostra como e.
+ */
+exports.GRUPO_DO_CICLO = Object.freeze({
+    'Concluído': 'concluidos',
+    'Disponível': 'disponiveis',
+    'Piloto': 'piloto',
+    'Em desenvolvimento': 'desenvolvimento', 'Em validação': 'desenvolvimento', 'Bloqueado': 'desenvolvimento',
+    'Refinamento': 'refinamento', 'Pronto para desenvolvimento': 'refinamento',
+    'Discovery': 'proposto', 'Backlog': 'proposto',
+    'Cancelado': 'descontinuado', 'Descontinuado': 'descontinuado',
+});
+/** Quantas linhas cada parte do fecho mostra antes de contar o resto. */
+exports.TETO_DO_FECHO = 5;
+/** A letra recomendada de uma pergunta v2, para o fecho dizer exatamente o que digitar. */
+const recomendadaDe = (p) => (0, hitl_contract_1.ehV2)(p) && p.classe === 'pergunta' ? p.alternativas.find(a => a.recomendada)?.letra : undefined;
+const mapa = (v) => (!!v && typeof v === 'object' && !Array.isArray(v) ? v : {});
+const texto = (v) => (v === undefined || v === null ? '' : String(v));
+/** O nome curto do item: o titulo ate o primeiro ":" ou 60 caracteres. */
+function nomeCurto(titulo) {
+    const antes = titulo.split(/:\s/)[0].trim();
+    return antes.length > 60 ? `${antes.slice(0, 57)}...` : antes;
+}
+/**
+ * O que espera o dono nesta thread, lido sem escrever: um gate que ainda espera (pausa do modo ou
+ * escalacao tipada do dono) ou uma pergunta de sessao aberta. Impedimento tecnico nao conta (D6).
+ */
+function esperaDoDono(raiz, t, quando) {
+    const eventos = (0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, t.id));
+    const escalacoes = [...new Set(eventos.filter(e => e.tipo === 'gate_blocked' && e.fase === t.faseAtual &&
+            hitl_gates_1.MOTIVOS_DE_ESCALACAO_HUMANA.includes(String(e.motivo)) && (0, hitl_classificacao_1.quemDecide)(String(e.motivo)) === 'dono')
+            .map(e => String(e.motivo)))];
+    for (const motivo of ['human.pending', ...escalacoes]) {
+        try {
+            const preparado = (0, hitl_gates_1.prepararPedidoGate)(raiz, t.id, motivo, quando);
+            const pedido = 'aberto' in preparado ? preparado.aberto : preparado.novo;
+            const codigo = 'aberto' in preparado ? pedido.codigo : undefined;
+            const recomendada = recomendadaDe(pedido);
+            return { thread: t.id, pergunta: (0, hitl_contract_1.textoDoPedido)(pedido), ...(typeof codigo === 'string' ? { codigo } : {}),
+                ...(recomendada ? { recomendada } : {}) };
+        }
+        catch { /* este motivo nao espera o dono agora */ }
+    }
+    const contexto = (0, hitl_gates_1.contextoHitlDosEventos)(t, eventos);
+    const respondidos = new Set(eventos.filter(e => ['human_gate', 'session_answered'].includes(e.tipo)).map(e => String(e.pedidoId)));
+    for (const e of [...eventos].reverse()) {
+        if (e.tipo !== 'hitl_requested' || e.contexto !== contexto)
+            continue;
+        const pedido = e.pedido;
+        try {
+            if ((0, hitl_contract_1.alvoDoPedido)(pedido)?.tipo !== 'session' || respondidos.has(pedido.id) || (0, hitl_contract_1.estadoDoPedido)(pedido, quando) !== 'aberto')
+                continue;
+            const codigo = (0, hitl_contract_1.ehV2)(pedido) && pedido.classe === 'pergunta' ? pedido.codigo : undefined;
+            const recomendada = recomendadaDe(pedido);
+            return { thread: t.id, pergunta: (0, hitl_contract_1.textoDoPedido)(pedido), ...(codigo ? { codigo } : {}), ...(recomendada ? { recomendada } : {}) };
+        }
+        catch { /* pedido invalido nao e espera */ }
+    }
+    return undefined;
+}
+/**
+ * Os fatos das threads deste disco: `ship_done` do dia e espera do dono lidos do ledger local.
+ * `fuso`: o do projeto consultado, na visao da rede; sem ele, o do dono deste processo.
+ */
+function fatosLocais(raiz, quando, fuso) {
+    const hoje = (0, horario_1.dataLocal)(quando, fuso);
+    const fatos = [];
+    for (const id of (0, thread_1.listarIds)(raiz)) {
+        let t;
+        try {
+            t = (0, thread_1.lerThread)(raiz, id);
+        }
+        catch {
+            continue; /* thread ilegivel fica de fora */
+        }
+        fatos.push({
+            id: t.id, roadmap: t.roadmap ?? null, aberta: t.status !== 'fechada', fase: t.faseAtual,
+            entregueHoje: () => (0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, t.id)).some(e => e.tipo === 'ship_done' && (0, horario_1.dataLocal)(e.ts, fuso) === hoje),
+            espera: () => esperaDoDono(raiz, t, quando),
+        });
+    }
+    return fatos;
+}
+/** Monta o relatorio. Leitura pura: nada e escrito, nenhum pedido e aberto. */
+function montarStatusDoRoadmap(raiz, opcoes = {}) {
+    const quando = opcoes.quando ?? new Date().toISOString();
+    return montarStatusDeFatos((0, docs_1.carregarDocs)(raiz).docs, fatosLocais(raiz, quando), { quando, projeto: opcoes.projeto, consulta: opcoes.consulta });
+}
+/** O relatorio a partir das paginas do roadmap e dos fatos das threads, de onde quer que venham. */
+function montarStatusDeFatos(docs, fatos, opcoes) {
+    const quando = opcoes.quando;
+    const porId = new Map(fatos.map(f => [f.id, f]));
+    const porItem = new Map();
+    for (const f of fatos)
+        if (f.roadmap)
+            porItem.set(f.roadmap, new Set([...(porItem.get(f.roadmap) ?? []), f.id]));
+    const itens = [];
+    for (const d of docs.filter(x => x.tipo === 'roadmap')) {
+        const estado = mapa(d.dados.estado), sdlc = mapa(d.dados.sdlc);
+        const ciclo = texto(estado.ciclo);
+        const ligadas = [...new Set([...(porItem.get(d.id) ?? []), ...(texto(sdlc.thread) ? [texto(sdlc.thread)] : [])])]
+            .filter(id => porId.has(id)).sort();
+        const entregueHoje = ligadas.some(id => porId.get(id).entregueHoje());
+        const abertas = ligadas.map(id => porId.get(id)).filter(f => f.aberta);
+        let hitl;
+        for (const f of abertas) {
+            hitl = f.espera();
+            if (hitl)
+                break;
+        }
+        const conduz = abertas[0];
+        const emAberto = exports.GRUPO_DO_CICLO[ciclo] === 'disponiveis' ? [
+            ...(texto(estado.exposicao) && texto(estado.exposicao) !== 'Geral' ? [`exposição ${texto(estado.exposicao)}`] : []),
+            ...(texto(estado.habilitacao) && texto(estado.habilitacao) !== 'Concluída' ? [`habilitação ${texto(estado.habilitacao)}`] : []),
+        ] : [];
+        itens.push({
+            id: d.id, titulo: nomeCurto(texto(d.dados.titulo) || d.id), ciclo,
+            grupo: entregueHoje ? 'hoje' : exports.GRUPO_DO_CICLO[ciclo] ?? 'proposto',
+            emAberto, threads: ligadas,
+            ...(conduz ? { conduzindo: { thread: conduz.id, fase: conduz.fase, ...(conduz.maquina ? { maquina: conduz.maquina } : {}) } } : {}),
+            ...(hitl ? { hitl } : {}),
+        });
+    }
+    const grupos = exports.GRUPOS_DO_ROADMAP.map(g => ({ ...g, itens: itens.filter(i => i.grupo === g.id) }));
+    return {
+        contrato: exports.CONTRATO_STATUS_DO_ROADMAP, consultadoEm: quando,
+        projeto: opcoes.projeto ?? 'projeto', grupos,
+        precisaDeVoce: itens.filter(i => i.hitl).map(i => ({ item: i.id, espera: i.hitl })),
+        emSeguida: itens.filter(i => i.conduzindo && !i.hitl).map(i => ({ item: i.id, ...i.conduzindo })),
+        ...(opcoes.consulta ? { consulta: opcoes.consulta } : {}),
+    };
+}
+/** "orkastery" vira "Orkastery": o titulo diz o nome do projeto como gente escreve. */
+const capitalizar = (s) => s ? s[0].toUpperCase() + s.slice(1) : s;
+/** A maquina entre parenteses, so quando o fato a traz (visao da rede, D7 da RM-054). */
+const naMaquina = (maquina) => maquina ? ` (${maquina})` : '';
+/**
+ * O texto do relatorio, igual em todo canal: os icones sao parte do formato aprovado. `fuso`: o do
+ * projeto consultado, na visao da rede; sem ele, o do dono deste processo.
+ */
+function textoDoStatusDoRoadmap(s, fuso) {
+    if (s.contrato !== exports.CONTRATO_STATUS_DO_ROADMAP)
+        throw new Error('status do roadmap: contrato inválido');
+    const p = (0, horario_1.partesLocais)(s.consultadoEm, fuso);
+    const linhaDoItem = (i) => {
+        const detalhe = i.emAberto.length ? `: ${i.emAberto.join(', ')}` : i.conduzindo && i.grupo !== 'concluidos' && i.grupo !== 'hoje'
+            ? ` (${i.conduzindo.fase}${i.conduzindo.maquina ? `, ${i.conduzindo.maquina}` : ''})` : '';
+        return `• ${i.id} ${i.titulo}${detalhe}${i.hitl ? ' #HITL' : ''}`;
+    };
+    const cortar = (lista, f) => [...lista.slice(0, exports.TETO_DO_FECHO).map(f), ...(lista.length > exports.TETO_DO_FECHO ? [`• e mais ${lista.length - exports.TETO_DO_FECHO}`] : [])];
+    return [
+        `Roadmap do ${capitalizar(s.projeto)} (${p.dia}/${p.mes}, ${p.hora}:${p.minuto})`,
+        // RM-052: logo abaixo do titulo aprovado, qual projeto foi lido e o que nao foi.
+        ...(s.consulta ? (0, projeto_alvo_1.linhasDaConsulta)(s.consulta) : []),
+        ...s.grupos.filter(g => g.itens.length).flatMap(g => ['', `${g.icone} ${g.titulo}`, ...g.itens.map(linhaDoItem)]),
+        '', 'O que precisa de você',
+        ...(s.precisaDeVoce.length ? cortar(s.precisaDeVoce, x => `• ${x.item}${naMaquina(x.espera.maquina)}: ${x.espera.pergunta}` +
+            (x.espera.codigo ? ` Responda ${x.espera.codigo} ${x.espera.recomendada ?? 'a'} (ou outra letra).` : ' A pergunta chega no próximo resumo.'))
+            : ['• Nada agora.']),
+        '', 'O que eu faço em seguida',
+        ...(s.emSeguida.length ? cortar(s.emSeguida, x => `• ${x.item}: sigo ${x.thread} na fase ${x.fase}${naMaquina(x.maquina)}.`)
+            : ['• Nada em andamento; sigo o que você priorizar.']),
+    ].join('\n');
+}

package/dist/runtime-ambiente.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ENVS_DE_PROVIDER_PAGO = void 0;
+exports.ENV_THREAD_DO_DESPACHO = exports.ENV_IDENTIDADE_DE_DESPACHO = exports.ENVS_DE_PROVIDER_PAGO = void 0;
 exports.nomesDeProviderAtivos = nomesDeProviderAtivos;
 exports.ambienteDeAssinatura = ambienteDeAssinatura;
 const hitl_public_receipt_1 = require("./hitl-public-receipt");
@@ -20,6 +20,13 @@ exports.ENVS_DE_PROVIDER_PAGO = [
 function nomesDeProviderAtivos(base = process.env) {
     return exports.ENVS_DE_PROVIDER_PAGO.filter(nome => (base[nome] ?? '').trim() !== '');
 }
+/**
+ * Identidade do despacho no ambiente da sessao filha (I-36, D4). RM-037 (defeitosdeco D-4): o domicilio
+ * dos nomes e aqui porque nenhum filho de runtime herda a identidade de quem despachou; o despacho
+ * acrescenta a sua explicitamente, e o `claude --bg` a leva por sessao em `--settings`.
+ */
+exports.ENV_IDENTIDADE_DE_DESPACHO = 'ORK_DISPATCH_ID';
+exports.ENV_THREAD_DO_DESPACHO = 'ORK_DISPATCH_THREAD';
 /** Copia, sem alterar o ambiente em que as policies ainda precisam ser avaliadas. */
 function ambienteDeAssinatura(base = process.env) {
     const env = { ...base };
@@ -31,6 +38,10 @@ function ambienteDeAssinatura(base = process.env) {
     for (const nome of Object.keys(env))
         if (nome.startsWith('ORK_HITL_'))
             delete env[nome];
+    // RM-037 (defeitosdeco D-4): a identidade herdada e de OUTRO despacho (o daemon do `claude --bg`
+    // guardava a do primeiro despacho e a passava a todas as sessoes reserva da conta).
+    delete env[exports.ENV_IDENTIDADE_DE_DESPACHO];
+    delete env[exports.ENV_THREAD_DO_DESPACHO];
     delete env[hitl_public_receipt_1.ENV_HITL_VERIFIERS];
     if (publicVerifiers)
         env[hitl_public_receipt_1.ENV_HITL_VERIFIERS] = publicVerifiers;