@semacode/cli 2.2.0 → 2.3.1

package/dist/discovery/command.js

@@ -0,0 +1,226 @@
+// SEMA-GOVERNED: sema.produto.descoberta_capacidades
+// Descrição: handler da CLI de descoberta; consulta, renderiza e nunca executa templates.
+import { montarCatalogoCapacidades, normalizarDiscoveryKind, obterEntradaDescoberta, } from "./catalog.js";
+import { recomendarCapacidadePorIntencao } from "./ranker.js";
+import { renderizarResultadoDescoberta } from "./render.js";
+import { DISCOVERY_SCHEMA_VERSION, } from "./types.js";
+const EXECUTION_BOUNDARY = {
+    executed: false,
+    workspaceMutated: false,
+    externalCalls: false,
+    requiresExplicitRun: true,
+};
+const OPCOES_COM_VALOR = new Set([
+    "--tipo",
+    "--id",
+    "--dominio",
+    "--intencao",
+    "--limite",
+]);
+function argumentosValidos(args, politica) {
+    const vistos = new Set();
+    let posicionais = 0;
+    for (let indice = 0; indice < args.length; indice += 1) {
+        const atual = args[indice];
+        if (!atual.startsWith("--")) {
+            posicionais += 1;
+            if (posicionais > politica.maxPosicionais)
+                return false;
+            continue;
+        }
+        if (vistos.has(atual))
+            return false;
+        vistos.add(atual);
+        if (politica.flags.has(atual))
+            continue;
+        if (!politica.opcoesComValor.has(atual))
+            return false;
+        const valor = args[indice + 1];
+        if (!valor || valor.startsWith("--"))
+            return false;
+        indice += 1;
+    }
+    return true;
+}
+function politicaParaOperacao(operacao) {
+    const flags = new Set(["--json"]);
+    if (operacao === "catalogo") {
+        return { opcoesComValor: new Set(["--tipo", "--id", "--dominio"]), flags, maxPosicionais: 0 };
+    }
+    if (operacao === "recomendar") {
+        return { opcoesComValor: new Set(["--intencao", "--limite"]), flags, maxPosicionais: 0 };
+    }
+    if (operacao === "explicar" || operacao === "pipeline descrever") {
+        return { opcoesComValor: new Set(["--id"]), flags, maxPosicionais: 1 };
+    }
+    if (operacao === "pipeline listar") {
+        return { opcoesComValor: new Set(), flags, maxPosicionais: 0 };
+    }
+    return null;
+}
+function normalizarSubcomando(valor) {
+    return (valor ?? "")
+        .normalize("NFD")
+        .replace(/[\u0300-\u036f]/gu, "")
+        .toLowerCase()
+        .replace(/[_-]+/gu, " ")
+        .trim()
+        .replace(/\s+/gu, " ");
+}
+function obterOpcao(args, nome) {
+    const indice = args.indexOf(nome);
+    if (indice < 0)
+        return null;
+    const valor = args[indice + 1];
+    return valor && !valor.startsWith("--") ? valor : null;
+}
+function obterPosicionais(args) {
+    const posicionais = [];
+    for (let indice = 0; indice < args.length; indice += 1) {
+        const atual = args[indice];
+        if (OPCOES_COM_VALOR.has(atual)) {
+            indice += 1;
+            continue;
+        }
+        if (atual.startsWith("--"))
+            continue;
+        posicionais.push(atual);
+    }
+    return posicionais;
+}
+function erro(code, message, emJson) {
+    const payload = {
+        schemaVersion: DISCOVERY_SCHEMA_VERSION,
+        command: "descobrir",
+        success: false,
+        mode: "error",
+        ...EXECUTION_BOUNDARY,
+        error: { code, message },
+    };
+    return {
+        exitCode: 2,
+        payload,
+        text: renderizarResultadoDescoberta(payload),
+        outputFormat: emJson ? "json" : "text",
+        executed: false,
+    };
+}
+function sucesso(payload, emJson) {
+    return {
+        exitCode: 0,
+        payload,
+        text: renderizarResultadoDescoberta(payload),
+        outputFormat: emJson ? "json" : "text",
+        executed: false,
+    };
+}
+function explicar(id, somentePipeline, emJson) {
+    if (!id)
+        return erro("DISCOVERY_ID_OBRIGATORIO", "Informe um id de capacidade explícito.", emJson);
+    const entry = obterEntradaDescoberta(id);
+    if (!entry || (somentePipeline && entry.kind !== "ORCHESTRATION_PIPELINE")) {
+        return erro(somentePipeline ? "DISCOVERY_PIPELINE_NAO_ENCONTRADO" : "DISCOVERY_ID_NAO_ENCONTRADO", somentePipeline ? "Pipeline não encontrado no catálogo público." : "Capacidade não encontrada no catálogo público.", emJson);
+    }
+    const payload = {
+        schemaVersion: DISCOVERY_SCHEMA_VERSION,
+        command: somentePipeline ? "descobrir pipeline descrever" : "descobrir explicar",
+        success: true,
+        mode: "explain",
+        ...EXECUTION_BOUNDARY,
+        entry,
+    };
+    return sucesso(payload, emJson);
+}
+export function comandoDescobertaCapacidades(subcomando, argumentos = []) {
+    const emJson = argumentos.includes("--json");
+    let operacao = normalizarSubcomando(subcomando);
+    let args = [...argumentos];
+    if (operacao === "pipeline") {
+        const posicionais = obterPosicionais(args);
+        const alias = normalizarSubcomando(posicionais[0]);
+        if (alias !== "listar" && alias !== "descrever") {
+            return erro("DISCOVERY_PIPELINE_SUBCOMANDO_INVALIDO", "Use `pipeline listar` ou `pipeline descrever <id>`.", emJson);
+        }
+        operacao = `pipeline ${alias}`;
+        const indiceAlias = args.indexOf(posicionais[0]);
+        if (indiceAlias >= 0)
+            args.splice(indiceAlias, 1);
+    }
+    if (operacao === "capabilities")
+        operacao = "catalogo";
+    const politica = politicaParaOperacao(operacao);
+    if (politica && !argumentosValidos(args, politica)) {
+        return erro("DISCOVERY_ARGUMENTOS_INVALIDOS", "Use apenas opções conhecidas, uma vez cada e com os valores obrigatórios.", emJson);
+    }
+    try {
+        if (operacao === "catalogo" || operacao === "pipeline listar") {
+            const tipoCru = operacao === "pipeline listar" ? "ORCHESTRATION_PIPELINE" : obterOpcao(args, "--tipo");
+            const kind = tipoCru ? normalizarDiscoveryKind(tipoCru) : null;
+            if (tipoCru && !kind) {
+                return erro("DISCOVERY_KIND_INVALIDO", "Tipo de capacidade inválido.", emJson);
+            }
+            const payloadBase = montarCatalogoCapacidades({
+                kind,
+                id: obterOpcao(args, "--id"),
+                domain: obterOpcao(args, "--dominio"),
+            });
+            const payload = operacao === "pipeline listar"
+                ? { ...payloadBase, command: "descobrir pipeline listar" }
+                : payloadBase;
+            return sucesso(payload, emJson);
+        }
+        if (operacao === "recomendar") {
+            const intencao = obterOpcao(args, "--intencao");
+            if (!intencao) {
+                return erro("DISCOVERY_INTENCAO_OBRIGATORIA", "Use `--intencao <texto>` para recomendar uma capacidade.", emJson);
+            }
+            const limiteCru = obterOpcao(args, "--limite");
+            const limite = limiteCru === null ? 5 : Number(limiteCru);
+            if (!Number.isInteger(limite) || limite < 1 || limite > 10) {
+                return erro("DISCOVERY_LIMITE_INVALIDO", "O limite deve ser um inteiro entre 1 e 10.", emJson);
+            }
+            return sucesso(recomendarCapacidadePorIntencao(intencao, limite), emJson);
+        }
+        if (operacao === "explicar" || operacao === "pipeline descrever") {
+            const id = obterOpcao(args, "--id") ?? obterPosicionais(args)[0] ?? null;
+            return explicar(id, operacao === "pipeline descrever", emJson);
+        }
+        if (!operacao) {
+            return erro("DISCOVERY_SUBCOMANDO_OBRIGATORIO", "Use `catalogo`, `recomendar`, `explicar`, `pipeline listar` ou `pipeline descrever`.", emJson);
+        }
+        return erro("DISCOVERY_SUBCOMANDO_INVALIDO", "Subcomando de descoberta inválido.", emJson);
+    }
+    catch {
+        return erro("DISCOVERY_ARGUMENTOS_INVALIDOS", "Não foi possível aplicar os argumentos de descoberta.", emJson);
+    }
+}
+function imprimirResultado(resultado, emJson) {
+    const saida = emJson ? JSON.stringify(resultado.payload, null, 2) : resultado.text;
+    if (resultado.exitCode === 0 || emJson)
+        console.log(saida);
+    else
+        console.error(saida);
+}
+export const comandoDescobrirHandler = async (posicionais, args, emJson) => {
+    const subcomando = posicionais[0];
+    const argsSemSubcomando = args[0] === subcomando ? args.slice(1) : args;
+    const resultado = comandoDescobertaCapacidades(subcomando, argsSemSubcomando);
+    imprimirResultado(resultado, emJson);
+    return resultado.exitCode;
+};
+export const comandoPipelineDescobertaHandler = async (_posicionais, args, emJson) => {
+    const resultado = comandoDescobertaCapacidades("pipeline", args);
+    imprimirResultado(resultado, emJson);
+    return resultado.exitCode;
+};
+export const comandoCapabilitiesDescobertaHandler = async (_posicionais, args, emJson) => {
+    const resultado = comandoDescobertaCapacidades("catalogo", args);
+    imprimirResultado(resultado, emJson);
+    return resultado.exitCode;
+};
+export const REGISTRO_HANDLERS_DESCOBERTA = {
+    descobrir: comandoDescobrirHandler,
+    pipeline: comandoPipelineDescobertaHandler,
+    capabilities: comandoCapabilitiesDescobertaHandler,
+};
+//# sourceMappingURL=command.js.map

