@orkastery/cli 0.5.3 → 0.5.6

package/dist/entrega-pr.js

@@ -24,6 +24,7 @@ const ledger_1 = require("./ledger");
 const modos_1 = require("./modos");
 const thread_1 = require("./thread");
 const util_1 = require("./util");
+const locale_1 = require("./locale");
 /** O merge `ship(<thread>)` mais recente na base remota, com o head do PR (segundo pai). */
 function mergeDaEntrega(raiz, thread, remoto, base) {
     const r = (0, util_1.exec)('git', ['log', `refs/remotes/${remoto}/${base}`, '--first-parent', '--format=%H%x09%P%x09%s', `--grep=^ship(${thread})`], raiz);
@@ -64,32 +65,32 @@ function registrarEntregaPorPr(carregado, threadId, opcoes = {}) {
     const base = carregado.manifesto.worktree.base_branch;
     const thread = (0, thread_1.lerThread)(raiz, threadId);
     if (thread.status === 'fechada')
-        return resultado(threadId, 'ja-registrada', 'thread ja fechada');
+        return resultado(threadId, 'ja-registrada', (0, locale_1.textoDoCatalogo)((m) => m.ship.prThreadFechada));
     if (opcoes.buscar !== false)
         (0, util_1.exec)('git', ['fetch', '-q', '--', remoto, `+refs/heads/${base}:refs/remotes/${remoto}/${base}`], raiz);
     const encontrado = mergeDaEntrega(raiz, threadId, remoto, base);
     if (!encontrado)
-        return resultado(threadId, 'sem-merge', `nenhum merge ship(${threadId}) em ${remoto}/${base}`);
+        return resultado(threadId, 'sem-merge', (0, locale_1.textoDoCatalogo)((m) => m.ship.prSemMerge(threadId, remoto, base)));
     // RM-044 (A3): o condutor roda o registrar-pr logo depois do merge; e aqui que ele fica sabendo da pagina que
     // vai deixar o push da base vermelho, lida da base remota que o fetch acabou de trazer.
     const merge = { ...encontrado, docsPendentes: (0, docs_1.docsPendentesDoMerge)(raiz, threadId, `refs/remotes/${remoto}/${base}`) };
     const dir = (0, thread_1.dirThread)(raiz, threadId);
     const jaTem = (0, ledger_1.lerLedger)(dir).some((e) => e.tipo === ledger_1.TIPOS_DE_EVENTO.shipConcluido && e.mergeSha === merge.mergeSha);
     if (jaTem)
-        return resultado(threadId, 'ja-registrada', 'esta entrega ja tem ship_done', merge);
+        return resultado(threadId, 'ja-registrada', (0, locale_1.textoDoCatalogo)((m) => m.ship.prJaTemShipDone), merge);
     // A ponta do remoto AGORA, e o merge dentro dela: e o que torna o push provado, nao presumido.
     const remotoAgora = (0, util_1.exec)('git', ['ls-remote', '--', remoto, `refs/heads/${base}`], raiz);
     const ponta = remotoAgora.ok ? remotoAgora.stdout.split('\t')[0].trim() : '';
     if (!ponta || !(0, util_1.exec)('git', ['merge-base', '--is-ancestor', merge.mergeSha, ponta], raiz).ok) {
-        return resultado(threadId, 'recusada', `o merge ${merge.mergeSha.slice(0, 7)} nao esta na ponta de ${remoto}/${base}`, merge);
+        return resultado(threadId, 'recusada', (0, locale_1.textoDoCatalogo)((m) => m.ship.prForaDaPonta(merge.mergeSha.slice(0, 7), remoto, base)), merge);
     }
     const ci = (0, ci_1.consultarCi)(carregado, merge.headSha ?? merge.mergeSha, remoto, opcoes.executorCi);
     if (ci.required && !ci.ok) {
-        return resultado(threadId, 'recusada', `sem CI verde no head do PR: ${ci.detail}`, { ...merge, ci });
+        return resultado(threadId, 'recusada', (0, locale_1.textoDoCatalogo)((m) => m.ship.prSemCiVerde((0, locale_1.remontar)(ci.detail))), { ...merge, ci });
     }
     // RM-037 (fatia 3, defeito 6): o ensaio confere tudo e para aqui, sem ledger, fase nem fabrica.
     if (opcoes.dryRun) {
-        return resultado(threadId, 'registraria', `ensaio: registraria ship_done pelo merge ${merge.mergeSha.slice(0, 7)} do PR (nada gravado)`, { ...merge, ci });
+        return resultado(threadId, 'registraria', (0, locale_1.textoDoCatalogo)((m) => m.ship.prRegistraria(merge.mergeSha.slice(0, 7))), { ...merge, ci });
     }
     (0, ledger_1.registrar)(dir, threadId, ledger_1.TIPOS_DE_EVENTO.shipConcluido, {
         de: thread.base?.branch ?? null,
@@ -114,7 +115,7 @@ function registrarEntregaPorPr(carregado, threadId, opcoes = {}) {
     avancarParaShip(raiz, threadId);
     if (opcoes.publicar !== false)
         (0, fabrica_publicar_1.publicarEmSegundoPlano)(raiz);
-    return resultado(threadId, 'registrou', `ship_done pelo merge ${merge.mergeSha.slice(0, 7)} do PR`, { ...merge, ci });
+    return resultado(threadId, 'registrou', (0, locale_1.textoDoCatalogo)((m) => m.ship.prRegistrou(merge.mergeSha.slice(0, 7))), { ...merge, ci });
 }
 const ghApi = (caminho) => (0, util_1.exec)('gh', ['api', caminho, '-H', 'Accept: application/vnd.github+json'], process.cwd(), 120000);
 function lerJson(r) {
@@ -139,25 +140,25 @@ function registrarEntregaExternaPorPr(carregado, threadId, opcoes) {
     const gh = opcoes.executorGitHub ?? ghApi;
     const declarados = carregado.manifesto.ci.external_repositories;
     if (!Object.hasOwn(declarados, repo)) {
-        return resultado(threadId, 'recusada', `o repositorio ${repo} nao esta declarado em ci.external_repositories do orkastery.yaml`);
+        return resultado(threadId, 'recusada', (0, locale_1.textoDoCatalogo)((m) => m.ship.prRepoNaoDeclarado(repo)));
     }
     if (!Number.isSafeInteger(n) || n < 1)
-        return resultado(threadId, 'recusada', `--pr precisa ser o numero do PR, recebido ${String(n)}`);
+        return resultado(threadId, 'recusada', (0, locale_1.textoDoCatalogo)((m) => m.ship.prNumeroInvalido(String(n))));
     const thread = (0, thread_1.lerThread)(raiz, threadId);
     if (thread.status === 'fechada')
-        return resultado(threadId, 'ja-registrada', 'thread ja fechada');
+        return resultado(threadId, 'ja-registrada', (0, locale_1.textoDoCatalogo)((m) => m.ship.prThreadFechada));
     const dir = (0, thread_1.dirThread)(raiz, threadId);
     if ((0, ledger_1.lerLedger)(dir).some((e) => e.tipo === ledger_1.TIPOS_DE_EVENTO.shipConcluido && e.repositorio === repo && e.pr === n)) {
-        return resultado(threadId, 'ja-registrada', `o PR #${n} de ${repo} ja tem ship_done`);
+        return resultado(threadId, 'ja-registrada', (0, locale_1.textoDoCatalogo)((m) => m.ship.prExternoJaTem(n, repo)));
     }
     const pr = lerJson(gh(`repos/${repo}/pulls/${n}`));
     if (!pr)
-        return resultado(threadId, 'recusada', `a consulta do PR #${n} de ${repo} ao GitHub falhou`);
+        return resultado(threadId, 'recusada', (0, locale_1.textoDoCatalogo)((m) => m.ship.prConsultaFalhou(n, repo)));
     const mergeSha = typeof pr.merge_commit_sha === 'string' && /^[0-9a-f]{40}$/.test(pr.merge_commit_sha) ? pr.merge_commit_sha : null;
     const headSha = typeof pr.head?.sha === 'string' && /^[0-9a-f]{40}$/.test(pr.head.sha) ? pr.head.sha : null;
     const base = typeof pr.base?.ref === 'string' && /^[A-Za-z0-9._/-]{1,200}$/.test(pr.base.ref) ? pr.base.ref : null;
     if (pr.merged !== true || !mergeSha || !headSha || !base) {
-        return resultado(threadId, 'sem-merge', `o PR #${n} de ${repo} nao esta mesclado`);
+        return resultado(threadId, 'sem-merge', (0, locale_1.textoDoCatalogo)((m) => m.ship.prNaoMesclado(n, repo)));
     }
     // Achado A4 do CHECK: o PR precisa ser DESTA thread e ter entrado na branch padrao do repositorio. Sem o
     // vinculo, qualquer PR mesclado do repositorio viraria entrega de qualquer thread; sem a base, um PR
@@ -167,28 +168,28 @@ function registrarEntregaExternaPorPr(carregado, threadId, opcoes) {
         // letra ou digito colado nao (outro id). Sem diferenciar maiusculas.
         .some((x) => new RegExp(`(^|[^a-z0-9-])${threadId.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(?![a-z0-9])`, 'i').test(x));
     if (!vinculo) {
-        return resultado(threadId, 'recusada', `o PR #${n} de ${repo} nao cita a thread ${threadId} no titulo, no corpo nem na branch`, { mergeSha, headSha });
+        return resultado(threadId, 'recusada', (0, locale_1.textoDoCatalogo)((m) => m.ship.prNaoCitaThread(n, repo, threadId)), { mergeSha, headSha });
     }
     const repositorio = lerJson(gh(`repos/${repo}`));
     if (!repositorio)
-        return resultado(threadId, 'recusada', `a consulta de ${repo} ao GitHub falhou`, { mergeSha, headSha });
+        return resultado(threadId, 'recusada', (0, locale_1.textoDoCatalogo)((m) => m.ship.prRepoFalhou(repo)), { mergeSha, headSha });
     if (repositorio.default_branch !== base) {
-        return resultado(threadId, 'recusada', `o PR #${n} entrou em ${base}, e a branch padrao de ${repo} e ${repositorio.default_branch ?? 'desconhecida'}`, { mergeSha, headSha });
+        return resultado(threadId, 'recusada', (0, locale_1.textoDoCatalogo)((m) => m.ship.prOutraBase(n, base, repo, repositorio.default_branch)), { mergeSha, headSha });
     }
     // A ponta da base AGORA, e o merge dentro dela: o push provado, pela mesma pergunta do ls-remote.
     const ramo = lerJson(gh(`repos/${repo}/branches/${encodeURIComponent(base)}`));
     const ponta = typeof ramo?.commit?.sha === 'string' && /^[0-9a-f]{40}$/.test(ramo.commit.sha) ? ramo.commit.sha : '';
     const comparacao = ponta ? lerJson(gh(`repos/${repo}/compare/${mergeSha}...${ponta}`)) : null;
     if (!ponta || !comparacao || !['ahead', 'identical'].includes(String(comparacao.status))) {
-        return resultado(threadId, 'recusada', `o merge ${mergeSha.slice(0, 7)} nao esta na ponta de ${repo}:${base}`, { mergeSha, headSha });
+        return resultado(threadId, 'recusada', (0, locale_1.textoDoCatalogo)((m) => m.ship.prExternoForaDaPonta(mergeSha.slice(0, 7), repo, base)), { mergeSha, headSha });
     }
     const check = declarados[repo];
     const ci = check ? (0, ci_1.consultarCiDoRepositorio)(repo, headSha, check, opcoes.executorCi) : null;
     if (ci && !ci.ok) {
-        return resultado(threadId, 'recusada', `sem CI verde no head do PR: ${ci.detail}`, { mergeSha, headSha, ci });
+        return resultado(threadId, 'recusada', (0, locale_1.textoDoCatalogo)((m) => m.ship.prSemCiVerde((0, locale_1.remontar)(ci.detail))), { mergeSha, headSha, ci });
     }
     if (opcoes.dryRun) {
-        return resultado(threadId, 'registraria', `ensaio: registraria ship_done pelo merge ${mergeSha.slice(0, 7)} do PR #${n} de ${repo} (nada gravado)`, { mergeSha, headSha, ci });
+        return resultado(threadId, 'registraria', (0, locale_1.textoDoCatalogo)((m) => m.ship.prExternoRegistraria(mergeSha.slice(0, 7), n, repo)), { mergeSha, headSha, ci });
     }
     (0, ledger_1.registrar)(dir, threadId, ledger_1.TIPOS_DE_EVENTO.shipConcluido, {
         de: thread.base?.branch ?? null,
@@ -215,7 +216,7 @@ function registrarEntregaExternaPorPr(carregado, threadId, opcoes) {
     avancarParaShip(raiz, threadId);
     if (opcoes.publicar !== false)
         (0, fabrica_publicar_1.publicarEmSegundoPlano)(raiz);
-    return resultado(threadId, 'registrou', `ship_done pelo merge ${mergeSha.slice(0, 7)} do PR #${n} de ${repo}`, { mergeSha, headSha, ci });
+    return resultado(threadId, 'registrou', (0, locale_1.textoDoCatalogo)((m) => m.ship.prExternoRegistrou(mergeSha.slice(0, 7), n, repo)), { mergeSha, headSha, ci });
 }
 /** `ork ship registrar-pr --todas`: toda thread aberta que ja tem merge `ship(<thread>)` na base. */
 function registrarEntregasPorPr(carregado, opcoes = {}) {
@@ -230,7 +231,7 @@ function registrarEntregasPorPr(carregado, opcoes = {}) {
             return registrarEntregaPorPr(carregado, id, { ...opcoes, buscar: false, publicar: false });
         }
         catch (e) {
-            return resultado(id, 'recusada', e.message);
+            return resultado(id, 'recusada', e instanceof locale_1.ErroDoCatalogo ? (0, locale_1.textoDoCatalogo)(e.montar) : e.message);
         }
     });
     // Uma publicacao so para o lote inteiro, nao uma por thread.

package/dist/escopo-escrita.js

@@ -60,7 +60,16 @@ function exigirEscopoDeEscrita(threads) {
 /** Um nome autorizado nao pode ser alias de outra thread ou de estado externo. */
 function validarDiretorioDeThread(raiz, id) {
     validarThreadDeEscrita(id);
-    const dir = (0, estado_thread_1.estadoCanonico)(raiz, id);
+    let dir;
+    // RM-047: o estadoCanonico já recusa link (estado.link); aqui a recusa mantém o código do escopo.
+    try {
+        dir = (0, estado_thread_1.estadoCanonico)(raiz, id);
+    }
+    catch (e) {
+        if (e.message.startsWith('estado.link'))
+            throw new Error('scope.thread.alias');
+        throw e;
+    }
     for (const candidato of [path.dirname(path.dirname(dir)), path.dirname(dir), dir]) {
         const stat = fs.lstatSync(candidato, { throwIfNoEntry: false });
         if (!stat)

package/dist/estado-thread.js

@@ -35,6 +35,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.raizDoEstado = raizDoEstado;
 exports.estadoCanonico = estadoCanonico;
+exports.exigirEstadoSemLink = exigirEstadoSemLink;
 exports.vincularEstado = vincularEstado;
 exports.comEstadoParaGit = comEstadoParaGit;
 exports.auditarEstado = auditarEstado;
@@ -66,7 +67,28 @@ function raizDoEstado(raiz) {
 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);
+    const principal = raizDoEstado(raiz);
+    exigirEstadoSemLink(principal, ['.orkastery', 'threads', id]);
+    return path.join(principal, '.orkastery', 'threads', id);
+}
+/**
+ * RM-047 (fronteira de confiança): na árvore principal, `.orkastery`, `threads` e o diretório da thread
+ * são pastas de verdade. Um link versionado no clone levaria ledger, claims e thread.json para fora da
+ * raiz, e o `ork` anexaria linhas em arquivo alheio. O link que o próprio `ork` cria fica na worktree
+ * (`vincularEstado`) e aponta para cá; ele nunca é um destes componentes.
+ */
+function exigirEstadoSemLink(principal, componentes) {
+    let atual = principal;
+    for (const nome of componentes) {
+        atual = path.join(atual, nome);
+        const stat = fs.lstatSync(atual, { throwIfNoEntry: false });
+        if (!stat)
+            return;
+        if (stat.isSymbolicLink()) {
+            throw new Error(`estado.link: ${path.relative(principal, atual)} é link simbólico; o estado do ork fica em ` +
+                'pastas de verdade dentro da raiz (um link versionado levaria a escrita para fora dela). Remova o link.');
+        }
+    }
 }
 function mesmoArquivo(a, b) {
     return fs.existsSync(a) && fs.existsSync(b) && fs.realpathSync(a) === fs.realpathSync(b);

package/dist/experiencia-instalacao.js

@@ -41,10 +41,14 @@ exports.aplicarExperiencia = aplicarExperiencia;
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const node_crypto_1 = require("node:crypto");
+const locale_1 = require("./locale");
 exports.INICIO_EXPERIENCIA = '<!-- orkastery:experiencia:begin -->';
 exports.FIM_EXPERIENCIA = '<!-- orkastery:experiencia:end -->';
 const CONTRATO = 'ork.experiencia-install/v1';
-const LINHA_DO_DIRETORIO = /^Se ativo, leia a skill selecionada pelo campo skill no diretório (".*")\.$/;
+/** RM-061 (F3a, D8): as linguas em que o bloco e escrito e, sem recibo, reconhecido. */
+const LOCALES_DO_BLOCO = ['pt-BR', 'en'];
+/** Marca do diretorio no molde da linha: o texto antes e depois dela reconhece a linha em cada lingua. */
+const MARCA_DO_DIRETORIO = '{{diretorio}}';
 const conflito = () => { throw Error('experiencia.bloco.conflict: bloco ou recibo alterado/duplicado; preserve os arquivos e revise a instalação'); };
 /** Recusa symlinks e hardlinks em qualquer componente antes da leitura/escrita. */
 function caminhoSeguro(projeto, arquivo) {
@@ -83,18 +87,35 @@ function decodificar(s) {
     return b;
 }
 const eolDe = (b) => b.includes('\r\n') ? '\r\n' : '\n';
-/** O caminho vai relativo ao projeto: o arquivo de instruções costuma ser versionado. */
-function nucleoDoBloco(skill, eol) {
-    return Buffer.from([exports.INICIO_EXPERIENCIA,
-        '## Experiência de orquestração',
-        'Consulte `ork experiencia show --json` neste projeto. Se experience for false, não ative o pacote.',
-        `Se ativo, leia a skill selecionada pelo campo skill no diretório ${JSON.stringify(skill)}.`,
-        'As preferências são dados do núcleo; preserve gates, proveniência humana e permissões do host.',
+/**
+ * O caminho vai relativo ao projeto: o arquivo de instruções costuma ser versionado. RM-061 (F3a, D1 e D2): o texto
+ * sai na língua pedida, pela família `gerados` do catálogo; os marcadores são os mesmos nas duas línguas.
+ */
+function nucleoDoBloco(skill, eol, locale) {
+    const t = (0, locale_1.msg)(locale).gerados.experiencia;
+    return Buffer.from([exports.INICIO_EXPERIENCIA, `## ${t.titulo}`, t.consulte, t.diretorio(JSON.stringify(skill)), t.preferencias,
         exports.FIM_EXPERIENCIA, ''].join(eol));
 }
+/** O diretório escrito na linha do bloco de uma língua, ou null se a linha não é a dessa língua. */
+function diretorioDaLinha(linha, locale) {
+    const molde = (0, locale_1.msg)(locale).gerados.experiencia.diretorio(MARCA_DO_DIRETORIO);
+    const corte = molde.indexOf(MARCA_DO_DIRETORIO);
+    const antes = molde.slice(0, corte), depois = molde.slice(corte + MARCA_DO_DIRETORIO.length);
+    if (linha.length < antes.length + depois.length || !linha.startsWith(antes) || !linha.endsWith(depois))
+        return null;
+    let skill;
+    try {
+        skill = JSON.parse(linha.slice(antes.length, linha.length - depois.length));
+    }
+    catch {
+        return null;
+    }
+    return typeof skill === 'string' && !/[\r\n`]/.test(skill) ? skill : null;
+}
 /**
  * Bloco sem recibo (clone novo, `.orkastery/` apagado) só é adotado quando é exatamente o texto
- * que esta versão ou a anterior geram, com qualquer diretório; qualquer outra edição é conflito.
+ * que esta versão ou a anterior geram, com qualquer diretório e em qualquer das duas línguas (RM-061,
+ * F3a, D8); qualquer outra edição é conflito.
  */
 function reconhecerBloco(antes) {
     if (contar(antes, exports.INICIO_EXPERIENCIA) !== 1 || contar(antes, exports.FIM_EXPERIENCIA) !== 1)
@@ -108,18 +129,14 @@ function reconhecerBloco(antes) {
         fim += eol.length;
     const texto = antes.subarray(inicio, fim);
     const linha = texto.toString('utf8').split(eol)[3] ?? '';
-    const m = LINHA_DO_DIRETORIO.exec(linha);
-    let skill;
-    try {
-        skill = m ? JSON.parse(m[1]) : undefined;
-    }
-    catch {
-        return null;
-    }
-    if (typeof skill !== 'string' || /[\r\n`]/.test(skill))
-        return null;
-    const esperado = nucleoDoBloco(skill, eol);
-    if (!texto.equals(esperado) && !texto.equals(esperado.subarray(0, esperado.length - eol.length)))
+    const reconhecido = LOCALES_DO_BLOCO.some((locale) => {
+        const skill = diretorioDaLinha(linha, locale);
+        if (skill === null)
+            return false;
+        const esperado = nucleoDoBloco(skill, eol, locale);
+        return texto.equals(esperado) || texto.equals(esperado.subarray(0, esperado.length - eol.length));
+    });
+    if (!reconhecido)
         return null;
     // Uma linha em branco antes do bloco é o separador que a instalação põe depois de uma linha.
     const sep = Buffer.from(eol);
@@ -144,8 +161,11 @@ function removerBloco(antes, bloco) {
     const juncao = prefixo.length && prefixo.at(-1) !== 10 && sufixo.length ? Buffer.from(bloco.eol) : Buffer.alloc(0);
     return Buffer.concat([prefixo, juncao, sufixo]);
 }
-/** Planejamento puro em relação ao disco: dry-run e preflight usam o mesmo contrato. */
-function planejarExperiencia(projeto, host, skill) {
+/**
+ * Planejamento puro em relação ao disco: dry-run e preflight usam o mesmo contrato. O bloco sai no `locale` pedido
+ * (RM-061, F3a), pt-BR por omissão: só o `ork adapter install` passa a língua do dono (D2).
+ */
+function planejarExperiencia(projeto, host, skill, locale = locale_1.LOCALE_PADRAO) {
     projeto = fs.realpathSync(path.resolve(projeto));
     if (!['claude-code', 'codex'].includes(host))
         throw Error('experiencia.host.unsupported');
@@ -189,7 +209,7 @@ function planejarExperiencia(projeto, host, skill) {
         let separador, nucleo, anterior;
         if (antes && bloco) {
             // Atualização no lugar: o que está antes e depois do bloco, inclusive edição externa, fica.
-            nucleo = nucleoDoBloco(skill, bloco.eol);
+            nucleo = nucleoDoBloco(skill, bloco.eol, locale);
             separador = bloco.separador;
             depois = Buffer.concat([antes.subarray(0, bloco.inicio), nucleo, antes.subarray(bloco.fim)]);
             // Adotado sem recibo: se só havia o bloco, o arquivo conta como criado pelo pacote.
@@ -198,7 +218,7 @@ function planejarExperiencia(projeto, host, skill) {
         }
         else {
             const base = antes ?? Buffer.alloc(0), eol = eolDe(base);
-            nucleo = nucleoDoBloco(skill, eol);
+            nucleo = nucleoDoBloco(skill, eol, locale);
             separador = Buffer.from(base.length ? (base.at(-1) === 10 ? eol : eol + eol) : '');
             depois = Buffer.concat([base, separador, nucleo]);
             anterior = antes?.toString('base64') ?? null;

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