@orkastery/cli 0.5.3 → 0.6.0

package/dist/tokens.js

@@ -63,6 +63,7 @@ const modos_1 = require("./modos");
 const phase_1 = require("./phase");
 const thread_1 = require("./thread");
 const util_1 = require("./util");
+const locale_1 = require("./locale");
 /**
  * Janela nominal usada na estimativa por transcript.
  * Declarada, nao escondida: quem le a medida sabe contra o que ela foi calculada.
@@ -208,21 +209,24 @@ function gateDeTokens(carregado, threadId, opcoes = {}) {
 }
 /** Texto de `ork gate next`. */
 function textoDoGateDeTokens(v) {
+    const m = (0, locale_1.msg)().operacao.restante.gate.tokens;
+    const detalhe = m.localizarDetalhe(v.medida.fonte, v.medida.detalhe);
+    const razao = m.localizarRazao(v.medida.ocupacao, v.limiares.rotate_above, v.limiares.force_rotate_above, v.passoPesado, v.razao.includes('refazer fase reprovada'), v.proximoPasso, v.razao);
     const linhas = [];
-    linhas.push(`ork gate next: thread ${v.thread}`);
-    linhas.push(`  ocupacao       ${v.medida.ocupacao === null ? 'nao medivel' : `${(v.medida.ocupacao * 100).toFixed(1)}%`}`);
-    linhas.push(`  fonte          ${v.medida.fonte}`);
-    linhas.push(`                 ${v.medida.detalhe}`);
-    linhas.push(`  limiares       rotate_above ${v.limiares.rotate_above} | force_rotate_above ${v.limiares.force_rotate_above}`);
-    linhas.push(`  proximo passo  ${v.proximoPasso} (${v.passoPesado ? 'pesado' : 'leve'})`);
+    linhas.push(m.titulo(v.thread));
+    linhas.push(m.ocupacao(v.medida.ocupacao === null ? m.naoMedivel : `${(v.medida.ocupacao * 100).toFixed(1)}%`));
+    linhas.push(m.fonte(v.medida.fonte));
+    linhas.push(m.detalhe(detalhe));
+    linhas.push(m.limiares(v.limiares.rotate_above, v.limiares.force_rotate_above));
+    linhas.push(m.proximo(v.proximoPasso, v.passoPesado ? m.pesado : m.leve));
     linhas.push('');
-    linhas.push(`VEREDITO: ${v.veredito}  (decidido por ${v.decididoPor})`);
-    linhas.push(`  razao: ${v.razao}`);
+    linhas.push(m.veredito(v.veredito, v.decididoPor));
+    linhas.push(m.razao(razao));
     if (v.slugSugerido) {
-        linhas.push(`  slug da nova sessao: ${v.slugSugerido}`);
-        linhas.push(`  proximo passo: ork handoff export ${v.thread} --proxima-fase ${v.proximoPasso}`);
+        linhas.push(m.slug(v.slugSugerido));
+        linhas.push(m.handoff(v.thread, v.proximoPasso));
     }
     linhas.push('');
-    linhas.push(`Registrado no ledger como token_gate: ork phase list ${v.thread}`);
+    linhas.push(m.ledger(v.thread));
     return linhas.join('\n');
 }

package/dist/trabalho-thread.js

