@orkastery/cli 0.5.1 → 0.5.6

package/dist/fabrica-batida.js

@@ -0,0 +1,310 @@
+"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.CRONTAB_DO_SISTEMA = exports.MARCA_DA_BATIDA = exports.ultimaRodadaDaVarredura = exports.ATRASO_DA_BATIDA_MIN = void 0;
+exports.gravarCrontabDoSistema = gravarCrontabDoSistema;
+exports.caminhoDaBatida = caminhoDaBatida;
+exports.scriptDaBatida = scriptDaBatida;
+exports.linhaDaBatida = linhaDaBatida;
+exports.linhaGerenciada = linhaGerenciada;
+exports.estadoDaBatida = estadoDaBatida;
+exports.instalarBatida = instalarBatida;
+exports.removerBatida = removerBatida;
+exports.textoDoEstadoDaBatida = textoDoEstadoDaBatida;
+exports.textoDoResultadoDaBatida = textoDoResultadoDaBatida;
+/**
+ * RM-063 (F1): a batida da fabrica, instalada e vigiada pelo proprio `ork`.
+ *
+ * Incidente do maquina-b, de 03/10 a 12/10/2026 (P1 e P7 da pagina da RM-063): o cron da varredura do
+ * pulse nunca foi instalado, o `ork doctor` so conferia o crontab com `pulse-host.json` e, sem
+ * transporte, calava; a correcao (editar o crontab) foi barrada como persistencia nao autorizada. A
+ * maquina ficou nove dias sem batida e ninguem soube.
+ *
+ * `ork fabrica batida instalar|status|remover` e o comando que o dono autoriza uma vez: instala a linha
+ * do template `monitor/pulse.cron` com o checkout canonico e o PATH que acha o `node`, o `claude` e o
+ * transporte, preserva as outras entradas do crontab e grava o evento no ledger da maquina
+ * (`~/.orkastery/ledger.jsonl`). A linha e marcada (`# ork-batida`) e diz o projeto
+ * (`ORK_PULSE_PROJECT`): e por elas que o `remover` tira so a linha dela.
+ *
+ * O crontab nunca e gravado sem ter sido lido, e a gravacao so vale depois de relida. O executor e
+ * injetado: os testes usam um crontab falso e nunca tocam no da maquina.
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const doctor_pulse_cron_1 = require("./doctor-pulse-cron");
+var doctor_pulse_cron_2 = require("./doctor-pulse-cron");
+Object.defineProperty(exports, "ATRASO_DA_BATIDA_MIN", { enumerable: true, get: function () { return doctor_pulse_cron_2.ATRASO_DA_BATIDA_MIN; } });
+Object.defineProperty(exports, "ultimaRodadaDaVarredura", { enumerable: true, get: function () { return doctor_pulse_cron_2.ultimaRodadaDaVarredura; } });
+const estado_thread_1 = require("./estado-thread");
+const ledger_1 = require("./ledger");
+const maquina_1 = require("./maquina");
+const horario_1 = require("./horario");
+const util_1 = require("./util");
+const procedencia_1 = require("./procedencia");
+/** O comentario no fim da linha que o `ork` instalou; o `sh` do cron o ignora. */
+exports.MARCA_DA_BATIDA = '# ork-batida';
+/** Os binarios que a varredura chama, alem do `node`: o runtime, a forja e o git. */
+const BINARIOS_DA_VARREDURA = ['claude', 'codex', 'gh', 'git'];
+const PATH_DO_SISTEMA = ['/usr/local/bin', '/usr/bin', '/bin'];
+/** `crontab -` com o texto no stdin, sem shell e com prazo. */
+function gravarCrontabDoSistema(texto) {
+    const r = (0, node_child_process_1.spawnSync)('crontab', ['-'], { input: texto, encoding: 'utf8', timeout: 5000 });
+    if (r.status === 0)
+        return { ok: true };
+    const erro = r.error ? r.error.code ?? r.error.message : null;
+    if (erro === 'ENOENT')
+        return { ok: false, motivo: 'comando crontab ausente nesta maquina' };
+    const primeira = `${r.stderr ?? ''}${r.stdout ?? ''}`.trim().split('\n')[0] ?? '';
+    return { ok: false, motivo: primeira ? `crontab - falhou: ${primeira}` : `crontab - saiu ${r.status ?? erro ?? 'sem codigo'}` };
+}
+exports.CRONTAB_DO_SISTEMA = { ler: doctor_pulse_cron_1.lerCrontabDoSistema, gravar: gravarCrontabDoSistema };
+/** Caminho que entra na linha do cron: absoluto, sem `%` (o cron o troca por quebra de linha) e sem controle. */
+function caminhoAceito(caminho) {
+    return path.isAbsolute(caminho) && !/[%\p{Cc}]/u.test(caminho);
+}
+/** Diretorio aceito no PATH da linha: alem do caminho aceito, sem `:`, o separador do PATH. */
+function diretorioAceito(dir) {
+    return caminhoAceito(dir) && !dir.includes(':');
+}
+/**
+ * O executavel do transporte, so do `pulse-host.json` local desta maquina (RM-047, P2): o versionado no git, ou o link,
+ * nao poe diretorio nenhum no PATH da batida.
+ */
+function transporteDoProjeto(raiz, dirMonitor) {
+    const arquivo = path.join(dirMonitor, 'pulse-host.json');
+    try {
+        (0, procedencia_1.exigirHostLocal)(raiz, arquivo);
+        const config = JSON.parse(fs.readFileSync(arquivo, 'utf8'));
+        return typeof config.executavel === 'string' && config.executavel.trim() ? config.executavel.trim() : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * O PATH da linha: o diretorio do `node` que roda este `ork`, os do `claude`, `codex`, `gh` e `git` achados
+ * agora, o do executavel do transporte (`pulse-host.json`) e o PATH minimo do sistema. O cron nao carrega o
+ * perfil do shell; sem isto a varredura nao acha o runtime nem o transporte (o template avisa).
+ */
+function caminhoDaBatida(opcoes = {}) {
+    const achar = opcoes.achar ?? ((bin) => (0, util_1.noPath)(bin));
+    const dirs = [];
+    const somar = (arquivo) => {
+        if (!arquivo || !path.isAbsolute(arquivo))
+            return;
+        const dir = path.dirname(arquivo);
+        if (diretorioAceito(dir) && !dirs.includes(dir))
+            dirs.push(dir);
+    };
+    somar(opcoes.node ?? process.execPath);
+    for (const bin of BINARIOS_DA_VARREDURA)
+        somar(achar(bin));
+    if (opcoes.transporte)
+        somar(path.isAbsolute(opcoes.transporte) ? opcoes.transporte : achar(opcoes.transporte));
+    for (const dir of PATH_DO_SISTEMA)
+        if (!dirs.includes(dir))
+            dirs.push(dir);
+    return dirs.join(':');
+}
+/** O script da varredura que a linha roda: o do checkout do projeto, senao o do `ork` instalado. */
+function scriptDaBatida(raiz, scriptDoOrk = (0, doctor_pulse_cron_1.scriptDaVarreduraDoOrk)()) {
+    const doProjeto = path.join(raiz, 'monitor', doctor_pulse_cron_1.SCRIPT_DA_VARREDURA);
+    return fs.existsSync(doProjeto) ? doProjeto : scriptDoOrk;
+}
+/**
+ * A linha que o `ork` instala: a batida do template (`*\/15`), o projeto alvo, o PATH e o script, com a
+ * marca no fim. `raiz` e a raiz canonica (o checkout principal, nunca a worktree de uma thread).
+ */
+function linhaDaBatida(raiz, opcoes = {}) {
+    const script = scriptDaBatida(raiz, opcoes.scriptDoOrk === undefined ? (0, doctor_pulse_cron_1.scriptDaVarreduraDoOrk)() : opcoes.scriptDoOrk);
+    if (!script) {
+        throw new Error(`fabrica.batida.sem-script: nem ${path.join(raiz, 'monitor', doctor_pulse_cron_1.SCRIPT_DA_VARREDURA)} nem o ` +
+            `${doctor_pulse_cron_1.SCRIPT_DA_VARREDURA} do ork instalado existem; reinstale o ork (npm i -g @orkastery/cli)`);
+    }
+    for (const caminho of [raiz, script]) {
+        if (!caminhoAceito(caminho)) {
+            throw new Error(`fabrica.batida.caminho-invalido: ${JSON.stringify(caminho)} nao cabe numa linha do cron ` +
+                '(precisa ser absoluto, sem % e sem caractere de controle)');
+        }
+    }
+    const PATH = caminhoDaBatida({ node: opcoes.node, achar: opcoes.achar,
+        transporte: transporteDoProjeto(raiz, path.join(raiz, '.orkastery', 'monitor')) });
+    return `${doctor_pulse_cron_1.BATIDA_DO_TEMPLATE} ORK_PULSE_PROJECT=${(0, doctor_pulse_cron_1.citarNoShell)(raiz)} PATH=${(0, doctor_pulse_cron_1.citarNoShell)(PATH)} ` +
+        `${(0, doctor_pulse_cron_1.citarNoShell)(script)} ${exports.MARCA_DA_BATIDA}`;
+}
+/** A linha foi instalada pelo `ork fabrica batida instalar` (traz a marca no fim)? */
+function linhaGerenciada(linha) {
+    return linha.trimEnd().endsWith(exports.MARCA_DA_BATIDA);
+}
+/**
+ * As entradas da varredura DESTE projeto, separadas pela marca. O projeto efetivo considera a linha de ambiente do
+ * crontab acima da entrada: o template abaixo de `ORK_PULSE_PROJECT=/outro` e a batida do outro, e fica.
+ */
+function separar(texto, raiz) {
+    const doProjeto = (0, doctor_pulse_cron_1.entradasDaVarredura)(texto).filter((e) => (0, doctor_pulse_cron_1.entradaDoProjeto)(e, raiz)).map((e) => e.linha);
+    return { gerenciadas: doProjeto.filter(linhaGerenciada), manuais: doProjeto.filter((l) => !linhaGerenciada(l)) };
+}
+function ritmoDa(linha) {
+    const t = linha.trim();
+    const m = t.startsWith('@') ? /^(@\S+)\s/.exec(t) : /^(\S+\s+\S+\s+\S+\s+\S+\s+\S+)\s/.exec(t);
+    return m ? (0, doctor_pulse_cron_1.intervaloEmMinutos)(m[1]) : null;
+}
+/** `ork fabrica batida status`: o que o crontab desta maquina diz da batida deste projeto, e a ultima rodada. */
+function estadoDaBatida(raizDoProjeto, opcoes = {}) {
+    const raiz = (0, estado_thread_1.raizDoEstado)(raizDoProjeto);
+    const executor = opcoes.executor ?? exports.CRONTAB_DO_SISTEMA;
+    const quando = opcoes.quando ?? new Date().toISOString();
+    const leitura = executor.ler();
+    const { gerenciadas, manuais } = leitura.ok ? separar(leitura.texto, raiz) : { gerenciadas: [], manuais: [] };
+    const ritmos = [...gerenciadas, ...manuais].map(ritmoDa).filter((r) => r !== null);
+    const rodada = (0, doctor_pulse_cron_1.ultimaRodadaDaVarredura)(path.join(raiz, '.orkastery', 'monitor'));
+    return {
+        projeto: raiz, maquina: (0, maquina_1.nomeDaMaquina)(),
+        leitura: leitura.ok ? { ok: true } : { ok: false, motivo: leitura.motivo },
+        gerenciada: gerenciadas[0]?.trim() ?? null, manuais: manuais.map((l) => l.trim()),
+        instalada: gerenciadas.length + manuais.length > 0,
+        intervaloMin: ritmos.length ? Math.min(...ritmos) : null,
+        ultimaRodada: rodada ? { ...rodada, haMin: Math.max(0, Math.floor((Date.parse(quando) - Date.parse(rodada.em)) / 60000)) } : null,
+    };
+}
+function lerParaEditar(executor) {
+    const leitura = executor.ler();
+    // Nunca gravar sem ter lido: um crontab que nao foi lido seria apagado pela gravacao.
+    if (!leitura.ok)
+        throw new Error(`fabrica.batida.sem-leitura: ${leitura.motivo}; nada foi gravado`);
+    return leitura.texto;
+}
+function gravarEConferir(executor, lido, texto, confere) {
+    // O crontab que mudou entre a leitura e a gravacao (um `crontab -e`, outro `instalar`) nao e sobrescrito.
+    const antes = executor.ler();
+    if (!antes.ok || antes.texto !== lido) {
+        throw new Error('fabrica.batida.concorrencia: o crontab mudou durante a operacao; nada foi gravado, rode de novo');
+    }
+    const gravacao = executor.gravar(texto);
+    if (!gravacao.ok)
+        throw new Error(`fabrica.batida.sem-gravacao: ${gravacao.motivo}`);
+    const relido = executor.ler();
+    if (!relido.ok || !confere(relido.texto)) {
+        throw new Error(`fabrica.batida.nao-confirmada: o crontab relido nao traz o que foi gravado` +
+            (relido.ok ? '' : ` (${relido.motivo})`) + '; confira com crontab -l');
+    }
+}
+/** O texto do crontab sem as linhas pedidas, com o fim de linha que o cron exige. */
+function semAsLinhas(texto, sair) {
+    const ficam = texto.split('\n').filter((l) => !sair.has(l));
+    while (ficam.length && ficam[ficam.length - 1].trim() === '')
+        ficam.pop();
+    return ficam.length ? `${ficam.join('\n')}\n` : '';
+}
+function noLedgerDaMaquina(tipo, dados) {
+    return (0, ledger_1.registrar)((0, maquina_1.pastaDoUsuario)(), 'maquina', tipo, { maquina: (0, maquina_1.nomeDaMaquina)(), ...dados }).eventId;
+}
+/**
+ * `ork fabrica batida instalar`: idempotente. A linha igual ja instalada nao muda nada; a linha antiga do
+ * `ork` e a linha posta a mao da varredura deste projeto saem, e a linha do template entra no lugar. As
+ * outras entradas do crontab ficam como estavam.
+ */
+function instalarBatida(raizDoProjeto, opcoes = {}) {
+    const raiz = (0, estado_thread_1.raizDoEstado)(raizDoProjeto);
+    const executor = opcoes.executor ?? exports.CRONTAB_DO_SISTEMA;
+    const linha = linhaDaBatida(raiz, opcoes);
+    const texto = lerParaEditar(executor);
+    const { gerenciadas, manuais } = separar(texto, raiz);
+    if (manuais.length === 0 && gerenciadas.length === 1 && gerenciadas[0].trim() === linha) {
+        return { acao: 'ja-instalada', projeto: raiz, linha, retiradas: [], manuais: [], eventId: null };
+    }
+    const retiradas = [...gerenciadas, ...manuais];
+    const base = semAsLinhas(texto, new Set(retiradas));
+    gravarEConferir(executor, texto, `${base}${linha}\n`, (relido) => relido.split('\n').some((l) => l.trim() === linha));
+    const eventId = noLedgerDaMaquina(ledger_1.TIPOS_DE_EVENTO.batidaInstalada, {
+        projeto: raiz, linha, retiradas: retiradas.map((l) => l.trim()), por: opcoes.por ?? null,
+        evidencia: 'crontab -l relido depois da gravacao traz a linha',
+    });
+    return { acao: 'instalou', projeto: raiz, linha, retiradas: retiradas.map((l) => l.trim()), manuais: [], eventId };
+}
+/** `ork fabrica batida remover`: tira so a linha que o `ork` instalou para este projeto. */
+function removerBatida(raizDoProjeto, opcoes = {}) {
+    const raiz = (0, estado_thread_1.raizDoEstado)(raizDoProjeto);
+    const executor = opcoes.executor ?? exports.CRONTAB_DO_SISTEMA;
+    const texto = lerParaEditar(executor);
+    const { gerenciadas, manuais } = separar(texto, raiz);
+    const ficam = manuais.map((l) => l.trim());
+    if (gerenciadas.length === 0)
+        return { acao: 'nao-instalada', projeto: raiz, linha: null, retiradas: [], manuais: ficam, eventId: null };
+    const sair = new Set(gerenciadas);
+    gravarEConferir(executor, texto, semAsLinhas(texto, sair), (relido) => separar(relido, raiz).gerenciadas.length === 0);
+    const eventId = noLedgerDaMaquina(ledger_1.TIPOS_DE_EVENTO.batidaRemovida, {
+        projeto: raiz, retiradas: gerenciadas.map((l) => l.trim()), manuaisQueFicaram: ficam, por: opcoes.por ?? null,
+        evidencia: 'crontab -l relido depois da gravacao nao traz a linha do ork',
+    });
+    return { acao: 'removeu', projeto: raiz, linha: null, retiradas: gerenciadas.map((l) => l.trim()), manuais: ficam, eventId };
+}
+function textoDoEstadoDaBatida(e, quando = new Date().toISOString()) {
+    const linhas = [`Batida da fábrica em ${e.maquina}, projeto ${e.projeto}`];
+    if (!e.leitura.ok)
+        linhas.push(`  crontab: não lido (${e.leitura.motivo}); não dá para dizer se a batida está instalada`);
+    else if (!e.instalada)
+        linhas.push('  instalada: não; instale com: ork fabrica batida instalar');
+    else {
+        const ritmo = e.intervaloMin === null ? 'com horário que o ork não lê' : `a cada ${e.intervaloMin} min`;
+        linhas.push(`  instalada: sim, ${ritmo}${e.gerenciada ? ', pelo ork fabrica batida instalar' : ', por linha posta à mão'}`);
+        for (const l of [...(e.gerenciada ? [e.gerenciada] : []), ...e.manuais])
+            linhas.push(`  linha: ${l}`);
+    }
+    const r = e.ultimaRodada;
+    if (!r)
+        linhas.push('  última rodada: nenhuma registrada (.orkastery/monitor/hitl.log)');
+    else {
+        linhas.push(`  última rodada: ${(0, horario_1.formatarHora)(r.em, { agora: quando })} (há ${r.haMin} min), ` +
+            `${r.code === 0 ? 'ok' : `código ${r.code ?? '?'}`}: ${r.detalhe || 'sem detalhe'}`);
+        if (e.instalada && r.haMin > doctor_pulse_cron_1.ATRASO_DA_BATIDA_MIN) {
+            linhas.push(`  atrasada: nenhuma rodada há ${r.haMin} min com a batida instalada; confira crontab -l e o hitl.log`);
+        }
+    }
+    linhas.push((0, horario_1.legendaDoFuso)());
+    return linhas.join('\n');
+}
+function textoDoResultadoDaBatida(r) {
+    switch (r.acao) {
+        case 'ja-instalada': return `Batida já instalada para ${r.projeto}; nada mudou no crontab.\n  linha: ${r.linha}`;
+        case 'instalou': return [`Batida instalada para ${r.projeto} (evento ${r.eventId} no ledger da máquina).`, `  linha: ${r.linha}`,
+            ...r.retiradas.map((l) => `  saiu: ${l}`), '  confira com: ork fabrica batida status'].join('\n');
+        case 'removeu': return [`Batida removida de ${r.projeto} (evento ${r.eventId} no ledger da máquina).`,
+            ...r.retiradas.map((l) => `  saiu: ${l}`), ...r.manuais.map((l) => `  ficou (posta à mão, não é do ork): ${l}`)].join('\n');
+        case 'nao-instalada': return [`Nenhuma batida do ork instalada para ${r.projeto}; nada mudou no crontab.`,
+            ...r.manuais.map((l) => `  ficou (posta à mão, não é do ork): ${l}`)].join('\n');
+    }
+}

package/dist/fabrica-estado.js

@@ -57,8 +57,9 @@ exports.painelDaFabricaEmMarkdown = painelDaFabricaEmMarkdown;
  * GitHub. `ork board`, `ork fabrica` e o resumo do pulse leem as outras maquinas dali. Cada
  * maquina so escreve o proprio arquivo: push recusado se resolve relendo a ponta.
  *
- * Publicar e empurrar para o remoto do projeto, entao so acontece sozinho com
- * `fabrica.compartilhada: true` no manifesto; `ork fabrica publicar` e o caminho explicito. Nada de
+ * Publicar e empurrar para o remoto do projeto, entao so acontece sozinho com a adesao da maquina
+ * (`ork fabrica entrar`); o `fabrica.compartilhada` do manifesto so pede (RM-047, P5), e
+ * `ork fabrica publicar` e o caminho explicito. Nada de
  * credencial, prompt, log ou caminho local sai daqui: so identificadores, fase, status e o assunto
  * da pausa que espera o dono.
  *
@@ -81,6 +82,8 @@ 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");
+const vida_da_thread_1 = require("./vida-da-thread");
 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. */
@@ -161,17 +164,37 @@ function retratoDaMaquina(carregado, opcoes = {}) {
     const linhas = new Map(monitor.linhas.map((l) => [l.thread, l]));
     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]));
