@orkastery/cli 0.4.2 → 0.5.0

package/dist/mcp-server.js

@@ -56,6 +56,8 @@ const leases_1 = require("./leases");
 const hitl_gates_1 = require("./hitl-gates");
 const hitl_contract_1 = require("./hitl-contract");
 const hitl_presentation_1 = require("./hitl-presentation");
+const roadmap_status_1 = require("./roadmap-status");
+const network_roadmap_1 = require("./network-roadmap");
 const hitl_sessions_1 = require("./hitl-sessions");
 const hitl_local_1 = require("./hitl-local");
 const mcp_artifacts_1 = require("./mcp-artifacts");
@@ -65,6 +67,7 @@ const modos_1 = require("./modos");
 const versao_1 = require("./versao");
 const mcp_verify_1 = require("./mcp-verify");
 const conducao_1 = require("./conducao");
+const decisao_autonoma_1 = require("./decisao-autonoma");
 const conducao_texto_1 = require("./conducao-texto");
 const mcp_ship_1 = require("./mcp-ship");
 const company_brain_mcp_1 = require("./company-brain-mcp");
@@ -72,6 +75,8 @@ const claude_bg_1 = require("./adapters/claude-bg");
 const session_watcher_claude_1 = require("./session-watcher-claude");
 const runtime_profiles_1 = require("./runtime-profiles");
 const mcp_maestro_1 = require("./mcp-maestro");
+const projeto_alvo_1 = require("./projeto-alvo");
+const mcp_experiencia_1 = require("./mcp-experiencia");
 const identidade = zod_1.z.string().min(1).max(80).regex(/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/);
 const daThread = zod_1.z.object({ threadId: identidade }).strict();
 const daDecisao = daThread.extend({ pedidoId: identidade }).strict();
@@ -297,15 +302,33 @@ function criarServidorMcp(opcoes) {
                 throw Error('lease.busy: ' + conflitos.map(l => l.nome + ' (' + l.thread + ')').join(', '));
         }
     };
-    const server = new index_js_1.Server({ name: 'orkastery', version: versao_1.VERSAO_DO_ORK }, { capabilities: { tools: {} }, instructions: 'Opere somente este projeto pelas ferramentas do nucleo. Decisoes humanas usam ork_request_decision e o dialogo do host; argumentos de ferramenta nunca sao respostas.' });
+    const server = new index_js_1.Server({ name: 'orkastery', version: versao_1.VERSAO_DO_ORK }, { capabilities: { tools: {} }, instructions: 'Opere somente este projeto pelas ferramentas do nucleo. O parametro opcional projeto so confere o projeto servido; nunca troca a raiz. O status do roadmap vem de ork_network_roadmap, transportado como vem. Decisoes humanas usam ork_request_decision e o dialogo do host; argumentos de ferramenta nunca sao respostas.' });
+    /**
+     * RM-052 (D5): toda tool aceita `projeto`, e ele so CONFERE o projeto fixado no startup. Pedido de
+     * outro projeto recusa tipado, com o projeto servido como unico candidato; a raiz nunca muda aqui.
+     */
+    const conferirProjeto = (pedido) => {
+        const c = carregar(), nome = c.manifesto.project.name, abbrev = c.manifesto.project.abbrev, v = pedido.toLowerCase();
+        if (nome.toLowerCase() === v || (!!abbrev && abbrev.toLowerCase() === v))
+            return;
+        throw new projeto_alvo_1.ErroDeProjeto('projeto.fora-do-servidor', `este servidor MCP atende somente o projeto ${nome}; "${pedido}" nao e ele`, [{ nome, abbrev, raiz: (0, projeto_alvo_1.raizParaExibir)(raiz), remoto: (0, projeto_alvo_1.remotoDoProjeto)(raiz, c.manifesto.fabrica?.remoto ?? 'origin'), presente: true }], 'Use o servidor MCP instalado no outro projeto (ork mcp install --project <raiz>), ou o CLI com --projeto <nome>.');
+    };
+    const campoProjeto = zod_1.z.string().regex(projeto_alvo_1.PADRAO_DO_NOME_DE_PROJETO)
+        .describe('Nome ou abbrev do projeto pedido; este servidor atende somente o projeto fixado na instalacao');
     const ferramentas = new Map();
     function registrarTool(nome, config, executar) {
         if (opcoes.threadId && ['ork_thread_new', 'ork_phase_run', 'ork_request_decision', 'ork_preflight'].includes(nome))
             return;
-        const schema = converterSchema(config.inputSchema, { $refStrategy: 'none' });
+        const entrada = config.inputSchema.extend({ projeto: campoProjeto.optional() });
+        const schema = converterSchema(entrada, { $refStrategy: 'none' });
         ferramentas.set(nome, { tool: { name: nome, description: config.description, annotations: config.annotations,
                 inputSchema: schema },
-            executar: async (raw, extra) => executar(config.inputSchema.parse(raw), extra) });
+            executar: async (raw, extra) => {
+                const { projeto, ...args } = entrada.parse(raw);
+                if (projeto !== undefined)
+                    conferirProjeto(projeto);
+                return executar(args, extra);
+            } });
     }
     server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => ({ tools: [...ferramentas.values()].map(f => f.tool) }));
     server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request, extra) => {
@@ -316,6 +339,8 @@ function criarServidorMcp(opcoes) {
             return await f.executar(request.params.arguments ?? {}, extra);
         }
         catch (e) {
+            if (e instanceof projeto_alvo_1.ErroDeProjeto)
+                return { ...resposta(e.recusa), isError: true };
             return { ...resposta({ erro: e.message }), isError: true };
         }
     });