@@ -0,0 +1,297 @@
+"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.LIMITE_DE_ARQUIVOS_DO_TRABALHO = exports.LIMITE_TOTAL_DO_TRABALHO = exports.LIMITE_DE_ARQUIVO_DO_TRABALHO = void 0;
+exports.diretorioDoTrabalho = diretorioDoTrabalho;
+exports.caminhoDoTrabalho = caminhoDoTrabalho;
+exports.garantirDiretorioDoTrabalho = garantirDiretorioDoTrabalho;
+exports.gravarRespostaFinalDaSessao = gravarRespostaFinalDaSessao;
+exports.resumirTrabalhoDaThread = resumirTrabalhoDaThread;
+exports.formatarResumoDoTrabalho = formatarResumoDoTrabalho;
+/** RM-064 T4: o trabalho pequeno da sessão acompanha a thread entre contas. */
+const node_crypto_1 = require("node:crypto");
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const thread_1 = require("./thread");
+exports.LIMITE_DE_ARQUIVO_DO_TRABALHO = 256 * 1024;
+exports.LIMITE_TOTAL_DO_TRABALHO = 512 * 1024;
+exports.LIMITE_DE_ARQUIVOS_DO_TRABALHO = 24;
+const LIMITE_DE_ENTRADAS = 256;
+const PROFUNDIDADE_MAXIMA = 4;
+/** Caminho real no estado canônico. O prompt usa a forma relativa e portátil de `caminhoDoTrabalho`. */
+function diretorioDoTrabalho(raiz, threadId) {
+    return path.join((0, thread_1.dirThread)(raiz, threadId), 'trabalho');
+}
+function caminhoDoTrabalho(threadId) {
+    return `.orkastery/threads/${threadId}/trabalho/`;
+}
+function abrirDiretorioDoTrabalho(raiz, threadId) {
+    const diretorio = diretorioDoTrabalho(raiz, threadId);
+    fs.mkdirSync(diretorio, { recursive: true, mode: 0o700 });
+    let fd;
+    try {
+        fd = fs.openSync(diretorio, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW | fs.constants.O_DIRECTORY);
+    }
+    catch {
+        throw new Error('trabalho da thread precisa ser diretorio real, nunca link');
+    }
+    try {
+        const aberto = fs.fstatSync(fd);
+        if (!aberto.isDirectory())
+            throw new Error('trabalho da thread precisa ser diretorio real, nunca link');
+        // `mode` de mkdir só vale na criação. Pelo descritor, uma troca de caminho não aplica modo em outro alvo.
+        fs.fchmodSync(fd, 0o700);
+        const real = fs.realpathSync(diretorio), peloCaminho = fs.statSync(real);
+        if (aberto.dev !== peloCaminho.dev || aberto.ino !== peloCaminho.ino)
+            throw new Error('trabalho da thread mudou durante a abertura');
+        return { diretorio, real, fd };
+    }
+    catch (erro) {
+        fs.closeSync(fd);
+        throw erro;
+    }
+}
+function garantirDiretorioDoTrabalho(raiz, threadId) {
+    const aberto = abrirDiretorioDoTrabalho(raiz, threadId);
+    fs.closeSync(aberto.fd);
+    const { diretorio } = aberto;
+    return diretorio;
+}
+function nomeSeguro(nome) {
+    return nome.replace(/[\u0000-\u001f\u007f]/g, '?');
+}
+/**
+ * Persiste a resposta do runtime na pasta privada da thread. O ledger recebe somente este recibo:
+ * conteúdo de agente pode conter detalhes grandes ou sensíveis e nunca é copiado para o evento.
+ */
+function gravarRespostaFinalDaSessao(raiz, threadId, sessionId, texto) {
+    if (!/^[a-zA-Z0-9-]{1,128}$/.test(sessionId))
+        throw new Error('id de sessão inválido para resposta final');
+    const aberto = abrirDiretorioDoTrabalho(raiz, threadId);
+    const bruto = Buffer.from(texto, 'utf8');
+    const truncada = bruto.byteLength > exports.LIMITE_DE_ARQUIVO_DO_TRABALHO;
+    const conteudo = truncada
+        ? Buffer.from(bruto.subarray(0, exports.LIMITE_DE_ARQUIVO_DO_TRABALHO).toString('utf8').replace(/\uFFFD$/, ''), 'utf8')
+        : bruto;
+    const arquivo = `resposta-final-${sessionId}.md`;
+    const alvo = path.join(aberto.diretorio, arquivo);
+    const temporario = path.join(aberto.diretorio, `.${arquivo}.${process.pid}.${(0, node_crypto_1.randomUUID)()}.tmp`);
+    try {
+        fs.writeFileSync(temporario, conteudo, { mode: 0o600, flag: 'wx' });
+        fs.chmodSync(temporario, 0o600);
+        try {
+            fs.linkSync(temporario, alvo);
+        }
+        catch (e) {
+            if (e.code !== 'EEXIST')
+                throw e;
+            const existente = lerArquivoSeguro(aberto.real, alvo, {});
+            if (existente.estado !== 'ok' || !existente.conteudo.equals(conteudo))
+                throw new Error('resposta final já existe com conteúdo divergente');
+        }
+        const persistido = lerArquivoSeguro(aberto.real, alvo, {});
+        if (persistido.estado !== 'ok')
+            throw new Error('resposta final não pôde ser reconferida');
+        fs.chmodSync(alvo, 0o600);
+        return { arquivo, bytes: persistido.conteudo.byteLength,
+            sha256: (0, node_crypto_1.createHash)('sha256').update(persistido.conteudo).digest('hex'), truncada };
+    }
+    finally {
+        try {
+            fs.rmSync(temporario, { force: true });
+        }
+        catch { /* temporário já ausente */ }
+        fs.closeSync(aberto.fd);
+    }
+}
+const contido = (base, alvo) => alvo === base || alvo.startsWith(base + path.sep);
+/** Abre a entrada sem seguir o componente final e nunca lê mais que o teto mais um byte. */
+function lerArquivoSeguro(baseReal, absoluto, opcoes) {
+    try {
+        const antes = fs.realpathSync(absoluto);
+        if (!contido(baseReal, antes))
+            return { estado: 'link' };
+    }
+    catch {
+        return { estado: 'outro' };
+    }
+    opcoes.antesDeAbrir?.(absoluto);
+    let fd;
+    try {
+        fd = fs.openSync(absoluto, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW | fs.constants.O_NONBLOCK);
+    }
+    catch (erro) {
+        return { estado: erro.code === 'ELOOP' ? 'link' : 'outro' };
+    }
+    try {
+        const inicial = fs.fstatSync(fd);
+        if (!inicial.isFile())
+            return { estado: 'outro' };
+        if (inicial.size > exports.LIMITE_DE_ARQUIVO_DO_TRABALHO)
+            return { estado: 'grande' };
+        const buffer = Buffer.alloc(exports.LIMITE_DE_ARQUIVO_DO_TRABALHO + 1);
+        let lidos = 0;
+        while (lidos < buffer.length) {
+            const n = fs.readSync(fd, buffer, lidos, buffer.length - lidos, null);
+            if (n === 0)
+                break;
+            lidos += n;
+        }
+        const final = fs.fstatSync(fd);
+        if (lidos > exports.LIMITE_DE_ARQUIVO_DO_TRABALHO || final.size > exports.LIMITE_DE_ARQUIVO_DO_TRABALHO)
+            return { estado: 'grande' };
+        // Confere que o caminho ainda aponta para o mesmo inode aberto e continua dentro da pasta.
+        let peloCaminho, realDepois;
+        try {
+            realDepois = fs.realpathSync(absoluto);
+            peloCaminho = fs.statSync(realDepois);
+        }
+        catch {
+            return { estado: 'outro' };
+        }
+        if (!contido(baseReal, realDepois) || peloCaminho.dev !== final.dev || peloCaminho.ino !== final.ino)
+            return { estado: 'link' };
+        // Mudança durante a leitura não produz hash de estado híbrido.
+        if (lidos !== final.size || inicial.size !== final.size || inicial.mtimeMs !== final.mtimeMs || inicial.ctimeMs !== final.ctimeMs)
+            return { estado: 'outro' };
+        return { estado: 'ok', conteudo: buffer.subarray(0, lidos) };
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+/**
+ * Inventário deliberadamente limitado: não segue links, lê cada arquivo por descritor limitado e não deixa uma árvore
+ * de job dominar o prompt. A sessão sucessora recebe nomes, tamanhos e hashes; lê o arquivo pelo caminho se precisar.
+ */
+function resumirTrabalhoDaThread(raiz, threadId, opcoes = {}) {
+    const aberto = abrirDiretorioDoTrabalho(raiz, threadId);
+    const base = aberto.diretorio, baseReal = aberto.real;
+    const arquivos = [];
+    const ignorados = { grandes: 0, links: 0, excedentes: 0, outros: 0 };
+    let bytes = 0;
+    let entradas = 0;
+    const visitar = (diretorio, relativo, profundidade) => {
+        if (profundidade > PROFUNDIDADE_MAXIMA || entradas >= LIMITE_DE_ENTRADAS) {
+            ignorados.excedentes += 1;
+            return;
+        }
+        let dir;
+        try {
+            const real = fs.realpathSync(diretorio);
+            if (!contido(baseReal, real) || !fs.lstatSync(diretorio).isDirectory()) {
+                ignorados.links += 1;
+                return;
+            }
+            dir = fs.opendirSync(diretorio);
+        }
+        catch {
+            ignorados.outros += 1;
+            return;
+        }
+        const itens = [];
+        try {
+            while (entradas + itens.length < LIMITE_DE_ENTRADAS) {
+                const item = dir.readSync();
+                if (!item)
+                    break;
+                itens.push(item);
+            }
+            if (entradas + itens.length >= LIMITE_DE_ENTRADAS && dir.readSync())
+                ignorados.excedentes += 1;
+        }
+        finally {
+            dir.closeSync();
+        }
+        entradas += itens.length;
+        itens.sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+        for (const item of itens) {
+            const absoluto = path.join(diretorio, item.name);
+            const nome = path.posix.join(relativo, nomeSeguro(item.name));
+            if (item.isSymbolicLink()) {
+                ignorados.links += 1;
+                continue;
+            }
+            if (item.isDirectory()) {
+                visitar(absoluto, nome, profundidade + 1);
+                continue;
+            }
+            if (!item.isFile()) {
+                ignorados.outros += 1;
+                continue;
+            }
+            // Lista ou orçamento já cheios: o arquivo só conta como excedente, sem ser aberto nem lido.
+            if (arquivos.length >= exports.LIMITE_DE_ARQUIVOS_DO_TRABALHO || bytes >= exports.LIMITE_TOTAL_DO_TRABALHO) {
+                ignorados.excedentes += 1;
+                continue;
+            }
+            const leitura = lerArquivoSeguro(baseReal, absoluto, opcoes);
+            if (leitura.estado !== 'ok') {
+                if (leitura.estado === 'grande')
+                    ignorados.grandes += 1;
+                else if (leitura.estado === 'link')
+                    ignorados.links += 1;
+                else
+                    ignorados.outros += 1;
+                continue;
+            }
+            if (arquivos.length >= exports.LIMITE_DE_ARQUIVOS_DO_TRABALHO || bytes + leitura.conteudo.byteLength > exports.LIMITE_TOTAL_DO_TRABALHO) {
+                ignorados.excedentes += 1;
+                continue;
+            }
+            arquivos.push({ arquivo: nome, bytes: leitura.conteudo.byteLength,
+                sha256: (0, node_crypto_1.createHash)('sha256').update(leitura.conteudo).digest('hex') });
+            bytes += leitura.conteudo.byteLength;
+        }
+    };
+    try {
+        visitar(base, '', 0);
+        return { caminho: caminhoDoTrabalho(threadId), arquivos, ignorados };
+    }
+    finally {
+        fs.closeSync(aberto.fd);
+    }
+}
+function formatarResumoDoTrabalho(resumo) {
+    const linhas = resumo.arquivos.length
+        ? resumo.arquivos.map((a) => `  - \`${a.arquivo.replace(/`/g, '\\`')}\` (${a.bytes} bytes, sha256 \`${a.sha256}\`)`)
+        : ['  - (nenhum arquivo pequeno)'];
+    const totalIgnorado = Object.values(resumo.ignorados).reduce((soma, n) => soma + n, 0);
+    if (totalIgnorado > 0) {
+        linhas.push(`  - Ignorados pelos limites: ${resumo.ignorados.grandes} grandes, ${resumo.ignorados.links} links, ` +
+            `${resumo.ignorados.excedentes} excedentes, ${resumo.ignorados.outros} outros.`);
+    }
+    return linhas.join('\n');
+}

