@orkastery/cli 0.5.6 → 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

@@ -65,6 +65,7 @@ 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;
@@ -74,21 +75,22 @@ 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 {
+class ErroDeConferencia extends locale_1.ErroDoCatalogo {
 }
 exports.ErroDeConferencia = ErroDeConferencia;
-const recusa = (motivo, detalhe) => new ErroDeConferencia(`claims.conferir.${motivo}: ${detalhe}`);
+/** 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', 'informe ao menos uma claim em --claims (ex.: C3,C7)');
+        throw recusa('uso', (m) => m.semClaims);
     const invalido = ids.find((id) => !/^C\d+$/.test(id));
     if (invalido)
-        throw recusa('uso', `id de claim invalido: ${invalido}`);
+        throw recusa('uso', (m) => m.idInvalido(invalido));
     const repetido = ids.find((id, i) => ids.indexOf(id) !== i);
     if (repetido)
-        throw recusa('repetida', `${repetido} pedida duas vezes`);
+        throw recusa('repetida', (m) => m.repetida(repetido));
     return ids;
 }
 /**
@@ -131,7 +133,7 @@ function itemDoVerify(bloco, k, inicio) {
 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)`);
+        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.:)]|$)/;
@@ -140,9 +142,9 @@ function verifyDaTarefa(plano, tarefaBruta) {
         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}`);
+        throw recusa('tarefa-ausente', (m) => m.tarefaAusente(tarefa));
     if (inicios.length > 1)
-        throw recusa('tarefa-repetida', `o plano tem ${inicios.length} cabecalhos da tarefa ${tarefa}`);
+        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);
@@ -151,17 +153,16 @@ function verifyDaTarefa(plano, tarefaBruta) {
         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`);
+        throw recusa('tarefa-sem-verify', (m) => m.tarefaSemVerify(tarefa));
     if (verifies.length > 1)
-        throw recusa('tarefa-ambigua', `a tarefa ${tarefa} tem ${verifies.length} linhas de verify`);
+        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', `o verify da tarefa ${tarefa} nao tem comando entre crases: ${resto.slice(0, 120)}`);
+        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', `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`);
+        throw recusa('tarefa-ambigua', (m) => m.tarefaVariosTrechos(tarefa, trechos, resto.slice(0, 120)));
     }
     return { tarefa, comando: unico[1].trim() };
 }
@@ -180,12 +181,12 @@ function lerPlano(raiz, threadId) {
     catch (e) {
         if (e.code === 'ENOENT')
             return null;
-        throw recusa('plano-inseguro', 'docs/plan.md da thread nao abre como arquivo comum');
+        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', 'docs/plan.md da thread nao e arquivo comum de ate 128 KiB');
+            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') };
     }
@@ -201,20 +202,20 @@ function lerPlano(raiz, threadId) {
  */
 function worktreeConferida(raiz, thread) {
     if (!thread.worktree)
-        throw recusa('sem-worktree', `a thread ${thread.id} nao tem worktree propria; a conferencia so roda nela`);
+        throw recusa('sem-worktree', (m) => m.semWorktree(thread.id));
     let dir;
     try {
         dir = fs.realpathSync(thread.worktree);
     }
     catch {
-        throw recusa('worktree-ausente', `a worktree da thread ${thread.id} nao existe no disco`);
+        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', `a worktree da thread ${thread.id} fica fora do projeto`);
+        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', `a worktree da thread ${thread.id} nao esta registrada no git do projeto na 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`. */
@@ -225,7 +226,9 @@ function confinado(fabrica, worktree, timeoutMs) {
         return fabrica(worktree, timeoutMs);
     }
     catch (e) {
-        throw recusa('sandbox-indisponivel', `${e.message}; a conferencia so roda confinada, sem fallback`);
+        // 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) {
@@ -241,15 +244,15 @@ function conferida(r) {
 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');
+        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', `--prazo vai de ${PRAZO_MINIMO_MS / 1000} a ${exports.PRAZO_MAXIMO_MS / 1000} segundos`);
+        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', `a thread ${threadId} nao existe neste projeto`);
+        throw recusa('thread-ausente', (m) => m.threadAusente(threadId));
     const thread = (0, thread_1.lerThread)(raiz, threadId);
     if (thread.status === 'fechada')
-        throw recusa('thread-fechada', `a thread ${threadId} esta 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;
@@ -260,9 +263,11 @@ function conferirClaims(carregado, threadId, pedido) {
         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'})`);
+                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 };
@@ -270,9 +275,10 @@ function conferirClaims(carregado, threadId, pedido) {
     else {
         const plano = lerPlano(raiz, threadId);
         if (!plano)
-            throw recusa('plano-ausente', `a thread ${threadId} nao tem docs/plan.md`);
+            throw recusa('plano-ausente', (m) => m.planoAusente(threadId));
         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`,
+        // 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 };
     }
@@ -291,7 +297,7 @@ function conferirClaims(carregado, threadId, pedido) {
         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' };
+                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);
@@ -320,23 +326,25 @@ function conferirClaims(carregado, threadId, pedido) {
 }
 /** 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`);
+    // 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'
-        ? `  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}`);
+        ? 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(`  ${i.id}  ${i.verificado ? 'passou' : `NAO PASSOU (${i.motivo})`}  ${i.alegacao}`);
+        linhas.push(m.item(i.id, i.verificado, i.motivo, (0, locale_1.remontar)(i.alegacao)));
         if (!i.verificado) {
-            linhas.push(`      ${i.detalhe}`);
+            linhas.push(`      ${(0, locale_1.remontar)(i.detalhe)}`);
             const falhou = i.execucoes.find((e) => !e.ok);
             if (falhou?.fim)
-                linhas.push(...falhou.fim.split('\n').map((l) => `      | ${l}`));
+                linhas.push(...(0, locale_1.remontar)(falhou.fim).split('\n').map((l) => `      | ${l}`));
         }
     }
     linhas.push('');
-    linhas.push(r.ok ? 'Resultado: tudo passou.' : `Resultado: nao passou. Motivos: ${r.motivos.join(', ')}`);
+    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');
@@ -250,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;
 }
@@ -309,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

@@ -40,6 +40,7 @@ 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 ||
@@ -64,21 +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' };
         // 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),
+        // 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-migration.js

@@ -43,25 +43,31 @@ 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');
         // 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)) {