+    let leitura;
+    const lerUmaVez = () => (leitura ??= (opcoes.runtime ?? (() => (0, vida_da_thread_1.lerRuntime)(raiz)))());
     const threads = itens.map(({ thread: t, raiz: raizDoPerfil }) => {
         const entregue = entregas.get(t.id) ?? null;
         // 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;
+        let eventos = [];
         try {
-            espera = (0, parado_no_condutor_1.esperaDoCondutor)(t, (0, ledger_1.lerLedger)((0, thread_1.dirThread)(raizDoPerfil, t.id)), quando);
+            eventos = (0, ledger_1.lerLedger)((0, thread_1.dirThread)(raizDoPerfil, t.id));
+        }
+        catch {
+            eventos = [];
+        }
+        try {
+            espera = (0, parado_no_condutor_1.esperaDoCondutor)(t, eventos, quando);
         }
         catch {
             espera = null;
         }
+        // RM-063 (F2): a fabrica so mostra a thread como andando com a sessao viva verificada no runtime.
+        let sessao = null;
+        if (!entregue) {
+            try {
+                const v = (0, vida_da_thread_1.vidaDaThread)(t, eventos, lerUmaVez, Date.parse(quando));
+                sessao = { viva: v.viva, desdeEm: v.desdeEm, motivo: v.motivo };
+            }
+            catch {
+                sessao = 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];
@@ -183,6 +206,7 @@ function retratoDaMaquina(carregado, opcoes = {}) {
             esperaVoce, pergunta: esperaVoce && pausa ? curto(pausa.pausaSobre || pausa.detalhe) : null,
             paradaDesde: esperaVoce && pausa ? pausa.desdeEm : null,
             ...despachoDaThread((0, thread_1.dirThread)(raizDoPerfil, t.id)),
+            sessao,
         };
     }).sort((a, b) => a.id.localeCompare(b.id));
     const eu = (0, roadmap_reservas_1.quemSouEu)(raiz, { por: opcoes.por, maquina: opcoes.maquina });
@@ -234,7 +258,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);
@@ -274,7 +299,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);
@@ -321,18 +346,29 @@ function tabela(cabecalho, linhas) {
     const linha = (l) => '  ' + l.map((c, i) => c.padEnd(largura[i])).join('  ').trimEnd();
     return [linha(cabecalho), linha(largura.map((n) => '-'.repeat(n))), ...linhas.map(linha)];
 }