package/dist/transporte-do-canal.js

@@ -0,0 +1,189 @@
+"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.DESTINO_DO_CANAL = exports.HOSTS_DO_CANAL = void 0;
+exports.canalValido = canalValido;
+exports.transporteValido = transporteValido;
+exports.hostDoTransporte = hostDoTransporte;
+exports.transporteDoCanal = transporteDoCanal;
+exports.caminhoDoPulseHost = caminhoDoPulseHost;
+exports.gravarTransporteDoCanal = gravarTransporteDoCanal;
+/**
+ * RM-063 (fatia 3, H3 e H4): o transporte do pulse pronto de cada host, gravado pelo onboarding junto com o canal do dono.
+ *
+ * Incidente de 03 a 12/10/2026 (P1 da pagina da RM-063): sem `pulse-host.json`, o `ork doctor` calava e a maquina ficou
+ * nove dias sem batida e sem aviso. O transporte era um JSON que o dono escrevia a mao, com o executavel e os argumentos
+ * de cada host, e so o do OpenClaw estava pronto num guia. Agora a etapa `maestro` do onboarding aceita o canal do dono
+ * (`canal: { host, destino }`) e grava o `.orkastery/monitor/pulse-host.json` desta maquina com o modelo pronto do host:
+ *
+ *  - `openclaw`: `openclaw message send --channel telegram --target <chat> --message {{mensagem}} --json`;
+ *  - `hermes`: o Python do venv do Hermes com o `ork-pulse-enviar.py` do adaptador e `--target telegram:<chat>[:<topico>]`.
+ *
+ * O canal de um host novo vira o principal, e o do outro host que ja estava fica como alternativo (H4): a entrega tenta o
+ * outro quando o primeiro falha. O arquivo e desta maquina e nunca vai ao git (RM-047).
+ */
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const estado_thread_1 = require("./estado-thread");
+const procedencia_1 = require("./procedencia");
+const util_1 = require("./util");
+exports.HOSTS_DO_CANAL = ['openclaw', 'hermes'];
+exports.DESTINO_DO_CANAL = /^telegram:(-?\d{1,20})(?::(\d{1,12}))?$/;
+const MARCA = '{' + '{mensagem}}';
+const CHAVES_DO_CANAL = ['host', 'destino', 'executavel', 'script'];
+const caminhoAceito = (v) => typeof v === 'string' && v.length <= 4096 && path.isAbsolute(v) && !/\p{Cc}/u.test(v);
+/** A forma do canal, sem tocar o disco: host conhecido, destino Telegram explicito e caminhos absolutos. */
+function canalValido(v) {
+    if (!v || typeof v !== 'object' || Array.isArray(v))
+        return false;
+    const c = v;
+    if (Object.keys(c).some((k) => !CHAVES_DO_CANAL.includes(k)))
+        return false;
+    if (!exports.HOSTS_DO_CANAL.includes(c.host))
+        return false;
+    if (typeof c.destino !== 'string' || !exports.DESTINO_DO_CANAL.test(c.destino))
+        return false;
+    if (c.executavel !== undefined && !caminhoAceito(c.executavel))
+        return false;
+    if (c.script !== undefined && (c.host !== 'hermes' || !caminhoAceito(c.script)))
+        return false;
+    // O `message send` do OpenClaw recebe o chat; o topico e do transporte do Hermes.
+    if (c.host === 'openclaw' && exports.DESTINO_DO_CANAL.exec(c.destino)?.[2] !== undefined)
+        return false;
+    return true;
+}
+/** Um transporte valido: executavel e argumentos de texto, com `{{mensagem}}` em algum. */
+function transporteValido(t) {
+    const c = t;
+    return !!c && typeof c.executavel === 'string' && !!c.executavel && Array.isArray(c.argumentos) &&
+        c.argumentos.every((a) => typeof a === 'string') && c.argumentos.some((a) => a.includes(MARCA));
+}
+/** O nome do host de um transporte: o declarado, ou o que o executavel e os argumentos dizem. */
+function hostDoTransporte(t) {
+    if (typeof t.host === 'string' && /^[a-z0-9][a-z0-9._-]{0,39}$/i.test(t.host))
+        return t.host;
+    const nomes = [t.executavel, ...t.argumentos].map((a) => path.basename(a)).join(' ');
+    return /openclaw/i.test(nomes) ? 'openclaw' : /hermes|ork-pulse-enviar/i.test(nomes) ? 'hermes' : path.basename(t.executavel).slice(0, 40);
+}
+const executavel = (arquivo) => {
+    try {
+        fs.accessSync(arquivo, fs.constants.X_OK);
+        return fs.statSync(arquivo).isFile();
+    }
+    catch {
+        return false;
+    }
+};
+/**
+ * O transporte pronto do host do canal, com os caminhos desta maquina. Lanca `onboarding.canal.transporte` com a
+ * correcao quando o executavel do host nao esta aqui: o onboarding nao grava um transporte que nunca entrega.
+ */
+function transporteDoCanal(raiz, canal, env = process.env) {
+    const falta = (detalhe) => { throw new Error(`onboarding.canal.transporte: ${detalhe}`); };
+    if (canal.host === 'openclaw') {
+        const bin = canal.executavel ?? (0, util_1.noPath)('openclaw', env);
+        if (!bin || !path.isAbsolute(bin) || !executavel(bin)) {
+            return falta('o openclaw não está no PATH desta máquina; informe canal.executavel com o caminho absoluto dele');
+        }
+        if ((0, procedencia_1.rastreadoPeloGit)(raiz, bin))
+            return falta(`${bin} está versionado no git: o transporte só vale de um arquivo local desta máquina`);
+        const chat = exports.DESTINO_DO_CANAL.exec(canal.destino)[1];
+        return { host: 'openclaw', destino: canal.destino, executavel: bin,
+            argumentos: ['message', 'send', '--channel', 'telegram', '--target', chat, '--message', MARCA, '--json'] };
+    }
+    const casa = (env.HERMES_HOME ?? '').trim() || path.join(os.homedir(), '.hermes');
+    const agente = (env.HERMES_AGENT_DIR ?? '').trim() || path.join(casa, 'hermes-agent');
+    const python = canal.executavel ?? path.join(agente, 'venv', 'bin', 'python3');
+    if (!executavel(python))
+        return falta(`o Python do venv do Hermes não está em ${python}; informe canal.executavel`);
+    const script = canal.script ?? [path.join(casa, 'bin', 'ork-pulse-enviar.py'), path.join((0, estado_thread_1.raizDoEstado)(raiz), '.hermes', 'bin', 'ork-pulse-enviar.py')]
+        .find((s) => fs.existsSync(s));
+    if (!script || !fs.existsSync(script)) {
+        return falta('o ork-pulse-enviar.py do adaptador Hermes não foi achado (ork adapter install hermes); informe canal.script');
+    }
+    // RM-047: o que a entrega executa so vale do arquivo local desta maquina; versionado no git, veio com o repositorio.
+    for (const arquivo of [python, script]) {
+        if ((0, procedencia_1.rastreadoPeloGit)(raiz, arquivo))
+            return falta(`${arquivo} está versionado no git: o transporte só vale de um arquivo local desta máquina`);
+    }
+    return { host: 'hermes', destino: canal.destino, executavel: python, argumentos: [script, '--target', canal.destino, '--message', MARCA] };
+}
+function caminhoDoPulseHost(raiz) {
+    return path.join((0, estado_thread_1.raizDoEstado)(raiz), '.orkastery', 'monitor', 'pulse-host.json');
+}
+/**
+ * Grava o transporte do canal como o principal do `pulse-host.json` desta maquina. O principal de outro host que ja
+ * estava vira alternativo, na frente dos outros; o do mesmo host e trocado. Devolve o arquivo e os hosts alternativos.
+ */
+function gravarTransporteDoCanal(raiz, novo) {
+    const arquivo = caminhoDoPulseHost(raiz);
+    (0, procedencia_1.exigirHostLocal)(raiz, arquivo);
+    let atual = null;
+    try {
+        const lido = JSON.parse(fs.readFileSync(arquivo, 'utf8'));
+        if (transporteValido(lido))
+            atual = lido;
+    }
+    catch {
+        atual = null;
+    }
+    const host = hostDoTransporte(novo);
+    const alternativos = [];
+    const somar = (t) => {
+        const h = hostDoTransporte(t);
+        if (h !== host && !alternativos.some((a) => hostDoTransporte(a) === h)) {
+            alternativos.push({ ...(t.host ? { host: t.host } : { host: h }), ...(t.destino ? { destino: t.destino } : {}),
+                executavel: t.executavel, argumentos: t.argumentos });
+        }
+    };
+    if (atual) {
+        somar(atual);
+        for (const a of Array.isArray(atual.alternativos) ? atual.alternativos.filter(transporteValido) : [])
+            somar(a);
+    }
+    const conteudo = { ...novo, ...(alternativos.length ? { alternativos } : {}) };
+    fs.mkdirSync(path.dirname(arquivo), { recursive: true });
+    const temporario = `${arquivo}.${process.pid}.${(0, node_crypto_1.randomUUID)().slice(0, 8)}.tmp`;
+    try {
+        fs.writeFileSync(temporario, JSON.stringify(conteudo, null, 2) + '\n', { encoding: 'utf8', mode: 0o600, flag: 'wx' });
+        fs.renameSync(temporario, arquivo);
+    }
+    finally {
+        fs.rmSync(temporario, { force: true });
+    }
+    return { arquivo, alternativos: alternativos.map(hostDoTransporte) };
+}

