@orkastery/cli 0.5.6 → 0.6.0

package/dist/conhecimento.js

@@ -33,7 +33,8 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LIMITES_DO_CONHECIMENTO = exports.REFERENCIA_DE_DECISAO = exports.NOME_DE_COLECAO = exports.ID_DE_DOCUMENTO = exports.CONTRATO_CONHECIMENTO = void 0;
+exports.compararLacunas = exports.detalheDoConhecimento = exports.LIMITES_DO_CONHECIMENTO = exports.REFERENCIA_DE_DECISAO = exports.NOME_DE_COLECAO = exports.ID_DE_DOCUMENTO = exports.CONTRATO_CONHECIMENTO = void 0;
+exports.lacunaDoConhecimento = lacunaDoConhecimento;
 exports.lerConhecimento = lerConhecimento;
 /**
  * RM-026 K7 (fatia 1): conhecimento escrito, no contrato `ork.conhecimento/v1`.
@@ -44,14 +45,17 @@ exports.lerConhecimento = lerConhecimento;
  *
  * Só leitura. Documento inválido ou referência que não confere vira lacuna tipada, nunca resposta (D4). A pasta
  * vem com o repositório e segue a fronteira da RM-047 (D6): relativa, dentro da raiz pelo caminho real, sem
- * seguir link e sem executar nada. Nesta fatia a decisão confere no ledger canônico e o id do Brain só pela forma
- * (D5); a CLI, as tools MCP e a conferência pelo Brain chegam nas fatias 2 e 3. Contrato:
+ * seguir link e sem executar nada. O leitor confere a decisão no ledger canônico e o id do Brain só pela forma
+ * (D5); a conferência por `get` mora na consulta (`conhecimento-consulta.ts`, fatia 2), a porta pública da CLI e das
+ * tools MCP. O detalhe das lacunas sai pelo catálogo (família `conhecimento`). Contrato:
  * docs/referencia/contratos/conhecimento-rm026.md.
  */
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
+const node_buffer_1 = require("node:buffer");
 const company_brain_journal_1 = require("./company-brain-journal");
 const docs_1 = require("./docs");
+const locale_1 = require("./locale");
 const portfolio_1 = require("./portfolio");
 const saida_segura_1 = require("./saida-segura");
 const thread_1 = require("./thread");
