@orkastery/cli 0.5.3 → 0.6.0

package/dist/claim-lint.js

@@ -19,12 +19,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.analisarComando = analisarComando;
 exports.analisarComandos = analisarComandos;
 exports.linhaDoLintDeClaim = linhaDoLintDeClaim;
+const locale_1 = require("./locale");
+/**
+ * A correcao que vai ao `claims.jsonl` com o achado: dado gravado, sempre em pt-BR. Fatia 2 do ensaio da 0.5.0 (P6): ela
+ * vale para qualquer projeto. RM-061 (F3b): o texto mora no catalogo (`claims.correcoesDoLint`), e a impressao do
+ * `claims add` a mostra no locale do comando, pela regra.
+ */
 const CORRECAO = {
-    // Fatia 2 do ensaio da 0.5.0 (P6): a correcao vale para qualquer projeto; o script do Orkastery saiu daqui.
-    'suite-inteira': 'rode só o teste da claim (`node --test` no arquivo do teste, ou o comando do projeto que roda um arquivo) ' +
-        'ou um script hermético do projeto',
-    'sha-intermediario': 'ancore na base (`git diff "$(git merge-base origin/main HEAD)" HEAD`) ou prove ancestralidade com `git merge-base --is-ancestor <sha> HEAD`',
-    'contagem-de-commits': 'use `git merge-base --is-ancestor <commit> HEAD`: contagem de commits quebra com rebase e merge',
+    'suite-inteira': (0, locale_1.msg)('pt-BR').claims.correcoesDoLint['suite-inteira'],
+    'sha-intermediario': (0, locale_1.msg)('pt-BR').claims.correcoesDoLint['sha-intermediario'],
+    'contagem-de-commits': (0, locale_1.msg)('pt-BR').claims.correcoesDoLint['contagem-de-commits'],
 };
 /**
  * (a) `npm [--prefix <dir>] [run] test` sem subcomando (`test:ci` nao casa) e sem arquivos
@@ -60,7 +64,7 @@ function analisarComandos(comandos) {
 }
 /** Uma linha por achado, para o terminal e para o ledger. */
 function linhaDoLintDeClaim(claimId, a) {
-    const nome = { 'suite-inteira': 'roda a suite inteira', 'sha-intermediario': 'fixa um SHA intermediario',
-        'contagem-de-commits': 'compara contagem de commits' }[a.regra];
-    return `${claimId} ${nome} (${a.trecho}); ${a.correcao}`;
+    // RM-061 (F3b): nome e correcao pela regra, no locale ativo. F3d (GO-FIX 1): o montador fica registrado, e o `ci prepare`,
+    // que grava a linha no ledger no escopo pt-BR, a remonta no locale do comando ao imprimir.
+    return (0, locale_1.textoDoCatalogo)((m) => m.claims.linhaDoLint(claimId, m.claims.nomesDoLint[a.regra] ?? a.regra, a.trecho, m.claims.correcoesDoLint[a.regra] ?? a.correcao));
 }

package/dist/claims-conferir.js

