@orkastery/cli 0.5.6 → 0.6.1

package/dist/conducao-sentinela.js

@@ -42,6 +42,7 @@ exports.faseJaFeita = faseJaFeita;
 exports.bloqueioDepoisDoDespacho = bloqueioDepoisDoDespacho;
 exports.passoDaThread = passoDaThread;
 exports.passosDoCondutor = passosDoCondutor;
+exports.passoDeQuemAge = passoDeQuemAge;
 exports.statusDaSentinela = statusDaSentinela;
 exports.textoDoStatusDaSentinela = textoDoStatusDaSentinela;
 /**
@@ -52,7 +53,8 @@ exports.textoDoStatusDaSentinela = textoDoStatusDaSentinela;
  * Dois fatos moram aqui, e so aqui:
  *
  * - a PRESENCA dela nesta maquina, com prazo curto renovado pela batida: enquanto ela vale, o condutor externo cede
- *   o despacho e o retry; vencida (a sessao do dono fechou), ele volta a conduzir sozinho, como reserva;
+ *   o despacho e o retry, menos a retomada por cota (RM-064 T5, `passosDaBatida`); vencida (a sessao do dono fechou),
+ *   ele volta a conduzir sozinho, como reserva;
  * - o PASSO DO CONDUTOR de cada thread aberta, calculado com as mesmas leituras do pulse (`entregasDoProjeto`,
  *   `esperaDoCondutor`), sem o limiar de 30 min e sem ler a forja. No #Auto, depois de uma fase concluida, sai a
  *   fase seguinte a prova mais adiantada que a sessao do bloco deixou (artefato gravado depois do despacho, produto
@@ -69,8 +71,10 @@ const estado_thread_1 = require("./estado-thread");
 const ledger_1 = require("./ledger");
 const manifest_1 = require("./manifest");
 const maquina_1 = require("./maquina");
+const noctum_guarda_1 = require("./noctum-guarda");
 const parado_no_condutor_1 = require("./parado-no-condutor");
 const thread_1 = require("./thread");
+const locale_1 = require("./locale");
 var conducao_2 = require("./conducao");
 Object.defineProperty(exports, "CANAL_DA_SENTINELA", { enumerable: true, get: function () { return conducao_2.CANAL_DA_SENTINELA; } });
 Object.defineProperty(exports, "CONTRATO_DA_SENTINELA", { enumerable: true, get: function () { return conducao_2.CONTRATO_DA_SENTINELA; } });
@@ -343,6 +347,8 @@ function temPedidoGuardado(raiz, t) {
 function passosDoCondutor(carregado, opcoes = {}) {
     const quando = opcoes.quando ?? new Date().toISOString();
     const entregas = (0, parado_no_condutor_1.entregasDoProjeto)(carregado, { quando, limiarMin: 0 });
+    // RM-058, integracao (T1.2): os arcos desta raiz, lidos uma vez para todas as threads.
+    const arcos = (0, noctum_guarda_1.lerArcosDaRaiz)(carregado.raiz, quando);
     const passos = [];
     for (const estado of entregas.estados) {
         let t;
@@ -357,10 +363,21 @@ function passosDoCondutor(carregado, opcoes = {}) {
             eventos = (0, ledger_1.lerLedger)((0, thread_1.dirThread)(carregado.raiz, t.id));
         }
         catch { /* ledger ilegivel: sem bloqueio */ }
-        passos.push(passoDaThread(t, estado, eventos, temPedidoGuardado(carregado.raiz, t), (fase) => faseJaFeita(carregado.raiz, t, fase, estado, eventos), (0, parado_no_condutor_1.pendenciaDoDono)(t, eventos, quando)));
+        const passo = passoDaThread(t, estado, eventos, temPedidoGuardado(carregado.raiz, t), (fase) => faseJaFeita(carregado.raiz, t, fase, estado, eventos), (0, parado_no_condutor_1.pendenciaDoDono)(t, eventos, quando));
+        const arco = (0, noctum_guarda_1.arcoDoPasso)(carregado.raiz, arcos, t.id, eventos);
+        passos.push(arco ? { ...passo, arco } : passo);
     }
     return passos.sort((a, b) => (a.thread < b.thread ? -1 : a.thread > b.thread ? 1 : 0));
 }
