@orkastery/cli 0.5.3 → 0.6.0

package/dist/fabrica-batida.js

@@ -0,0 +1,323 @@
+"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");
+const autorizacao_duravel_1 = require("./autorizacao-duravel");
+const locale_1 = require("./locale");
+/** 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'));
+        // RM-063 (fatia 3, H4): o outro host configurado tambem precisa estar no PATH da batida.
+        const todos = [config, ...(Array.isArray(config.alternativos) ? config.alternativos : [])];
+        return todos.map((t) => (typeof t?.executavel === 'string' ? t.executavel.trim() : '')).filter(Boolean);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * 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));
+    for (const t of typeof opcoes.transporte === 'string' ? [opcoes.transporte] : opcoes.transporte ?? []) {
+        somar(path.isAbsolute(t) ? t : achar(t));
+    }
+    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,
+        ...(opcoes.projeto ? { autorizacao: autorizacaoDaBatida(raiz, opcoes.projeto, quando) } : {}),
+    };
+}
+function autorizacaoDaBatida(raiz, projeto, quando) {
+    const l = (0, autorizacao_duravel_1.lerAutorizacao)(raiz, { projeto, agora: new Date(quando) });
+    const a = l.valida ? l.autorizacao : null;
+    return { estado: l.valida ? 'valida' : l.motivo === 'autorizacao.ausente' ? 'ausente' : 'invalida', motivo: l.valida ? null : l.motivo,
+        por: a?.por ?? null, ate: a?.ate ?? null, pode: a ? [...a.pode] : [], linha: (0, autorizacao_duravel_1.linhaDaAutorizacao)(l, quando) };
+}
+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 m = (0, locale_1.msg)().operacao.restante.fabrica.batida;
+    const linhas = [m.titulo(e.maquina, e.projeto)];
+    if (!e.leitura.ok)
+        linhas.push(m.naoLido(e.leitura.motivo));
+    else if (!e.instalada)
+        linhas.push(m.naoInstalada);
+    else {
+        const ritmo = e.intervaloMin === null ? m.horarioIlegivel : m.aCada(e.intervaloMin);
+        linhas.push(m.instalada(ritmo, !!e.gerenciada));
+        for (const l of [...(e.gerenciada ? [e.gerenciada] : []), ...e.manuais])
+            linhas.push(m.linha(l));
+    }
+    const r = e.ultimaRodada;
+    if (!r)
+        linhas.push(m.semRodada);
+    else {
+        linhas.push(m.rodada((0, horario_1.formatarHora)(r.em, { agora: quando }), r.haMin, m.codigo(r.code), r.detalhe || m.semDetalhe));
+        if (e.instalada && r.haMin > doctor_pulse_cron_1.ATRASO_DA_BATIDA_MIN) {
+            linhas.push(m.atrasada(r.haMin));
+        }
+    }
+    if (e.autorizacao)
+        linhas.push(`  ${e.autorizacao.linha}`);
+    linhas.push((0, horario_1.legendaDoFuso)());
+    return linhas.join('\n');
+}
+function textoDoResultadoDaBatida(r) {
+    const m = (0, locale_1.msg)().operacao.restante.fabrica.batida;
+    switch (r.acao) {
+        case 'ja-instalada': return m.jaInstalada(r.projeto, r.linha);
+        case 'instalou': return [m.instalou(r.projeto, r.eventId), m.linha(r.linha),
+            ...r.retiradas.map(m.saiu), m.confira].join('\n');
+        case 'removeu': return [m.removeu(r.projeto, r.eventId), ...r.retiradas.map(m.saiu), ...r.manuais.map(m.ficou)].join('\n');
+        case 'nao-instalada': return [m.nenhumaInstalada(r.projeto), ...r.manuais.map(m.ficou)].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.
  *
@@ -82,6 +83,8 @@ 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");
+const locale_1 = require("./locale");
 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. */
@@ -162,17 +165,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];
@@ -184,6 +207,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 });
@@ -323,14 +347,20 @@ 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 t = (0, locale_1.msg)().operacao.restante.fabrica;
     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` : '');
+    const cabeca = t.maquina(m.maquina, m.maquina === eu ? t.estaMaquina : '', m.por, (0, horario_1.formatarDataHora)(m.publicadoEm), vivas.length, entregues);
     if (vivas.length === 0)
         return [cabeca];
-    return [cabeca, ...tabela(['THREAD', 'MODO', 'FASE', 'RUNTIME', 'ITEM', 'ESPERA VOCE'], vivas.map((t) => [
-            t.id, t.modo, t.fase, runtimeDaThread(t), t.roadmap ?? '-', t.esperaVoce ? `sim: ${curto(t.pergunta ?? 'veredito', 40)}` : '-',
+    return [cabeca, ...tabela([...t.colunas], vivas.map((thread) => [
+            thread.id, thread.modo, thread.fase, runtimeDaThread(thread), thread.roadmap ?? '-',
+            thread.esperaVoce ? t.espera(curto(thread.pergunta ?? t.veredito, 40)) : '-', sessaoNaFabrica(thread, 70),
         ]))];
 }
 /**
@@ -339,12 +369,13 @@ function blocoDaMaquina(m, eu) {
  * que o terminal execute.
  */
 function textoDaFabrica(painel, eu) {
+    const t = (0, locale_1.msg)().operacao.restante.fabrica;
     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.', '');
+        linhas.push(t.copia, '');
     if (p.maquinas.length === 0) {
-        linhas.push(`Nenhuma maquina publicou ainda em ${exports.BRANCH_DA_FABRICA}. Publique esta com: ork fabrica publicar`);
+        linhas.push(t.nenhuma(exports.BRANCH_DA_FABRICA));
         return linhas.join('\n');
     }
     for (const m of p.maquinas)
@@ -354,12 +385,13 @@ function textoDaFabrica(painel, eu) {
 }
 /** A secao de `ork board` com as outras maquinas, saneada como o `ork fabrica`. */
 function textoDasOutrasMaquinas(painel, eu) {
+    const t = (0, locale_1.msg)().operacao.restante.fabrica;
     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';
+    const origem = p.atualizado ? t.origens.atual : t.origens.copia;
     if (outras.length === 0)
-        return `Outras maquinas (${exports.BRANCH_DA_FABRICA}, ${origem}): nenhuma publicou ainda.`;
-    const linhas = [`Outras maquinas (${exports.BRANCH_DA_FABRICA}, ${origem}):`];
+        return t.outrasNenhuma(exports.BRANCH_DA_FABRICA, origem);
+    const linhas = [t.outras(exports.BRANCH_DA_FABRICA, origem)];
     for (const m of outras)
         linhas.push(...blocoDaMaquina(m, eu).map((l, i) => (i === 0 ? `  ${l}` : l)));
     return linhas.join('\n');
@@ -372,17 +404,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

@@ -48,6 +48,7 @@ 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
@@ -72,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;
     }