package/dist/discovery/index.d.ts

@@ -0,0 +1,5 @@
+export { criarResumoDescobertaAgentContext, montarCatalogoCapacidades, normalizarDiscoveryKind, obterEntradaDescoberta, } from "./catalog.js";
+export { comandoCapabilitiesDescobertaHandler, comandoDescobertaCapacidades, comandoDescobrirHandler, comandoPipelineDescobertaHandler, REGISTRO_HANDLERS_DESCOBERTA, type DiscoveryCliHandler, } from "./command.js";
+export { normalizarIntencaoDescoberta, recomendarCapacidadePorIntencao, } from "./ranker.js";
+export { renderizarResultadoDescoberta } from "./render.js";
+export * from "./types.js";

package/dist/discovery/index.js

@@ -0,0 +1,8 @@
+// SEMA-GOVERNED: sema.produto.descoberta_capacidades
+// Descrição: superfície única dos módulos puros e handlers de descoberta.
+export { criarResumoDescobertaAgentContext, montarCatalogoCapacidades, normalizarDiscoveryKind, obterEntradaDescoberta, } from "./catalog.js";
+export { comandoCapabilitiesDescobertaHandler, comandoDescobertaCapacidades, comandoDescobrirHandler, comandoPipelineDescobertaHandler, REGISTRO_HANDLERS_DESCOBERTA, } from "./command.js";
+export { normalizarIntencaoDescoberta, recomendarCapacidadePorIntencao, } from "./ranker.js";
+export { renderizarResultadoDescoberta } from "./render.js";
+export * from "./types.js";
+//# sourceMappingURL=index.js.map