+/**
+ * RM-058, integracao (T1.2): o passo como quem age o le. A thread que o arco segura nao tem acao nenhuma de fora; a que ele
+ * retem nao e despachada nem retomada. O motivo vai no `porque`, e o passo do nucleo (o da fila do arco) nao muda.
+ */
+function passoDeQuemAge(p) {
+    if (!p.arco || (p.arco.efeito === 'retencao' && p.acao !== 'despachar' && p.acao !== 'retomar'))
+        return p;
+    return { ...p, acao: 'nada', fase: null, porque: p.arco.detalhe };
+}
 /** O `ork conducao sentinela status`: a presenca desta maquina e o passo do condutor em cada thread aberta. */
 function statusDaSentinela(carregado, opcoes = {}) {
     const agora = opcoes.agora ?? new Date();
@@ -368,20 +385,20 @@ function statusDaSentinela(carregado, opcoes = {}) {
     return {
         contrato: conducao_1.CONTRATO_DA_SENTINELA, consultadoEm: agora.toISOString(), maquina,
         presenca: presencaDaSentinela(carregado.raiz, { agora, maquina }),
-        threads: passosDoCondutor(carregado, { quando: agora.toISOString() }),
+        // RM-058, integracao (T1.2): a Sentinela despacha o que este status diz; a thread do arco sai com `nada` e o motivo.
+        threads: passosDoCondutor(carregado, { quando: agora.toISOString() }).map(passoDeQuemAge),
     };
 }
 /** O status em texto, para o terminal. */
 function textoDoStatusDaSentinela(s) {
+    const m = (0, locale_1.msg)().conducao.sentinela;
     const linhas = [];
     const p = s.presenca;
-    linhas.push(!p ? `Sentinela: desligada na maquina ${s.maquina}; o condutor externo conduz.`
-        : p.ativa ? `Sentinela: ligada na maquina ${s.maquina}, canal ${p.canal}, sessao ${p.sessao.slice(0, 8)}; o condutor externo cede o despacho e o retry.`
-            : `Sentinela: a presenca da sessao ${p.sessao.slice(0, 8)} venceu; o condutor externo conduz.`);
+    linhas.push(!p ? m.desligada(s.maquina) : p.ativa ? m.ligada(s.maquina, p.canal, p.sessao.slice(0, 8)) : m.vencida(p.sessao.slice(0, 8)));
     if (s.threads.length === 0)
-        linhas.push('  nenhuma thread aberta neste checkout');
+        linhas.push(m.nenhuma);
     for (const t of s.threads) {
-        const acao = t.acao === 'despachar' ? `despachar ${t.fase}` : t.acao;
+        const acao = t.acao === 'despachar' ? m.despachar(t.fase) : t.acao;
         linhas.push(`  ${t.thread.padEnd(20)} ${t.modo.padEnd(8)} ${acao.padEnd(16)} ${t.porque}`);
     }
     return linhas.join('\n');

package/dist/conducao.js

@@ -113,6 +113,11 @@ exports.CANAIS_DE_CONDUCAO = {
         origem: 'sessao do Codex',
         declaracao: 'servidor MCP iniciado com --host codex',
     },
+    // RM-067 (F4b, G5): o servidor do grok so serve a sessao filha; o canal e o do host dele, como no codex.
+    grok: {
+        origem: 'sessao filha do Grok Build',
+        declaracao: 'servidor MCP iniciado com --host grok, so na sessao filha vinculada a thread',
+    },
     mcp: {
         origem: 'cliente MCP sem host homologado',
         declaracao: 'reservado: o servidor MCP atual exige host homologado e declara o canal dele',
@@ -239,10 +244,30 @@ function nomeDaConducao(threadId) {
 }
 /** Estados em que o runtime ja deu a sessao por encerrada. */
 const TERMINAIS = ['done', 'completed', 'exited', 'stopped', 'failed'];
+/** Os eventos que sao contabilidade do proprio ork, e nao sinal de que a sessao voltou a trabalhar. */
+const SO_DA_CONTABILIDADE = /^(conducao_|retry_|session_watcher_|despacho_idempotente$|varredura_acao$)/;
+/**
+ * RM-063 (fatia 3, achado c): o observador viu a sessao num estado terminal do runtime (`done`, `failed`, `stopped`) e
+ * encerrou sem inferir a conclusao da fase (`session_watcher_error` com `estadoNativo`). A fase pode nao estar provada,
+ * mas a sessao nao executa mais nada: o lease dela cai. Vale o ultimo desses vistos, se nenhum evento da mesma sessao
+ * depois dele mostra trabalho (a sessao retomada por alguem).
+ */
+function terminalVistoPeloObservador(eventos, sessionId, desde) {
+    let visto = null;
+    for (const e of eventos) {
+        if (e.sessionId !== sessionId || Date.parse(e.ts) < desde)
+            continue;
+        if (e.tipo === 'session_watcher_error' && typeof e.estadoNativo === 'string' && TERMINAIS.includes(e.estadoNativo))
+            visto = e;
+        else if (visto && !SO_DA_CONTABILIDADE.test(e.tipo))
+            visto = null;
+    }
+    return visto;
+}
 /**
  * O evento que prova que a sessao dona do lease acabou: o resultado da fase dela (a prova da I-34
- * que o observador grava), a morte registrada, a superacao, ou a thread fechada. So conta evento
- * posterior ao inicio da conducao.
+ * que o observador grava), a morte registrada, a superacao, o estado terminal que o observador viu
+ * no runtime (RM-063), ou a thread fechada. So conta evento posterior ao inicio da conducao.
  */
 function fimDaSessao(eventos, lease) {
     const dono = lease.conducao?.dono;
@@ -250,7 +275,7 @@ function fimDaSessao(eventos, lease) {
         return null;
     const desde = Date.parse(lease.adquiridoEm);
     return eventos.find((e) => Date.parse(e.ts) >= desde && ((['phase_result', 'sessao_morta', 'session_superseded'].includes(e.tipo) && e.sessionId === dono.sessionId) ||
-        ['thread_closed_admin', 'master_done'].includes(e.tipo))) ?? null;
+        ['thread_closed_admin', 'master_done'].includes(e.tipo))) ?? terminalVistoPeloObservador(eventos, dono.sessionId, desde);
 }
 /**
  * A leitura pura, para quem so tem os dados (o snapshot do Maestro le por um leitor confinado).
@@ -375,16 +400,49 @@ const emCurso = new Map();
 function chave(raiz, threadId) {
     return `${(0, leases_1.caminhoLease)(raiz, nomeDaConducao(threadId))}`;
 }
+/**
+ * RM-063 (fatia 3, achado c): a consulta do claude-bg na conta do perfil da sessao (`CLAUDE_CONFIG_DIR` dele). A conta do
+ * processo nao lista a sessao de outro perfil, e a ausencia la nao prova nada; na conta dela, prova. `null` quando o
+ * perfil nao esta mais no store desta maquina (vale a consulta de sempre).
+ */
+function consultaNaContaDoPerfil(dono, raiz) {
+    if (dono.runtime !== 'claude-bg' || !dono.perfil)
+        return null;
+    // Carregados na hora, como o controle nativo: a leitura da conducao nao puxa o adapter inteiro.
+    const { lerPerfis, perfilDeDespacho } = require('./runtime-profiles');
+    const { ambienteDoPerfil, consultarSessoes } = require('./adapters/claude-bg');
+    let perfil = null;
+    try {
+        const p = lerPerfis(raiz).perfis.find((x) => x.id === dono.perfil && x.runtime === 'claude-bg');
+        perfil = p ? perfilDeDespacho(p) : null;
+    }
+    catch {
+        return null;
+    }
+    if (!perfil?.configDir)
+        return null;
+    const r = consultarSessoes(undefined, true, ambienteDoPerfil(perfil));
+    if (!r.ok)
+        return { ok: false, estado: null, detalhe: `o runtime nao respondeu a consulta na conta do perfil ${dono.perfil}`, naConta: true };
+    const achada = r.sessoes.find((x) => x.sessionId === dono.sessionId);
+    const estado = achada ? String(achada.state ?? achada.status ?? '') : null;
+    return { ok: true, estado, detalhe: achada ? `estado ${estado} na conta do perfil ${dono.perfil}` : `sessao ausente da conta do perfil ${dono.perfil}`,
+        naConta: true };
+}
 /** A consulta padrao: o controle nativo do runtime (claude-bg ou o controller do codex). */
 const consultaNativa = (dono, raiz, threadId) => {
     try {
+        const naConta = consultaNaContaDoPerfil(dono, raiz);
+        if (naConta)
+            return naConta;
         // Carregado na hora: o modulo de sessoes puxa o HITL inteiro, que nao pertence a leitura.
         const { controleNativo } = require('./hitl-sessions');
         const r = controleNativo(dono.runtime, raiz, threadId, dono.sessionId).consultar();
         if (!r.ok)
             return { ok: false, estado: null, detalhe: 'o runtime nao respondeu a consulta' };
         const achadas = r.sessoes.filter((s) => s.sessionId === dono.sessionId);
-        return { ok: true, estado: achadas[0]?.estado ?? null, detalhe: achadas.length ? `estado ${achadas[0].estado}` : 'sessao ausente' };
+        return { ok: true, estado: achadas[0]?.estado ?? null, detalhe: achadas.length ? `estado ${achadas[0].estado}` : 'sessao ausente',
+            naConta: !dono.perfil };
     }
     catch (e) {
         return { ok: false, estado: null, detalhe: e.message };
@@ -425,7 +483,9 @@ function provaDeFimDaSessao(raiz, threadId, lease, pedido, anotarEstado = () =>
     anotarEstado(r.estado);
     if (r.estado && TERMINAIS.includes(r.estado))
         return { motivo: 'sessao-orfa', prova: `runtime ${dono.runtime}: ${r.detalhe}` };
-    if (r.estado === null && !dono.perfil)
+    // A ausencia so prova o fim quando a consulta foi feita na conta da sessao: sem perfil, a do processo; com perfil, a
+    // dele (RM-063, fatia 3, achado c).
+    if (r.estado === null && (!dono.perfil || r.naConta === true))
         return { motivo: 'sessao-orfa', prova: `runtime ${dono.runtime}: ${r.detalhe}` };
     return null;
 }
@@ -624,9 +684,10 @@ function sucessaoAindaVale(raiz, threadId, estado) {
     // Sem resposta do runtime nao ha prova de que ela segue parada: a sucessao nao vale.
     if (!r.ok)
         return false;
-    // S1 do CHECK 6: a sessao que sumiu do runtime, sem perfil, acabou; a mesma prova de `provaDeFimDaSessao`.
+    // S1 do CHECK 6: a sessao que sumiu do runtime, sem perfil (ou da conta do perfil dela), acabou; a mesma prova de
+    // `provaDeFimDaSessao`.
     if (r.estado === null)
-        return !dono.perfil;
+        return !dono.perfil || r.naConta === true;
     return r.estado === 'blocked' || TERMINAIS.includes(r.estado);
 }
 function renovar(raiz, threadId, estado, prazoDoProximoMs, agoraMs) {
@@ -718,6 +779,7 @@ function comandoDeEsperar(threadId, pedido) {
         case 'baseline': return `ork verify ${threadId} --baseline --esperar 30`;
         case 'fix.open': return `ork fix open ${threadId} --esperar 30`;
         case 'fix.reverify': return `ork fix reverify ${threadId} --esperar 30`;
+        case 'branch.atualizar': return `ork conducao atualizar ${threadId} --esperar 30`;
         default: return `ork verify ${threadId} --esperar 30`;
     }
 }
@@ -731,32 +793,30 @@ function comandoDeAcompanhar(threadId, atual) {
  * aconteceu e o que fazer: o texto sai daqui e de lugar nenhum mais, e o JSON e a mesma estrutura.
  */
 function recusaDeConducao(threadId, atual, pedido, opcoes = {}) {
+    const m = (0, locale_1.msg)().conducao.recusa;
     const conducao = atual
         ? { ...atual, desdeLocal: (0, horario_1.formatarDataHoraRotulada)(atual.desde, opcoes), linha: (0, conducao_texto_1.linhaDeConducao)(atual, opcoes) }
         : null;
     const acoes = [
-        { acao: 'esperar', comando: comandoDeEsperar(threadId, pedido),
-            explicacao: 'Esperar a vez: repete este pedido e segue sozinho quando a conducao atual terminar (ate 30 min).' },
-        { acao: 'acompanhar', comando: comandoDeAcompanhar(threadId, atual),
-            explicacao: 'Acompanhar quem conduz, sem mexer em nada.' },
-        { acao: 'assumir', comando: `ork conducao assumir ${threadId} --por <voce> --motivo "<por que>"`,
-            explicacao: 'Assumir a conducao: encerra a atual pelo proprio runtime e registra no ledger quem assumiu, de qual canal e por que.' },
+        { acao: 'esperar', comando: comandoDeEsperar(threadId, pedido), explicacao: m.esperar },
+        { acao: 'acompanhar', comando: comandoDeAcompanhar(threadId, atual), explicacao: m.acompanhar },
+        { acao: 'assumir', comando: m.comandoAssumir(threadId),
+            explicacao: m.assumir },
     ];
     const linhas = [
-        `Pedido nao executado: a thread ${threadId} ja esta sendo conduzida agora, e duas execucoes na mesma worktree ` +
-            'se corrompem (foi o que aconteceu em 19/09/2026).',
+        m.titulo(threadId),
     ];
     if (conducao) {
-        linhas.push(`  Quem conduz: canal ${conducao.canal}, ${(0, conducao_texto_1.quemConduz)(conducao)}, fase ${conducao.fase ?? '-'}, desde ${conducao.desdeLocal}.`);
+        linhas.push(m.quem(conducao.canal, (0, conducao_texto_1.quemConduz)(conducao), conducao.fase ?? '-', conducao.desdeLocal));
         if (conducao.promptSha256)
-            linhas.push(`  Pedido em curso: prompt sha256 ${conducao.promptSha256.slice(0, 12)}.`);
+            linhas.push(m.prompt(conducao.promptSha256.slice(0, 12)));
     }
     else {
-        linhas.push('  Outra operacao esta tomando a conducao neste instante; o registro dela ainda nao apareceu.');
+        linhas.push(m.entrando);
     }
-    linhas.push(`  Pedido recusado: ${conducao_texto_1.NOME_DA_OPERACAO[pedido.operacao]}${pedido.fase ? ` da fase ${pedido.fase}` : ''}, pelo canal ${pedido.canal}.`);
-    linhas.push('O que voce pode fazer:');
-    acoes.forEach((a, i) => { linhas.push(`  ${i + 1}. ${a.explicacao}`); linhas.push(`     ${a.comando}`); });
+    linhas.push(m.pedido((0, locale_1.msg)().thread.operacoes[pedido.operacao], pedido.fase ?? null, pedido.canal));
+    linhas.push(m.opcoes);
+    acoes.forEach((a, i) => { linhas.push(m.passo(i + 1, a.explicacao)); linhas.push(`     ${a.comando}`); });
     return {
         contrato: 'ork.conducao-recusa/v1',
         motivo: 'conducao.em-andamento',
@@ -1032,8 +1092,7 @@ function assumirConducao(raiz, threadId, opcoes) {
             worktree: estadoDaWorktree(raiz, threadId),
         });
         return { ok: true, thread: threadId, anterior, mecanismo,
-            detalhe: `conducao assumida por ${por} pelo canal ${opcoes.canal}; a proxima operacao desse canal usa a reserva ate ` +
-                `${(0, horario_1.formatarDataHoraRotulada)(reserva.expiraEm)}` };
+            detalhe: (0, locale_1.msg)().conducao.cli.detalheAssumida(por, opcoes.canal, (0, horario_1.formatarDataHoraRotulada)(reserva.expiraEm)) };
     }
     finally {
         fs.closeSync(fd);
@@ -1041,14 +1100,15 @@ function assumirConducao(raiz, threadId, opcoes) {
 }
 /** Texto de `ork conducao status`. */
 function textoDoStatusDaConducao(threadId, atual) {
+    const m = (0, locale_1.msg)().conducao.status;
     if (!atual)
-        return `Thread ${threadId}: ninguem conduz agora. Qualquer canal pode despachar ou verificar.`;
-    const linhas = [`Thread ${threadId}: ${(0, conducao_texto_1.linhaDeConducao)(atual)}`];
+        return m.livre(threadId);
+    const linhas = [m.titulo(threadId, (0, conducao_texto_1.linhaDeConducao)(atual))];
     if (atual.promptSha256)
-        linhas.push(`  prompt sha256 ${atual.promptSha256.slice(0, 12)}`);
-    linhas.push(`  prazo do lease (metadado, nao prova): ${(0, horario_1.formatarDataHoraRotulada)(atual.expiraEm)}`);
+        linhas.push(m.prompt(atual.promptSha256.slice(0, 12)));
+    linhas.push(m.prazo((0, horario_1.formatarDataHoraRotulada)(atual.expiraEm)));
     if (atual.sessao)
-        linhas.push(`  acompanhar: ork sessions logs ${atual.sessao.slice(0, 8)}`);
-    linhas.push(`  assumir: ork conducao assumir ${threadId} --por <voce> --motivo "<por que>"`);
+        linhas.push(m.acompanhar(atual.sessao.slice(0, 8)));
+    linhas.push(m.assumir(threadId));
     return linhas.join('\n');
 }

package/dist/conhecimento-consulta.js

@@ -0,0 +1,270 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONSULTAS_DO_CONHECIMENTO = void 0;
+exports.brainDoProjeto = brainDoProjeto;
+exports.consultarConhecimento = consultarConhecimento;
+exports.consultaRespondeu = consultaRespondeu;
+exports.textoDoConhecimento = textoDoConhecimento;
+/**
+ * RM-026 K7 (fatia 2): as consultas do conhecimento escrito, a porta pública do contrato `ork.conhecimento/v1`. A CLI
+ * (`ork conhecimento listar|mostrar|colecoes|verificar`) e as tools MCP (`ork_conhecimento_*`) chamam
+ * `consultarConhecimento` e devolvem o mesmo JSON (D11).
+ *
+ * Só leitura. O id do Brain referenciado confere por `get` no Company Brain (D12), só onde a resposta mostra
+ * referência: o `mostrar` (as do documento pedido) e o `verificar` (as de todos). `listar` e `colecoes` não abrem o
+ * Brain e não mostram referência nem lacuna de referência. Id inexistente, retido e Brain fora do ar são lacunas
+ * distintas, nunca resposta. O transporte do Brain é o do `ork brain get` (`memory.cli` conferido no manifesto, cwd
+ * fora do clone), na fronteira da RM-047. Contrato: docs/referencia/contratos/conhecimento-rm026.md.
+ */
+const company_brain_client_1 = require("./company-brain-client");
+const company_brain_contract_1 = require("./company-brain-contract");
+const conhecimento_1 = require("./conhecimento");
+const locale_1 = require("./locale");
+const project_state_1 = require("./project-state");
+const saida_segura_1 = require("./saida-segura");
+exports.CONSULTAS_DO_CONHECIMENTO = ['listar', 'mostrar', 'colecoes', 'verificar'];
+/**
+ * O Brain do projeto, como o `ork brain get` o abre: a configuração de memória vem da árvore principal também numa
+ * worktree (`memoryState`), e o tenant do pedido é o dela.
+ */
+function brainDoProjeto(c) {
+    const contexto = (0, project_state_1.memoryState)(c);
+    return { transporte: (0, company_brain_client_1.brainClient)(contexto.loaded), tenant: contexto.loaded.manifesto.memory.tenant };
+}
+const comparar = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+const t = conhecimento_1.detalheDoConhecimento;
+/** Lacuna da pasta: nada foi lido, e nenhuma consulta responde. */
+const daPasta = (l) => l.codigo.startsWith('conhecimento.');
+/** O código de erro do Brain, só quando tem a forma de um; texto alheio não chega ao detalhe. */
+const erroDoBrain = (e) => typeof e === 'string' && /^brain\.[a-z0-9.-]{1,80}$/.test(e) ? e : null;
+/** O código de uma exceção na abertura do Brain (`project-state.memory.unavailable`), só quando tem a forma de um. */
+const codigoDaExcecao = (e) => {
+    const m = e instanceof Error ? e.message : '';
+    return /^[a-z][a-z0-9-]*(?:\.[a-z0-9-]+){1,4}$/.test(m) && m.length <= 80 ? m : null;
+};
+/** D12: a resposta `ok` do `get` vale só no contrato da entidade, com o id e o tenant pedidos. */
+function referenciaDoBrain(r, id, tenant) {
+    let e;
+    try {
+        e = (0, company_brain_contract_1.validateContract)(r.entity);
+    }
+    catch {
+        return null;
+    }
+    if (e.schema !== 'orkmind.company-brain-entity/v1' || e.id !== id || e.tenant_id !== tenant)
+        return null;
+    return { id, kind: e.kind, titulo: (0, saida_segura_1.emUmaLinha)(e.title), versao: e.version, fonte: e.source.source_ref, sha256: e.source.source_hash };
+}
+/** Os estados do Brain que encerram a conferência: os mesmos que o contexto e o dossiê tratam como falha. */
+const FALHAS_DO_BRAIN = ['unavailable', 'forbidden', 'conflict'];
+/**
+ * D12 (revista depois do CHECK): um `get` por id distinto, em ordem, até o teto de `get` e o prazo da consulta (cada
+ * `get` é um processo do `memory.cli`). O Brain que não responde (fora do ar, sem configuração, recusa ou conflito) para
+ * a conferência: nenhum `get` sai depois, e o resto leva o mesmo detalhe. A resposta fora do contrato vale só para o id
+ * dela. `unknown` e `empty` são o id que o Brain não tem, como no dossiê.
+ */
+function conferirNoBrain(ids, abrir, limites) {
+    const conferidas = new Map();
+    const naoConferida = (detalhe) => ({ codigo: 'referencia.brain-indisponivel', detalhe });
+    let brain = null, parada = null, gets = 0;
+    const inicio = Date.now();
+    for (const id of [...new Set(ids)].sort(comparar)) {
+        if (parada === null && gets >= limites.getsDoBrain)
+            parada = t((l) => l.brainTeto(limites.getsDoBrain));
+        if (parada === null && gets > 0 && Date.now() - inicio > limites.msDaConferencia) {
+            parada = t((l) => l.brainPrazo(limites.msDaConferencia / 1000));
+        }
+        if (parada !== null) {
+            conferidas.set(id, naoConferida(parada));
+            continue;
+        }
+        if (brain === null) {
+            try {
+                brain = abrir();
+            }
+            catch (e) {
+                const codigo = codigoDaExcecao(e);
+                parada = t((l) => l.brainSemConfiguracao(codigo));
+                conferidas.set(id, naoConferida(parada));
+                continue;
+            }
+        }
+        gets++;
+        let r;
+        try {
+            r = brain.transporte({ schema: company_brain_client_1.BRAIN_API, operation: 'get', payload: { tenant_id: brain.tenant, id } });
+        }
+        catch (e) {
+            const codigo = erroDoBrain(codigoDaExcecao(e));
+            parada = t((l) => l.brainNaoRespondeu('unavailable', codigo));
+            conferidas.set(id, naoConferida(parada));
+            continue;
+        }
+        if (r.state === 'ok')
+            conferidas.set(id, referenciaDoBrain(r, id, brain.tenant) ?? naoConferida(t((l) => l.brainForaDoContrato)));
+        else if (r.state === 'unknown' || r.state === 'empty') {
+            conferidas.set(id, { codigo: 'referencia.brain-inexistente', detalhe: t((l) => l.brainInexistente) });
+        }
+        else if (r.state === 'withheld')
+            conferidas.set(id, { codigo: 'referencia.brain-retido', detalhe: t((l) => l.brainRetido) });
+        else if (FALHAS_DO_BRAIN.includes(r.state)) {
+            const estado = r.state, erro = erroDoBrain(r.error);
+            parada = t((l) => l.brainNaoRespondeu(estado, erro));
+            conferidas.set(id, naoConferida(parada));
+        }
+        else
+            conferidas.set(id, naoConferida(t((l) => l.brainForaDoContrato)));
+    }
+    return conferidas;
+}
+/** As referências do Brain conferidas; a que não confere vira lacuna, e o documento segue sem ela (D4). */
+function conferirDocumentos(docs, abrir, lacunas, limites) {
+    const conferencias = conferirNoBrain(docs.flatMap((d) => d.referencias.brain), abrir, limites);
+    return docs.map((d) => {
+        const brain = [];
+        for (const id of d.referencias.brain) {
+            const r = conferencias.get(id);
+            if ('codigo' in r)
+                lacunas.push((0, conhecimento_1.lacunaDoConhecimento)(r.codigo, r.detalhe, { arquivo: d.arquivo, documento: d.id, referencia: id }));
+            else
+                brain.push(r);
+        }
+        return { id: d.id, titulo: d.titulo, colecoes: d.colecoes, referencias: { brain, decisoes: d.referencias.decisoes },
+            arquivo: d.arquivo, bytes: d.bytes, sha256: d.sha256 };
+    });
+}
+const resumo = (d) => ({ id: d.id, titulo: d.titulo, colecoes: d.colecoes, arquivo: d.arquivo, bytes: d.bytes, sha256: d.sha256 });
+/**
+ * A consulta pedida, no contrato `ork.conhecimento/v1`. Nunca lança por causa do conteúdo do repositório nem do Brain:
+ * o que não vale vira lacuna. O pedido fora da forma (id de documento, nome de coleção) é erro de quem chama; a CLI e
+ * as tools o recusam antes. A resposta nasce em pt-BR em qualquer locale (D13): o detalhe das lacunas é o do `--json`
+ * e do MCP, e só a impressão o remonta.
+ */
+function consultarConhecimento(c, pedido, abrirBrain = () => brainDoProjeto(c), limites = conhecimento_1.LIMITES_DO_CONHECIMENTO) {
+    if (pedido.consulta === 'mostrar' && !conhecimento_1.ID_DE_DOCUMENTO.test(pedido.id))
+        throw new Error('conhecimento.pedido-invalido: id de documento');
+    if (pedido.consulta === 'listar' && pedido.colecao !== undefined && !conhecimento_1.NOME_DE_COLECAO.test(pedido.colecao)) {
+        throw new Error('conhecimento.pedido-invalido: nome de coleção');
+    }
+    return (0, locale_1.comLocale)('pt-BR', () => responder(c, pedido, abrirBrain, limites));
+}
+function responder(c, pedido, abrirBrain, limites) {
+    // D12 (revista): as decisões só conferem onde a resposta as mostra; listar e colecoes não leem ledger.
+    const k = (0, conhecimento_1.lerConhecimento)(c, limites, pedido.consulta === 'mostrar' ? { corpoDe: pedido.id, decisoesDe: pedido.id }
+        : pedido.consulta === 'verificar' ? {} : { decisoesDe: 'nenhum' });
+    const base = { contrato: conhecimento_1.CONTRATO_CONHECIMENTO, consulta: pedido.consulta, dir: k.dir };
+    // D12: quem não mostra referência não mostra a lacuna dela.
+    const semReferencia = () => k.lacunas.filter((l) => !l.codigo.startsWith('referencia.'));
+    switch (pedido.consulta) {
+        case 'listar': {
+            const colecao = pedido.colecao ?? null;
+            return { ...base, consulta: 'listar', colecao,
+                documentos: k.documentos.filter((d) => colecao === null || d.colecoes.includes(colecao)).map(resumo), lacunas: semReferencia() };
+        }
+        case 'colecoes':
+            return { ...base, consulta: 'colecoes', colecoes: k.colecoes, lacunas: semReferencia() };
+        case 'mostrar': {
+            const comum = { ...base, consulta: 'mostrar', id: pedido.id };
+            if (k.lacunas.some(daPasta))
+                return { ...comum, documento: null, lacunas: k.lacunas };
+            const lacunas = k.lacunas.filter((l) => l.documento === pedido.id);
+            const doc = k.documentos.find((d) => d.id === pedido.id);
+            if (!doc) {
+                // D13: o id que nenhum documento válido tem; os arquivos que viraram lacuna antes de o id ser lido entram na conta.
+                if (!lacunas.length) {
+                    const semId = k.lacunas.filter((l) => l.arquivo !== null && l.documento === null).length;
+                    lacunas.push((0, conhecimento_1.lacunaDoConhecimento)('documento.inexistente', t((l) => l.documentoInexistente(pedido.id, semId)), { documento: pedido.id }));
+                }
+                return { ...comum, documento: null, lacunas };
+            }
+            const [conferido] = conferirDocumentos([doc], abrirBrain, lacunas, limites);
+            return { ...comum, documento: { ...conferido, corpo: doc.corpo ?? '' }, lacunas: lacunas.sort(conhecimento_1.compararLacunas) };
+        }
+        case 'verificar': {
+            const lacunas = [...k.lacunas];
+            const documentos = conferirDocumentos(k.documentos, abrirBrain, lacunas, limites);
+            return { ...base, consulta: 'verificar', documentos, colecoes: k.colecoes, lacunas: lacunas.sort(conhecimento_1.compararLacunas) };
+        }
+    }
+}
+/**
+ * D13: a consulta respondeu? `listar` e `colecoes`, quando a pasta foi lida; `mostrar`, quando o documento veio;
+ * `verificar`, sem nenhuma lacuna. É a saída 0 da CLI e a tool sem `isError`.
+ */
+function consultaRespondeu(r) {
+    if (r.consulta === 'verificar')
+        return r.lacunas.length === 0;
+    if (r.consulta === 'mostrar')
+        return r.documento !== null;
+    return !r.lacunas.some(daPasta);
+}
+/**
+ * D13: o texto para gente, pelo catálogo, no locale ativo. O detalhe das lacunas nasce em pt-BR na consulta e é
+ * remontado aqui; o corpo do documento é dado do repositório e sai linha a linha, sem caractere invisível.
+ */
+function textoDoConhecimento(r) {
+    const m = (0, locale_1.msg)().conhecimento, linhas = [];
+    const leu = !r.lacunas.some(daPasta), dir = r.dir ?? '';
+    if (r.consulta === 'listar') {
+        if (!leu)
+            linhas.push(m.naoLido);
+        else {
+            linhas.push(m.listar(dir, r.documentos.length, r.colecao));
+            const largura = r.documentos.reduce((n, d) => Math.max(n, d.id.length), 0);
+            for (const d of r.documentos)
+                linhas.push(m.documento(d.id.padEnd(largura), d.titulo, d.colecoes.join(', ')));
+            if (!r.documentos.length)
+                linhas.push(m.nenhumDocumento);
+        }
+    }
+    else if (r.consulta === 'colecoes') {
+        if (!leu)
+            linhas.push(m.naoLido);
+        else {
+            linhas.push(m.colecoes(dir, r.colecoes.length));
+            const largura = r.colecoes.reduce((n, x) => Math.max(n, x.nome.length), 0);
+            for (const x of r.colecoes)
+                linhas.push(m.colecao(x.nome.padEnd(largura), x.documentos.join(', ')));
+            if (!r.colecoes.length)
+                linhas.push(m.nenhumaColecao);
+        }
+    }
+    else if (r.consulta === 'mostrar') {
+        const d = r.documento;
+        if (!d)
+            linhas.push(leu ? m.semDocumento(r.id) : m.naoLido);
+        else {
+            linhas.push(m.mostrar(d.id, d.titulo), m.colecoesDoDocumento(d.colecoes.join(', ')), m.arquivo(d.arquivo), m.versao(d.sha256, d.bytes));
+            for (const b of d.referencias.brain)
+                linhas.push(m.brain(b.id, b.titulo, b.kind, b.versao, b.fonte));
+            for (const x of d.referencias.decisoes)
+                linhas.push(m.decisao(x.ref, x.tipo, x.fonte));
+            if (!d.referencias.brain.length && !d.referencias.decisoes.length)
+                linhas.push(m.semReferencia);
+        }
+    }
+    else if (!leu)
+        linhas.push(m.naoLido);
+    else {
+        const soma = (f) => r.documentos.reduce((n, d) => n + f(d), 0);
+        linhas.push(m.verificar(dir, r.documentos.length, soma((d) => d.referencias.brain.length), soma((d) => d.referencias.decisoes.length)));
+    }
+    if (r.lacunas.length) {
+        linhas.push(m.lacunasTitulo(r.lacunas.length));
+        for (const l of r.lacunas) {
+            const onde = (l.arquivo ?? m.pasta) + (l.documento ? ` (${l.documento})` : '') + (l.referencia !== null ? `, ${m.naReferencia(l.referencia)}` : '');
+            linhas.push(m.lacuna(l.codigo, onde, (0, locale_1.remontar)(l.detalhe)));
+        }
+    }
+    if (r.consulta === 'listar' && r.documentos.length)
+        linhas.push(m.paraLer);
+    if (r.consulta === 'verificar')
+        linhas.push(r.lacunas.length ? m.reprovado(r.lacunas.length) : m.aprovado);
+    // O corpo vai linha a linha: espalhar um documento de muitas linhas nos argumentos estoura a pilha (achado do CHECK).
+    if (r.consulta === 'mostrar' && r.documento) {
+        linhas.push('', m.corpo);
+        for (const linha of r.documento.corpo.replace(/\n$/, '').split('\n'))
+            linhas.push((0, saida_segura_1.emUmaLinha)(linha));
+    }
+    return linhas.join('\n');
+}