@orkastery/cli 0.2.0 → 0.4.1

package/dist/estado-thread.js

@@ -0,0 +1,222 @@
+"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.raizDoEstado = raizDoEstado;
+exports.estadoCanonico = estadoCanonico;
+exports.vincularEstado = vincularEstado;
+exports.comEstadoParaGit = comEstadoParaGit;
+exports.auditarEstado = auditarEstado;
+/** D1: a árvore principal é o domicílio do estado, mesmo em uma linked worktree. */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const util_1 = require("./util");
+function raizDoEstado(raiz) {
+    const local = path.resolve(raiz);
+    const git = path.join(local, '.git');
+    if (!fs.existsSync(git) || !fs.statSync(git).isFile())
+        return local;
+    const match = /^gitdir: (.+)\s*$/m.exec(fs.readFileSync(git, 'utf8'));
+    if (!match)
+        throw new Error(`.git inválido em ${local}`);
+    const gitdir = path.resolve(local, match[1].trim());
+    const commondir = path.join(gitdir, 'commondir');
+    if (!fs.existsSync(commondir))
+        return local; // submódulo, não linked worktree
+    const comum = path.resolve(gitdir, fs.readFileSync(commondir, 'utf8').trim());
+    const principal = path.dirname(comum);
+    if (!fs.existsSync(path.join(principal, '.git')) ||
+        fs.realpathSync(path.join(principal, '.git')) !== fs.realpathSync(comum)) {
+        throw new Error(`árvore principal não resolvida pelo git-common-dir: ${comum}`);
+    }
+    return principal;
+}
+function estadoCanonico(raiz, id) {
+    if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(id))
+        throw new Error('id de thread inválido');
+    return path.join(raizDoEstado(raiz), '.orkastery', 'threads', id);
+}
+function mesmoArquivo(a, b) {
+    return fs.existsSync(a) && fs.existsSync(b) && fs.realpathSync(a) === fs.realpathSync(b);
+}
+function arquivos(dir, prefixo = '') {
+    return fs.readdirSync(path.join(dir, prefixo), { withFileTypes: true }).flatMap(e => {
+        const nome = path.join(prefixo, e.name);
+        if (e.isSymbolicLink())
+            throw new Error(`estado legado contém link: ${nome}`);
+        if (e.isDirectory())
+            return arquivos(dir, nome);
+        if (!e.isFile())
+            throw new Error(`estado legado contém arquivo especial: ${nome}`);
+        return [nome];
+    });
+}
+function ignorarEstadoLocal(raiz, id) {
+    const exclude = path.join(raizDoEstado(raiz), '.git', 'info', 'exclude');
+    fs.mkdirSync(path.dirname(exclude), { recursive: true });
+    const regras = [`/.orkastery/threads/${id}`, '/.orkastery/state-backups/'];
+    const atual = fs.existsSync(exclude) ? fs.readFileSync(exclude, 'utf8') : '';
+    for (const regra of regras) {
+        if (!atual.split('\n').includes(regra))
+            fs.appendFileSync(exclude, `\n${regra}\n`);
+    }
+}
+/** Preflight integral antes de copiar. Divergência preserva ambas as fontes. */
+function vincularEstado(raiz, id, worktree, dryRun = false) {
+    const alvo = estadoCanonico(raiz, id);
+    const local = path.join(worktree, '.orkastery', 'threads', id);
+    if (path.resolve(local) === alvo)
+        return;
+    if (raizDoEstado(worktree) !== raizDoEstado(raiz))
+        throw new Error('worktree não pertence à árvore principal');
+    // O índice é próprio da linked worktree. A main continua versionando seu estado.
+    const rastreados = (0, util_1.exec)('git', ['ls-files', '-z', '--', `.orkastery/threads/${id}/`], worktree);
+    if (!rastreados.ok)
+        throw new Error(`índice da worktree indisponível: ${rastreados.stderr}`);
+    const nomes = rastreados.stdout.split('\0').filter(Boolean);
+    const prepararIndice = () => {
+        if (dryRun || nomes.length === 0)
+            return;
+        const r = (0, util_1.exec)('git', ['update-index', '--skip-worktree', '--', ...nomes], worktree);
+        if (!r.ok)
+            throw new Error(`não foi possível preservar o estado versionado no índice: ${r.stderr}`);
+    };
+    if (mesmoArquivo(local, alvo)) {
+        prepararIndice();
+        if (!dryRun)
+            ignorarEstadoLocal(raiz, id);
+        return;
+    }
+    const copiar = [];
+    const existe = fs.existsSync(local);
+    if (!existe && fs.lstatSync(path.dirname(local), { throwIfNoEntry: false })?.isSymbolicLink()) {
+        throw new Error('diretório de threads inesperadamente vinculado');
+    }
+    if (existe) {
+        if (fs.lstatSync(local).isSymbolicLink())
+            throw new Error(`link de estado aponta para outro destino: ${local}`);
+        for (const nome of arquivos(local)) {
+            const destino = path.join(alvo, nome);
+            if (!fs.existsSync(destino)) {
+                copiar.push(nome);
+                continue;
+            }
+            const a = fs.readFileSync(path.join(local, nome));
+            const b = fs.readFileSync(destino);
+            if (a.equals(b))
+                continue;
+            // Prefixo JSONL já incorporado na main não é conflito nem deve ser duplicado.
+            if (nome.endsWith('.jsonl') && a.toString().endsWith('\n') && b.subarray(0, a.length).equals(a))
+                continue;
+            throw new Error(`estado dividido: ${nome} diverge entre ${local} e ${alvo}; reconcilie antes do sync`);
+        }
+    }
+    else if (fs.lstatSync(local, { throwIfNoEntry: false })) {
+        throw new Error(`link de estado quebrado: ${local}`);
+    }
+    // O ensaio executa o mesmo preflight, sem tocar em arquivos ou no índice.
+    if (dryRun)
+        return;
+    fs.mkdirSync(alvo, { recursive: true });
+    for (const nome of copiar) {
+        const destino = path.join(alvo, nome);
+        fs.mkdirSync(path.dirname(destino), { recursive: true });
+        fs.copyFileSync(path.join(local, nome), destino, fs.constants.COPYFILE_EXCL);
+    }
+    prepararIndice();
+    if (existe) {
+        const backup = path.join(raizDoEstado(raiz), '.orkastery', 'state-backups', `${id}-${(0, node_crypto_1.randomUUID)()}`);
+        fs.mkdirSync(path.dirname(backup), { recursive: true });
+        fs.renameSync(local, backup);
+    }
+    fs.mkdirSync(path.dirname(local), { recursive: true });
+    fs.symlinkSync(path.relative(path.dirname(local), alvo), local, 'dir');
+    // O vínculo é estado desta máquina, nunca parte do commit de produto.
+    ignorarEstadoLocal(raiz, id);
+}
+/**
+ * Git precisa materializar arquivos rastreados ao rebasar. Durante essa operação a
+ * cópia local vem exclusivamente do índice; a fonte canônica permanece intocada na main.
+ * O chamador conclui ou aborta o rebase antes de devolver o controle para a restauração.
+ */
+function comEstadoParaGit(raiz, id, worktree, executar) {
+    vincularEstado(raiz, id, worktree);
+    const local = path.join(worktree, '.orkastery', 'threads', id);
+    const prefixo = `.orkastery/threads/${id}/`;
+    const git = (args) => {
+        const r = (0, util_1.exec)('git', args, worktree);
+        if (!r.ok)
+            throw new Error(`preparação do estado para Git falhou: ${r.stderr || r.stdout}`);
+        return r.stdout;
+    };
+    const nomes = git(['ls-files', '-z', '--', prefixo]).split('\0').filter(Boolean);
+    fs.unlinkSync(local); // somente o alias; nunca o diretório canônico
+    fs.mkdirSync(local);
+    let materializado = false;
+    try {
+        if (nomes.length) {
+            git(['update-index', '--no-skip-worktree', '--', ...nomes]);
+            git(['checkout-index', '--force', '--', ...nomes]);
+        }
+        materializado = true;
+        return executar();
+    }
+    finally {
+        // Uma escrita externa durante a operação é conflito, não estado descartável.
+        const mudou = materializado && (!(0, util_1.exec)('git', ['diff', '--quiet', '--', prefixo], worktree).ok ||
+            git(['ls-files', '--others', '--', prefixo]).trim() !== '');
+        if (mudou)
+            throw new Error(`estado local alterado durante operação Git: ${local}; cópia e main preservadas para reconciliação`);
+        if (fs.existsSync(local)) {
+            const backup = path.join(raizDoEstado(raiz), '.orkastery', 'state-backups', `${id}-git-${(0, node_crypto_1.randomUUID)()}`);
+            fs.mkdirSync(path.dirname(backup), { recursive: true });
+            fs.renameSync(local, backup);
+        }
+        // A nova versão do índice pode ter incluído ou removido arquivos de estado.
+        vincularEstado(raiz, id, worktree);
+    }
+}
+/** Inspeciona o caminho físico, para o resolvedor não esconder uma cópia obsoleta. */
+function auditarEstado(raiz, id, worktree) {
+    const main = estadoCanonico(raiz, id), local = path.join(worktree, '.orkastery', 'threads', id);
+    const contar = (dir) => {
+        const file = path.join(dir, 'ledger.jsonl');
+        return fs.existsSync(file) ? fs.readFileSync(file, 'utf8').split('\n').filter(Boolean).length : 0;
+    };
+    const ok = mesmoArquivo(main, local);
+    return { nome: 'estado-unico', nivel: ok ? 'ok' : 'fail',
+        detalhe: `${ok ? 'mesmo estado' : 'estado dividido'}: main=${contar(main)} eventos, worktree=${contar(local)} eventos; ${main}`,
+        ...(ok ? {} : { correcao: `ork worktree sync ${id}; divergências exigem reconciliação preservando evidências` }) };
+}