+/** RM-063 (F2): a coluna da sessao: `viva`, `parada desde HH:MM: <motivo>`, ou `-` no retrato que nao a traz. */
+function sessaoNaFabrica(t, teto) {
+    const v = (0, vida_da_thread_1.vidaDoRetrato)(t.sessao);
+    return v.viva ? 'viva' : v.motivo === null ? '-' : curto((0, vida_da_thread_1.paradaDesde)(v), teto);
+}
 function blocoDaMaquina(m, eu) {
     const vivas = ativas(m), entregues = m.threads.length - vivas.length;
     const cabeca = `${m.maquina}${m.maquina === eu ? ' (esta maquina)' : ''}, ${m.por}, publicado ${(0, horario_1.formatarDataHora)(m.publicadoEm)}: ` +
         `${vivas.length} thread(s) ativa(s)` + (entregues ? `, ${entregues} entregue(s) sem MASTER` : '');
     if (vivas.length === 0)
         return [cabeca];
-    return [cabeca, ...tabela(['THREAD', 'MODO', 'FASE', 'RUNTIME', 'ITEM', 'ESPERA VOCE'], vivas.map((t) => [
+    return [cabeca, ...tabela(['THREAD', 'MODO', 'FASE', 'RUNTIME', 'ITEM', 'ESPERA VOCE', 'SESSAO'], vivas.map((t) => [
             t.id, t.modo, t.fase, runtimeDaThread(t), t.roadmap ?? '-', t.esperaVoce ? `sim: ${curto(t.pergunta ?? 'veredito', 40)}` : '-',
+            sessaoNaFabrica(t, 70),
         ]))];
 }
-/** `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.', '');
@@ -345,8 +381,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)
@@ -364,17 +401,18 @@ function painelDaFabricaEmMarkdown(maquinas) {
         'O que cada máquina está conduzindo agora. Gerado pelo `ork fabrica publicar`; não edite à mão.',
         'Antes de pegar um item do roadmap: `ork roadmap reservas`.',
         '',
-        '| Máquina | Thread | Modo | Fase | Runtime | Item | Espera você | Publicado |',
-        '| --- | --- | --- | --- | --- | --- | --- | --- |',
+        '| Máquina | Thread | Modo | Fase | Runtime | Item | Espera você | Publicado | Sessão |',
+        '| --- | --- | --- | --- | --- | --- | --- | --- | --- |',
     ];
     const vivas = maquinas.flatMap((m) => ativas(m).map((t) => ({ m, t })));
     if (vivas.length === 0)
-        linhas.push('| — | nenhuma thread ativa | — | — |  | — | — | — |');
+        linhas.push('| — | nenhuma thread ativa | — | — |  | — | — | — | — |');
     for (const { m, t } of vivas) {
         const pergunta = t.esperaVoce ? `sim: ${curto(t.pergunta ?? 'veredito', 60).replace(/\|/g, '/')}` : '—';
         // RM-037 (sugestao 6 do CHECK 1): a celula sem despacho diz isso, sem travessao novo.
         const runtime = t.runtime || t.modelo ? runtimeDaThread(t).replace(/\|/g, '/') : 'sem despacho';
-        linhas.push(`| ${m.maquina} | ${t.id} | ${t.modo} | ${t.fase} | ${runtime} | ${t.roadmap ?? '—'} | ${pergunta} | ${(0, horario_1.formatarDataHora)(m.publicadoEm)} |`);
+        const sessao = sessaoNaFabrica(t, 80).replace(/\|/g, '/').replace(/^-$/, '—');
+        linhas.push(`| ${m.maquina} | ${t.id} | ${t.modo} | ${t.fase} | ${runtime} | ${t.roadmap ?? '—'} | ${pergunta} | ${(0, horario_1.formatarDataHora)(m.publicadoEm)} | ${sessao} |`);
     }
     return [...linhas, '', (0, horario_1.legendaDoFuso)(), ''].join('\n');
 }

package/dist/fabrica-publicar.js

@@ -39,18 +39,25 @@ 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 projeto_alvo_1 = require("./projeto-alvo");
+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;
@@ -66,7 +73,8 @@ function publicarEmSegundoPlano(raiz) {
     if (!fs.existsSync(cli))
         return false;
     try {
-        const filho = (0, node_child_process_1.spawn)(process.execPath, [cli, 'fabrica', 'publicar', '--silencioso'], { cwd: carregado.raiz, detached: true, stdio: 'ignore', env: process.env });
+        // RM-052 (fatia 2, D2): o filho publica o projeto do proprio cwd; o modo host de quem chamou nao o segue.
+        const filho = (0, node_child_process_1.spawn)(process.execPath, [cli, 'fabrica', 'publicar', '--silencioso'], { cwd: carregado.raiz, detached: true, stdio: 'ignore', env: { ...process.env, ...projeto_alvo_1.AMBIENTE_SEM_PROJETO_HERDADO } });
         filho.unref();
         return true;
     }

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 */ }
     }