@@ -0,0 +1,350 @@
+"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");
+const locale_1 = require("./locale");
+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 locale_1.ErroDoCatalogo {
+}
+exports.ErroDeConferencia = ErroDeConferencia;
+/** RM-061 (F3b): a recusa nasce do catalogo; o `--json` a leva como nasceu e o texto a remonta no locale do comando. */
+const recusa = (motivo, detalhe) => new ErroDeConferencia((m) => m.claims.recusa(motivo, detalhe(m.claims)));
+/** `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', (m) => m.semClaims);
+    const invalido = ids.find((id) => !/^C\d+$/.test(id));
+    if (invalido)
+        throw recusa('uso', (m) => m.idInvalido(invalido));
+    const repetido = ids.find((id, i) => ids.indexOf(id) !== i);
+    if (repetido)
+        throw recusa('repetida', (m) => m.repetida(repetido));
+    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', (m) => m.tarefaInvalida(tarefaBruta));
+    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', (m) => m.tarefaAusente(tarefa));
+    if (inicios.length > 1)
+        throw recusa('tarefa-repetida', (m) => m.tarefaRepetida(inicios.length, 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', (m) => m.tarefaSemVerify(tarefa));
+    if (verifies.length > 1)
+        throw recusa('tarefa-ambigua', (m) => m.tarefaAmbigua(tarefa, verifies.length));
+    const resto = verifies[0];
+    const trechos = [...resto.matchAll(/`([^`]+)`/g)].length;
+    if (trechos === 0)
+        throw recusa('tarefa-sem-comando', (m) => m.tarefaSemComando(tarefa, resto.slice(0, 120)));
+    const unico = /^`([^`]+)`\s*\.?$/.exec(resto);
+    if (!unico || !unico[1].trim()) {
+        throw recusa('tarefa-ambigua', (m) => m.tarefaVariosTrechos(tarefa, trechos, resto.slice(0, 120)));
+    }
+    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', (m) => m.planoNaoAbre);
+    }
+    try {
+        const st = fs.fstatSync(fd);
+        if (!st.isFile() || st.size > LIMITE_DO_PLANO)
+            throw recusa('plano-inseguro', (m) => m.planoGrande);
+        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', (m) => m.semWorktree(thread.id));
+    let dir;
+    try {
+        dir = fs.realpathSync(thread.worktree);
+    }
+    catch {
+        throw recusa('worktree-ausente', (m) => m.worktreeAusente(thread.id));
+    }
+    const projeto = fs.realpathSync((0, estado_thread_1.raizDoEstado)(raiz));
+    if (!dir.startsWith(projeto + path.sep))
+        throw recusa('worktree-fora-do-projeto', (m) => m.worktreeFora(thread.id));
+    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', (m) => m.worktreeNaoRegistrada(thread.id, 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) {
+        // RM-061 (F3b, GO-FIX 1): o erro do catalogo guarda o montador; o do executor sai traduzido pela frase exata.
+        const erro = e instanceof locale_1.ErroDoCatalogo ? e.montar : (m) => m.claims.erroDoSandbox(e.message);
+        throw new ErroDeConferencia((m) => m.claims.recusa('sandbox-indisponivel', m.claims.sandboxIndisponivel(erro(m))));
+    }
+}
+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', (m) => m.claimsOuTarefa);
+    const prazoTotalMs = pedido.prazoMs ?? exports.PRAZO_PADRAO_MS;
+    if (!Number.isInteger(prazoTotalMs) || prazoTotalMs < PRAZO_MINIMO_MS || prazoTotalMs > exports.PRAZO_MAXIMO_MS)
+        throw recusa('prazo', (m) => m.prazo(PRAZO_MINIMO_MS / 1000, exports.PRAZO_MAXIMO_MS / 1000));
+    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', (m) => m.threadAusente(threadId));
+    const thread = (0, thread_1.lerThread)(raiz, threadId);
+    if (thread.status === 'fechada')
+        throw recusa('thread-fechada', (m) => m.threadFechada(threadId));
+    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', (m) => m.desconhecida(id, threadId));
+            if (claim.estado === 'retirada') {
+                const motivo = claim.motivoDaRetirada;
+                throw recusa('retirada', (m) => m.retiradaNaConferencia(id, motivo));
+            }
+            return claim;
+        });
+        alvo = { tipo: 'claims', ids };
+    }
+    else {
+        const plano = lerPlano(raiz, threadId);
+        if (!plano)
+            throw recusa('plano-ausente', (m) => m.planoAusente(threadId));
+        const { tarefa, comando } = verifyDaTarefa(plano.conteudo, pedido.tarefa);
+        // RM-061 (F3b, GO-FIX 1): a alegacao sintetica nasce pelo catalogo (pt-BR no `--json`) e o texto a remonta.
+        selecionadas = [{ id: tarefa, thread: threadId, fase: null, arquivo: plano.arquivo, alegacao: (0, locale_1.textoDoCatalogo)((m) => m.claims.verifyDaTarefa(tarefa)),
+                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: (0, locale_1.textoDoCatalogo)((m) => m.claims.prazoEsgotado) };
+            }
+            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) {
+    // RM-061 (F3b): a moldura pelo catalogo; o detalhe de cada claim (montado em pt-BR, como o --json o leva) remontado.
+    const m = (0, locale_1.msg)().claims;
+    const linhas = [m.conferencia(r.thread)];
+    linhas.push(m.headReal(r.commit));
+    linhas.push(m.executor(r.executor, Math.round(r.prazoTotalMs / 1000)));
+    linhas.push(r.alvo.tipo === 'claims'
+        ? m.alvoClaims(r.alvo.ids.join(', '))
+        : m.alvoTarefa(r.alvo.tarefa, r.alvo.plano.sha256.slice(0, 12), r.alvo.comando));
+    linhas.push('');
+    for (const i of r.itens) {
+        linhas.push(m.item(i.id, i.verificado, i.motivo, (0, locale_1.remontar)(i.alegacao)));
+        if (!i.verificado) {
+            linhas.push(`      ${(0, locale_1.remontar)(i.detalhe)}`);
+            const falhou = i.execucoes.find((e) => !e.ok);
+            if (falhou?.fim)
+                linhas.push(...(0, locale_1.remontar)(falhou.fim).split('\n').map((l) => `      | ${l}`));
+        }
+    }
+    linhas.push('');
+    linhas.push(r.ok ? m.tudoPassou : m.naoPassou(r.motivos.join(', ')));
+    return linhas.join('\n');
+}

package/dist/claims.js

@@ -68,6 +68,7 @@ const policies_1 = require("./policies");
 const verify_1 = require("./verify");
 const util_1 = require("./util");
 const claim_lint_1 = require("./claim-lint");
+const locale_1 = require("./locale");
 /** Caminho do `claims.jsonl` da thread (append-only, como o ledger). */
 function caminhoClaims(raiz, threadId) {
     return path.join((0, thread_1.dirThread)(raiz, threadId), 'claims.jsonl');
@@ -181,7 +182,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))
@@ -248,7 +251,7 @@ function registrarCriteriosDePronto(raiz, threadId) {
 function exigirClaim(raiz, threadId, claimId) {
     const claim = lerClaims(raiz, threadId).find((c) => c.id === claimId);
     if (!claim) {
-        throw new Error(`claim "${claimId}" nao existe na thread ${threadId}`);
+        throw new locale_1.ErroDoCatalogo((m) => m.claims.naoExiste(claimId, threadId));
     }
     return claim;
 }
@@ -307,18 +310,18 @@ function carimbarEstado(raiz, claim, estado) {
 /** Tabela de `ork claims list`. */
 function tabelaDeClaims(raiz, threadId) {
     const claims = lerClaims(raiz, threadId);
-    if (claims.length === 0) {
-        return (`Nenhuma claim na thread ${threadId}.\n` +
-            `Registre uma com: ork claims add ${threadId} <arquivo> --claim "<alegacao>" --verificar "<comando>"`);
-    }
+    // RM-061 (F3b): o texto pelo catalogo; o estado (dado do `claims.jsonl`) so se traduz aqui, pelo id.
+    const m = (0, locale_1.msg)().claims;
+    if (claims.length === 0)
+        return m.listaVazia(threadId);
     const linhas = claims.map((c) => [
         c.id,
         c.fase ?? '-',
-        c.estado,
-        c.negativa ? 'sim' : 'nao',
+        m.estado(c.estado),
+        c.negativa ? m.sim : m.nao,
         c.arquivo,
-        c.verificar.join(' && ') || '(sem comando)',
+        c.verificar.join(' && ') || m.semComando,
         c.alegacao,
     ]);
-    return (0, util_1.tabela)(['ID', 'FASE', 'ESTADO', 'NEGATIVA', 'ARQUIVO', 'VERIFICAR', 'ALEGACAO'], linhas);
+    return (0, util_1.tabela)([...m.colunas], linhas);
 }

package/dist/company-brain-client.js

@@ -1,11 +1,46 @@
 "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");
+const dsn_da_memoria_1 = require("./dsn-da-memoria");
 exports.BRAIN_API = 'orkmind.company-brain-api/v1';
 function validateRequest(value) {
     if (!value || typeof value !== 'object' || Array.isArray(value) || value.schema !== exports.BRAIN_API ||
@@ -30,20 +65,27 @@ function brainClient(loaded, execute = node_child_process_1.spawnSync) {
     return raw => {
         const request = validateRequest(raw);
         const unavailable = (error) => ({ schema: exports.BRAIN_API, state: 'unavailable', error });
-        const dsn = config.database_url_env ? process.env[config.database_url_env] : undefined;
+        // RM-069: a DSN pelo resolvedor unico, no momento do pedido (a variavel ou o arquivo da pasta de segredos).
+        const dsn = (0, dsn_da_memoria_1.resolverDsn)(config).dsn;
         if (config.mode !== 'orkmind' || (!dsn && request.operation !== 'capabilities'))
             return unavailable('brain.configuration.missing');
         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.
+        // RM-026 K7 (fatia 2, CHECK): timeout_ms fora da faixa (0, negativo, fração) vale o padrão de 15 s, nunca espera sem prazo.
+        const prazo = Number.isFinite(config.timeout_ms) && config.timeout_ms >= 1 ? Math.min(Math.floor(config.timeout_ms), 15000) : 15000;
+        const result = execute(config.cli, ['brain', 'request'], { cwd: os.homedir(), encoding: 'utf8', timeout: prazo,
             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 } });
+                ORKMIND_DATABASE_URL: dsn, ORKMIND_BRAIN_TENANT: config.tenant } });
         if (result.error || result.signal)
             return unavailable('brain.transport.unavailable');
         try {
             const response = JSON.parse(String(result.stdout));
+            // RM-069 (D21): a resposta que repete a DSN ou a senha dela nunca sai do cliente; recusada inteira, sem o valor.
+            if ((0, dsn_da_memoria_1.contemFragmentoDaDsn)(response, dsn))
+                return unavailable('brain.transport.secret');
             if (response.schema !== exports.BRAIN_API || !['ok', 'empty', 'unknown', 'unavailable', 'withheld', 'forbidden', 'conflict'].includes(response.state))
                 throw Error();
             if (response.state === 'ok' && result.status !== 0)

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,32 +1,73 @@
 "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");
 const company_brain_source_1 = require("./company-brain-source");
 const company_brain_journal_1 = require("./company-brain-journal");
 const company_brain_contract_1 = require("./company-brain-contract");
+const dsn_da_memoria_1 = require("./dsn-da-memoria");
 function brainAdmin(c) {
     const config = (0, project_state_1.memoryState)(c).loaded.manifesto.memory;
     return (operation, payload) => {
-        const dsn = config.database_url_env ? process.env[config.database_url_env] : undefined;
+        // RM-069: a DSN pelo resolvedor unico (a variavel ou o arquivo da pasta de segredos).
+        const dsn = (0, dsn_da_memoria_1.resolverDsn)(config).dsn;
         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 } });
+        let response;
         try {
-            const response = JSON.parse(r.stdout);
-            if (r.status !== 0 || response.state !== 'ok')
-                throw Error();
-            return response.result;
+            response = JSON.parse(r.stdout);
         }
         catch {
             throw Error('brain.migration.unconfirmed');
         }
+        // RM-069 (D21): a resposta que repete a DSN ou a senha dela nunca sai da migracao; recusada inteira, sem o valor.
+        if ((0, dsn_da_memoria_1.contemFragmentoDaDsn)(response, dsn))
+            throw Error('brain.migration.secret');
+        if (r.status !== 0 || response?.state !== 'ok')
+            throw Error('brain.migration.unconfirmed');
+        return response.result;
     };
 }
 function reconcileBrain(c, scope, batch, transport = brainAdmin(c)) {