@orkastery/cli 0.4.3 → 0.5.0

package/dist/ci.js

@@ -33,14 +33,21 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.BUNDLE_LEGADO = exports.DIR_DO_BUNDLE = void 0;
 exports.motivoDiferimentoCi = motivoDiferimentoCi;
 exports.repositorioGitHub = repositorioGitHub;
 exports.consultarCi = consultarCi;
+exports.consultarCiDoRepositorio = consultarCiDoRepositorio;
 exports.executarCi = executarCi;
+exports.arquivoDoBundle = arquivoDoBundle;
 exports.lintDoBundle = lintDoBundle;
+exports.destinoDoBundle = destinoDoBundle;
 exports.prepararBundleCi = prepararBundleCi;
+exports.bundleDaBranch = bundleDaBranch;
+exports.executarCiDaBranch = executarCiDaBranch;
 exports.executarBundleCi = executarBundleCi;
 const util_1 = require("./util");
+const worktree_1 = require("./worktree");
 const verify_1 = require("./verify");
 const verify_2 = require("./verify");
 const claims_1 = require("./claims");
@@ -64,6 +71,21 @@ const CASOS_DE_VERIFICADOR_LOCAIS = [
 ];
 const CASOS_DE_VERIFICADOR_COM_INTEGRACAO_LOCAL = [
     /verify-check-c2-b3\.cjs\s+channel-offer(?:\s|$)/,
+    // I-38: a prova da busca por significado le a memoria do tenant pela DSN do manifesto.
+    /prova-busca-semantica\.sh(?:\s|$)/,
+    // RM-051: o ensaio instala o tarball com npm --offline e resolve as dependencias pelo cache do npm
+    // da estacao; o runner hospedado so tem os tarballs do npm ci, sem os metadados do registro.
+    /testar-experiencia-e2e\.cjs(?:\s|$)/,
+];
+/**
+ * I-38: o runner hospedado nao oferece OrkMind nem a base do tenant. Claim que chama a memoria
+ * pelo CLI (a DSN vem do manifesto), que exige o OrkMind instalado ou que roda a suite inteira
+ * (ela inclui `TESTES_DE_INTEGRACAO_LOCAL`; o runner roda `test:ci`) fica para a estacao.
+ */
+const USA_A_ESTACAO = [
+    /(?:^|\s)memory\s+(?:status|index|search|sync|migrate|inventory)(?=\s|$)/,
+    /command -v orkmind(?=[\s)"']|$)/,
+    /npm\s+--prefix\s+core\s+test(?![:\w-])/,
 ];
 function exigeIntegracaoLocal(command) {
     return [...command.matchAll(/(?:^|[\s/])([a-z0-9-]+\.test\.js)(?=$|[\s;&|])/g)]
@@ -90,7 +112,8 @@ function motivoDiferimentoCi(claim, raiz) {
         return 'host-runtime-required';
     }
     if (claim.verificar.some((command) => exigeIntegracaoLocal(command)
-        || CASOS_DE_VERIFICADOR_COM_INTEGRACAO_LOCAL.some((caso) => caso.test(command)))) {
+        || CASOS_DE_VERIFICADOR_COM_INTEGRACAO_LOCAL.some((caso) => caso.test(command))
+        || USA_A_ESTACAO.some((caso) => caso.test(command)))) {
         return 'local-integration-required';
     }
     return null;
@@ -114,6 +137,13 @@ function consultarCi(carregado, sha, remoto = 'origin', executor = executorPadra
     const repository = remote.ok ? repositorioGitHub(remote.stdout) : null;
     if (!repository)
         return { schema: 'ork.ci-status/v1', required: true, ok: false, provider: 'github', repository: null, sha, context, state: 'unavailable', url: null, detail: `remoto ${remoto} não é um repositório GitHub reconhecível` };
+    return consultarCiDoRepositorio(repository, sha, context, executor);
+}
+/**
+ * O check `context` no `sha` de um repositorio GitHub ja resolvido: o do remoto do projeto ou, desde a
+ * RM-037 (rm037defeito, defeito 5), um repositorio externo declarado em `ci.external_repositories`.
+ */
+function consultarCiDoRepositorio(repository, sha, context, executor = executorPadrao) {
     const result = executor({ repository, sha, context });
     if (!result.ok)
         return { schema: 'ork.ci-status/v1', required: true, ok: false, provider: 'github', repository, sha, context, state: 'unavailable', url: null, detail: (result.stderr || result.stdout || 'consulta ao GitHub falhou').trim().slice(0, 400) };
@@ -148,6 +178,28 @@ function executarCi(carregado, threadId) {
         verify,
     };
 }
+/**
+ * RM-037 (rm037noite, defeito 1): um bundle por thread. O `.ork-ci/bundle.json` era o mesmo caminho em
+ * toda thread, entao toda PR conflitava com todas as outras e cada merge pedia merge da main, `ork ci
+ * prepare` e CI de novo na proxima. Cada thread grava agora o proprio `.ork-ci/<thread>.json`, e o CI
+ * acha o da thread pelo nome da branch (`ork ci run --branch`). O bundle nao nasce no CI porque as
+ * claims ficam no `.orkastery/` da maquina que conduz, fora do git.
+ */
+exports.DIR_DO_BUNDLE = '.ork-ci';
+/** O caminho unico de antes: so vale quando o `thread` dele bate com a branch (PR aberta antes da mudanca). */
+exports.BUNDLE_LEGADO = 'bundle.json';
+const THREAD_DO_BUNDLE = /^ork-[a-z0-9-]+$/;
+/** O nome do arquivo do bundle da thread, dentro de `.ork-ci/`. */
+function arquivoDoBundle(threadId) {
+    if (!THREAD_DO_BUNDLE.test(threadId))
+        throw new Error(`ci.bundle: "${threadId}" nao e id de thread`);
+    return `${threadId}.json`;
+}
+function comandosDoBundle(carregado) {
+    return carregado.manifesto.ci.command
+        ? [{ name: 'ci', command: carregado.manifesto.ci.command }]
+        : (0, verify_2.comandosDoManifesto)(carregado.manifesto).map(({ nome, comando }) => ({ name: nome, command: comando }));
+}
 /**
  * I-53 (RM-037, P6): o lint no `ci prepare`. Claim nascida sob a regra (com o campo `lint`) que
  * roda a suite inteira e recusada: o bundle vai para o runner hospedado e reprovaria la, depois de
@@ -166,10 +218,20 @@ function lintDoBundle(claims) {
     }
     return { recusas, avisos };
 }
+/**
+ * RM-037 (rm037defeito, defeito 6): onde o bundle nasce. Ele e artefato da branch da thread (o commit
+ * `ci(<thread>)` vai no PR dela), entao o destino e a worktree da thread, rodando o `ork` da raiz ou da
+ * worktree. Gravado na raiz, ele sujava o checkout compartilhado com o bundle de outra thread, e o
+ * `git ls-files` da raiz adiava claim de arquivo que so existe na branch da thread.
+ */
+function destinoDoBundle(carregado, threadId) {
+    const worktree = (0, thread_1.lerThread)(carregado.raiz, threadId).worktree;
+    return worktree && fs.existsSync(worktree) ? worktree : carregado.raiz;
+}
 function prepararBundleCi(carregado, threadId, opcoes = {}) {
-    const commands = carregado.manifesto.ci.command
-        ? [{ name: 'ci', command: carregado.manifesto.ci.command }]
-        : (0, verify_2.comandosDoManifesto)(carregado.manifesto).map(({ nome, comando }) => ({ name: nome, command: comando }));
+    const commands = comandosDoBundle(carregado);
+    const nomeDoArquivo = arquivoDoBundle(threadId);
+    const branch = (0, worktree_1.branchDaWorktree)((0, thread_1.lerThread)(carregado.raiz, threadId));
     const activeClaims = (0, claims_1.lerClaims)(carregado.raiz, threadId).filter((claim) => claim.estado !== 'retirada');
     const lint = lintDoBundle(activeClaims);
     if (lint.recusas.length || lint.avisos.length) {
@@ -181,13 +243,20 @@ function prepararBundleCi(carregado, threadId, opcoes = {}) {
         throw new Error(`claims.lint: o bundle nao foi gerado; retire a claim e registre de novo com o comando focado:\n  ` +
             lint.recusas.join('\n  '));
     }
+    const destino = destinoDoBundle(carregado, threadId);
+    // Achado S8 do CHECK: a worktree registrada que sumiu nao e silencio; o bundle na raiz vem com aviso.
+    const registrada = (0, thread_1.lerThread)(carregado.raiz, threadId).worktree;
+    if (registrada && destino !== registrada) {
+        opcoes.aoAvisar?.(`a worktree ${registrada} da thread nao existe mais; o bundle vai para a raiz do projeto`);
+    }
     const classified = activeClaims.map((claim) => ({
         claim,
-        reason: motivoDiferimentoCi(claim, carregado.raiz),
+        reason: motivoDiferimentoCi(claim, destino),
     }));
     const bundle = {
         schema: 'ork.ci-bundle/v1',
         thread: threadId,
+        branch,
         base: carregado.manifesto.worktree.base_branch,
         claims: classified.filter((item) => item.reason === null).map((item) => item.claim),
         deferredClaims: classified
@@ -195,20 +264,82 @@ function prepararBundleCi(carregado, threadId, opcoes = {}) {
             .map((item) => ({ id: item.claim.id, reason: item.reason })),
         commands,
     };
-    const dir = path.join(carregado.raiz, '.ork-ci');
+    const dir = path.join(destino, '.ork-ci');
     fs.mkdirSync(dir, { recursive: true });
-    const file = path.join(dir, 'bundle.json');
+    const file = path.join(dir, nomeDoArquivo);
     fs.writeFileSync(file, JSON.stringify(bundle, null, 2) + '\n', 'utf8');
     return file;
 }
-function executarBundleCi(carregado, file = '.ork-ci/bundle.json') {
-    const absolute = path.resolve(carregado.raiz, file);
+function lerBundle(raiz, file) {
+    const absolute = path.resolve(raiz, file);
     const stat = fs.statSync(absolute);
     if (!stat.isFile() || stat.size > 1024 * 1024)
         throw new Error('bundle de CI ausente ou acima de 1 MiB');
     const bundle = JSON.parse(fs.readFileSync(absolute, 'utf8'));
-    if (bundle.schema !== 'ork.ci-bundle/v1' || !/^ork-[a-z0-9-]+$/.test(bundle.thread) || !Array.isArray(bundle.claims) || !Array.isArray(bundle.commands))
+    if (bundle.schema !== 'ork.ci-bundle/v1' || !THREAD_DO_BUNDLE.test(bundle.thread) || !Array.isArray(bundle.claims) || !Array.isArray(bundle.commands))
         throw new Error('bundle de CI inválido');
+    return bundle;
+}
+const casaComBranch = (thread, branch) => branch === `ork/${thread}` || branch.startsWith(`ork/${thread}-`);
+/**
+ * O bundle da branch, entre os `.ork-ci/*.json` do checkout. Vale o de `branch` igual. O bundle sem
+ * `branch` (o `bundle.json` legado, de antes da RM-037) vale pela thread, quando a branch e
+ * `ork/<thread>` ou `ork/<thread>-*` (a mais longa ganha: `ork-a` nao leva a branch da `ork-ab`).
+ * Bundle novo de outra branch nunca vale, nem da mesma thread (achado A4 do CHECK 1), e o arquivo da
+ * thread da branch que nao abre reprova em vez de ceder a vez a outro. `null` quando nenhum bate.
+ */
+function bundleDaBranch(raiz, branch) {
+    const dir = path.join(raiz, exports.DIR_DO_BUNDLE);
+    if (!fs.existsSync(dir))
+        return null;
+    let melhor = null;
+    let quebrado = null;
+    for (const nome of fs.readdirSync(dir).filter((n) => n.endsWith('.json')).sort()) {
+        const arquivo = path.posix.join(exports.DIR_DO_BUNDLE, nome);
+        let bundle;
+        try {
+            bundle = lerBundle(raiz, arquivo);
+        }
+        catch (e) {
+            if (!quebrado && nome !== exports.BUNDLE_LEGADO && casaComBranch(nome.slice(0, -'.json'.length), branch)) {
+                quebrado = new Error(`ci.bundle.invalido: ${arquivo} e o bundle da branch ${branch} e nao abre ` +
+                    `(${e.message}); rode ork ci prepare <thread> de novo e versione o arquivo`);
+            }
+            continue;
+        }
+        if (nome !== exports.BUNDLE_LEGADO && nome !== `${bundle.thread}.json`)
+            continue;
+        const peso = bundle.branch === branch ? Number.MAX_SAFE_INTEGER
+            : !bundle.branch && casaComBranch(bundle.thread, branch) ? bundle.thread.length : 0;
+        if (peso > 0 && (!melhor || peso > melhor.peso))
+            melhor = { arquivo, bundle, peso };
+    }
+    // Sugestao 4 do CHECK 2: o arquivo quebrado so reprova se nenhum bundle valido for da branch exata.
+    if (quebrado && melhor?.peso !== Number.MAX_SAFE_INTEGER)
+        throw quebrado;
+    return melhor ? { arquivo: melhor.arquivo, bundle: melhor.bundle } : null;
+}
+/**
+ * `ork ci run --branch <branch>`: o CHECK do CI pela branch. Branch de thread (`ork/*`) roda o bundle
+ * dela e reprova sem ele; outra branch (a `main`, por exemplo) nao tem thread e roda so os comandos
+ * do manifesto.
+ */
+function executarCiDaBranch(carregado, branch) {
+    const achado = bundleDaBranch(carregado.raiz, branch);
+    if (achado)
+        return { ...rodarBundle(carregado, achado.bundle), branch, bundle: achado.arquivo };
+    if (branch.startsWith('ork/')) {
+        throw new Error(`ci.bundle.ausente: a branch ${branch} e de thread e nao tem bundle em ${exports.DIR_DO_BUNDLE}/; ` +
+            'rode ork ci prepare <thread> na worktree e versione o arquivo');
+    }
+    const semThread = { schema: 'ork.ci-bundle/v1', thread: '', base: carregado.manifesto.worktree.base_branch,
+        claims: [], commands: comandosDoBundle(carregado) };
+    return { ...rodarBundle(carregado, semThread), thread: null, branch, bundle: null };
+}
+function executarBundleCi(carregado, file = path.posix.join(exports.DIR_DO_BUNDLE, exports.BUNDLE_LEGADO)) {
+    return rodarBundle(carregado, lerBundle(carregado.raiz, file));
+}
+function rodarBundle(carregado, bundle) {
     // O CI roda o mesmo preparo do `ork verify` local (I-54), uma vez e antes das claims: a claim
     // que passa na maquina de quem entrega passa aqui pelo mesmo caminho. Como no verify, o
     // preparo nao e condicao de claim; ele so deixa a compilacao pronta e sai no resultado.

package/dist/company-brain-cli.js

@@ -48,7 +48,9 @@ const company_brain_source_1 = require("./company-brain-source");
 const company_brain_migration_1 = require("./company-brain-migration");
 const company_brain_journal_1 = require("./company-brain-journal");
 const company_brain_contract_1 = require("./company-brain-contract");
-exports.BRAIN_READ = ['status', 'inventory', 'get', 'query', 'receipts', 'reconcile'];
+const company_brain_context_1 = require("./company-brain-context");
+const company_brain_dossie_1 = require("./company-brain-dossie");
+exports.BRAIN_READ = ['status', 'inventory', 'get', 'query', 'receipts', 'reconcile', 'context', 'dossie'];
 exports.BRAIN_WRITE = ['sync', 'apply', 'rollback', 'bind'];
 function runBrain(c, sub, options, positionals = [], transport) {
     const context = (0, project_state_1.memoryState)(c);
@@ -56,7 +58,7 @@ function runBrain(c, sub, options, positionals = [], transport) {
     const config = c.manifesto.memory;
     if (![...exports.BRAIN_READ, ...exports.BRAIN_WRITE].includes(sub))
         throw Error('brain.operation.invalid');
-    const allowed = new Set(['thread', 'json', 'id', 'ids', 'kinds', 'workspaces', 'limit', 'offset', 'batch', 'dry-run', 'plan', 'expected-sha256', 'project', 'initiatives']);
+    const allowed = new Set(['thread', 'json', 'id', 'ids', 'kinds', 'workspaces', 'limit', 'offset', 'batch', 'dry-run', 'plan', 'expected-sha256', 'project', 'initiatives', 'decisao']);
     if (Object.keys(options).some(k => !allowed.has(k)))
         throw Error('brain.argument.invalid');
     const value = (name) => typeof options[name] === 'string' ? options[name] : undefined;
@@ -80,6 +82,29 @@ function runBrain(c, sub, options, positionals = [], transport) {
             throw Error('brain.migration.dry-run-required');
         return { state: 'ok', ...(0, company_brain_migration_1.reconcileBrain)(c, scope, value('batch') ?? 'inventory-' + (0, company_brain_contract_1.digest)((0, portfolio_1.readPortfolio)(c.raiz)).slice(0, 20)) };
     }
+    // B4.1: só leitura, por isso fica antes da ativação. Sem --ids, vale o escopo vinculado da thread.
+    if (sub === 'context') {
+        let ids = (value('ids') ?? '').split(',').map(s => s.trim()).filter(Boolean);
+        const bindingFile = path.join((0, thread_1.dirThread)(c.raiz, thread), 'brain-scope.json');
+        if (!ids.length && fs.existsSync(bindingFile)) {
+            let binding;
+            try {
+                binding = JSON.parse(fs.readFileSync(bindingFile, 'utf8'));
+            }
+            catch {
+                throw Error('brain.scope.invalid');
+            }
+            // Mesma conferência do sync: o escopo vinculado vale só se for desta thread e do formato gravado pelo bind.
+            if (binding?.schema !== 'ork.brain-cycle-scope/v1' || binding.version !== 1 || binding.thread !== thread || typeof binding.projectId !== 'string' ||
+                !Array.isArray(binding.initiativeIds) || binding.initiativeIds.some((i) => typeof i !== 'string'))
+                throw Error('brain.scope.invalid');
+            ids = [binding.projectId, ...binding.initiativeIds];
+        }
+        return (0, company_brain_context_1.buildContext)(c, ids, client, thread);
+    }
+    // K3.1: dossiê de decisão, só leitura como o contexto; decidir continua no registro e no ingresso.
+    if (sub === 'dossie')
+        return (0, company_brain_dossie_1.buildDossie)(c, thread, options.decisao === undefined ? undefined : value('decisao') ?? '', client);
     // Existing reviewed activation plus dedicated Brain DB grants: neither grants the other.
     (0, write_activation_1.exigirAtivacao)(c, thread, 'memory');
     const dir = (0, thread_1.dirThread)(c.raiz, thread);

package/dist/company-brain-context.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONTEXT_SCHEMA = void 0;
+exports.buildContext = buildContext;
+const portfolio_1 = require("./portfolio");
+const company_brain_client_1 = require("./company-brain-client");
+const company_brain_contract_1 = require("./company-brain-contract");
+const company_brain_source_1 = require("./company-brain-source");
+exports.CONTEXT_SCHEMA = 'ork.brain-context/v1';
+const ID = /^(prod|proj|init)-[a-z0-9][a-z0-9-]{2,47}$/;
+const ORDEM = { prod: 0, proj: 1, init: 2 };
+const LIMITE = 1000;
+/** Teto de `get` por pacote: só o caso misto (alguns retidos, alguns ausentes) precisa deles. */
+const LIMITE_DE_GET = 100;
+const kindDe = (id) => id.slice(0, 4);
+/** Por code point: o digest é identidade citável e não pode depender do locale do processo. */
+const comparar = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+// Além do que o D7 lista, `conflict` também encerra: resposta de conflito não é conteúdo citável.
+const falha = (state) => ['forbidden', 'unavailable', 'conflict'].includes(state);
+/** A citação só vale inteira: sem um dos campos, o item sai do conteúdo e vira lacuna. */
+function citacaoDe(source) {
+    if (!source || typeof source !== 'object')
+        return null;
+    const { instance, source_ref, source_hash, source_version, location } = source;
+    if ([instance, source_ref, location].some(v => typeof v !== 'string' || !v) || typeof source_hash !== 'string' ||
+        !/^[a-f0-9]{64}$/.test(source_hash) || !Number.isInteger(source_version))
+        return null;
+    return { instance, source_ref, source_hash, source_version, location };
+}
+/**
+ * Monta o pacote dos ids pedidos mais a cadeia de pais. A fonte canônica é o portfólio local;
+ * o Brain é projeção, e a diferença entre os dois sai como frescor e lacuna, nunca é corrigida aqui.
+ */
+function buildContext(c, ids, transport, thread) {
+    const tenant = c.manifesto.memory.tenant;
+    const pedido = [...new Set(ids)].sort(comparar);
+    if (!pedido.length)
+        throw Error('brain.context.ids-required');
+    if (pedido.some(id => !ID.test(id)))
+        throw Error('brain.context.id-invalid');
+    if (pedido.length > LIMITE)
+        throw Error('brain.context.too-many');
+    const fonte = new Map((0, company_brain_source_1.portfolioEntities)((0, portfolio_1.readPortfolio)(c.raiz), { tenant, instance: c.manifesto.project.name, thread, aclRef: 'ork-factory' }).map(e => [e.id, e]));
+    const base = { schema: exports.CONTEXT_SCHEMA, tenant, contrato: company_brain_contract_1.CONTRACT_HASH, thread, pedido };
+    const encerrar = (r) => ({ ...base, state: r.state, ...(r.error ? { error: r.error } : {}), itens: [], lacunas: [], digest: null, consultadoEm: new Date().toISOString() });
+    const escopo = new Set(pedido), brain = new Map(), retidos = new Set();
+    // O pai só entra por um filho visível e tem kind acima dele: init, proj e prod fecham em três voltas.
+    const pai = (id, parent) => typeof parent === 'string' && ID.test(parent) && ORDEM[kindDe(parent)] < ORDEM[kindDe(id)] ? parent : null;
+    let gets = 0;
+    for (let pendentes = pedido; pendentes.length;) {
+        for (let inicio = 0; inicio < pendentes.length; inicio += LIMITE) {
+            const lote = pendentes.slice(inicio, inicio + LIMITE), doLote = new Set(lote);
+            const r = transport({ schema: company_brain_client_1.BRAIN_API, operation: 'query', payload: (0, company_brain_contract_1.validateContract)({ schema: 'orkmind.company-brain-selection/v1',
+                    tenant_id: tenant, facets: { ids: lote, kinds: [], workspace_ids: [], source_instances: [] }, mode: 'selection',
+                    limit: lote.length, offset: 0 }) });
+            if (falha(r.state))
+                return encerrar(r);
+            const itens = Array.isArray(r.items) ? r.items : [];
+            for (const item of itens)
+                if (item?.state === 'ok' && doLote.has(item.entity?.id))
+                    brain.set(item.entity.id, item.entity);
+            // Retido chega sem id na seleção. Sem retido no lote, o que faltou é desconhecido; com todos os
+            // faltantes retidos, não há o que atribuir. Só no caso misto o `get` diz qual id é qual.
+            const faltantes = lote.filter(id => !brain.has(id)), retidosNoLote = itens.filter((i) => i?.state === 'withheld').length;
+            if (retidosNoLote && retidosNoLote === faltantes.length)
+                faltantes.forEach(id => retidos.add(id));
+            else if (retidosNoLote)
+                for (const id of faltantes) {
+                    if (++gets > LIMITE_DE_GET)
+                        return encerrar({ state: 'unavailable', error: 'brain.context.get-limit' });
+                    const g = transport({ schema: company_brain_client_1.BRAIN_API, operation: 'get', payload: { tenant_id: tenant, id } });
+                    if (falha(g.state))
+                        return encerrar(g);
+                    if (g.state === 'withheld')
+                        retidos.add(id);
+                    else if (g.state === 'ok' && g.entity?.id === id)
+                        brain.set(id, g.entity);
+                }
+        }
+        const novos = [];
+        for (const id of pendentes)
+            if (!retidos.has(id))
+                for (const parent of [pai(id, fonte.get(id)?.parent_id), pai(id, brain.get(id)?.parent_id)])
+                    if (parent && !escopo.has(parent)) {
+                        escopo.add(parent);
+                        novos.push(parent);
+                    }
+        pendentes = novos.sort(comparar);
+    }
+    const itens = [], lacunas = [];
+    const lacuna = (id, codigo) => lacunas.push({ id, codigo });
+    for (const id of escopo) {
+        if (retidos.has(id)) {
+            itens.push({ id, estado: 'retido', frescor: 'retido', origem: 'brain' });
+            lacuna(id, 'brain.retido');
+            continue;
+        }
+        const b = brain.get(id), f = fonte.get(id);
+        if (!b && !f) {
+            lacuna(id, 'entidade.desconhecida');
+            continue;
+        }
+        const entidade = b ?? f, citacao = citacaoDe(entidade.source);
+        if (!citacao) {
+            lacuna(id, 'citacao.incompleta');
+            continue;
+        }
+        const frescor = !b ? 'ausente-no-brain' : !f ? 'ausente-na-fonte'
+            : b.source?.source_hash === f.source.source_hash && b.version === f.version ? 'confere' : 'divergente';
+        itens.push({ id, kind: entidade.kind, estado: 'ok', frescor, origem: b ? 'brain' : 'fonte', titulo: entidade.title ?? '',
+            status: entidade.status ?? '', parent_id: entidade.parent_id ?? null, depends_on: entidade.depends_on ?? [],
+            owner: { raw: entidade.owner?.raw ?? null, state: entidade.owner?.state ?? 'unknown' }, versao: entidade.version, citacao,
+            fonte: f ? { source_hash: f.source.source_hash, version: f.version } : null });
+        if (frescor === 'ausente-no-brain')
+            lacuna(id, 'brain.ausente');
+        if (frescor === 'ausente-na-fonte')
+            lacuna(id, 'fonte.ausente');
+        if (frescor === 'divergente')
+            lacuna(id, 'fonte.divergente');
+        if ((entidade.owner?.principal ?? null) === null)
+            lacuna(id, 'dono.sem-principal');
+        if ((entidade.observed_at ?? null) === null)
+            lacuna(id, 'observado.desconhecido');
+        if ((entidade.recorded_at ?? null) === null)
+            lacuna(id, 'registrado.desconhecido');
+    }
+    itens.sort((a, b) => ORDEM[kindDe(a.id)] - ORDEM[kindDe(b.id)] || comparar(a.id, b.id));
+    lacunas.sort((a, b) => comparar(a.id, b.id) || comparar(a.codigo, b.codigo));
+    // O digest cobre o que foi dito e de onde veio; o horário da consulta fica fora para o pacote ser reproduzível.
+    const corpo = { ...base, state: (itens.length ? 'ok' : 'empty'), itens, lacunas };
+    return { ...corpo, digest: (0, company_brain_contract_1.digest)(corpo), consultadoEm: new Date().toISOString() };
+}