@orkastery/cli 0.5.3 → 0.5.6

package/dist/claims-conferir.js

@@ -0,0 +1,342 @@
+"use strict";
+/**
+ * `ork claims conferir` (RM-059, T0.10): reexecuta so as claims pedidas, ou o verify de uma tarefa do
+ * plano da thread, no mesmo sandbox do `ork_verify`, sem gravar recibo.
+ *
+ * E por aqui que os mods de fase (Freio e Portao, no plano dos mods) conferem o que um lote do GO
+ * mexeu: o comando de claim e de verify e escrito pelo modelo, e fora do sandbox ele passaria longe do
+ * guard e daria resultado diferente do `ork verify` (D12 do plano). Por isso:
+ *
+ *  - o executor e o confinado do codex (`criarExecutorSandbox`), um por comando, e nunca ha fallback:
+ *    sem sandbox, a conferencia recusa (D6 da thread ork-rm059nucleo);
+ *  - o julgamento de cada claim e o do `ork verify` (`verificarClaim`), sem regra paralela;
+ *  - quem executa na worktree precisa da conducao da thread, como o `ork verify` (I-36): a sessao que
+ *    conduz reentra pela identidade do despacho, e outra conducao recusa;
+ *  - nada e gravado: nem `verify_run`, nem estado de claim, nem `gate_blocked`. Quem verifica de
+ *    verdade continua sendo o `ork verify`.
+ */
+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.ErroDeConferencia = exports.PRAZO_MAXIMO_MS = exports.PRAZO_PADRAO_MS = exports.FORMATO_DA_CONFERENCIA = void 0;
+exports.idsDeClaims = idsDeClaims;
+exports.verifyDaTarefa = verifyDaTarefa;
+exports.conferirClaims = conferirClaims;
+exports.textoDaConferencia = textoDaConferencia;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const claims_1 = require("./claims");
+const conducao_1 = require("./conducao");
+const estado_thread_1 = require("./estado-thread");
+const redacao_saida_1 = require("./redacao-saida");
+const thread_1 = require("./thread");
+const verify_1 = require("./verify");
+const verify_sandbox_1 = require("./verify-sandbox");
+const worktree_1 = require("./worktree");
+exports.FORMATO_DA_CONFERENCIA = 'ork.claims-conferencia/v1';
+/** O prazo total do `ork_verify` pelo MCP: a conferencia e pontual e nao deve demorar mais que ele. */
+exports.PRAZO_PADRAO_MS = 180_000;
+/** Teto: o prazo de um comando de verify. Pedir mais e pedir o `ork verify` inteiro. */
+exports.PRAZO_MAXIMO_MS = verify_1.TIMEOUT_VERIFY_MS;
+const PRAZO_MINIMO_MS = 10_000;
+/** Folga para fechar o sandbox e responder dentro do prazo pedido. */
+const RESERVA_MS = 5_000;
+/** Erro de uso tipado: o CLI sai 2 com ele. */
+class ErroDeConferencia extends Error {
+}
+exports.ErroDeConferencia = ErroDeConferencia;
+const recusa = (motivo, detalhe) => new ErroDeConferencia(`claims.conferir.${motivo}: ${detalhe}`);
+/** `C3,C7, c9` vira `['C3', 'C7', 'C9']`, sem repeticao e na ordem pedida. */
+function idsDeClaims(bruto) {
+    const ids = bruto.split(',').map((s) => s.trim().toUpperCase()).filter(Boolean);
+    if (!ids.length)
+        throw recusa('uso', 'informe ao menos uma claim em --claims (ex.: C3,C7)');
+    const invalido = ids.find((id) => !/^C\d+$/.test(id));
+    if (invalido)
+        throw recusa('uso', `id de claim invalido: ${invalido}`);
+    const repetido = ids.find((id, i) => ids.indexOf(id) !== i);
+    if (repetido)
+        throw recusa('repetida', `${repetido} pedida duas vezes`);
+    return ids;
+}
+/**
+ * A linha de verify de uma tarefa nos formatos em uso nos planos: `- **verify:** ...`, `- **verify**: ...`,
+ * `- verify: ...`, `` - `verify`: ... `` e `Verify: ...` fora de lista. O grupo 1 e o que vem depois do rotulo.
+ */
+const ROTULO_DE_VERIFY = /^\s*(?:[-*]\s+)?(?:\*\*verify:\*\*|\*\*verify\*\*\s*:|`verify`\s*:|verify\s*:)\s*(.*)$/i;
+/** Linha que abre outro item de lista, cabecalho ou cerca de codigo. */
+const ABRE_BLOCO = /^\s*(?:[-*+]\s|\d+[.)]\s|#{1,6}\s|```|~~~)/;
+const recuo = (linha) => /^[ \t]*/.exec(linha)[0].replace(/\t/g, '    ').length;
+/**
+ * O item inteiro do verify da linha `k`: o texto depois do rotulo e as linhas que o Markdown junta a ele, a
+ * continuacao logo abaixo que nao abre outro item e as linhas mais recuadas que o rotulo, mesmo depois de
+ * linha em branco. Verify que quebra na linha seguinte ("e o teste da fatia 1 (`node --test ...`)") e um
+ * item so, e o pedaco da linha de baixo nao pode ficar de fora.
+ */
+function itemDoVerify(bloco, k, inicio) {
+    const base = recuo(bloco[k]);
+    const partes = [inicio];
+    let depoisDeBranco = false;
+    for (const linha of bloco.slice(k + 1)) {
+        if (!linha.trim()) {
+            depoisDeBranco = true;
+            continue;
+        }
+        if (recuo(linha) <= base && (depoisDeBranco || ABRE_BLOCO.test(linha)))
+            break;
+        partes.push(linha.trim());
+        depoisDeBranco = false;
+    }
+    return partes.join(' ').trim();
+}
+/**
+ * O comando de verify da tarefa `T<id>` no texto do plano (D7). O cabeçalho (niveis `##` a `######`)
+ * aparece uma vez so; no bloco dele, ate o proximo cabecalho de nivel igual ou maior, ha um unico
+ * item `verify`, e ele e um trecho entre crases e nada mais (ponto final aceito), contando as linhas
+ * de continuacao do item. Item com dois trechos ou com texto alem do comando ("`git status` vazio e
+ * `ork verify`") recusa: rodar so um pedaco daria "passou" a um verify que nao rodou inteiro.
+ */
+function verifyDaTarefa(plano, tarefaBruta) {
+    const id = tarefaBruta.trim().replace(/^T/i, '');
+    if (!/^\d+(?:\.\d+)*$/.test(id))
+        throw recusa('uso', `tarefa invalida: ${tarefaBruta} (ex.: T2.1)`);
+    const tarefa = `T${id}`;
+    const linhas = plano.replace(/\r\n/g, '\n').split('\n');
+    const cabecalho = /^(#{2,6})\s+T(\d+(?:\.\d+)*)(?=[\s.:)]|$)/;
+    const inicios = linhas.flatMap((l, i) => {
+        const m = cabecalho.exec(l);
+        return m && m[2] === id ? [{ i, nivel: m[1].length }] : [];
+    });
+    if (inicios.length === 0)
+        throw recusa('tarefa-ausente', `o plano nao tem a tarefa ${tarefa}`);
+    if (inicios.length > 1)
+        throw recusa('tarefa-repetida', `o plano tem ${inicios.length} cabecalhos da tarefa ${tarefa}`);
+    const { i, nivel } = inicios[0];
+    const fimDoBloco = linhas.findIndex((l, j) => j > i && new RegExp(`^#{1,${nivel}}\\s`).test(l));
+    const bloco = linhas.slice(i + 1, fimDoBloco < 0 ? undefined : fimDoBloco);
+    const verifies = bloco.flatMap((l, k) => {
+        const m = ROTULO_DE_VERIFY.exec(l);
+        return m ? [itemDoVerify(bloco, k, m[1].trim())] : [];
+    });
+    if (verifies.length === 0)
+        throw recusa('tarefa-sem-verify', `a tarefa ${tarefa} nao tem linha de verify`);
+    if (verifies.length > 1)
+        throw recusa('tarefa-ambigua', `a tarefa ${tarefa} tem ${verifies.length} linhas de verify`);
+    const resto = verifies[0];
+    const trechos = [...resto.matchAll(/`([^`]+)`/g)].length;
+    if (trechos === 0)
+        throw recusa('tarefa-sem-comando', `o verify da tarefa ${tarefa} nao tem comando entre crases: ${resto.slice(0, 120)}`);
+    const unico = /^`([^`]+)`\s*\.?$/.exec(resto);
+    if (!unico || !unico[1].trim()) {
+        throw recusa('tarefa-ambigua', `o verify da tarefa ${tarefa} tem ${trechos} trecho(s) entre crases e texto alem de um comando so ` +
+            `(${resto.slice(0, 120)}); a conferencia nao escolhe qual pedaco rodar`);
+    }
+    return { tarefa, comando: unico[1].trim() };
+}
+/** O teto dos documentos de fase (`docs/*.md` da thread). */
+const LIMITE_DO_PLANO = 128 * 1024;
+/**
+ * O `docs/plan.md` da thread, com o sha256 dos bytes lidos; `null` quando ele nao existe. Le pela pasta
+ * de estado da thread, que e a do checkout principal mesmo com o CLI rodando de dentro da worktree.
+ */
+function lerPlano(raiz, threadId) {
+    const arquivo = path.join((0, thread_1.dirThread)(raiz, threadId), 'docs', 'plan.md');
+    let fd;
+    try {
+        fd = fs.openSync(arquivo, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW | fs.constants.O_NONBLOCK);
+    }
+    catch (e) {
+        if (e.code === 'ENOENT')
+            return null;
+        throw recusa('plano-inseguro', 'docs/plan.md da thread nao abre como arquivo comum');
+    }
+    try {
+        const st = fs.fstatSync(fd);
+        if (!st.isFile() || st.size > LIMITE_DO_PLANO)
+            throw recusa('plano-inseguro', 'docs/plan.md da thread nao e arquivo comum de ate 128 KiB');
+        const bytes = fs.readFileSync(fd);
+        return { arquivo: 'docs/plan.md', sha256: (0, node_crypto_1.createHash)('sha256').update(bytes).digest('hex'), conteudo: bytes.toString('utf8') };
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+/**
+ * Como o `ork_verify` (`mcp-verify.ts`): so a worktree propria da thread, dentro do projeto e registrada no git
+ * dele na branch da thread, fica gravavel no sandbox. O projeto e a arvore principal, mesmo com o CLI rodando de
+ * dentro de uma worktree. Thread sem worktree seria conferida com a arvore principal gravavel, e worktree de
+ * outro repositorio numa branch de mesmo nome abriria escrita fora do projeto: as duas recusam.
+ */
+function worktreeConferida(raiz, thread) {
+    if (!thread.worktree)
+        throw recusa('sem-worktree', `a thread ${thread.id} nao tem worktree propria; a conferencia so roda nela`);
+    let dir;
+    try {
+        dir = fs.realpathSync(thread.worktree);
+    }
+    catch {
+        throw recusa('worktree-ausente', `a worktree da thread ${thread.id} nao existe no disco`);
+    }
+    const projeto = fs.realpathSync((0, estado_thread_1.raizDoEstado)(raiz));
+    if (!dir.startsWith(projeto + path.sep))
+        throw recusa('worktree-fora-do-projeto', `a worktree da thread ${thread.id} fica fora do projeto`);
+    const branch = (0, worktree_1.branchDaWorktree)(thread);
+    if (!(0, worktree_1.worktreesDoGit)(projeto).some((w) => w.dir === dir && w.branch === branch))
+        throw recusa('worktree-nao-registrada', `a worktree da thread ${thread.id} nao esta registrada no git do projeto na branch ${branch}`);
+    return dir;
+}
+/** A fabrica padrao: o sandbox do codex, um por comando, como o `ork_verify`. */
+const fabricaPadrao = (worktree, timeoutMs) => (0, verify_sandbox_1.criarExecutorSandbox)({ worktree, timeoutMs });
+/** Sandbox que nao abre vira recusa tipada: a conferencia nunca roda fora dele (D6). */
+function confinado(fabrica, worktree, timeoutMs) {
+    try {
+        return fabrica(worktree, timeoutMs);
+    }
+    catch (e) {
+        throw recusa('sandbox-indisponivel', `${e.message}; a conferencia so roda confinada, sem fallback`);
+    }
+}
+function conferida(r) {
+    return {
+        nome: r.nome, comando: r.comando, ok: r.ok, code: r.code, executado: r.executado !== false,
+        ...(r.causa ? { causa: r.causa } : {}),
+        ...(r.prazoMs !== undefined ? { prazoMs: r.prazoMs } : {}),
+        ...(r.duracaoMs !== undefined ? { duracaoMs: r.duracaoMs } : {}),
+        fim: r.resumo ? (0, redacao_saida_1.redigirSaida)(r.resumo) : '',
+    };
+}
+/** `ork claims conferir`: so o que foi pedido, no sandbox, sob a conducao da thread, sem gravar nada. */
+function conferirClaims(carregado, threadId, pedido) {
+    const { raiz, manifesto } = carregado;
+    if (!pedido.claims === !pedido.tarefa)
+        throw recusa('uso', 'informe --claims C1,C2 ou --tarefa T1, um dos dois');
+    const prazoTotalMs = pedido.prazoMs ?? exports.PRAZO_PADRAO_MS;
+    if (!Number.isInteger(prazoTotalMs) || prazoTotalMs < PRAZO_MINIMO_MS || prazoTotalMs > exports.PRAZO_MAXIMO_MS)
+        throw recusa('prazo', `--prazo vai de ${PRAZO_MINIMO_MS / 1000} a ${exports.PRAZO_MAXIMO_MS / 1000} segundos`);
+    if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,79}$/.test(threadId) || !fs.existsSync((0, thread_1.caminhoThread)(raiz, threadId)))
+        throw recusa('thread-ausente', `a thread ${threadId} nao existe neste projeto`);
+    const thread = (0, thread_1.lerThread)(raiz, threadId);
+    if (thread.status === 'fechada')
+        throw recusa('thread-fechada', `a thread ${threadId} esta fechada`);
+    const cwd = worktreeConferida(raiz, thread);
+    // O que vai rodar, inteiro resolvido antes de tomar a conducao: recusa de uso nao toca a worktree.
+    let alvo;
+    let selecionadas;
+    if (pedido.claims) {
+        const ids = pedido.claims;
+        const todas = (0, claims_1.lerClaims)(raiz, threadId);
+        selecionadas = ids.map((id) => {
+            const claim = todas.find((c) => c.id === id);
+            if (!claim)
+                throw recusa('desconhecida', `${id} nao existe na thread ${threadId}`);
+            if (claim.estado === 'retirada')
+                throw recusa('retirada', `${id} foi retirada (${claim.motivoDaRetirada ?? 'sem motivo'})`);
+            return claim;
+        });
+        alvo = { tipo: 'claims', ids };
+    }
+    else {
+        const plano = lerPlano(raiz, threadId);
+        if (!plano)
+            throw recusa('plano-ausente', `a thread ${threadId} nao tem docs/plan.md`);
+        const { tarefa, comando } = verifyDaTarefa(plano.conteudo, pedido.tarefa);
+        selecionadas = [{ id: tarefa, thread: threadId, fase: null, arquivo: plano.arquivo, alegacao: `verify da tarefa ${tarefa} do plano`,
+                negativa: false, verificar: [comando], criadoEm: '', estado: 'pendente' }];
+        alvo = { tipo: 'tarefa', tarefa, plano: { arquivo: plano.arquivo, sha256: plano.sha256 }, comando };
+    }
+    // O sandbox e conferido antes da conducao: sem ele, nada toma o lease nem toca a worktree.
+    const fabrica = pedido.fabrica ?? fabricaPadrao;
+    confinado(fabrica, cwd, PRAZO_MINIMO_MS).fechar();
+    const pedidoDeConducao = {
+        canal: pedido.canal ?? (0, conducao_1.canalDoProcesso)(),
+        correlacao: pedido.correlacao ?? null,
+        operacao: 'verify',
+        identidade: (0, conducao_1.identidadeDoAmbiente)(threadId, process.env, raiz),
+        prazoMs: (0, conducao_1.prazoDaVerificacao)(prazoTotalMs, 1),
+    };
+    return (0, conducao_1.comConducao)(raiz, threadId, pedidoDeConducao, (tomada) => {
+        const prazoFinal = Date.now() + prazoTotalMs;
+        const executor = (nome, comando, dir) => {
+            const restante = prazoFinal - Date.now() - RESERVA_MS;
+            if (restante < 100) {
+                return { nome, comando, ok: false, code: -1, executado: false, resumo: 'nao executado: prazo total da conferencia esgotado' };
+            }
+            const prazoMs = Math.min((0, verify_1.prazoDoComando)(manifesto, nome), restante);
+            tomada.renovar(prazoMs);
+            const sandbox = confinado(fabrica, cwd, prazoMs);
+            const inicio = Date.now();
+            try {
+                const r = sandbox.executar(nome, comando, dir);
+                const estourou = !r.ok && /timeout do sandbox/.test(`${r.stderr ?? ''}${r.resumo}`);
+                return { ...r, executado: true, prazoMs, duracaoMs: Date.now() - inicio, ...(estourou ? { causa: 'timeout' } : {}) };
+            }
+            finally {
+                sandbox.fechar();
+            }
+        };
+        const resultados = selecionadas.map((c) => (0, verify_1.verificarClaim)(c, cwd, executor));
+        const itens = resultados.map((r) => ({
+            id: r.claim.id, alegacao: r.claim.alegacao, arquivo: r.claim.arquivo ?? null, verificado: r.verificado,
+            motivo: r.motivo, detalhe: r.detalhe, execucoes: r.execucoes.map(conferida),
+        }));
+        const motivos = [...new Set(itens.map((i) => i.motivo).filter((m) => m !== null))];
+        return {
+            formato: exports.FORMATO_DA_CONFERENCIA, thread: threadId, commit: (0, verify_1.commitReal)(cwd), cwd, executor: 'codex-sandbox',
+            reciboOficial: false, prazoTotalMs, alvo, itens, ok: itens.every((i) => i.verificado), motivos,
+        };
+    });
+}
+/** Texto de `ork claims conferir`, para quem roda no terminal. */
+function textoDaConferencia(r) {
+    const linhas = [`Conferencia pontual da thread ${r.thread} (sem recibo: o ork verify continua sendo quem verifica)`];
+    linhas.push(`  HEAD real   ${r.commit}`);
+    linhas.push(`  executor    ${r.executor}, prazo total ${Math.round(r.prazoTotalMs / 1000)} s`);
+    linhas.push(r.alvo.tipo === 'claims'
+        ? `  alvo        claims ${r.alvo.ids.join(', ')}`
+        : `  alvo        verify da tarefa ${r.alvo.tarefa} (plano sha256 ${r.alvo.plano.sha256.slice(0, 12)}): ${r.alvo.comando}`);
+    linhas.push('');
+    for (const i of r.itens) {
+        linhas.push(`  ${i.id}  ${i.verificado ? 'passou' : `NAO PASSOU (${i.motivo})`}  ${i.alegacao}`);
+        if (!i.verificado) {
+            linhas.push(`      ${i.detalhe}`);
+            const falhou = i.execucoes.find((e) => !e.ok);
+            if (falhou?.fim)
+                linhas.push(...falhou.fim.split('\n').map((l) => `      | ${l}`));
+        }
+    }
+    linhas.push('');
+    linhas.push(r.ok ? 'Resultado: tudo passou.' : `Resultado: nao passou. Motivos: ${r.motivos.join(', ')}`);
+    return linhas.join('\n');
+}

package/dist/claims.js

@@ -181,7 +181,9 @@ function conferirProvaLocal(raiz, thread, claim, executarProva) {
     if (!carregado || claim.verificar.length === 0 || !(0, policies_1.policyDeProvaLocal)(carregado.manifesto))
         return [];
     const prazoMs = carregado.manifesto.verify.timeout_ms ?? verify_1.TIMEOUT_VERIFY_MS;
-    const cwd = (0, verify_1.cwdDaThread)(raiz, thread);
+    // RM-047 (P2): worktree apagada nao passa pela procedencia, porque nada roda nela; vira o aviso abaixo.
+    const apagada = thread.worktree && !fs.existsSync(thread.worktree) ? thread.worktree : undefined;
+    const cwd = apagada ?? (0, verify_1.cwdDaThread)(raiz, thread);
     let reprovada;
     // Suspeitas da revisao de 03/10: sem a worktree (apagada), nada roda e o aviso diz por que, sem culpar a claim.
     if (!fs.existsSync(cwd))

package/dist/company-brain-client.js

@@ -1,8 +1,42 @@
 "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.BRAIN_API = void 0;
 exports.validateRequest = validateRequest;
 exports.brainClient = brainClient;
+const os = __importStar(require("node:os"));
 const node_child_process_1 = require("node:child_process");
 const project_state_1 = require("./project-state");
 const company_brain_contract_1 = require("./company-brain-contract");
@@ -36,7 +70,8 @@ function brainClient(loaded, execute = node_child_process_1.spawnSync) {
         const payload = request.payload;
         if (payload?.tenant_id !== undefined && payload.tenant_id !== config.tenant)
             return { schema: exports.BRAIN_API, state: 'forbidden', error: 'brain.tenant.mismatch' };
-        const result = execute(config.cli, ['brain', 'request'], { cwd: loaded.raiz, encoding: 'utf8', timeout: Math.min(config.timeout_ms, 15000),
+        // RM-047: cwd fora do clone; um nome de interpretador em memory.cli não acha arquivo do repositório.
+        const result = execute(config.cli, ['brain', 'request'], { cwd: os.homedir(), encoding: 'utf8', timeout: Math.min(config.timeout_ms, 15000),
             maxBuffer: 2 * 1024 * 1024, input: JSON.stringify(request), shell: false,
             env: { PATH: process.env.PATH ?? '/usr/bin:/bin', PYTHONDONTWRITEBYTECODE: '1',
                 ORKMIND_DATABASE_URL: dsn ?? '', ORKMIND_BRAIN_TENANT: config.tenant } });

package/dist/company-brain-journal.js

@@ -118,7 +118,8 @@ function withProcessLock(dir, busy, run) {
 }
 function durableAppend(file, value) {
     fs.mkdirSync(path.dirname(file), { recursive: true });
-    const fd = fs.openSync(file, 'a', 0o600);
+    // RM-047: O_NOFOLLOW; um ledger versionado como link não leva o append para fora da raiz.
+    const fd = fs.openSync(file, fs.constants.O_WRONLY | fs.constants.O_APPEND | fs.constants.O_CREAT | fs.constants.O_NOFOLLOW, 0o600);
     try {
         fs.writeFileSync(fd, JSON.stringify(value) + '\n');
         fs.fsyncSync(fd);

package/dist/company-brain-migration.js

@@ -1,8 +1,42 @@
 "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.brainAdmin = brainAdmin;
 exports.reconcileBrain = reconcileBrain;
 exports.applyBrain = applyBrain;
+const os = __importStar(require("node:os"));
 const node_child_process_1 = require("node:child_process");
 const project_state_1 = require("./project-state");
 const portfolio_1 = require("./portfolio");
@@ -15,7 +49,8 @@ function brainAdmin(c) {
         const dsn = config.database_url_env ? process.env[config.database_url_env] : undefined;
         if (config.mode !== 'orkmind' || !dsn)
             throw Error('brain.configuration.missing');
-        const r = (0, node_child_process_1.spawnSync)(config.cli, ['brain', 'migration'], { cwd: c.raiz, shell: false, encoding: 'utf8', timeout: Math.min(config.timeout_ms, 15000), maxBuffer: 2 * 1024 * 1024,
+        // RM-047: cwd fora do clone; um nome de interpretador em memory.cli não acha arquivo do repositório.
+        const r = (0, node_child_process_1.spawnSync)(config.cli, ['brain', 'migration'], { cwd: os.homedir(), shell: false, encoding: 'utf8', timeout: Math.min(config.timeout_ms, 15000), maxBuffer: 2 * 1024 * 1024,
             input: JSON.stringify({ schema: 'orkmind.company-brain-admin/v1', operation, payload }),
             env: { PATH: process.env.PATH ?? '/usr/bin:/bin', PYTHONDONTWRITEBYTECODE: '1', ORKMIND_DATABASE_URL: dsn, ORKMIND_BRAIN_TENANT: config.tenant } });
         try {