package/dist/evalrunner.js

@@ -276,6 +276,14 @@ function rodarCanarios(catalogo, filtro) {
     const falhas = [];
     const temGit = (0, canarios_1.gitDisponivel)();
     const nomes = fs.existsSync(dir) ? fs.readdirSync(dir).sort() : [];
+    if (filtro && filtro.length === 0) {
+        falhas.push({ codigo: 'fixture-invalida', detalhe: 'filtro de canários vazio: nenhuma prova foi executada' });
+    }
+    for (const id of new Set(filtro ?? [])) {
+        if (!nomes.includes(id) || !(0, canarios_1.canarioPorId)(id)) {
+            falhas.push({ codigo: 'canario-sem-executor', caso: id, detalhe: `canário solicitado ausente: ${id}` });
+        }
+    }
     for (const nome of nomes) {
         if (!nome.startsWith('fx-'))
             continue;
@@ -295,6 +303,10 @@ function rodarCanarios(catalogo, filtro) {
             continue;
         }
         const canario = (0, canarios_1.canarioPorId)(fixture.id ?? nome);
+        if (fixture.id !== nome) {
+            falhas.push({ codigo: 'fixture-invalida', caso: nome, detalhe: 'id da fixture diverge do canário solicitado' });
+            continue;
+        }
         if (!canario) {
             falhas.push({
                 codigo: 'canario-sem-executor',

package/dist/fabrica-estado.js

@@ -0,0 +1,329 @@
+"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.PULSACAO_MS = exports.BRANCH_DA_FABRICA = exports.CONTRATO_MAQUINA = void 0;
+exports.arquivoDaMaquina = arquivoDaMaquina;
+exports.entregasNaBase = entregasNaBase;
+exports.retratoDaMaquina = retratoDaMaquina;
+exports.assinaturaDoRetrato = assinaturaDoRetrato;
+exports.lerFabrica = lerFabrica;
+exports.publicarMaquina = publicarMaquina;
+exports.removerMaquina = removerMaquina;
+exports.registrarPublicacao = registrarPublicacao;
+exports.resumoDasOutrasMaquinas = resumoDasOutrasMaquinas;
+exports.textoDaFabrica = textoDaFabrica;
+exports.textoDasOutrasMaquinas = textoDasOutrasMaquinas;
+exports.painelDaFabricaEmMarkdown = painelDaFabricaEmMarkdown;
+/**
+ * I-51 (RM-047, fatia 2): a fabrica vista de qualquer maquina.
+ *
+ * Cada maquina publica o retrato das proprias threads em `maquinas/<maquina>.json` (contrato
+ * `ork.fabrica-maquina/v1`) na branch `ork/fabrica-estado`, com um `FABRICA.md` legivel no
+ * 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
+ * credencial, prompt, log ou caminho local sai daqui: so identificadores, fase, status e o assunto
+ * da pausa que espera o dono.
+ *
+ * O retrato conta a verdade do git, nao so a do `thread.json`: thread cujo `ship(<thread>)` ja esta
+ * na base e entregue, mesmo que ninguem tenha fechado o MASTER dela.
+ */
+const node_crypto_1 = require("node:crypto");
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const branch_de_estado_1 = require("./branch-de-estado");
+const monitor_lock_1 = require("./monitor-lock");
+const board_1 = require("./board");
+const estado_thread_1 = require("./estado-thread");
+const horario_1 = require("./horario");
+const modos_1 = require("./modos");
+const orquestracao_1 = require("./orquestracao");
+const roadmap_reservas_1 = require("./roadmap-reservas");
+const util_1 = require("./util");
+const versao_1 = require("./versao");
+exports.CONTRATO_MAQUINA = 'ork.fabrica-maquina/v1';
+exports.BRANCH_DA_FABRICA = 'ork/fabrica-estado';
+const DIR = 'maquinas';
+const PAINEL = 'FABRICA.md';
+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;
+const ARQUIVO_DA_MARCA = 'fabrica-publicada.json';
+const ARQUIVO_DO_LOG = 'fabrica.log';
+const curto = (texto, teto = 120) => {
+    const limpo = String(texto ?? '').replace(/\s+/g, ' ').trim();
+    return limpo.length > teto ? `${limpo.slice(0, teto - 3)}...` : limpo;
+};
+/** O nome do arquivo da maquina na branch: so o que o git e o GitHub aceitam sem surpresa. */
+function arquivoDaMaquina(maquina) {
+    const nome = maquina.trim().replace(/[^A-Za-z0-9._-]+/g, '-').replace(/^[.-]+/, '').slice(0, 64);
+    if (!nome)
+        throw new Error(`fabrica.maquina: nome de maquina invalido ("${maquina}"); defina ORK_MAQUINA`);
+    return `${nome}.json`;
+}
+/**
+ * As entregas que ja estao na base: `ship(<thread>): ...` e o assunto do merge que o fluxo de
+ * entrega usa, o mesmo fato que o `ork docs sincronizar` le. Um `git log` so, para todas.
+ */
+function entregasNaBase(raiz, base, remoto = 'origin') {
+    const ref = (0, branch_de_estado_1.git)(raiz, ['rev-parse', '--verify', '--quiet', `refs/remotes/${remoto}/${base}`]).ok ? `${remoto}/${base}` : base;
+    // Regex basica do git: o `(` e literal.
+    const r = (0, branch_de_estado_1.git)(raiz, ['log', ref, '--format=%h%x09%s', '--grep=^ship(']);
+    const entregas = new Map();
+    if (!r.ok)
+        return entregas;
+    for (const linha of r.stdout.split('\n')) {
+        const m = /^([0-9a-f]+)\tship\(([A-Za-z0-9._-]+)\)/.exec(linha);
+        // O log vem do mais novo para o mais velho: a primeira entrega de cada thread e a que vale.
+        if (m && !entregas.has(m[2]))
+            entregas.set(m[2], m[1]);
+    }
+    return entregas;
+}
+/** O retrato desta maquina: as threads nao fechadas do projeto, com a verdade do git por cima. */
+function retratoDaMaquina(carregado, opcoes = {}) {
+    const quando = opcoes.agora ?? (0, util_1.agora)();
+    const raiz = carregado.raiz;
+    const remoto = opcoes.remoto ?? carregado.manifesto.fabrica.remoto;
+    const itens = (0, board_1.threadsDeTodosOsPerfis)(carregado, false).filter((i) => i.thread.status !== 'fechada');
+    const monitor = (0, orquestracao_1.montarMonitor)(carregado, { semRuntime: true, agora: quando });
+    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]));
+    const threads = itens.map(({ thread: t }) => {
+        const pausa = linhas.get(t.id)?.pausas[0];
+        const entregue = entregas.get(t.id) ?? null;
+        const esperaVoce = !entregue && linhas.get(t.id)?.precisaDeHumano === 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,
+            atualizadaEm: t.atualizadaEm ?? null, entregue,
+            esperaVoce, pergunta: esperaVoce && pausa ? curto(pausa.pausaSobre || pausa.detalhe) : null,
+            paradaDesde: esperaVoce && pausa ? pausa.desdeEm : null,
+        };
+    }).sort((a, b) => a.id.localeCompare(b.id));
+    const eu = (0, roadmap_reservas_1.quemSouEu)(raiz, { por: opcoes.por, maquina: opcoes.maquina });
+    return { contrato: exports.CONTRATO_MAQUINA, maquina: eu.maquina, por: eu.por, projeto: carregado.manifesto.project.name,
+        versaoOrk: versao_1.VERSAO_DO_ORK, publicadoEm: quando, threads };
+}
+/** O que muda o retrato (sem o carimbo de hora): retrato igual nao precisa de push. */
+function assinaturaDoRetrato(e) {
+    const { publicadoEm: _publicadoEm, ...resto } = e;
+    return (0, node_crypto_1.createHash)('sha256').update(JSON.stringify(resto)).digest('hex');
+}
+function estadoValido(bruto) {
+    const e = bruto;
+    return !!e && e.contrato === exports.CONTRATO_MAQUINA && typeof e.maquina === 'string' && !!e.maquina.trim() &&
+        typeof e.publicadoEm === 'string' && Array.isArray(e.threads) &&
+        e.threads.every((t) => !!t && typeof t.id === 'string' && typeof t.fase === 'string');
+}
+function maquinasDaPonta(raiz, ponta) {
+    return (0, branch_de_estado_1.jsonsDaPonta)(raiz, ponta, DIR, PREFIXO).filter(estadoValido).sort((a, b) => a.maquina.localeCompare(b.maquina));
+}
+/** `ork fabrica` e `ork board`: todas as maquinas, lidas do remoto (ou da ultima copia, sem rede). */
+function lerFabrica(raiz, opcoes = {}) {
+    const remoto = opcoes.remoto ?? 'origin';
+    if (opcoes.semRemoto) {
+        const ponta = (0, branch_de_estado_1.pontaLocal)(raiz, remoto, exports.BRANCH_DA_FABRICA);
+        return { maquinas: maquinasDaPonta(raiz, ponta), atualizado: false, ponta };
+    }
+    const { ponta, atualizado } = (0, branch_de_estado_1.buscarBranch)(raiz, remoto, exports.BRANCH_DA_FABRICA, PREFIXO, opcoes.timeoutMs ?? 15000);
+    return { maquinas: maquinasDaPonta(raiz, ponta), atualizado, ponta };
+}
+const dirDoMonitor = (raiz) => path.join((0, estado_thread_1.raizDoEstado)(raiz), '.orkastery', 'monitor');
+function lerMarca(raiz) {
+    try {
+        return JSON.parse(fs.readFileSync(path.join(dirDoMonitor(raiz), ARQUIVO_DA_MARCA), 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+function gravarMarca(raiz, marca) {
+    const dir = dirDoMonitor(raiz);
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(path.join(dir, ARQUIVO_DA_MARCA), JSON.stringify(marca, null, 2) + '\n', { mode: 0o600 });
+}
+/**
+ * `ork fabrica publicar`: grava o retrato desta maquina na branch. Retrato igual ao ultimo, dentro
+ * da pulsacao, nem busca o remoto; `forcar` publica mesmo assim.
+ */
+function publicarMaquina(carregado, opcoes = {}) {
+    const raiz = carregado.raiz;
+    const remoto = opcoes.remoto ?? carregado.manifesto.fabrica.remoto;
+    const estado = retratoDaMaquina(carregado, { ...opcoes, remoto });
+    const assinatura = assinaturaDoRetrato(estado);
+    const marca = lerMarca(raiz);
+    if (!opcoes.forcar && marca && marca.assinatura === assinatura && marca.remoto === remoto && marca.maquina === estado.maquina &&
+        Date.parse(estado.publicadoEm) - Date.parse(marca.em) < exports.PULSACAO_MS) {
+        return { acao: 'sem-mudanca', maquina: estado.maquina, threads: estado.threads.length, commit: marca.commit, tentativas: 0 };
+    }
+    const arquivo = `${DIR}/${arquivoDaMaquina(estado.maquina)}`;
+    // I-57: uma publicacao por vez nesta maquina. Rajada de eventos (lote, fases em paralelo) nao
+    // vira N pushes disputando a mesma branch; quem chega depois sai, e a proxima batida publica.
+    fs.mkdirSync(dirDoMonitor(raiz), { recursive: true });
+    const trava = (0, monitor_lock_1.adquirirLockMonitor)(path.join(dirDoMonitor(raiz), 'fabrica.lock'));
+    if (!trava.ok)
+        return { acao: 'ocupado', maquina: estado.maquina, threads: estado.threads.length, commit: null, tentativas: 0 };
+    try {
+        for (let tentativa = 1; tentativa <= TENTATIVAS; tentativa++) {
+            const { ponta, atualizado } = (0, branch_de_estado_1.buscarBranch)(raiz, remoto, exports.BRANCH_DA_FABRICA, PREFIXO, 30000);
+            if (!atualizado)
+                throw new Error(`fabrica.sem-remoto: nao consegui ler ${exports.BRANCH_DA_FABRICA} em ${remoto}; publicar exige rede`);
+            const todas = [...maquinasDaPonta(raiz, ponta).filter((m) => m.maquina !== estado.maquina), estado]
+                .sort((a, b) => a.maquina.localeCompare(b.maquina));
+            const commit = (0, branch_de_estado_1.gravarNaBranch)(raiz, remoto, exports.BRANCH_DA_FABRICA, ponta, [
+                { caminho: arquivo, conteudo: JSON.stringify(estado, null, 2) + '\n' },
+                { caminho: PAINEL, conteudo: painelDaFabricaEmMarkdown(todas) },
+            ], `fabrica: ${estado.maquina} publicou ${estado.threads.length} thread(s)`, PREFIXO);
+            if (commit) {
+                gravarMarca(raiz, { assinatura, em: estado.publicadoEm, commit, remoto, maquina: estado.maquina });
+                return { acao: 'publicou', maquina: estado.maquina, threads: estado.threads.length, commit, tentativas: tentativa };
+            }
+        }
+        throw new Error(`fabrica.concorrencia: ${TENTATIVAS} pushes recusados seguidos; tente de novo em instantes`);
+    }
+    finally {
+        trava.liberar();
+    }
+}
+/** `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 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);
+        if (!atualizado)
+            throw new Error(`fabrica.sem-remoto: nao consegui ler ${exports.BRANCH_DA_FABRICA} em ${remoto}; sair exige rede`);
+        const todas = maquinasDaPonta(raiz, ponta);
+        if (!todas.some((m) => m.maquina === maquina))
+            return null;
+        const restantes = todas.filter((m) => m.maquina !== maquina);
+        const commit = (0, branch_de_estado_1.gravarNaBranch)(raiz, remoto, exports.BRANCH_DA_FABRICA, ponta, [
+            { caminho: `${DIR}/${arquivoDaMaquina(maquina)}`, conteudo: null },
+            { caminho: PAINEL, conteudo: painelDaFabricaEmMarkdown(restantes) },
+        ], `fabrica: ${maquina} saiu`, PREFIXO);
+        if (commit) {
+            try {
+                fs.rmSync(path.join(dirDoMonitor(raiz), ARQUIVO_DA_MARCA), { force: true });
+            }
+            catch { /* marca local */ }
+            return commit;
+        }
+    }
+    throw new Error(`fabrica.concorrencia: ${TENTATIVAS} pushes recusados seguidos; tente de novo em instantes`);
+}
+/** Uma linha JSON por publicacao em segundo plano: quem publica sozinho precisa deixar rastro. */
+function registrarPublicacao(raiz, registro) {
+    try {
+        const dir = dirDoMonitor(raiz);
+        fs.mkdirSync(dir, { recursive: true });
+        fs.appendFileSync(path.join(dir, ARQUIVO_DO_LOG), JSON.stringify({ ts: (0, util_1.agora)(), ...registro }) + '\n', { mode: 0o600 });
+    }
+    catch { /* o log e informativo */ }
+}
+const ativas = (e) => e.threads.filter((t) => !t.entregue);
+/** O que o resumo do pulse mostra das outras maquinas: so ativas, e quem espera o dono. */
+function resumoDasOutrasMaquinas(p, eu) {
+    return p.maquinas.filter((m) => m.maquina !== eu).map((m) => ({
+        maquina: m.maquina, publicadoEm: m.publicadoEm, ativas: ativas(m).length,
+        esperando: ativas(m).filter((t) => t.esperaVoce).map((t) => ({ thread: t.id, fase: t.fase, pergunta: t.pergunta,
+            desdeEm: t.paradaDesde })),
+    })).filter((m) => m.ativas > 0);
+}
+function tabela(cabecalho, linhas) {
+    const largura = cabecalho.map((c, i) => Math.max(c.length, ...linhas.map((l) => l[i].length)));
+    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)];
+}
+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', 'ITEM', 'ESPERA VOCE'], vivas.map((t) => [
+            t.id, t.modo, t.fase, t.roadmap ?? '-', t.esperaVoce ? `sim: ${curto(t.pergunta ?? 'veredito', 40)}` : '-',
+        ]))];
+}
+/** `ork fabrica`: todas as maquinas. */
+function textoDaFabrica(p, eu) {
+    const linhas = [];
+    if (!p.atualizado)
+        linhas.push('AVISO: sem leitura nova do remoto; esta e a ultima copia lida nesta maquina.', '');
+    if (p.maquinas.length === 0) {
+        linhas.push(`Nenhuma maquina publicou ainda em ${exports.BRANCH_DA_FABRICA}. Publique esta com: ork fabrica publicar`);
+        return linhas.join('\n');
+    }
+    for (const m of p.maquinas)
+        linhas.push(...blocoDaMaquina(m, eu), '');
+    linhas.push((0, horario_1.legendaDoFuso)());
+    return linhas.join('\n');
+}
+/** A secao de `ork board` com as outras maquinas. */
+function textoDasOutrasMaquinas(p, eu) {
+    const outras = p.maquinas.filter((m) => m.maquina !== eu);
+    const origem = p.atualizado ? 'lido agora' : 'ultima copia local';
+    if (outras.length === 0)
+        return `Outras maquinas (${exports.BRANCH_DA_FABRICA}, ${origem}): nenhuma publicou ainda.`;
+    const linhas = [`Outras maquinas (${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');
+}
+/** O `FABRICA.md` da branch: o mesmo retrato, para quem abre o GitHub. */
+function painelDaFabricaEmMarkdown(maquinas) {
+    const linhas = [
+        '# Fábrica',
+        '',
+        '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 | Item | Espera você | Publicado |',
+        '| --- | --- | --- | --- | --- | --- | --- |',
+    ];
+    const vivas = maquinas.flatMap((m) => ativas(m).map((t) => ({ m, t })));
+    if (vivas.length === 0)
+        linhas.push('| — | nenhuma thread ativa | — | — | — | — | — |');
+    for (const { m, t } of vivas) {
+        const pergunta = t.esperaVoce ? `sim: ${curto(t.pergunta ?? 'veredito', 60).replace(/\|/g, '/')}` : '—';
+        linhas.push(`| ${m.maquina} | ${t.id} | ${t.modo} | ${t.fase} | ${t.roadmap ?? '—'} | ${pergunta} | ${(0, horario_1.formatarDataHora)(m.publicadoEm)} |`);
+    }
+    return [...linhas, '', (0, horario_1.legendaDoFuso)(), ''].join('\n');
+}

package/dist/fabrica-publicar.js

@@ -0,0 +1,76 @@
+"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.publicarEmSegundoPlano = publicarEmSegundoPlano;
+/**
+ * I-51 (RM-047): a publicacao do estado da fabrica em segundo plano.
+ *
+ * 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.
+ */
+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");
+/**
+ * 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) {
+    if (process.env.ORK_FABRICA_PUBLICAR === '0')
+        return false;
+    let carregado;
+    try {
+        carregado = (0, manifest_1.carregarManifesto)(raiz);
+    }
+    catch {
+        return false;
+    }
+    if (!carregado || carregado.erros.length > 0 || !(0, maquina_1.fabricaCompartilhada)(carregado.manifesto))
+        return false;
+    const cli = path.join(__dirname, 'index.js');
+    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 });
+        filho.unref();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}