package/dist/discovery/ranker.d.ts

@@ -0,0 +1,3 @@
+import { type DiscoveryRecommendationPayload } from "./types.js";
+export declare function normalizarIntencaoDescoberta(valor: string): string;
+export declare function recomendarCapacidadePorIntencao(intencao: string, limite?: number): DiscoveryRecommendationPayload;

package/dist/discovery/ranker.js

@@ -0,0 +1,310 @@
+// SEMA-GOVERNED: sema.produto.descoberta_capacidades
+// Descrição: ranking determinístico, explicável e sem execução por intenção.
+import { montarCatalogoCapacidades } from "./catalog.js";
+import { DISCOVERY_SCHEMA_VERSION, } from "./types.js";
+import { redigirTextoControladoDescoberta } from "./redaction.js";
+const EXECUTION_BOUNDARY = {
+    executed: false,
+    workspaceMutated: false,
+    externalCalls: false,
+    requiresExplicitRun: true,
+};
+const TOKEN_EQUIVALENCES = [
+    ["game", "games", "jogo", "jogos"],
+    ["simulation", "simulator", "simulacao", "simulacoes", "simulador", "simuladores"],
+    ["calibrate", "calibrated", "calibration", "calibracao", "calibrar", "calibrado", "calibrada"],
+    ["autonomous", "autonomo", "autonoma", "autonomia"],
+    ["realistic", "realista", "realismo"],
+    ["balance", "balancing", "balanceamento", "balancear"],
+    ["playtest", "jogabilidade", "jogavel"],
+    ["workflow", "automacao", "orquestracao"],
+    ["content", "conteudo", "editorial"],
+    ["publish", "publishing", "publicar", "publicacao"],
+    ["author", "autoria", "autoral"],
+    ["chapter", "chapters", "capitulo", "capitulos"],
+    ["research", "pesquisa", "pesquisar"],
+    ["proposal", "proposals", "proposta", "propostas"],
+    ["conversation", "conversations", "conversa", "conversas"],
+    ["operation", "operations", "operacao", "operacoes", "ops"],
+    ["portability", "portable", "portar", "portabilidade", "converter"],
+    ["migration", "migrate", "migrar", "migracao", "upgrade"],
+    ["provenance", "proveniencia", "linhagem", "license", "licenca"],
+    ["evidence", "evidencia", "prova", "evidencias"],
+    ["timeline", "timebase", "temporal", "4d"],
+    ["camera", "shot", "cameras", "enquadramento"],
+    ["physics", "fisica", "colisao", "collision"],
+    ["worker", "workers", "distribuido", "distribuidos"],
+    ["checkpoint", "retomar", "retomada", "recovery"],
+];
+const TOKEN_CANONICO = new Map();
+for (const grupo of TOKEN_EQUIVALENCES) {
+    const canonico = grupo[0];
+    for (const token of grupo)
+        TOKEN_CANONICO.set(token, canonico);
+}
+function normalizarBase(valor) {
+    return valor
+        .normalize("NFD")
+        .replace(/[\u0300-\u036f]/gu, "")
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/gu, " ")
+        .trim()
+        .replace(/\s+/gu, " ");
+}
+function tokenCanonico(token) {
+    return TOKEN_CANONICO.get(token) ?? token;
+}
+export function normalizarIntencaoDescoberta(valor) {
+    return normalizarBase(valor)
+        .split(" ")
+        .filter(Boolean)
+        .map(tokenCanonico)
+        .join(" ");
+}
+function tokens(valor) {
+    const normalizado = normalizarIntencaoDescoberta(valor);
+    return normalizado ? normalizado.split(" ") : [];
+}
+function contemSinal(tokensIntencao, sinal) {
+    const tokensSinal = tokens(sinal);
+    return tokensSinal.length > 0 && tokensSinal.every((token) => tokensIntencao.has(token));
+}
+function possuiAlgum(tokensIntencao, termos) {
+    return termos.some((termo) => tokens(termo).some((token) => tokensIntencao.has(token)));
+}
+function adicionarUnico(lista, valor) {
+    if (!lista.includes(valor))
+        lista.push(valor);
+}
+function comandoLiteral(template) {
+    return normalizarIntencaoDescoberta(template.replace(/<[^>]+>/gu, " "));
+}
+function matchExato(entry, intencaoNormalizada) {
+    const ids = [entry.id, ...(entry.aliases ?? [])].map(normalizarIntencaoDescoberta);
+    if (ids.includes(intencaoNormalizada))
+        return true;
+    if (!intencaoNormalizada.startsWith("sema "))
+        return false;
+    return entry.commandTemplates.some((item) => {
+        const literal = comandoLiteral(item.command);
+        return literal.length > 0 && intencaoNormalizada.startsWith(literal);
+    });
+}
+function pontuar(entry, intencao) {
+    const intencaoNormalizada = normalizarIntencaoDescoberta(intencao);
+    const tokensIntencao = new Set(tokens(intencao));
+    if (matchExato(entry, intencaoNormalizada)) {
+        return {
+            entry,
+            score: 100,
+            matchedSignals: [entry.id],
+            reasons: ["identificador, alias ou namespace de comando corresponde exatamente"],
+            exact: true,
+        };
+    }
+    let score = 0;
+    const matchedSignals = [];
+    const reasons = [];
+    let pontosSinais = 0;
+    const sinaisCanonicos = new Set();
+    for (const sinal of entry.intentSignals) {
+        if (!contemSinal(tokensIntencao, sinal))
+            continue;
+        const sinalCanonico = normalizarIntencaoDescoberta(sinal);
+        if (sinaisCanonicos.has(sinalCanonico))
+            continue;
+        sinaisCanonicos.add(sinalCanonico);
+        const quantidade = tokens(sinal).length;
+        pontosSinais = Math.min(40, pontosSinais + (quantidade > 1 ? 30 : 10));
+        adicionarUnico(matchedSignals, sinal);
+    }
+    if (pontosSinais > 0) {
+        score += pontosSinais;
+        reasons.push(`sinais positivos do catálogo: +${pontosSinais}`);
+    }
+    const alias = (entry.aliases ?? []).find((item) => contemSinal(tokensIntencao, item));
+    if (alias) {
+        score += 20;
+        adicionarUnico(matchedSignals, alias);
+        reasons.push("alias explícito da capacidade: +20");
+    }
+    const domain = entry.domains.find((item) => contemSinal(tokensIntencao, item));
+    if (domain) {
+        score += 20;
+        adicionarUnico(matchedSignals, domain);
+        reasons.push("domínio da capacidade corresponde à intenção: +20");
+    }
+    const modoValidacao = possuiAlgum(tokensIntencao, ["validar", "auditar", "contrato", "artefato", "aderencia"]);
+    const modoPipeline = possuiAlgum(tokensIntencao, [
+        "pipeline", "estagios", "dag", "multicanal", "multi-formato", "adapters", "ledger", "publicar",
+    ]);
+    if (modoValidacao && entry.kind === "PROFILE_GATE") {
+        score += 20;
+        reasons.push("intenção pede gate de validação: +20");
+    }
+    if (modoPipeline && entry.kind === "ORCHESTRATION_PIPELINE") {
+        score += 30;
+        reasons.push("intenção pede orquestração multietapas: +30");
+    }
+    if (modoValidacao && !modoPipeline && entry.kind === "ORCHESTRATION_PIPELINE" && !entry.id.startsWith("interactive.")) {
+        score -= 20;
+        reasons.push("pedido de validação sem estágios explícitos: -20");
+    }
+    const aplicarModoEspecifico = (id, termos, motivo) => {
+        const correspondencias = new Set(termos
+            .filter((termo) => contemSinal(tokensIntencao, termo))
+            .map(normalizarIntencaoDescoberta)).size;
+        if (entry.id === id && correspondencias > 0) {
+            const base = entry.id.startsWith("interactive.") ? 60 : 30;
+            const pontos = Math.min(80, base + ((correspondencias - 1) * 10));
+            score += pontos;
+            reasons.push(`${motivo}: +${pontos}`);
+        }
+    };
+    aplicarModoEspecifico("workflow.author", ["romance", "conto", "roteiro", "lore", "capitulos", "continuidade", "personagem"], "workflow narrativo especializado");
+    aplicarModoEspecifico("profile.workflow", ["webhook", "cron", "n8n", "fila", "automacao"], "domínio de automação e workflow");
+    aplicarModoEspecifico("profile.ops", ["deploy", "rollback", "runbook", "healthcheck", "incidente", "oncall"], "domínio operacional");
+    aplicarModoEspecifico("profile.game", ["loop", "jogador", "balanceamento", "playtest", "telemetria", "jogo"], "gate de game design");
+    aplicarModoEspecifico("profile.legal", ["lei", "juridico", "lgpd", "compliance", "dpa", "privacidade"], "gate legal");
+    aplicarModoEspecifico("profile.research", ["fontes", "evidencia", "metodo", "incerteza", "pesquisa"], "gate de pesquisa");
+    aplicarModoEspecifico("profile.redacao", ["seo", "materia", "blog", "editorial", "redacao"], "gate editorial");
+    aplicarModoEspecifico("profile.propostas", ["proposta", "orcamento", "cliente", "freela", "marketplace"], "gate comercial");
+    aplicarModoEspecifico("profile.conversas", ["atendimento", "chatbot", "objecao", "retencao", "conversa"], "gate conversacional");
+    aplicarModoEspecifico("profile.software", ["api", "codigo", "refactor", "security", "persistencia"], "gate de software");
+    aplicarModoEspecifico("interactive.experience_ir", ["experience ir", "grafo", "scene", "cena", "content addressed", "ids semanticos"], "grafo portavel de experiencia");
+    aplicarModoEspecifico("interactive.observe", ["detect", "probe", "snapshot", "diff", "inspecionar engine"], "observacao read-only de engine");
+    aplicarModoEspecifico("interactive.asset_provenance", ["proveniencia", "licenca", "linhagem", "asset"], "proveniencia de assets");
+    aplicarModoEspecifico("interactive.editor_state", ["editor state", "nao salvo", "shaders", "imports", "modal"], "estado recuperavel do editor");
+    aplicarModoEspecifico("interactive.evidence_capture", ["evidencia", "depth", "normals", "object id", "motion vectors", "telemetria"], "captura multimodal de evidencia");
+    aplicarModoEspecifico("interactive.job_recovery", ["lock", "heartbeat", "checkpoint", "retomar", "recovery"], "job com checkpoint e retomada");
+    aplicarModoEspecifico("interactive.acceptance_lock", ["aprovou", "aceite", "nao mexa", "regressao"], "aceite humano ligado a hash e intervalo");
+    aplicarModoEspecifico("interactive.temporal_validate", ["timeline", "4d", "timebase", "sincronizar", "legenda", "fala", "qa temporal", "validar timeline camera fisica qa"], "contrato temporal multimodal");
+    aplicarModoEspecifico("interactive.shot_validate", ["camera", "shot", "enquadramento", "sujeito visivel"], "contrato de camera e shot");
+    aplicarModoEspecifico("interactive.physics_validate", ["fisica", "colisao", "attachment", "separacao", "constraint"], "relacoes fisicas verificaveis");
+    aplicarModoEspecifico("interactive.temporal_qa", ["flicker", "ghosting", "popping", "exposicao", "jitter"], "QA temporal visual");
+    aplicarModoEspecifico("interactive.clean_install_smoke", ["instalacao limpa", "clean install", "pacote", "launch", "smoke"], "instalacao limpa e smoke do pacote");
+    aplicarModoEspecifico("interactive.hardware_budget", ["hardware", "fps", "frame time", "ram", "vram", "rtx"], "budget por hardware");
+    aplicarModoEspecifico("interactive.autonomous_repair", ["diagnosticar", "propor patch", "simular", "provar", "reparo autonomo"], "reparo autonomo seguro");
+    aplicarModoEspecifico("interactive.bot_playtest", ["bot", "bots", "playtest automatico", "seed"], "playtest por bots seeded");
+    aplicarModoEspecifico("interactive.state_fuzz", ["fuzz", "save", "load", "corrupcao", "state"], "fuzz bounded de estado");
+    aplicarModoEspecifico("interactive.multiplayer_authority", ["autoridade", "replicacao", "server authoritative", "reconnect", "anti replay"], "autoridade multiplayer");
+    aplicarModoEspecifico("interactive.engine_migration", ["migrar", "migracao", "upgrade", "versao da engine"], "migracao versionada de engine");
+    aplicarModoEspecifico("interactive.portability", ["portar", "portabilidade", "converter entre engines", "perdas", "unreal unity godot"], "portabilidade com perdas declaradas");
+    aplicarModoEspecifico("interactive.distributed_jobs", ["workers", "distribuido", "cook", "shaders", "render distribuido"], "workers distribuidos");
+    const pedidoCalibracaoDeSimulacao = contemSinal(tokensIntencao, "simulation calibrate");
+    if (pedidoCalibracaoDeSimulacao && entry.id === "simulation.calibrate") {
+        score += 25;
+        reasons.push("calibracao pertence ao pipeline especializado de simulacao: +25");
+    }
+    else if (pedidoCalibracaoDeSimulacao && entry.id === "interactive.calibrate") {
+        score -= 15;
+        reasons.push("calibracao transversal perde para simulacao explicitamente declarada: -15");
+    }
+    if (entry.id === "pipeline.content"
+        && possuiAlgum(tokensIntencao, ["trailer", "thumbnail", "post", "multicanal", "publicar", "conteudo"])) {
+        score += 20;
+        reasons.push("pipeline de conteúdo: +20");
+    }
+    const quantidadeFormatosConteudo = ["trailer", "thumbnail", "post", "video", "imagem", "texto"]
+        .filter((formato) => possuiAlgum(tokensIntencao, [formato]))
+        .length;
+    if (quantidadeFormatosConteudo >= 2 && entry.id === "pipeline.content") {
+        score += 30;
+        reasons.push("múltiplos formatos de conteúdo exigem pipeline: +30");
+    }
+    else if (quantidadeFormatosConteudo >= 2 && entry.kind === "PROFILE_GATE") {
+        score -= 30;
+        reasons.push("profile isolado não orquestra múltiplos formatos: -30");
+    }
+    if (entry.id === "profile.simulation"
+        && possuiAlgum(tokensIntencao, ["calibrar", "batch", "autonomo", "safety", "incerteza"])) {
+        score -= 25;
+        reasons.push("capacidade específica de simulação disponível: -25");
+    }
+    if ((entry.kind === "ORCHESTRATION_PIPELINE" || entry.kind === "CAPABILITY_TOKEN")
+        && entry.domains.includes("sistemas-interativos")
+        && possuiAlgum(tokensIntencao, ["simulador", "simulacao", "jogo", "interativo", "autonomo", "multiplayer", "replay"])) {
+        score += 25;
+        reasons.push("domínio de sistema interativo: +25");
+    }
+    const pedidoTemporalComposto = ["timeline", "camera", "physics", "qa"]
+        .every((token) => tokensIntencao.has(token));
+    if (pedidoTemporalComposto
+        && ["interactive.shot_validate", "interactive.physics_validate", "interactive.temporal_qa"].includes(entry.id)) {
+        score -= 25;
+        reasons.push("subvalidador isolado perde para o contrato temporal composto: -25");
+    }
+    if (entry.kind === "GENERATOR") {
+        const alvo = entry.id.slice("generator.".length);
+        if (possuiAlgum(tokensIntencao, ["gerar", "compilar", "codigo"]) && contemSinal(tokensIntencao, alvo)) {
+            score += 30;
+            reasons.push("geração e alvo foram declarados: +30");
+        }
+    }
+    let penalidade = 0;
+    for (const sinal of entry.negativeSignals) {
+        if (!contemSinal(tokensIntencao, sinal))
+            continue;
+        penalidade += 25;
+        adicionarUnico(matchedSignals, `-${sinal}`);
+    }
+    if (penalidade > 0) {
+        score -= penalidade;
+        reasons.push(`sinais negativos do catálogo: -${penalidade}`);
+    }
+    return {
+        entry,
+        score: Math.max(0, Math.min(100, score)),
+        matchedSignals,
+        reasons: reasons.length > 0 ? reasons : ["nenhum sinal suficiente encontrado"],
+        exact: false,
+    };
+}
+export function recomendarCapacidadePorIntencao(intencao, limite = 5) {
+    if (typeof intencao !== "string" || intencao.trim().length === 0) {
+        throw new TypeError("discovery_intencao_obrigatoria");
+    }
+    if (!Number.isInteger(limite) || limite < 1 || limite > 10) {
+        throw new RangeError("discovery_limite_invalido");
+    }
+    const pontuadas = montarCatalogoCapacidades().entries
+        .map((entry) => pontuar(entry, intencao))
+        .sort((a, b) => b.score - a.score || a.entry.id.localeCompare(b.entry.id));
+    const exatas = pontuadas.filter((item) => item.exact);
+    const ordenadas = exatas.length > 0 ? exatas : pontuadas.filter((item) => item.score > 0);
+    const top = ordenadas[0];
+    const segunda = ordenadas[1];
+    const noMatch = !top || top.score < 60;
+    const delta = top && segunda ? top.score - segunda.score : null;
+    const ambiguityDetected = !noMatch && delta !== null && delta <= 7;
+    const candidatas = ordenadas.slice(0, limite);
+    const recommendations = candidatas.map((item, indice) => ({
+        rank: indice + 1,
+        id: item.entry.id,
+        kind: item.entry.kind,
+        label: item.entry.label,
+        score: item.score,
+        matchedSignals: [...item.matchedSignals],
+        reasons: [...item.reasons],
+        missingInputs: [...item.entry.requiredInputs],
+        suggestedCommandTemplate: !noMatch && !ambiguityDetected && indice === 0
+            ? item.entry.commandTemplates[0]?.command ?? null
+            : null,
+    }));
+    return {
+        schemaVersion: DISCOVERY_SCHEMA_VERSION,
+        command: "descobrir recomendar",
+        success: true,
+        mode: "ranking",
+        ...EXECUTION_BOUNDARY,
+        intent: redigirTextoControladoDescoberta(intencao.trim()),
+        recommendations,
+        ambiguity: {
+            detected: ambiguityDetected,
+            delta,
+            candidates: ambiguityDetected ? ordenadas.slice(0, 2).map((item) => item.entry.id) : [],
+        },
+        noMatch,
+    };
+}
+//# sourceMappingURL=ranker.js.map

