@orkastery/cli 0.5.0 → 0.5.3

package/dist/entrega-pr.js

@@ -16,7 +16,9 @@ exports.registrarEntregasPorPr = registrarEntregasPorPr;
  * remota (ancestralidade conferida contra a ponta que o `ls-remote` devolve) e o check do CI no
  * head do PR. Sem CI verde, nao registra: merge sem prova independente nao e entrega.
  */
+const branch_de_estado_1 = require("./branch-de-estado");
 const ci_1 = require("./ci");
+const docs_1 = require("./docs");
 const fabrica_publicar_1 = require("./fabrica-publicar");
 const ledger_1 = require("./ledger");
 const modos_1 = require("./modos");
@@ -49,7 +51,7 @@ function avancarParaShip(raiz, threadId) {
     (0, thread_1.gravarThread)(raiz, atualizada);
 }
 function resultado(thread, acao, motivo, extra = {}) {
-    return { thread, acao, motivo, mergeSha: null, headSha: null, ci: null, ...extra };
+    return { thread, acao, motivo, mergeSha: null, headSha: null, ci: null, docsPendentes: [], ...extra };
 }
 /**
  * `ork ship registrar-pr <thread>`: grava o `ship_done` da entrega feita por PR. Idempotente:
@@ -57,22 +59,26 @@ function resultado(thread, acao, motivo, extra = {}) {
  */
 function registrarEntregaPorPr(carregado, threadId, opcoes = {}) {
     const raiz = carregado.raiz;
-    const remoto = opcoes.remoto ?? 'origin';
+    // RM-047: o `--remoto` vem da linha de comando; so nome de remoto chega ao git, e depois do `--`.
+    const remoto = (0, branch_de_estado_1.exigirRemoto)(opcoes.remoto ?? 'origin', 'ship');
     const base = carregado.manifesto.worktree.base_branch;
     const thread = (0, thread_1.lerThread)(raiz, threadId);
     if (thread.status === 'fechada')
         return resultado(threadId, 'ja-registrada', 'thread ja fechada');
     if (opcoes.buscar !== false)
-        (0, util_1.exec)('git', ['fetch', '-q', remoto, `+refs/heads/${base}:refs/remotes/${remoto}/${base}`], raiz);
-    const merge = mergeDaEntrega(raiz, threadId, remoto, base);
-    if (!merge)
+        (0, util_1.exec)('git', ['fetch', '-q', '--', remoto, `+refs/heads/${base}:refs/remotes/${remoto}/${base}`], raiz);
+    const encontrado = mergeDaEntrega(raiz, threadId, remoto, base);
+    if (!encontrado)
         return resultado(threadId, 'sem-merge', `nenhum merge ship(${threadId}) em ${remoto}/${base}`);
+    // RM-044 (A3): o condutor roda o registrar-pr logo depois do merge; e aqui que ele fica sabendo da pagina que
+    // vai deixar o push da base vermelho, lida da base remota que o fetch acabou de trazer.
+    const merge = { ...encontrado, docsPendentes: (0, docs_1.docsPendentesDoMerge)(raiz, threadId, `refs/remotes/${remoto}/${base}`) };
     const dir = (0, thread_1.dirThread)(raiz, threadId);
     const jaTem = (0, ledger_1.lerLedger)(dir).some((e) => e.tipo === ledger_1.TIPOS_DE_EVENTO.shipConcluido && e.mergeSha === merge.mergeSha);
     if (jaTem)
         return resultado(threadId, 'ja-registrada', 'esta entrega ja tem ship_done', merge);
     // A ponta do remoto AGORA, e o merge dentro dela: e o que torna o push provado, nao presumido.
-    const remotoAgora = (0, util_1.exec)('git', ['ls-remote', remoto, `refs/heads/${base}`], raiz);
+    const remotoAgora = (0, util_1.exec)('git', ['ls-remote', '--', remoto, `refs/heads/${base}`], raiz);
     const ponta = remotoAgora.ok ? remotoAgora.stdout.split('\t')[0].trim() : '';
     if (!ponta || !(0, util_1.exec)('git', ['merge-base', '--is-ancestor', merge.mergeSha, ponta], raiz).ok) {
         return resultado(threadId, 'recusada', `o merge ${merge.mergeSha.slice(0, 7)} nao esta na ponta de ${remoto}/${base}`, merge);
@@ -81,11 +87,18 @@ function registrarEntregaPorPr(carregado, threadId, opcoes = {}) {
     if (ci.required && !ci.ok) {
         return resultado(threadId, 'recusada', `sem CI verde no head do PR: ${ci.detail}`, { ...merge, ci });
     }
+    // RM-037 (fatia 3, defeito 6): o ensaio confere tudo e para aqui, sem ledger, fase nem fabrica.
+    if (opcoes.dryRun) {
+        return resultado(threadId, 'registraria', `ensaio: registraria ship_done pelo merge ${merge.mergeSha.slice(0, 7)} do PR (nada gravado)`, { ...merge, ci });
+    }
     (0, ledger_1.registrar)(dir, threadId, ledger_1.TIPOS_DE_EVENTO.shipConcluido, {
         de: thread.base?.branch ?? null,
         para: base,
         shaDe: merge.headSha,
         mergeSha: merge.mergeSha,
+        // RM-037 (fatia 5, A1): a ponta que o ls-remote provou vai em campo proprio; o recibo do Maestro confere o push
+        // contra ela quando a base andou depois do merge.
+        pontaDaBase: ponta,
         jaIncorporado: true,
         remoto,
         shaRemoto: ponta,
@@ -174,6 +187,9 @@ function registrarEntregaExternaPorPr(carregado, threadId, opcoes) {
     if (ci && !ci.ok) {
         return resultado(threadId, 'recusada', `sem CI verde no head do PR: ${ci.detail}`, { mergeSha, headSha, ci });
     }
+    if (opcoes.dryRun) {
+        return resultado(threadId, 'registraria', `ensaio: registraria ship_done pelo merge ${mergeSha.slice(0, 7)} do PR #${n} de ${repo} (nada gravado)`, { mergeSha, headSha, ci });
+    }
     (0, ledger_1.registrar)(dir, threadId, ledger_1.TIPOS_DE_EVENTO.shipConcluido, {
         de: thread.base?.branch ?? null,
         para: `${repo}:${base}`,
@@ -182,6 +198,9 @@ function registrarEntregaExternaPorPr(carregado, threadId, opcoes) {
         url: pr.html_url ?? `https://github.com/${repo}/pull/${n}`,
         shaDe: headSha,
         mergeSha,
+        // RM-037 (fatia 5, A1; aviso da rodada 1 do CHECK): a ponta conferida vai em campo proprio, como no PR local; a
+        // comparacao aceita `ahead`, e o recibo do Maestro confere o push contra ela.
+        pontaDaBase: ponta,
         jaIncorporado: true,
         remoto: `github:${repo}`,
         shaRemoto: ponta,
@@ -200,9 +219,9 @@ function registrarEntregaExternaPorPr(carregado, threadId, opcoes) {
 }
 /** `ork ship registrar-pr --todas`: toda thread aberta que ja tem merge `ship(<thread>)` na base. */
 function registrarEntregasPorPr(carregado, opcoes = {}) {
-    const remoto = opcoes.remoto ?? 'origin';
+    const remoto = (0, branch_de_estado_1.exigirRemoto)(opcoes.remoto ?? 'origin', 'ship');
     const base = carregado.manifesto.worktree.base_branch;
-    (0, util_1.exec)('git', ['fetch', '-q', remoto, `+refs/heads/${base}:refs/remotes/${remoto}/${base}`], carregado.raiz);
+    (0, util_1.exec)('git', ['fetch', '-q', '--', remoto, `+refs/heads/${base}:refs/remotes/${remoto}/${base}`], carregado.raiz);
     const r = (0, thread_1.listarIds)(carregado.raiz)
         .filter((id) => (0, thread_1.lerThread)(carregado.raiz, id).status !== 'fechada')
         .filter((id) => mergeDaEntrega(carregado.raiz, id, remoto, base) !== null)

package/dist/esgotamentos.js

@@ -0,0 +1,181 @@
+"use strict";
+/**
+ * RM-040 (B7): `ork accounts esgotamentos`, a medida da metrica do item.
+ *
+ * A metrica da RM-040 e "zero despacho numa conta que outro projeto do mesmo usuario ja viu
+ * esgotada, dentro do prazo dela". Este relatorio so le: as marcas do registro compartilhado
+ * (`~/.orkastery/private/contas.json`) e os `phase_dispatch` com perfil dos ledgers de cada projeto
+ * registrado nesta maquina (`~/.orkastery/projetos.json`). Conta o despacho que caiu na conta de
+ * uma marca, dentro da janela dela, vindo de projeto diferente do que marcou.
+ *
+ * A saida nunca leva diretorio de conta: a conta vira um id opaco (sha256 da chave, 12 hex), o
+ * projeto sai pelo nome registrado e o perfil, pelo id.
+ *
+ * Limite declarado: o registro so guarda as marcas vivas. Uso bem sucedido, login reconferido e
+ * prazo vencido apagam a marca na gravacao seguinte; por isso o numero e um piso, e a leitura vale
+ * enquanto a marca existe.
+ */
+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.NAO_REGISTRADO = exports.LIMITE_DO_RELATORIO = exports.CONTRATO_ESGOTAMENTOS = void 0;
+exports.contaOpaca = contaOpaca;
+exports.fimDaJanela = fimDaJanela;
+exports.relatorioDeEsgotamentos = relatorioDeEsgotamentos;
+exports.textoDosEsgotamentos = textoDosEsgotamentos;
+const node_crypto_1 = require("node:crypto");
+const fs = __importStar(require("node:fs"));
+const horario_1 = require("./horario");
+const ledger_1 = require("./ledger");
+const ledger_stats_1 = require("./ledger-stats");
+const projeto_alvo_1 = require("./projeto-alvo");
+const runtime_profiles_1 = require("./runtime-profiles");
+const thread_1 = require("./thread");
+const util_1 = require("./util");
+exports.CONTRATO_ESGOTAMENTOS = 'ork.esgotamentos/v1';
+exports.LIMITE_DO_RELATORIO = 'o registro guarda so as marcas vivas (uso bem sucedido, login reconferido e prazo vencido ' +
+    'apagam a marca): o total e um piso, valido enquanto a marca existe';
+exports.NAO_REGISTRADO = 'nao registrado';
+function contaOpaca(chave) {
+    return (0, node_crypto_1.createHash)('sha256').update(chave).digest('hex').slice(0, 12);
+}
+function caminhoReal(p) {
+    try {
+        return fs.realpathSync(p);
+    }
+    catch {
+        return p;
+    }
+}
+/** Fim da janela da marca: o prazo para cota esgotada; sem prazo (login, credencial paga), aberta. */
+function fimDaJanela(m) {
+    if (m.estado !== 'esgotado')
+        return Number.POSITIVE_INFINITY;
+    const ate = m.esgotadoAte === null ? NaN : Date.parse(m.esgotadoAte);
+    return Number.isFinite(ate) ? ate : Number.NEGATIVE_INFINITY;
+}
+function relatorioDeEsgotamentos(opcoes = {}) {
+    const agoraMs = opcoes.agoraMs ?? Date.now();
+    const desdeMs = (0, ledger_stats_1.parsePeriodo)(opcoes.desde ?? '7d', agoraMs);
+    if (desdeMs >= agoraMs)
+        throw Error('ledger.period.order');
+    // Um projeto por raiz real: o registro pode trazer a mesma copia por dois caminhos.
+    const vistos = new Set();
+    const projetos = (0, projeto_alvo_1.listarProjetos)().filter((p) => {
+        const real = caminhoReal(p.raiz);
+        if (vistos.has(real))
+            return false;
+        vistos.add(real);
+        return true;
+    }).map((p) => ({ ...p, real: caminhoReal(p.raiz) }));
+    const nomeDaRaiz = (raiz) => projetos.find((p) => p.real === caminhoReal(raiz))?.nome ?? exports.NAO_REGISTRADO;
+    const contas = (0, runtime_profiles_1.lerContasCompartilhadas)();
+    const marcas = contas.map((c) => ({ c, real: caminhoReal(c.projeto), inicio: Date.parse(c.em), fim: fimDaJanela(c) }));
+    const despachos = [];
+    const lidos = [];
+    for (const p of projetos) {
+        let comPerfil = 0;
+        let ids = [];
+        try {
+            ids = p.presente ? (0, thread_1.listarIds)(p.raiz) : [];
+        }
+        catch {
+            ids = [];
+        }
+        for (const id of ids) {
+            let eventos = [];
+            try {
+                eventos = (0, ledger_1.lerLedger)((0, thread_1.dirThread)(p.raiz, id));
+            }
+            catch {
+                continue;
+            }
+            for (const e of eventos) {
+                if (e.tipo !== 'phase_dispatch' || e.perfil === undefined || e.perfil === null)
+                    continue;
+                const t = Date.parse(String(e.ts));
+                if (!Number.isFinite(t) || t < desdeMs || t >= agoraMs)
+                    continue;
+                let perfil, chave;
+                try {
+                    perfil = (0, runtime_profiles_1.validarPerfilDeDespacho)(e.perfil);
+                    chave = (0, runtime_profiles_1.chaveDaConta)(perfil);
+                }
+                catch {
+                    continue;
+                }
+                comPerfil++;
+                const marca = marcas.find((m) => m.c.chave === chave && m.real !== p.real && t >= m.inicio && t < m.fim);
+                if (!marca)
+                    continue;
+                despachos.push({ em: new Date(t).toISOString(), projeto: p.nome, thread: String(e.thread ?? id),
+                    fase: typeof e.fase === 'string' ? e.fase : null, runtime: perfil.runtime, perfil: perfil.id,
+                    conta: contaOpaca(chave), marcadaPor: nomeDaRaiz(marca.c.projeto) });
+            }
+        }
+        lidos.push({ nome: p.nome, presente: p.presente, despachosComPerfil: comPerfil });
+    }
+    despachos.sort((a, b) => a.em.localeCompare(b.em));
+    return {
+        contrato: exports.CONTRATO_ESGOTAMENTOS,
+        periodo: { desde: new Date(desdeMs).toISOString(), ate: new Date(agoraMs).toISOString(), intervalo: '[desde,ate)' },
+        marcas: contas.map((c) => ({ conta: contaOpaca(c.chave), runtime: c.chave.slice(0, c.chave.indexOf(':')), estado: c.estado,
+            motivo: c.motivo, em: c.em, esgotadoAte: c.esgotadoAte, projeto: nomeDaRaiz(c.projeto) })),
+        projetos: lidos,
+        despachos,
+        total: despachos.length,
+        limite: exports.LIMITE_DO_RELATORIO,
+    };
+}
+/** Texto para o terminal, com o horario do dono e o fuso uma vez no fim. */
+function textoDosEsgotamentos(r) {
+    const linhas = [
+        `Esgotamentos de conta  ${(0, horario_1.formatarDataHora)(r.periodo.desde)} ate ${(0, horario_1.formatarDataHora)(r.periodo.ate)} ${r.periodo.intervalo}`,
+        `  marcas vivas no registro: ${r.marcas.length}`,
+    ];
+    for (const m of r.marcas) {
+        const ate = m.estado === 'esgotado' ? `ate ${(0, horario_1.formatarDataHora)(m.esgotadoAte)}` : 'sem prazo';
+        linhas.push(`    conta ${m.conta}  ${m.runtime}  ${m.estado} desde ${(0, horario_1.formatarDataHora)(m.em)}, ${ate}  visto em ${m.projeto} (${m.motivo})`);
+    }
+    linhas.push(`  projetos lidos: ${r.projetos.length === 0 ? 'nenhum registrado'
+        : r.projetos.map((p) => `${p.nome} (${p.presente ? `${p.despachosComPerfil} despacho(s) com perfil` : 'fora do disco'})`).join(', ')}`);
+    linhas.push(`  despachos em conta marcada por outro projeto: ${r.total}`);
+    if (r.despachos.length > 0) {
+        linhas.push((0, util_1.tabela)(['QUANDO', 'PROJETO', 'THREAD', 'FASE', 'PERFIL', 'CONTA', 'MARCADA POR'], r.despachos.map((d) => [(0, horario_1.formatarDataHora)(d.em), d.projeto, d.thread, d.fase ?? '-', d.perfil, d.conta, d.marcadaPor]))
+            .split('\n').map((l) => `    ${l}`).join('\n'));
+    }
+    linhas.push(`  limite: ${r.limite}`);
+    linhas.push((0, horario_1.legendaDoFuso)());
+    return linhas.join('\n');
+}

package/dist/experiencia.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.IDIOMA_PADRAO = void 0;
 exports.normalizarIdioma = normalizarIdioma;
 exports.validarPreferencias = validarPreferencias;
 exports.idiomaDoSistema = idiomaDoSistema;
@@ -44,6 +45,11 @@ function validarPreferencias(valor) {
     }
     return resultado;
 }
+/**
+ * Ensaio de 03/10 (R2): sem idioma escolhido, vale a língua da CLI. Antes era en-US, e uma máquina com
+ * LANG=C.UTF-8 (contêiner, CI, servidor) recebia a experiência em inglês de uma CLI que fala português.
+ */
+exports.IDIOMA_PADRAO = 'pt-BR';
 /** C, POSIX e und (raiz do ICU) dizem que o sistema não escolheu idioma: vale o padrão. */
 const SEM_IDIOMA = new Set(['c', 'posix', 'und']);
 function idiomaEscolhido(valor) {
@@ -52,11 +58,15 @@ function idiomaEscolhido(valor) {
 }
 function idiomaDoSistema(env = process.env, doIntl = () => Intl.DateTimeFormat().resolvedOptions().locale) {
     const locale = env.LC_ALL || env.LC_MESSAGES || env.LANG;
-    return idiomaEscolhido(locale?.split(/[.@]/)[0].replace(/_/g, '-')) ?? idiomaEscolhido(doIntl()) ?? 'en-US';
+    if (locale) {
+        // Com C ou POSIX explícito, o Intl do Node cai no en-US do ICU: ele não diz a escolha de ninguém.
+        return idiomaEscolhido(locale.split(/[.@]/)[0].replace(/_/g, '-')) ?? exports.IDIOMA_PADRAO;
+    }
+    return idiomaEscolhido(doIntl()) ?? exports.IDIOMA_PADRAO;
 }
 function resolverExperiencia(owner = {}, sistema = { language: idiomaDoSistema(), timezone: (0, horario_1.fusoDoSistema)() }) {
     const p = validarPreferencias(owner);
-    const language = p.language ?? normalizarIdioma(sistema.language) ?? 'en-US';
+    const language = p.language ?? normalizarIdioma(sistema.language) ?? exports.IDIOMA_PADRAO;
     return {
         language, timezone: p.timezone ?? (0, horario_1.normalizarFuso)(sistema.timezone) ?? 'UTC',
         depth: p.depth ?? 'curta', experience: p.experience ?? true,

package/dist/fabrica-estado.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PULSACAO_MS = exports.DIR_DA_FABRICA = exports.BRANCH_DA_FABRICA = exports.CONTRATO_MAQUINA = void 0;
+exports.LIMIAR_SEM_BATIDA_MS = exports.PULSACAO_MS = exports.DIR_DA_FABRICA = exports.BRANCH_DA_FABRICA = exports.CONTRATO_MAQUINA = void 0;
 exports.despachoDaThread = despachoDaThread;
 exports.runtimeDaThread = runtimeDaThread;
 exports.arquivoDaMaquina = arquivoDaMaquina;
@@ -76,10 +76,12 @@ const horario_1 = require("./horario");
 const ledger_1 = require("./ledger");
 const modos_1 = require("./modos");
 const orquestracao_1 = require("./orquestracao");
+const parado_no_condutor_1 = require("./parado-no-condutor");
 const roadmap_reservas_1 = require("./roadmap-reservas");
 const thread_1 = require("./thread");
 const util_1 = require("./util");
 const versao_1 = require("./versao");
+const saida_segura_1 = require("./saida-segura");
 exports.CONTRATO_MAQUINA = 'ork.fabrica-maquina/v1';
 exports.BRANCH_DA_FABRICA = 'ork/fabrica-estado';
 /** O diretorio dos retratos na branch; a leitura sem clone (RM-054) le o mesmo. */
@@ -90,6 +92,12 @@ const PREFIXO = 'fabrica';
 const TENTATIVAS = 5;
 /** Retrato igual ao ultimo publicado so volta ao remoto depois disto: e o sinal de vida da maquina. */
 exports.PULSACAO_MS = 60 * 60 * 1000;
+/**
+ * Maquina sem retrato novo ha mais disto esta sem batida: o mesmo limiar da rede (RM-053, `SEM_BATIDA_MS`).
+ * RM-037 (fatia 4): mora aqui, junto da pulsacao, porque o status do roadmap tambem o le; o panorama da
+ * rede o reexporta.
+ */
+exports.LIMIAR_SEM_BATIDA_MS = 3 * 60 * 60 * 1000;
 const ARQUIVO_DA_MARCA = 'fabrica-publicada.json';
 const ARQUIVO_DO_LOG = 'fabrica.log';
 /** O trio do ultimo `phase_dispatch` do ledger da thread; tudo `null` quando nao ha despacho legivel. */
@@ -155,9 +163,20 @@ function retratoDaMaquina(carregado, opcoes = {}) {
     const entregas = entregasNaBase(raiz, carregado.manifesto.worktree.base_branch, remoto);
     const itemDaThread = new Map((0, roadmap_reservas_1.reservasLocais)(raiz, remoto).filter((r) => r.thread).map((r) => [r.thread, r.item]));
     const threads = itens.map(({ thread: t, raiz: raizDoPerfil }) => {
-        const pausa = linhas.get(t.id)?.pausas[0];
         const entregue = entregas.get(t.id) ?? null;
-        const esperaVoce = !entregue && linhas.get(t.id)?.precisaDeHumano === true;
+        // RM-037 (fatia 4): o fim de turno sem pergunta e do condutor, e as outras maquinas nao o leem como espera
+        // do dono. Sai so a pausa que o observador abriu nele; outra pausa da thread continua contando.
+        let espera = null;
+        try {
+            espera = (0, parado_no_condutor_1.esperaDoCondutor)(t, (0, ledger_1.lerLedger)((0, thread_1.dirThread)(raizDoPerfil, t.id)), quando);
+        }
+        catch {
+            espera = null;
+        }
+        const pausas = (linhas.get(t.id)?.pausas ?? []).filter((p) => !(espera && p.motivo === 'human.pending' && p.fonte === 'ledger' &&
+            p.fase === (espera.fase ?? t.faseAtual)));
+        const pausa = pausas[0];
+        const esperaVoce = !entregue && pausas.some((p) => p.sessaoViva !== true);
         return {
             id: t.id, nome: curto(t.nome, 100), modo: (0, modos_1.tagDoModo)(t.modo), fase: t.faseAtual, status: t.status,
             roadmap: t.roadmap ?? itemDaThread.get(t.id) ?? null, branch: t.base?.branch ?? null,
@@ -216,7 +235,8 @@ function gravarMarca(raiz, marca) {
  */
 function publicarMaquina(carregado, opcoes = {}) {
     const raiz = carregado.raiz;
-    const remoto = opcoes.remoto ?? carregado.manifesto.fabrica.remoto;
+    // RM-047: antes do retrato e da marca, para o remoto invalido recusar mesmo sem mudanca a enviar.
+    const remoto = (0, branch_de_estado_1.exigirRemoto)(opcoes.remoto ?? carregado.manifesto.fabrica.remoto, PREFIXO);
     const estado = retratoDaMaquina(carregado, { ...opcoes, remoto });
     const assinatura = assinaturaDoRetrato(estado);
     const marca = lerMarca(raiz);
@@ -256,7 +276,7 @@ function publicarMaquina(carregado, opcoes = {}) {
 /** `ork fabrica sair`: tira o retrato desta maquina da branch. `null` quando nao havia retrato. */
 function removerMaquina(carregado, opcoes = {}) {
     const raiz = carregado.raiz;
-    const remoto = opcoes.remoto ?? carregado.manifesto.fabrica.remoto;
+    const remoto = (0, branch_de_estado_1.exigirRemoto)(opcoes.remoto ?? carregado.manifesto.fabrica.remoto, PREFIXO);
     const maquina = (0, roadmap_reservas_1.quemSouEu)(raiz, { maquina: opcoes.maquina }).maquina;
     for (let tentativa = 1; tentativa <= TENTATIVAS; tentativa++) {
         const { ponta, atualizado } = (0, branch_de_estado_1.buscarBranch)(raiz, remoto, exports.BRANCH_DA_FABRICA, PREFIXO, 30000);
@@ -313,8 +333,13 @@ function blocoDaMaquina(m, eu) {
             t.id, t.modo, t.fase, runtimeDaThread(t), t.roadmap ?? '-', t.esperaVoce ? `sim: ${curto(t.pergunta ?? 'veredito', 40)}` : '-',
         ]))];
 }
-/** `ork fabrica`: todas as maquinas. */
-function textoDaFabrica(p, eu) {
+/**
+ * `ork fabrica`: todas as maquinas. RM-053 (fatia 2): o painel vem do remoto, onde outras pessoas
+ * escrevem; cada valor dele (o `por`, o `projeto`, a pergunta) chega a tela numa linha so, sem nada
+ * que o terminal execute.
+ */
+function textoDaFabrica(painel, eu) {
+    const p = (0, saida_segura_1.valoresEmUmaLinha)(painel);
     const linhas = [];
     if (!p.atualizado)
         linhas.push('AVISO: sem leitura nova do remoto; esta e a ultima copia lida nesta maquina.', '');
@@ -327,8 +352,9 @@ function textoDaFabrica(p, eu) {
     linhas.push((0, horario_1.legendaDoFuso)());
     return linhas.join('\n');
 }
-/** A secao de `ork board` com as outras maquinas. */
-function textoDasOutrasMaquinas(p, eu) {
+/** A secao de `ork board` com as outras maquinas, saneada como o `ork fabrica`. */
+function textoDasOutrasMaquinas(painel, eu) {
+    const p = (0, saida_segura_1.valoresEmUmaLinha)(painel);
     const outras = p.maquinas.filter((m) => m.maquina !== eu);
     const origem = p.atualizado ? 'lido agora' : 'ultima copia local';
     if (outras.length === 0)

package/dist/fabrica-publicar.js

@@ -39,18 +39,24 @@ exports.publicarEmSegundoPlano = publicarEmSegundoPlano;
  *
  * Modulo a parte, com o minimo de dependencias, porque quem chama (despacho de fase, entrega,
  * thread nova) nao pode esperar rede nem arrastar o retrato inteiro para dentro de si.
+ *
+ * RM-053 (D9): o mesmo evento tambem dispara o retrato desta maquina na rede da pessoa, pela
+ * `rede-adesao` (tao leve quanto este modulo): so membro, no maximo uma vez a cada 14 minutos.
  */
 const node_child_process_1 = require("node:child_process");
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const maquina_1 = require("./maquina");
 const manifest_1 = require("./manifest");
+const rede_adesao_1 = require("./rede-adesao");
 /**
  * Publica sem segurar quem chamou (thread nova, despacho de fase, entrega). So com a fabrica
  * compartilhada nesta maquina (`ork fabrica entrar`) ou no projeto; `ORK_FABRICA_PUBLICAR=0`
  * desliga (testes e `ork eval`).
  */
 function publicarEmSegundoPlano(raiz) {
+    // A rede decide por si (adesao, teto e ambiente); o retorno continua sendo o da fabrica.
+    (0, rede_adesao_1.publicarRedeEmSegundoPlano)({ diretorio: raiz });
     if (process.env.ORK_FABRICA_PUBLICAR === '0')
         return false;
     let carregado;

package/dist/fechamento.js

@@ -1,37 +1,4 @@
 "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.liberarAoFechar = liberarAoFechar;
 /**
@@ -43,61 +10,48 @@ exports.liberarAoFechar = liberarAoFechar;
  * derruba. Cada parte roda isolada (achado A1 do CHECK 1): erro de E/S numa nao impede a outra, e o
  * que nao saiu agora sai na poda do proximo pedido de regiao ou no `ork roadmap reservas --soltar-orfas`.
  */
-const fs = __importStar(require("node:fs"));
-const path = __importStar(require("node:path"));
-const estado_thread_1 = require("./estado-thread");
 const ledger_1 = require("./ledger");
 const leases_1 = require("./leases");
 const roadmap_reservas_1 = require("./roadmap-reservas");
+const sessoes_1 = require("./sessoes");
 const thread_1 = require("./thread");
 function liberarAoFechar(raiz, threadId) {
-    const saida = { leases: [], fila: [], reservas: [], falhas: [] };
+    const saida = { leases: [], fila: [], reservas: [], sessoes: [], falhas: [] };
     const falhou = (parte, e) => saida.falhas.push(`${parte}: ${e?.message ?? String(e)}`);
-    // Os leases de regiao sao por checkout: o de quem fecha, a raiz do projeto e, quando a thread tem
-    // worktree, os pegos de la (sugestao 6 do CHECK 2: fechar da worktree tambem solta os da raiz).
-    const real = (p) => { try {
-        return fs.realpathSync(p);
-    }
-    catch {
-        return path.resolve(p);
-    } };
-    const candidatos = [raiz];
+    // RM-036 (D6): os leases de regiao moram todos no estado canonico, chamado de qualquer checkout, e a
+    // soltura de la ja alcanca o legado que a versao anterior gravou nas worktrees. Uma soltura basta.
     try {
-        candidatos.push((0, estado_thread_1.raizDoEstado)(raiz));
+        const solto = (0, leases_1.soltarThreadFechada)(raiz, threadId, 'fechamento');
+        saida.leases.push(...solto.leases);
+        saida.fila.push(...solto.fila);
     }
     catch (e) {
-        falhou('raiz', e);
+        falhou(`leases em ${raiz}`, e);
     }
     try {
-        const wt = (0, thread_1.lerThread)(raiz, threadId).worktree;
-        if (wt && fs.existsSync(wt))
-            candidatos.push(wt);
+        saida.reservas = (0, roadmap_reservas_1.soltarReservaDaThread)(raiz, threadId);
     }
     catch (e) {
-        falhou('thread', e);
-    }
-    const checkouts = candidatos.filter((c, i) => candidatos.findIndex((x) => real(x) === real(c)) === i);
-    for (const checkout of checkouts) {
-        try {
-            const solto = (0, leases_1.soltarThreadFechada)(checkout, threadId, 'fechamento');
-            saida.leases.push(...solto.leases);
-            saida.fila.push(...solto.fila);
-        }
-        catch (e) {
-            falhou(`leases em ${checkout}`, e);
-        }
+        falhou('reserva', e);
     }
+    // RM-056 (ao fechar): a sessao fantasma presa a thread fechada seguia no inventario e no doctor ate
+    // alguem rodar `ork sessions limpar-fantasmas` (624f65db e d38ae1d4, 03/10). So consulta o runtime
+    // quando o ledger tem sessao sem fim; nunca para nem remove nada no runtime, e sessao viva fica.
     try {
-        saida.reservas = (0, roadmap_reservas_1.soltarReservaDaThread)(raiz, threadId);
+        if ((0, sessoes_1.sessoesSemFim)(raiz, threadId).length > 0) {
+            const r = (0, sessoes_1.limparFantasmas)(raiz, { thread: threadId, origem: 'fechamento' });
+            saida.sessoes = r.itens.filter((i) => i.acao === 'solto');
+        }
     }
     catch (e) {
-        falhou('reserva', e);
+        falhou('sessoes', e);
     }
     // Sugestao 2 do CHECK 2: a falha tambem vai ao ledger da thread, de melhor esforco.
     if (saida.falhas.length > 0) {
         try {
             (0, ledger_1.registrarSeExiste)((0, thread_1.dirThread)(raiz, threadId), threadId, ledger_1.TIPOS_DE_EVENTO.solturaFalhou, { falhas: saida.falhas,
-                correcao: 'a poda do proximo pedido de regiao solta o que ficou; reserva: ork roadmap reservas --soltar-orfas' });
+                correcao: 'a poda do proximo pedido de regiao solta o que ficou; reserva: ork roadmap reservas --soltar-orfas; ' +
+                    'sessao fantasma: ork sessions limpar-fantasmas' });
         }
         catch { /* o ledger que nao grava ja esta nas falhas */ }
     }

package/dist/fix.js

@@ -150,7 +150,7 @@ function derivarCorrecoes(thread, rodada, resultado, idsUsados) {
     }
     for (const cmd of resultado.regressoes) {
         nascer('verify.regression', `comando ${cmd.nome}`, `REGRESSAO: "${cmd.comando}" passava na baseline gravada antes do GO (commit ` +
-            `${resultado.baseline?.commit.slice(0, 8) ?? 'desconhecido'}) e falha agora. Este defeito ` +
+            `${resultado.baseline ? (0, util_1.shaCurto)(resultado.baseline.commit) : 'desconhecido'}) e falha agora. Este defeito ` +
             'e desta thread, nao divida pre-existente. Corrija ate o comando voltar a passar.', [cmd.comando], `codigo ${cmd.code}:\n${cmd.resumo}`);
     }
     for (const cmd of resultado.falhasSemBaseline) {
@@ -339,7 +339,7 @@ function reverificarSobConducao(carregado, threadId, opcoes) {
         veredito = 'PASSOU';
         razao =
             `${vereditos.length} correcao(oes) aprovada(s) por comando reexecutado no HEAD real` +
-                (verify ? `, com o verify completo verde no commit ${verify.commit.slice(0, 8)}` : '');
+                (verify ? `, com o verify completo verde no commit ${(0, util_1.shaCurto)(verify.commit)}` : '');
     }
     else if (rodadas >= limite) {
         veredito = 'BLOQUEADO';
@@ -459,7 +459,7 @@ function textoDoReverify(r) {
     }
     if (r.verify) {
         linhas.push('');
-        linhas.push(`Verify completo no HEAD ${r.verify.commit.slice(0, 8)}: ${r.verify.ok ? 'verde' : `reprovado (${r.verify.motivos.join(', ')})`}`);
+        linhas.push(`Verify completo no HEAD ${(0, util_1.shaCurto)(r.verify.commit)}: ${r.verify.ok ? 'verde' : `reprovado (${r.verify.motivos.join(', ')})`}`);
     }
     linhas.push('');
     linhas.push(`Veredito final: ${r.veredito}`);