@@ -76,14 +80,21 @@ const reservada = (segmento) => PASTAS_RESERVADAS.includes(segmento.toLowerCase(
 const INVISIVEIS = new RegExp(saida_segura_1.INVISIVEL.source, 'gu');
 exports.LIMITES_DO_CONHECIMENTO = Object.freeze({
     entradas: 5000, profundidade: 8, bytesPorDocumento: 1024 * 1024, bytesDoFrontmatter: 16 * 1024,
-    bytesNoTotal: 32 * 1024 * 1024, bytesDoLedger: 16 * 1024 * 1024,
+    bytesNoTotal: 32 * 1024 * 1024, bytesDoLedger: 16 * 1024 * 1024, bytesDosLedgers: 64 * 1024 * 1024,
+    getsDoBrain: 100, msDaConferencia: 60 * 1000,
 });
 const comparar = (a, b) => a < b ? -1 : a > b ? 1 : 0;
 const ehMapa = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
 /** Texto que veio do repositório, pronto para a resposta: numa linha, sem invisível e, com teto, cortado sem partir caractere. */
 const limpo = (v, teto = Infinity) => Array.from((0, saida_segura_1.emUmaLinha)(v)).slice(0, teto).join('');
 const relativo = (raizReal, abs) => path.relative(raizReal, abs).split(path.sep).join('/');
-const LINK = 'link simbólico não é seguido; o documento é o arquivo versionado';
+/**
+ * O detalhe de uma lacuna, pelo catálogo (D13 da fatia 2): nasce no locale ativo, o pt-BR do `--json` e do MCP, e a
+ * impressão do comando coberto o remonta no locale dela.
+ */
+const detalheDoConhecimento = (montar) => (0, locale_1.textoDoCatalogo)((m) => montar(m.conhecimento.lacunas));
+exports.detalheDoConhecimento = detalheDoConhecimento;
+const t = exports.detalheDoConhecimento;
 /** `stat` que nunca lança: a pasta que some ou não abre vale como ausente. */
 const statOuNulo = (p) => { try {
     return fs.statSync(p, { throwIfNoEntry: false }) ?? null;
@@ -91,10 +102,15 @@ const statOuNulo = (p) => { try {
 catch {
     return null;
 } };
-function lacuna(codigo, detalhe, onde = {}) {
+/** Uma lacuna, com a referência como escrita, numa linha e cortada (a mesma regra no leitor e na consulta). */
+function lacunaDoConhecimento(codigo, detalhe, onde = {}) {
     return { codigo, arquivo: onde.arquivo ?? null, documento: onde.documento ?? null,
         referencia: typeof onde.referencia === 'string' ? limpo(onde.referencia, 200) : null, detalhe };
 }
+const lacuna = lacunaDoConhecimento;
+/** A ordem estável das lacunas: por arquivo, código e referência. */
+const compararLacunas = (a, b) => comparar(a.arquivo ?? '', b.arquivo ?? '') || comparar(a.codigo, b.codigo) || comparar(a.referencia ?? '', b.referencia ?? '');
+exports.compararLacunas = compararLacunas;
 /**
  * D6: a pasta declarada, pelo caminho real. A forma recusa antes de tocar o disco (vazia, absoluta, `..`, `\`,
  * invisível, a própria raiz, `.git` e `.orkastery`); o caminho real, com os links resolvidos, precisa ficar dentro
@@ -104,8 +120,7 @@ function pastaDoConhecimento(raiz, dir) {
     const segmentos = dir.split('/').filter((s) => s !== '' && s !== '.');
     if (path.isAbsolute(dir) || dir.includes('\\') || saida_segura_1.INVISIVEL.test(dir) || !segmentos.length || segmentos.includes('..') ||
         reservada(segmentos[0])) {
-        return lacuna('conhecimento.dir-invalido', 'conhecimento.dir precisa ser uma pasta relativa à raiz, sem "..", ' +
-            'fora de .git e .orkastery, como docs/conhecimento; nada foi lido');
+        return lacuna('conhecimento.dir-invalido', t((l) => l.dirForma));
     }
     let raizReal, real;
     try {
@@ -113,19 +128,17 @@ function pastaDoConhecimento(raiz, dir) {
         real = fs.realpathSync(path.join(raizReal, ...segmentos));
     }
     catch {
-        return lacuna('conhecimento.dir-ausente', 'a pasta de conhecimento.dir não existe ou não abre');
+        return lacuna('conhecimento.dir-ausente', t((l) => l.dirNaoAbre));
     }
     const rel = path.relative(raizReal, real);
     if (rel === '..' || rel.startsWith('..' + path.sep) || path.isAbsolute(rel)) {
-        return lacuna('conhecimento.dir-fora-da-raiz', 'pelo caminho real (links resolvidos), conhecimento.dir sai da raiz ' +
-            'do projeto; o manifesto vem com o repositório e não escolhe caminho fora dela; nada foi lido');
+        return lacuna('conhecimento.dir-fora-da-raiz', t((l) => l.dirForaDaRaiz));
     }
     if (rel === '' || reservada(rel.split(path.sep)[0]) || saida_segura_1.INVISIVEL.test(rel)) {
-        return lacuna('conhecimento.dir-invalido', 'pelo caminho real, conhecimento.dir é a própria raiz, cai em .git ou ' +
-            '.orkastery, ou tem caractere invisível; nada foi lido');
+        return lacuna('conhecimento.dir-invalido', t((l) => l.dirReal));
     }
     if (!statOuNulo(real)?.isDirectory())
-        return lacuna('conhecimento.dir-ausente', 'conhecimento.dir não é uma pasta');
+        return lacuna('conhecimento.dir-ausente', t((l) => l.dirNaoEPasta));
     return { real, raizReal };
 }
 /**
@@ -148,7 +161,7 @@ function varrer(real, raizReal, limites, lacunas) {
             realDaPasta = null;
         }
         if (realDaPasta !== atual.abs) {
-            lacunas.push(lacuna('documento.link', LINK, { arquivo: relativo(raizReal, atual.abs) }));
+            lacunas.push(lacuna('documento.link', t((l) => l.link), { arquivo: relativo(raizReal, atual.abs) }));
             continue;
         }
         let nomes;
@@ -156,17 +169,17 @@ function varrer(real, raizReal, limites, lacunas) {
             nomes = fs.readdirSync(atual.abs, { encoding: 'buffer' }).sort(Buffer.compare);
         }
         catch {
-            lacunas.push(lacuna('documento.nao-regular', 'a pasta não abriu para leitura; o que está nela não foi lido', { arquivo: relativo(raizReal, atual.abs) }));
+            lacunas.push(lacuna('documento.nao-regular', t((l) => l.pastaNaoAbriu), { arquivo: relativo(raizReal, atual.abs) }));
             continue;
         }
         for (const bruto of nomes) {
             if (bruto[0] === 0x2e)
                 continue;
             if (++entradas > limites.entradas)
-                return { teto: `a pasta passa de ${limites.entradas} entradas` };
+                return { teto: t((l) => l.limiteEntradas(limites.entradas)) };
             const nome = bruto.toString('utf8');
             if (!Buffer.from(nome, 'utf8').equals(bruto) || saida_segura_1.INVISIVEL.test(nome)) {
-                lacunas.push(lacuna('documento.nome-invalido', 'nome fora de UTF-8 ou com caractere invisível; não foi lido', { arquivo: relativo(raizReal, path.join(atual.abs, nome.replace(INVISIVEIS, '?'))) }));
+                lacunas.push(lacuna('documento.nome-invalido', t((l) => l.nomeInvalido), { arquivo: relativo(raizReal, path.join(atual.abs, nome.replace(INVISIVEIS, '?'))) }));
                 continue;
             }
             const abs = path.join(atual.abs, nome), arquivo = relativo(raizReal, abs);
@@ -175,25 +188,25 @@ function varrer(real, raizReal, limites, lacunas) {
                 st = fs.lstatSync(abs, { throwIfNoEntry: false });
             }
             catch {
-                lacunas.push(lacuna('documento.nao-regular', 'a entrada não abriu para leitura; não foi lida', { arquivo }));
+                lacunas.push(lacuna('documento.nao-regular', t((l) => l.entradaNaoAbriu), { arquivo }));
                 continue;
             }
             if (!st)
                 continue;
             if (st.isSymbolicLink()) {
-                lacunas.push(lacuna('documento.link', LINK, { arquivo }));
+                lacunas.push(lacuna('documento.link', t((l) => l.link), { arquivo }));
                 continue;
             }
             if (st.isDirectory()) {
                 if (atual.profundidade + 1 > limites.profundidade)
-                    return { teto: `a pasta passa de ${limites.profundidade} níveis` };
+                    return { teto: t((l) => l.limiteNiveis(limites.profundidade)) };
                 pilha.push({ abs, profundidade: atual.profundidade + 1 });
                 continue;
             }
             if (!(0, docs_1.ehPaginaDeDocs)(nome))
                 continue;
             if (!st.isFile()) {
-                lacunas.push(lacuna('documento.nao-regular', 'não é arquivo comum; não foi lido', { arquivo }));
+                lacunas.push(lacuna('documento.nao-regular', t((l) => l.naoRegular), { arquivo }));
                 continue;
             }
             candidatos.push({ abs, arquivo, st });
@@ -254,50 +267,47 @@ function lista(v) {
 /** D2 e D3: o frontmatter vale inteiro ou devolve a lacuna do primeiro problema, com o id quando ele já vale. */
 function validarFrontmatter(dados, arquivo) {
     if (!ehMapa(dados))
-        return lacuna('documento.frontmatter-invalido', 'o frontmatter precisa ser um mapa de chaves', { arquivo });
+        return lacuna('documento.frontmatter-invalido', t((l) => l.frontmatterNaoEMapa), { arquivo });
     const id = typeof dados.id === 'string' && exports.ID_DE_DOCUMENTO.test(dados.id) ? dados.id : null;
-    if (!id) {
-        return lacuna('documento.id-invalido', 'id precisa ser doc- seguido de 3 a 48 letras minúsculas, números ou hífens, ' +
-            'começando por letra ou número', { arquivo });
-    }
+    if (!id)
+        return lacuna('documento.id-invalido', t((l) => l.idInvalido), { arquivo });
     const onde = { arquivo, documento: id };
     const estranhas = Object.keys(dados).filter((k) => !CHAVES_DO_DOCUMENTO.includes(k));
     if (estranhas.length) {
-        return lacuna('documento.chave-desconhecida', `chave fora do contrato: ${estranhas.map((k) => JSON.stringify(limpo(k, 40))).join(', ')} ` +
-            `(o frontmatter tem só ${CHAVES_DO_DOCUMENTO.join(', ')})`, onde);
+        const chaves = estranhas.map((k) => JSON.stringify(limpo(k, 40))).join(', ');
+        return lacuna('documento.chave-desconhecida', t((l) => l.chaveDesconhecida(chaves, CHAVES_DO_DOCUMENTO.join(', '))), onde);
     }
     const titulo = typeof dados.titulo === 'string' ? dados.titulo.trim() : '';
     if (!titulo || titulo.length > LIMITE_DO_TITULO || saida_segura_1.INVISIVEL.test(titulo)) {
-        return lacuna('documento.titulo-invalido', `titulo precisa ser texto de 1 a ${LIMITE_DO_TITULO} caracteres, ` +
-            'sem caractere de controle', onde);
+        return lacuna('documento.titulo-invalido', t((l) => l.tituloInvalido(LIMITE_DO_TITULO)), onde);
     }
     const colecoes = lista(dados.colecoes);
     if (!colecoes || !colecoes.length || colecoes.length > COLECOES_POR_DOCUMENTO ||
         colecoes.some((c) => !exports.NOME_DE_COLECAO.test(c)) || new Set(colecoes).size !== colecoes.length) {
-        return lacuna('documento.colecoes-invalidas', `colecoes precisa listar de 1 a ${COLECOES_POR_DOCUMENTO} nomes ` +
-            'de 1 a 48 letras minúsculas, números ou hífens, sem repetir', onde);
+        return lacuna('documento.colecoes-invalidas', t((l) => l.colecoesInvalidas(COLECOES_POR_DOCUMENTO)), onde);
     }
     const refs = dados.referencias ?? null;
     const brain = ehMapa(refs) ? lista(refs.brain) : [], decisoes = ehMapa(refs) ? lista(refs.decisoes) : [];
     if ((refs !== null && !ehMapa(refs)) || (ehMapa(refs) && Object.keys(refs).some((k) => !CHAVES_DAS_REFERENCIAS.includes(k))) ||
         !brain || brain.length > REFERENCIAS_POR_LISTA || !decisoes || decisoes.length > REFERENCIAS_POR_LISTA) {
-        return lacuna('documento.referencias-invalidas', 'referencias é um mapa só com brain e decisoes, cada uma uma lista ' +
-            `de até ${REFERENCIAS_POR_LISTA} textos`, onde);
+        return lacuna('documento.referencias-invalidas', t((l) => l.referenciasInvalidas(REFERENCIAS_POR_LISTA)), onde);
     }
     return { id, titulo, colecoes: [...colecoes].sort(comparar), brain: [...new Set(brain)], decisoes: [...new Set(decisoes)] };
 }
 /**
  * As linhas citadas do ledger canônico de uma thread (D5). O ledger é lido como a captura do Brain o lê
  * (`readCycle`): só linhas completas, em UTF-8 exato, para o sha256 da linha ser o `source_hash` dela no Brain.
- * Cada ledger é lido uma vez, e só as linhas citadas ficam na memória.
+ * Cada ledger é lido uma vez, até a maior linha citada, e só as linhas citadas viram texto (fatia 2: a leitura não parte
+ * o ledger inteiro em linhas). `completas` é exato quando alguma linha citada passa do fim, o único caso em que ele é
+ * dito. O `orcamento` é o que resta do teto de bytes dos ledgers da leitura.
  */
-function linhasCitadas(raiz, thread, citadas, teto) {
+function linhasCitadas(raiz, thread, citadas, limites, orcamento) {
     let arquivo;
     try {
         arquivo = path.join((0, thread_1.dirThread)(raiz, thread), 'ledger.jsonl');
     }
     catch {
-        return { motivo: 'a pasta da thread no estado do projeto é link ou fica fora da regra de id' };
+        return { motivo: t((l) => l.ledgerLinkOuId) };
     }
     let st;
     try {
@@ -306,36 +316,46 @@ function linhasCitadas(raiz, thread, citadas, teto) {
     catch (e) {
         // A pasta da thread que é arquivo comum dá ENOTDIR: a thread não tem ledger, e nada lança.
         if (e.code !== 'ENOTDIR')
-            return { motivo: `o ledger da thread ${thread} não abriu para leitura` };
+            return { motivo: t((l) => l.ledgerNaoAbriu(thread)) };
     }
     if (!st)
-        return { motivo: `a thread ${thread} não tem ledger neste projeto` };
-    const bytes = lerArquivo(arquivo, st, teto, true);
+        return { motivo: t((l) => l.semLedger(thread)) };
+    if (st.size > orcamento.restante)
+        return { motivo: t((l) => l.ledgersDemais(limites.bytesDosLedgers / 1024 / 1024)) };
+    const bytes = lerArquivo(arquivo, st, limites.bytesDoLedger, true);
     if (!Buffer.isBuffer(bytes))
-        return { motivo: `o ledger da thread ${thread} não é arquivo comum de até ${teto / 1024 / 1024} MiB` };
-    const fim = bytes.lastIndexOf(10) + 1;
-    const completo = bytes.subarray(0, fim).toString('utf8');
-    if (!Buffer.from(completo, 'utf8').equals(bytes.subarray(0, fim)))
-        return { motivo: `o ledger da thread ${thread} não é UTF-8` };
-    const todas = completo.split('\n').slice(0, -1);
-    const linhas = new Map();
+        return { motivo: t((l) => l.ledgerNaoRegular(thread, limites.bytesDoLedger / 1024 / 1024)) };
+    orcamento.restante -= bytes.length;
+    const completo = bytes.subarray(0, bytes.lastIndexOf(10) + 1);
+    if (!(0, node_buffer_1.isUtf8)(completo))
+        return { motivo: t((l) => l.ledgerNaoUtf8(thread)) };
+    let maior = 0;
     for (const n of citadas)
-        if (n <= todas.length)
-            linhas.set(n, todas[n - 1]);
-    return { linhas, completas: todas.length };
+        if (n > maior)
+            maior = n;
+    const linhas = new Map();
+    let inicio = 0, n = 0;
+    while (inicio < completo.length && n < maior) {
+        const fimDaLinha = completo.indexOf(10, inicio);
+        n++;
+        if (citadas.has(n))
+            linhas.set(n, completo.subarray(inicio, fimDaLinha).toString('utf8'));
+        inicio = fimDaLinha + 1;
+    }
+    return { linhas, completas: n };
 }
 /** D5: a referência `thread#linha` confere quando a linha completa existe, é da thread e é uma decisão. */
 function conferirDecisao(ref, ledgers) {
     const m = exports.REFERENCIA_DE_DECISAO.exec(ref);
     if (!m)
-        return { codigo: 'referencia.invalida', detalhe: 'decisão é <thread>#<linha>, com o id da thread e a linha do ledger a partir de 1' };
+        return { codigo: 'referencia.invalida', detalhe: t((l) => l.decisaoForma) };
     const thread = m[1], linha = Number(m[2]);
     const ledger = ledgers.get(thread);
     if ('motivo' in ledger)
         return { codigo: 'referencia.decisao-ausente', detalhe: ledger.motivo };
     const bruta = ledger.linhas.get(linha);
     if (bruta === undefined) {
-        return { codigo: 'referencia.decisao-ausente', detalhe: `o ledger da thread ${thread} tem ${ledger.completas} linha(s) completa(s)` };
+        return { codigo: 'referencia.decisao-ausente', detalhe: t((l) => l.linhasCompletas(thread, ledger.completas)) };
     }
     let evento = null;
     try {
@@ -344,15 +364,14 @@ function conferirDecisao(ref, ledgers) {
             evento = lido;
     }
     catch { /* linha que não é JSON não é decisão */ }
-    const onde = `a linha ${linha} do ledger da thread ${thread}`;
     if (!evento)
-        return { codigo: 'referencia.nao-e-decisao', detalhe: `${onde} não é um evento JSON` };
+        return { codigo: 'referencia.nao-e-decisao', detalhe: t((l) => l.naoEJson(linha, thread)) };
     if (evento.thread !== thread)
-        return { codigo: 'referencia.nao-e-decisao', detalhe: `${onde} é de outra thread` };
-    const tipo = TIPOS_DE_DECISAO.find((t) => t === evento?.tipo);
+        return { codigo: 'referencia.nao-e-decisao', detalhe: t((l) => l.outraThread(linha, thread)) };
+    const tipo = TIPOS_DE_DECISAO.find((x) => x === evento?.tipo);
     if (!tipo) {
-        const visto = typeof evento.tipo === 'string' && /^[a-z_]{1,40}$/.test(evento.tipo) ? evento.tipo : 'sem tipo conhecido';
-        return { codigo: 'referencia.nao-e-decisao', detalhe: `${onde} é ${visto}, não decisão (${TIPOS_DE_DECISAO.join(', ')})` };
+        const visto = typeof evento.tipo === 'string' && /^[a-z_]{1,40}$/.test(evento.tipo) ? evento.tipo : null;
+        return { codigo: 'referencia.nao-e-decisao', detalhe: t((l) => l.naoEDecisao(linha, thread, visto, TIPOS_DE_DECISAO.join(', '))) };
     }
     return { ref, thread, linha, tipo, fonte: `threads/${thread}/ledger.jsonl#L${linha}`, sha256: (0, company_brain_journal_1.bytesHash)(bruta) };
 }
@@ -360,16 +379,16 @@ function conferirDecisao(ref, ledgers) {
  * Lê o conhecimento declarado no manifesto: documentos válidos, coleções e lacunas, tudo em ordem estável.
  * Nunca lança por causa do conteúdo do repositório; o que não vale vira lacuna tipada.
  */
-function lerConhecimento(c, limites = exports.LIMITES_DO_CONHECIMENTO) {
+function lerConhecimento(c, limites = exports.LIMITES_DO_CONHECIMENTO, opcoes = {}) {
     const declarado = c.manifesto.conhecimento?.dir ?? null;
     const dir = declarado === null ? null : limpo(declarado);
     const so = (l) => ({ contrato: exports.CONTRATO_CONHECIMENTO, dir, documentos: [], colecoes: [], lacunas: [l] });
     if (declarado === null)
-        return so(lacuna('conhecimento.nao-declarado', 'o orkastery.yaml não declara conhecimento.dir'));
+        return so(lacuna('conhecimento.nao-declarado', t((l) => l.naoDeclarado)));
     const pasta = pastaDoConhecimento(c.raiz, declarado);
     if ('codigo' in pasta)
         return so(pasta);
-    const teto = (detalhe) => so(lacuna('conhecimento.limite', `${detalhe}; nenhum documento foi devolvido`));
+    const teto = (detalhe) => so(lacuna('conhecimento.limite', detalhe));
     const lacunas = [];
     const candidatos = varrer(pasta.real, pasta.raizReal, limites, lacunas);
     if (!Array.isArray(candidatos))
@@ -381,35 +400,35 @@ function lerConhecimento(c, limites = exports.LIMITES_DO_CONHECIMENTO) {
     for (const { abs, arquivo, st } of candidatos) {
         const bytes = lerArquivo(abs, st, limites.bytesPorDocumento);
         if (bytes === 'link') {
-            lacunas.push(lacuna('documento.link', LINK, { arquivo }));
+            lacunas.push(lacuna('documento.link', t((l) => l.link), { arquivo }));
             continue;
         }
         if (bytes === 'nao-regular') {
-            lacunas.push(lacuna('documento.nao-regular', 'não abriu como arquivo comum, ou mudou durante a leitura', { arquivo }));
+            lacunas.push(lacuna('documento.nao-regular', t((l) => l.naoAbriuComoArquivo), { arquivo }));
             continue;
         }
         if (bytes === 'grande') {
-            lacunas.push(lacuna('documento.grande-demais', `o documento passa de ${limites.bytesPorDocumento / 1024} KiB`, { arquivo }));
+            lacunas.push(lacuna('documento.grande-demais', t((l) => l.grandeDemais(limites.bytesPorDocumento / 1024)), { arquivo }));
             continue;
         }
         total += bytes.length;
         if (total > limites.bytesNoTotal)
-            return teto(`os documentos passam de ${limites.bytesNoTotal / 1024 / 1024} MiB no total`);
+            return teto(t((l) => l.limiteTotal(limites.bytesNoTotal / 1024 / 1024)));
         let texto;
         try {
             texto = decodificador.decode(bytes);
         }
         catch {
-            lacunas.push(lacuna('documento.codificacao', 'o arquivo não é UTF-8', { arquivo }));
+            lacunas.push(lacuna('documento.codificacao', t((l) => l.codificacao), { arquivo }));
             continue;
         }
-        const { bruto } = (0, docs_1.separarFrontmatter)(texto);
+        const { bruto, corpo } = (0, docs_1.separarFrontmatter)(texto);
         if (bruto === null) {
-            lacunas.push(lacuna('documento.sem-frontmatter', 'o arquivo não começa com o frontmatter entre duas linhas ---', { arquivo }));
+            lacunas.push(lacuna('documento.sem-frontmatter', t((l) => l.semFrontmatter), { arquivo }));
             continue;
         }
         if (Buffer.byteLength(bruto, 'utf8') > limites.bytesDoFrontmatter) {
-            lacunas.push(lacuna('documento.frontmatter-invalido', `o frontmatter passa de ${limites.bytesDoFrontmatter / 1024} KiB`, { arquivo }));
+            lacunas.push(lacuna('documento.frontmatter-invalido', t((l) => l.frontmatterGrande(limites.bytesDoFrontmatter / 1024)), { arquivo }));
             continue;
         }
         let dados;
@@ -418,7 +437,8 @@ function lerConhecimento(c, limites = exports.LIMITES_DO_CONHECIMENTO) {
             dados = (0, yaml_1.lerYaml)('---\n' + bruto, { estrito: true });
         }
         catch (e) {
-            lacunas.push(lacuna('documento.frontmatter-invalido', limpo(e.message, 200), { arquivo }));
+            const erro = limpo(e.message, 200);
+            lacunas.push(lacuna('documento.frontmatter-invalido', t((l) => l.frontmatterYaml(erro)), { arquivo }));
             continue;
         }
         // D4: o id na forma certa conta para a regra do repetido mesmo quando o resto do documento não vale.
@@ -430,28 +450,33 @@ function lerConhecimento(c, limites = exports.LIMITES_DO_CONHECIMENTO) {
             lacunas.push(v);
             continue;
         }
-        validos.push({ ...v, arquivo, bytes: bytes.length, sha256: (0, company_brain_journal_1.bytesHash)(bytes) });
+        validos.push({ ...v, arquivo, bytes: bytes.length, sha256: (0, company_brain_journal_1.bytesHash)(bytes), ...(v.id === opcoes.corpoDe ? { corpo } : {}) });
     }
     // D4: id repetido não escolhe arquivo; todos os documentos com ele saem da resposta, também quando a outra
     // cópia não vale por outro motivo (ela já tem a lacuna dela).
     const unicos = validos.filter((v) => {
         const vezes = declarados.get(v.id);
         if (vezes > 1) {
-            lacunas.push(lacuna('documento.id-repetido', `o id aparece em ${vezes} arquivos; nenhum deles vale até sobrar um`, { arquivo: v.arquivo, documento: v.id }));
+            lacunas.push(lacuna('documento.id-repetido', t((l) => l.idRepetido(vezes)), { arquivo: v.arquivo, documento: v.id }));
         }
         return vezes === 1;
     });
-    // D5: cada ledger citado é lido uma vez, com as linhas que os documentos válidos pedem.
+    // D5: cada ledger citado é lido uma vez, com as linhas que os documentos válidos pedem, em ordem de thread e até o
+    // teto de bytes da leitura. Fatia 2: só os documentos cujas decisões a consulta mostra (`decisoesDe`).
+    const decisoesDe = opcoes.decisoesDe ?? 'todos';
+    const confere = (id) => decisoesDe === 'todos' || decisoesDe === id;
     const citadas = new Map();
     for (const v of unicos)
-        for (const ref of v.decisoes) {
-            const m = exports.REFERENCIA_DE_DECISAO.exec(ref);
-            if (m)
-                citadas.set(m[1], (citadas.get(m[1]) ?? new Set()).add(Number(m[2])));
-        }
-    const ledgers = new Map();
-    for (const [thread, linhas] of citadas)
-        ledgers.set(thread, linhasCitadas(c.raiz, thread, linhas, limites.bytesDoLedger));
+        if (confere(v.id))
+            for (const ref of v.decisoes) {
+                const m = exports.REFERENCIA_DE_DECISAO.exec(ref);
+                if (m)
+                    citadas.set(m[1], (citadas.get(m[1]) ?? new Set()).add(Number(m[2])));
+            }
+    const ledgers = new Map(), orcamento = { restante: limites.bytesDosLedgers };
+    for (const thread of [...citadas.keys()].sort(comparar)) {
+        ledgers.set(thread, linhasCitadas(c.raiz, thread, citadas.get(thread), limites, orcamento));
+    }
     const documentos = [];
     for (const v of unicos) {
         const onde = { arquivo: v.arquivo, documento: v.id };
@@ -460,9 +485,9 @@ function lerConhecimento(c, limites = exports.LIMITES_DO_CONHECIMENTO) {
             if (portfolio_1.ID_DE_ENTIDADE.test(referencia))
                 brain.push(referencia);
             else
-                lacunas.push(lacuna('referencia.invalida', 'id do Brain é prod-, proj- ou init-, na regra dos ids do portfólio', { ...onde, referencia }));
+                lacunas.push(lacuna('referencia.invalida', t((l) => l.brainForma), { ...onde, referencia }));
         }
-        for (const referencia of v.decisoes) {
+        for (const referencia of confere(v.id) ? v.decisoes : []) {
             const r = conferirDecisao(referencia, ledgers);
             if ('codigo' in r)
                 lacunas.push(lacuna(r.codigo, r.detalhe, { ...onde, referencia }));
@@ -471,7 +496,7 @@ function lerConhecimento(c, limites = exports.LIMITES_DO_CONHECIMENTO) {
         }
         documentos.push({ id: v.id, titulo: v.titulo, colecoes: v.colecoes,
             referencias: { brain: brain.sort(comparar), decisoes: decisoes.sort((a, b) => comparar(a.thread, b.thread) || a.linha - b.linha) },
-            arquivo: v.arquivo, bytes: v.bytes, sha256: v.sha256 });
+            arquivo: v.arquivo, bytes: v.bytes, sha256: v.sha256, ...(v.corpo !== undefined ? { corpo: v.corpo } : {}) });
     }
     const colecoes = new Map();
     for (const d of documentos)
@@ -484,7 +509,6 @@ function lerConhecimento(c, limites = exports.LIMITES_DO_CONHECIMENTO) {
         contrato: exports.CONTRATO_CONHECIMENTO, dir,
         documentos: documentos.sort((a, b) => comparar(a.id, b.id)),
         colecoes: [...colecoes].map(([nome, ids]) => ({ nome, documentos: ids.sort(comparar) })).sort((a, b) => comparar(a.nome, b.nome)),
-        lacunas: lacunas.sort((a, b) => comparar(a.arquivo ?? '', b.arquivo ?? '') || comparar(a.codigo, b.codigo) ||
-            comparar(a.referencia ?? '', b.referencia ?? '')),
+        lacunas: lacunas.sort(exports.compararLacunas),
     };
 }

package/dist/conta-esgotada.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reconciliarContaEsgotada = reconciliarContaEsgotada;
+/** RM-064 T1/T2: uma cota esgotada pertence à conta, não só à sessão que a revelou. */
+const node_crypto_1 = require("node:crypto");
+const claude_bg_1 = require("./adapters/claude-bg");
+const hitl_sessions_1 = require("./hitl-sessions");
+const ledger_1 = require("./ledger");
+const projeto_alvo_1 = require("./projeto-alvo");
+const runtime_profiles_1 = require("./runtime-profiles");
+const session_events_1 = require("./session-events");
+const sessoes_inventario_1 = require("./sessoes-inventario");
+const thread_1 = require("./thread");
+const sha = (v) => (0, node_crypto_1.createHash)('sha256').update(JSON.stringify(v)).digest('hex');
+const padrao = {
+    inventario: (raiz) => (0, sessoes_inventario_1.inventariarSessoes)(raiz, { global: true, todas: true, prazoMs: 30_000 }),
+    projetos: (raiz) => [...new Set([raiz, ...(0, projeto_alvo_1.listarProjetos)().filter((p) => p.presente).map((p) => p.raiz)])],
+    parar: (sessionId, id, perfil, vinculo) => {
+        if (perfil.runtime === 'codex') {
+            if (!vinculo)
+                return { ok: false, detalhe: 'vínculo canônico do controller ausente' };
+            try {
+                const ctl = (0, hitl_sessions_1.controleNativo)('codex', vinculo.raiz, vinculo.thread, sessionId);
+                const consulta = ctl.consultar();
+                const candidatas = consulta.sessoes.filter((s) => s.sessionId === sessionId && s.runtime === 'codex');
+                if (!consulta.ok || candidatas.length !== 1)
+                    return { ok: false, detalhe: 'controller codex não confirmou identidade única' };
+                return { ok: ctl.parar(candidatas[0]), detalhe: 'controller codex vinculado recebeu interrupção' };
+            }
+            catch (e) {
+                return { ok: false, detalhe: e.message };
+            }
+        }
+        const r = (0, claude_bg_1.pararAchada)({ sessionId, ...(id ? { id } : {}) }, (0, claude_bg_1.ambienteDoPerfil)(perfil));
+        return { ok: r.ok, detalhe: r.texto || (r.ok ? 'runtime confirmou a parada' : 'runtime recusou a parada') };
+    },
+};
+function vinculosDaConta(projetos, sessionId, conta) {
+    const vinculos = [], falhas = [];
+    for (const raiz of projetos) {
+        let ids;
+        try {
+            ids = (0, thread_1.listarIds)(raiz);
+        }
+        catch (e) {
+            falhas.push(`projeto não lido: ${e.message}`);
+            continue;
+        }
+        for (const id of ids) {
+            try {
+                const thread = (0, thread_1.lerThread)(raiz, id);
+                const sessao = thread.sessoes.find((s) => s.sessionId === sessionId && s.origem !== 'adocao');
+                if (!sessao?.despachadaEm)
+                    continue;
+                const eventos = (0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, id));
+                const perfil = (0, runtime_profiles_1.perfilDoRegistro)(eventos, { sessionId, despachadaEm: sessao.despachadaEm });
+                if (!perfil || (0, runtime_profiles_1.chaveDaConta)(perfil) !== conta)
+                    continue;
+                vinculos.push({ raiz, thread: id, fase: sessao.fase, despachoEm: sessao.despachadaEm });
+            }
+            catch (e) {
+                falhas.push(`vínculo ${id} não confirmado: ${e.message}`);
+            }
+        }
+    }
+    return { vinculos: vinculos.filter((v, i, a) => a.findIndex((x) => x.raiz === v.raiz && x.thread === v.thread) === i), falhas };
+}
+/**
+ * Para cada sessão viva da mesma conta: prova o vínculo pelo ledger, pede a parada uma vez e só
+ * então grava o terminal que libera a condução. Consulta incompleta nunca vira falso sucesso.
+ */
+function reconciliarContaEsgotada(entrada, deps = padrao) {
+    const agoraMs = entrada.agoraMs ?? Date.now();
+    const contaBruta = (0, runtime_profiles_1.chaveDaConta)(entrada.perfil), conta = sha(contaBruta);
+    const episodio = sha([conta, entrada.erroEm, entrada.esgotadoAte]);
+    const inv = deps.inventario(entrada.raiz);
+    const projetos = deps.projetos(entrada.raiz);
+    const falhas = inv.fontes.filter((f) => !f.ok).map((f) => f.detalhe);
+    const sessoes = [];
+    const candidatas = inv.sessoes.filter((s) => s.runtime === entrada.perfil.runtime && s.perfil === entrada.perfil.id && s.viva);
+    for (const sessao of candidatas) {
+        const achados = vinculosDaConta(projetos, sessao.sessionId, contaBruta);
+        falhas.push(...achados.falhas);
+        if (achados.vinculos.length === 0)
+            continue;
+        const pendentes = achados.vinculos.filter((v) => !(0, ledger_1.lerLedger)((0, thread_1.dirThread)(v.raiz, v.thread)).some((e) => e.tipo === 'phase_result' && e.quotaEpisodeId === episodio && e.sessionId === sessao.sessionId));
+        for (const v of achados.vinculos.filter((x) => !pendentes.includes(x))) {
+            sessoes.push({ ...v, sessionId: sessao.sessionId, parada: true, registrada: false, detalhe: 'episódio já reconciliado' });
+        }
+        if (pendentes.length === 0)
+            continue;
+        const paradaUnica = sessao.runtime === 'claude-bg'
+            ? deps.parar(sessao.sessionId, sessao.id, entrada.perfil) : null;
+        for (const v of pendentes) {
+            const parada = paradaUnica ?? deps.parar(sessao.sessionId, sessao.id, entrada.perfil, v);
+            const dir = (0, thread_1.dirThread)(v.raiz, v.thread);
+            if (!parada.ok || !(0, ledger_1.threadPresente)(dir)) {
+                sessoes.push({ ...v, sessionId: sessao.sessionId, parada: parada.ok, registrada: false, detalhe: parada.detalhe });
+                continue;
+            }
+            let registrada = false;
+            (0, session_events_1.comLockDeSessao)(dir, () => {
+                const atuais = (0, ledger_1.lerLedger)(dir);
+                if (atuais.some((e) => e.tipo === 'phase_result' && e.quotaEpisodeId === episodio && e.sessionId === sessao.sessionId))
+                    return;
+                const dados = { fase: v.fase, sessionId: sessao.sessionId, despachoEm: v.despachoEm, runtime: sessao.runtime,
+                    motivo: 'runtime.quota-exhausted', quotaEpisodeId: episodio, conta, resetEm: entrada.falha.resetEm,
+                    esgotadoAte: entrada.esgotadoAte, observadoEm: new Date(agoraMs).toISOString(), origem: 'account.quota-exhausted',
+                    perfil: { id: entrada.perfil.id, runtime: entrada.perfil.runtime },
+                    falhaDeConta: { motivo: entrada.falha.motivo, resetEm: entrada.falha.resetEm,
+                        fonte: entrada.falha.fonte, trecho: entrada.falha.trecho },
+                    evidencia: 'vínculo da sessão, conta do despacho e parada confirmados pelo núcleo' };
+                (0, ledger_1.registrarSeExiste)(dir, v.thread, 'runtime_account_exhausted', dados);
+                (0, ledger_1.registrarSeExiste)(dir, v.thread, ledger_1.TIPOS_DE_EVENTO.gateBloqueado, { ...dados, gate: 'phase.dispatch',
+                    modo: (0, thread_1.lerThread)(v.raiz, v.thread).modo, detalhe: 'a conta do despacho esgotou; retomar no próximo destino capaz',
+                    correcao: `ork retry run ${v.thread}` });
+                (0, ledger_1.registrarSeExiste)(dir, v.thread, 'phase_result', { ...dados, sensorResultId: `quota:${episodio}:${sessao.sessionId}`,
+                    classificacao: 'gate_blocked', ok: false, estado: 'bloqueada', paradaConfirmada: true });
+                registrada = true;
+            });
+            sessoes.push({ ...v, sessionId: sessao.sessionId, parada: true, registrada,
+                detalhe: registrada ? 'sessão parada e condução liberada' : 'episódio já reconciliado' });
+        }
+    }
+    return { conta, episodio, completo: inv.ok && falhas.length === 0 && sessoes.every((s) => s.parada && (s.registrada || s.detalhe.includes('já'))),
+        sessoes, falhas };
+}