package/dist/discovery/redaction.d.ts

@@ -0,0 +1,2 @@
+export declare function contémTextoSensívelDescoberta(valor: string): boolean;
+export declare function redigirTextoControladoDescoberta(valor: string | null): string | null;

package/dist/discovery/redaction.js

@@ -0,0 +1,21 @@
+// SEMA-GOVERNED: sema.produto.descoberta_capacidades
+// Descrição: redação fail-closed de texto controlado antes de expor payloads públicos de descoberta.
+const MARCADOR_REDAÇÃO = "[REDACTED]";
+const PADRÕES_SENSÍVEIS = [
+    /\bBearer\s+\S+/iu,
+    /-----BEGIN\s+(?:RSA\s+|EC\s+|OPENSSH\s+)?PRIVATE\s+KEY-----/iu,
+    /\b(?:sk|ghp|gho|ghu|ghs|github_pat|xoxb|xoxp|xoxa|xoxr|AIza)[_-][A-Za-z0-9_-]{8,}\b/u,
+    /\b(?:api[_-]?key|access[_-]?token|refresh[_-]?token|client[_-]?secret|private[_-]?key|password|senha)\b\s*[:=]\s*\S+/iu,
+    /(?:^|\s)[A-Za-z]:[\\/][^\r\n]*/u,
+    /(?:^|\s)\\\\[^\\\s]+\\[^\s]+/u,
+    /(?:^|\s)\/(?:Users|home|root|var|etc|opt|srv|tmp)\/[^\s]*/u,
+];
+export function contémTextoSensívelDescoberta(valor) {
+    return PADRÕES_SENSÍVEIS.some((padrão) => padrão.test(valor));
+}
+export function redigirTextoControladoDescoberta(valor) {
+    if (valor === null)
+        return null;
+    return contémTextoSensívelDescoberta(valor) ? MARCADOR_REDAÇÃO : valor;
+}
+//# sourceMappingURL=redaction.js.map

package/dist/discovery/render.d.ts

@@ -0,0 +1,2 @@
+import type { DiscoveryPayload } from "./types.js";
+export declare function renderizarResultadoDescoberta(payload: DiscoveryPayload): string;