package/dist/types.js

@@ -6,7 +6,8 @@
  * Nada aqui depende de LLM; tudo e deterministico e testavel.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DIGITO_DA_FASE = exports.FASES = void 0;
+exports.ESTADOS_DE_TRABALHO = exports.DIGITO_DA_FASE = exports.FASES = void 0;
+exports.estadoDeTrabalho = estadoDeTrabalho;
 /** Ordem canonica das fases. */
 exports.FASES = ['GOAL', 'PLAN', 'GO', 'CHECK', 'SHIP', 'MASTER'];
 /** Alias numerico herdado do Devmaster (F1..F6), usado na parte 3 do slug. */
@@ -18,3 +19,13 @@ exports.DIGITO_DA_FASE = {
     SHIP: '5',
     MASTER: '6',
 };
+/**
+ * RM-063 (fatia 3, achado a): os estados crus do runtime que sao trabalho em curso. O `claude agents --json` diz
+ * `working` para a sessao de fundo, e `busy` ou `running` para a interativa que executa um turno: nenhum dos tres e
+ * parada, com ou sem thread.
+ */
+exports.ESTADOS_DE_TRABALHO = ['working', 'busy', 'running'];
+/** O estado cru e trabalho em curso? */
+function estadoDeTrabalho(estado) {
+    return typeof estado === 'string' && exports.ESTADOS_DE_TRABALHO.includes(estado.trim().toLowerCase());
+}