@@ -344,6 +369,7 @@ function criarServidorMcp(opcoes) {
     });
     server.onclose = () => ingresso.fechar();
     (0, company_brain_mcp_1.registerBrainTools)(registrarTool, carregar, thread, opcoes.brainWrites ?? []);
+    (0, mcp_experiencia_1.registrarConsultasExperiencia)(registrarTool, { raiz, carregar, transporte: opcoes.transporteShip ?? 'github-ssh' });
     (0, mcp_maestro_1.registerMaestro)(registrarTool, { root: raiz, threadId: opcoes.threadId, load: carregar, checkThread: thread, tools: () => [...ferramentas.keys()] });
     registrarTool('ork_preflight', { description: 'Preflight contextual por modo e bloco, sem inventário global/modelos. Não autoriza despacho nem comprova entrega.',
         inputSchema: zod_1.z.object({ modo: modoDeConducao }).strict(), annotations: { readOnlyHint: true } }, async ({ modo }) => {
@@ -402,6 +428,35 @@ function criarServidorMcp(opcoes) {
         livre(threadId);
         return resposta((0, mcp_artifacts_1.escreverArtefatoMcp)(raiz, threadId, tipo, conteudo, expectedSha256));
     });
+    // RM-037 (rm037defeito, defeito 1): a decisao que a sessao toma sem perguntar ao dono. O sandbox do
+    // codex nao grava o ledger e o `ork decisao registrar` morria em EROFS. Mesma `registrarDecisao` do CLI:
+    // contrato v2, criterio que resolve e rastro no mesmo evento. Nao pergunta ao dono e nao toca gate.
+    const campoDaDecisao = zod_1.z.string().min(1).max(4096);
+    registrarTool('ork_decision_record', { description: 'Registra decisao ja tomada pela sessao sem perguntar ao dono (classe decidido), com criterio que resolve e rastro. Nao pergunta, nao responde nem aprova gate.',
+        inputSchema: daThread.extend({ decidido: campoDaDecisao, porque: campoDaDecisao, comoMudar: campoDaDecisao,
+            custoAgora: campoDaDecisao, custoDepois: campoDaDecisao,
+            criterio: zod_1.z.object({ tipo: zod_1.z.enum(['manifesto', 'ledger', 'medicao']), referencia: campoDaDecisao }).strict(),
+            quemDecidiu: zod_1.z.string().min(1).max(200), evidencia: campoDaDecisao, razao: campoDaDecisao.optional(),
+            reverte: zod_1.z.string().min(1).max(80).optional() }).strict(),
+        annotations: { readOnlyHint: false, destructiveHint: false } }, async ({ threadId, ...e }) => {
+        thread(threadId);
+        livre(threadId);
+        // A sessao decide por ela: o rastro nao pode nascer assinado em nome do dono.
+        if (/^\s*(?:o\s+|a\s+)?(?:dono|owner|builder|maestro)\b/i.test(e.quemDecidiu))
+            throw Error('mcp.decision.author: quemDecidiu e a sessao que decidiu, nunca o dono');
+        let registro;
+        try {
+            registro = (0, decisao_autonoma_1.registrarDecisao)(raiz, threadId, { decidido: e.decidido, porque: e.porque, comoMudar: e.comoMudar,
+                custoDeReverter: { agora: e.custoAgora, depois: e.custoDepois }, criterio: e.criterio, quemDecidiu: e.quemDecidiu,
+                evidencia: e.evidencia, ...(e.razao ? { razao: e.razao } : {}), ...(e.reverte ? { reverte: e.reverte } : {}), origem: 'mcp', host: opcoes.host,
+                despacho: opcoes.dispatchId ?? null });
+        }
+        catch (erro) {
+            throw Error((0, hitl_contract_1.recusaNaSuperficie)(erro.message, hitl_contract_1.CAMPOS_DA_DECISAO_NO_MCP));
+        }
+        const { pedido, evento } = registro;
+        return resposta({ ok: true, pedidoId: pedido.id, eventId: evento.eventId, fase: pedido.fase, reciboOficial: false });
+    });
     registrarTool('ork_claims_list', { description: 'Lista alegacoes e seu estado de verificacao registrado pelo nucleo.',
         inputSchema: daThread, annotations: { readOnlyHint: true } }, async ({ threadId }) => {
         thread(threadId);
@@ -423,6 +478,25 @@ function criarServidorMcp(opcoes) {
     });
     registrarTool('ork_hitl_pending', { description: 'Pedidos HITL atuais da thread, incluindo prazo; nao aprova nem abre pedido.',
         inputSchema: daThread, annotations: { readOnlyHint: true } }, async ({ threadId }) => resposta({ threadId, pendencias: pendencias(threadId) }));
+    registrarTool('ork_roadmap_status', { description: 'Status report do roadmap SO desta maquina (o checkout local), no formato aprovado pelo dono: grupos com icones, #HITL no que espera o dono e o fecho. Somente leitura; transporte o texto como vem. O cabecalho diz o projeto consultado e o que nao foi lido (reservas, outras maquinas). Para o status do roadmap com as threads de todas as maquinas, as reservas, as fontes e as lacunas, use ork_network_roadmap; nunca conclua sobre ele a partir de ork_maestro ou de threads.',
+        inputSchema: zod_1.z.object({}).strict(), annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false } }, async () => {
+        const c = carregar();
+        // RM-052: origem `instalacao`; o servidor fixado nao revela os outros projetos da maquina.
+        const consulta = (0, projeto_alvo_1.consultaDoProjeto)(c, { origem: 'instalacao', outrosProjetos: false,
+            lido: ['roadmap (docs/roadmap)', projeto_alvo_1.FORA_DA_CONSULTA.threadsDaMaquina], naoLido: [projeto_alvo_1.FORA_DA_CONSULTA.reservas, 'threads de outras máquinas (ork network roadmap)'] });
+        const status = (0, roadmap_status_1.montarStatusDoRoadmap)(raiz, { projeto: c.manifesto.project.name, consulta });
+        return resposta({ texto: (0, roadmap_status_1.textoDoStatusDoRoadmap)(status), status });
+    });
+    /**
+     * RM-054 (fatia 2, D-G5): o roadmap da rede do projeto servido, em todas as maquinas dele. O servidor
+     * fixado nao le o registro nem revela os outros projetos (D5 da RM-052); o texto e o do CLI.
+     */
+    registrarTool('ork_network_roadmap', { description: 'Roadmap da rede do projeto servido, somente leitura: o status report do roadmap (RM-048) com as threads de TODAS as maquinas, as reservas, as threads por maquina com a idade da batida, a fonte e a hora de cada parte e as lacunas tipadas. E a fonte do status do roadmap: transporte o texto como vem, sem reescrever nem resumir. Lacuna e "Nao consultado" sao o que nao foi lido: nunca conclua "roadmap vazio" nem "nenhuma maquina publicou" a partir deles. Este servidor le so o projeto fixado; os outros projetos vem do CLI ork network roadmap.',
+        inputSchema: zod_1.z.object({}).strict(), annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: true } }, async () => {
+        carregar();
+        const panorama = (0, network_roadmap_1.montarPanoramaDaRede)({ fixado: raiz });
+        return resposta({ texto: (0, network_roadmap_1.textoDoPanoramaDaRede)(panorama), panorama });
+    });
     registrarTool('ork_observe', { description: 'Observa uma vez o progresso canonico e pedidos da thread. Nao cria monitor ou despacho.',
         inputSchema: daThread, annotations: { readOnlyHint: true } }, async ({ threadId }) => {
         return resposta(observar(threadId));
@@ -439,14 +513,19 @@ function criarServidorMcp(opcoes) {
         while (!fs.existsSync(existente))
             existente = path.dirname(existente);
         confinado(existente);
-        return resposta((0, thread_1.novaThread)(c, { nome, modo: modo ?? c.manifesto.conduction.default_mode, criarWorktree: true }));
+        const criada = (0, thread_1.novaThread)(c, { nome, modo: modo ?? c.manifesto.conduction.default_mode, criarWorktree: true });
+        // RM-052 (D7): thread nova, projeto conhecido pelo nome nesta maquina; o registro nunca derruba a criacao.
+        if (criada.gravada)
+            (0, projeto_alvo_1.registrarProjetoEmSilencio)(raiz, 'mcp thread new');
+        return resposta(criada);
     });
     registrarTool('ork_phase_run', { description: 'Despacha fase autorizada pelo nucleo, preservando policies, estado e runtime/modelo. dryRun nao inicia modelo, mas pode registrar prompt/eventos.',
         inputSchema: fase, annotations: { readOnlyHint: false, destructiveHint: false } }, async (args) => {
         const t = thread(args.threadId);
         livre(t.id);
         const { threadId, fase: f, ...op } = args;
-        return resposta((0, phase_1.rodarFase)(carregar(), threadId, { ...op, fase: (0, thread_1.exigirFase)(t, f), canal: conducao.canal }));
+        // RM-037 (A3): o MCP nao roda a suite para a baseline do despacho; a falta dela volta como pendencia.
+        return resposta((0, phase_1.rodarFase)(carregar(), threadId, { ...op, fase: (0, thread_1.exigirFase)(t, f), canal: conducao.canal, baselinePeloDespacho: false }));
     });
     registrarTool('ork_gate_request', { description: 'Abre pedido de gate somente quando pausa ou escalacao tipada esta comprovada no nucleo; nao aprova.',
         inputSchema: daThread.extend({ motivo: zod_1.z.enum(['human.pending', 'policy.violation', 'cost.violation',

package/dist/memoria.js

@@ -35,6 +35,8 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.sincronizarOnboarding = sincronizarOnboarding;
 exports.abrirMemoria = abrirMemoria;
+exports.estadoDeEmbeddings = estadoDeEmbeddings;
+exports.sondarEmbeddings = sondarEmbeddings;
 exports.tagsDoProjeto = tagsDoProjeto;
 exports.situacaoDaThread = situacaoDaThread;
 exports.situacaoDaFase = situacaoDaFase;
@@ -64,6 +66,7 @@ exports.sincronizarMemoria = sincronizarMemoria;
 exports.publicar = publicar;
 exports.publicarPropostas = publicarPropostas;
 exports.textoDoEstado = textoDoEstado;
+exports.textoDosEmbeddings = textoDosEmbeddings;
 exports.textoDoSync = textoDoSync;
 exports.parsePrioridade = parsePrioridade;
 const write_activation_1 = require("./write-activation");
@@ -97,6 +100,7 @@ const memoria_humana_1 = require("./memoria-humana");
 const master_1 = require("./master");
 const modos_1 = require("./modos");
 const orkmind_1 = require("./orkmind");
+const indice_vetorial_1 = require("./indice-vetorial");
 const ledger_1 = require("./ledger");
 const thread_1 = require("./thread");
 const util_1 = require("./util");
@@ -167,6 +171,10 @@ function abrirMemoria(carregado, opcoes = {}) {
     const leituraRestrita = resolverLeituraRestrita(carregado.manifesto, opcoes.leituraRestrita);
     const { estado, driver } = (0, orkmind_1.resolverRegime)(carregado.manifesto, opcoes.driver ?? null);
     const ativo = estado.efetivo === 'orkmind' && driver !== null;
+    const config = (0, orkmind_1.configDoManifesto)(carregado.manifesto);
+    const embeddings = (universo) => estadoDeEmbeddings(carregado.manifesto, ativo ? driver?.disponivel().saude ?? null : null, carregado.raiz, estado.tenant, config.dsn, { universo });
+    if (estado.pedido === 'orkmind')
+        estado.embeddings = embeddings();
     const consultarRestrito = (collection, tags) => {
         if (!leituraRestrita)
             throw Error('memory.query.invalid');
@@ -178,7 +186,7 @@ function abrirMemoria(carregado, opcoes = {}) {
             throw Error('memory.query.unsupported');
         return (0, orkmind_1.concluirConsultaDelimitada)(driver.consultar(q), q);
     };
-    return {
+    const memoria = {
         configSource: context.source,
         configDivergent: context.divergent,
         get leituraRestrita() { return leituraRestrita; },
@@ -243,6 +251,114 @@ function abrirMemoria(carregado, opcoes = {}) {
             return driver.exportar(colecao).find((e) => e.id === id) ?? null;
         },
     };
+    // A cobertura precisa do universo do tenant (um export por colecao): so quando pedida.
+    if (opcoes.embeddings === 'detalhado' && ativo && !leituraRestrita) {
+        estado.embeddings = embeddings((0, indice_vetorial_1.universoDoTenant)(memoria, estado.tenant));
+    }
+    return memoria;
+}
+// ---------------------------------------------------------------------------
+// I-38 (T4, D6): estado sondado dos embeddings. Nunca derruba o regime.
+// ---------------------------------------------------------------------------
+/** Os indices locais do tenant nesta base, por modelo e dimensao. */
+function indicesDoTenant(raiz, tenant, base, universo) {
+    const dir = (0, indice_vetorial_1.dirDosIndices)(raiz, tenant);
+    if (!fs.existsSync(dir))
+        return [];
+    const indices = [];
+    for (const nome of fs.readdirSync(dir).filter(n => n.endsWith('.json')).sort()) {
+        try {
+            const bruto = JSON.parse(fs.readFileSync(path.join(dir, nome), 'utf8'));
+            if (bruto.contrato !== indice_vetorial_1.CONTRATO_INDICE || bruto.tenant !== tenant || bruto.base !== base)
+                continue;
+            const { indice } = (0, indice_vetorial_1.lerIndice)(path.join(dir, nome), { tenant, base, modelo: bruto.modelo, dim: bruto.dim });
+            const vetores = Object.keys(indice.entradas).length;
+            const coerentes = (0, indice_vetorial_1.vetoresCoerentes)(indice, universo).size;
+            indices.push({ modelo: indice.modelo, dim: indice.dim, vetores, coerentes, desatualizados: vetores - coerentes });
+        }
+        catch { /* arquivo ilegivel nao e indice: `ork memory index` o reconstroi */ }
+    }
+    return indices;
+}
+/**
+ * Estado de embeddings: configuracao, presenca da chave (nome, nunca valor), a sonda `health`
+ * da ponte e os arquivos de indice. `saude` null quer dizer que a ponte nao foi sondada.
+ */
+function estadoDeEmbeddings(manifesto, saude, raiz, tenant, dsn, opcoes = {}) {
+    const config = (0, manifest_1.configDeEmbedding)(manifesto);
+    const env = opcoes.env ?? process.env;
+    const configurado = config.provider !== 'none';
+    const variavel = config.api_key_env;
+    const bruto = variavel ? (env[variavel] ?? '').trim() : '';
+    const chavePresente = !!variavel && (0, orkmind_1.chaveDeEmbeddingAceita)(bruto, dsn);
+    const recusada = bruto !== '' && !chavePresente;
+    const dimLocal = configurado && config.fallback_model ? (0, indice_vetorial_1.dimDoModeloLocal)(config.fallback_model, env) : null;
+    const dependencias = saude?.fallback.dependencias ?? false;
+    const fallback = { modelo: config.fallback_model || null, presente: dimLocal !== null, dependencias, dim: dimLocal };
+    const base = (0, indice_vetorial_1.impressaoDaBase)(dsn);
+    const existe = (modelo, dim) => dim !== null && fs.existsSync((0, indice_vetorial_1.arquivoDoIndice)(raiz, tenant, modelo, dim));
+    const estado = {
+        configurado, provider: config.provider, modelo: configurado ? config.model : null, dim: configurado ? config.dim : null,
+        variavelDaChave: variavel, chavePresente, fallback, indices: [], entradas: null, cobertura: null,
+        ativo: 'nenhum', sondado: saude !== null, motivo: null, detalhe: '', correcao: '',
+    };
+    if (!configurado) {
+        return { ...estado, motivo: 'embeddings.nao-configurado',
+            detalhe: 'memory.embedding ausente ou provider none: busca por significado desligada; o recall por tag segue identico',
+            correcao: 'declare memory.embedding no manifesto (provider openrouter e api_key_env com o NOME da variavel da chave)' };
+    }
+    const fallbackUsavel = saude !== null && fallback.presente && dependencias;
+    if (chavePresente) {
+        estado.ativo = 'primario';
+        if (!existe(config.model, config.dim)) {
+            estado.motivo = 'embeddings.indice-ausente';
+            estado.detalhe = `chave presente em ${variavel}; o indice local de ${config.model} ainda nao existe`;
+            estado.correcao = 'rode ork memory index (use --dry-run antes para ver tokens e custo)';
+        }
+        else
+            estado.detalhe = `primario ${config.model} (${config.dim} dim) pela chave em ${variavel}`;
+    }
+    else {
+        estado.ativo = fallbackUsavel ? 'fallback' : 'nenhum';
+        estado.motivo = 'embeddings.chave-ausente';
+        const local = !fallback.modelo ? 'sem fallback local declarado: a busca por significado cai para FTS'
+            : !fallback.presente ? `fallback ${fallback.modelo} ausente do cache local: a busca cai para FTS`
+                : !saude ? 'ponte nao sondada: fallback local nao conferido'
+                    : !dependencias ? `fallback ${fallback.modelo} sem torch/transformers no interpretador da ponte: a busca cai para FTS`
+                        : `busca usa o fallback local ${fallback.modelo} (${fallback.dim} dim)` +
+                            (existe(fallback.modelo, fallback.dim) ? '' : '; indice local ausente: rode ork memory index --modelo fallback');
+        estado.detalhe = `${variavel} ${recusada ? 'tem valor recusado (parece URL, DSN ou texto com espaco; nunca impresso)' : 'nao esta no ambiente (valor nunca impresso)'}; ${local}`;
+        estado.correcao = `exporte ${variavel} com a chave dedicada ao Orkastery; o valor nunca vai ao manifesto`;
+    }
+    if (opcoes.universo) {
+        const universo = opcoes.universo.filter(e => (e.tags.project ?? []).includes(tenant));
+        estado.indices = indicesDoTenant(raiz, tenant, base, universo);
+        estado.entradas = universo.length;
+        const referencia = estado.ativo === 'fallback' ? { modelo: fallback.modelo, dim: fallback.dim } : { modelo: config.model, dim: config.dim };
+        const indice = estado.indices.find(i => i.modelo === referencia.modelo && i.dim === referencia.dim);
+        estado.cobertura = universo.length === 0 ? 0 : Math.round(((indice?.coerentes ?? 0) / universo.length) * 10_000) / 10_000;
+    }
+    return estado;
+}
+/**
+ * `ork memory status --sondar`: UMA chamada real com texto fixo curto pelo caminho ativo, com
+ * a latencia medida (primario custa cerca de US$ 0,00000005; fallback local, so CPU).
+ */
+function sondarEmbeddings(manifesto, estado, embeddar, timeoutMs) {
+    if (estado.ativo === 'nenhum')
+        return { ok: false, alvo: null, latenciaMs: null, motivo: estado.motivo };
+    const config = (0, manifest_1.configDeEmbedding)(manifesto);
+    const primario = estado.ativo === 'primario';
+    const modelo = primario ? config.model : estado.fallback.modelo;
+    const dim = primario ? config.dim : estado.fallback.dim;
+    const inicio = Date.now();
+    try {
+        embeddar({ papel: 'consulta', alvo: estado.ativo, modelo, dim, textos: ['sonda de saude do ork'] }, { timeoutMs });
+        return { ok: true, alvo: estado.ativo, latenciaMs: Date.now() - inicio, motivo: null };
+    }
+    catch (erro) {
+        return { ok: false, alvo: estado.ativo, latenciaMs: Date.now() - inicio, motivo: (0, indice_vetorial_1.codigoDeEmbedding)(erro) };
+    }
 }
 // ---------------------------------------------------------------------------
 // Tags: as 5 dimensoes, montadas em um lugar so.
@@ -968,8 +1084,38 @@ function textoDoEstado(estado) {
         linhas.push(`  colecoes gravadas: ${orkmind_1.COLECOES_DO_ORK.join(', ')}`);
         linhas.push('  governanca: source=agent; decision/human exige human_gate comprovado; mandatory=false e regra nunca critical.');
     }
+    if (estado.embeddings)
+        linhas.push('', ...textoDosEmbeddings(estado.embeddings));
     return linhas.join('\n');
 }
+/** Secao de embeddings do `ork memory status` (I-38 D6): nome da variavel, nunca o valor. */
+function textoDosEmbeddings(e) {
+    const linhas = ['Busca por significado (embeddings, nao deterministica; o recall por tag nao muda)', ''];
+    linhas.push(`  provider              ${e.configurado ? `${e.provider} ${e.modelo} (${e.dim} dim)` : 'none (desligada)'}`);
+    if (e.configurado) {
+        linhas.push(`  chave                 ${e.variavelDaChave} ${e.chavePresente ? 'presente' : 'ausente'} no ambiente (valor nunca impresso)`);
+        linhas.push(`  fallback local        ${e.fallback.modelo ? `${e.fallback.modelo}: ${e.fallback.presente ? `no cache (${e.fallback.dim} dim)` : 'ausente do cache'}, ` +
+            `dependencias ${e.fallback.dependencias ? 'ok' : e.sondado ? 'ausentes' : 'nao sondadas'}` : '(nao declarado)'}`);
+        linhas.push(`  caminho ativo         ${e.ativo}${e.sondado ? '' : ' (ponte nao sondada)'}`);
+    }
+    for (const i of e.indices) {
+        linhas.push(`  indice                ${i.modelo} / ${i.dim} dim: ${i.vetores} vetor(es), ${i.coerentes ?? '?'} coerente(s), ${i.desatualizados ?? '?'} desatualizado(s)`);
+    }
+    if (e.entradas !== null) {
+        linhas.push(`  cobertura             ${e.cobertura === null ? '-' : `${Math.round(e.cobertura * 1000) / 10}%`} de ${e.entradas} entrada(s) do tenant`);
+    }
+    if (e.sonda) {
+        linhas.push(`  sonda                 ${e.sonda.ok ? `${e.sonda.alvo} respondeu em ${e.sonda.latenciaMs} ms` : `sem resposta (${e.sonda.motivo ?? 'sem caminho ativo'})`}`);
+    }
+    if (e.motivo) {
+        linhas.push(`  motivo                ${e.motivo}`);
+        linhas.push(`    ${e.detalhe}`);
+        linhas.push(`    correcao: ${e.correcao}`);
+    }
+    else
+        linhas.push(`  ${e.detalhe}`);
+    return linhas;
+}
 /** Texto de `ork memory sync`. */
 function textoDoSync(r) {
     const linhas = [];