package/dist/util.js

@@ -53,6 +53,8 @@ exports.tabela = tabela;
 const node_child_process_1 = require("node:child_process");
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
+/** Saidas de build e teste podem passar do teto padrao de 1 MiB do `spawnSync`. */
+const MAX_BUFFER_EXEC = 64 * 1024 * 1024;
 /** Executa um comando capturando saida, sem shell (argumentos vao como array). */
 function exec(cmd, args, cwd, timeoutMs = 120000, env = process.env) {
     const r = (0, node_child_process_1.spawnSync)(cmd, args, {
@@ -60,6 +62,7 @@ function exec(cmd, args, cwd, timeoutMs = 120000, env = process.env) {
         encoding: 'utf8',
         timeout: timeoutMs,
         env,
+        maxBuffer: MAX_BUFFER_EXEC,
     });
     return {
         ok: r.status === 0,
@@ -119,7 +122,7 @@ exports.GITIGNORE_DA_MAQUINA = '# Criado pelo ork: esta pasta é da máquina, n
  * nao cria quando o repositorio ja rastreia algo nela: o projeto que versiona o proprio estado segue
  * versionando. Devolve se criou.
  */
-function ignorarPastaNoGit(dir, raizDoRepo) {
+function ignorarPastaNoGit(dir, raizDoRepo, conteudo = exports.GITIGNORE_DA_MAQUINA) {
     const relativo = path.relative(raizDoRepo, dir);
     if (!relativo || relativo.startsWith('..') || path.isAbsolute(relativo))
         return false;
@@ -131,7 +134,7 @@ function ignorarPastaNoGit(dir, raizDoRepo) {
         return false;
     fs.mkdirSync(dir, { recursive: true });
     try {
-        fs.writeFileSync(arquivo, exports.GITIGNORE_DA_MAQUINA, { flag: 'wx' });
+        fs.writeFileSync(arquivo, conteudo, { flag: 'wx' });
     }
     catch {
         return false;
@@ -197,7 +200,14 @@ function lerJsonl(caminho) {
 /** Anexa um registro ao armazem JSONL, criando o diretorio que faltar. */
 function anexarJsonl(caminho, valor) {
     fs.mkdirSync(path.dirname(caminho), { recursive: true });
-    fs.appendFileSync(caminho, JSON.stringify(valor) + '\n', 'utf8');
+    // RM-047: O_NOFOLLOW; um armazém versionado como link (claims, board) não leva o append para fora da raiz.
+    const fd = fs.openSync(caminho, fs.constants.O_WRONLY | fs.constants.O_APPEND | fs.constants.O_CREAT | fs.constants.O_NOFOLLOW, 0o644);
+    try {
+        fs.writeFileSync(fd, JSON.stringify(valor) + '\n', 'utf8');
+    }
+    finally {
+        fs.closeSync(fd);
+    }
 }
 /** Proximo id sequencial de um armazem (`C1`, `C2`, ... / `F1`, `F2`, ...). */
 function proximoIdSequencial(ids, prefixo) {