@semacode/cli 1.5.19 → 1.5.26

package/dist/index.js

@@ -479,6 +479,8 @@ function ajuda() {
             "sema profile validar workflow contratos/sema/workflow_ops.sema --maturidade production --preset webhook --artefato-arquivo workflow.md --json",
             "sema profile validar ops contratos/sema/workflow_ops.sema --maturidade critical --preset deploy --artefato-arquivo runbook.md --json",
             "sema profile validar game contratos/sema/game.sema --maturidade prototype --preset playtest --artefato-arquivo playtest.md --json",
+            "sema profile capabilities --json",
+            "sema rule-packs --profile legal --json",
             "",
             "[5] Adotar Sema em projeto que ainda nao usa",
             "sema importar <fonte> <diretorio> --saida <diretorio> --json",
@@ -507,6 +509,8 @@ function ajuda() {
             "formatacao: sema formatar <arquivo-ou-pasta> [--check] [--json]",
             "author: sema author <iniciar|validar|briefing|revisar-cliches|validar-narrativa|validar-proibicoes> [arquivo] [--tema-sensivel] [--preset conto|romance|roteiro|lore|campanha] [--saida <arquivo>] [--texto <texto>] [--json]",
             "profile: sema profile validar <software|workflow|ops|game|legal|research> <arquivo-ou-pasta> [--maturidade draft|prototype|production|critical] [--preset <preset>] [--artefato <texto>|--artefato-arquivo <arquivo>] [--json]",
+            "capabilities: sema profile capabilities [--json]",
+            "rule packs: sema rule-packs [--profile <author|software|workflow|ops|game|legal|research>] [--json]",
         ]),
         "",
         renderizarSecaoAscii("Ajuda IA-first", [
@@ -530,6 +534,8 @@ function ajuda() {
             "sema author validar-narrativa <arquivo.sema> [--texto <texto>|--texto-arquivo <arquivo>] [--json]",
             "sema author validar-proibicoes <arquivo.sema> [--texto <texto>|--texto-arquivo <arquivo>] [--json]",
             "sema profile validar <profile> <arquivo.sema> [--maturidade draft|prototype|production|critical] [--preset <preset>] [--artefato <texto>|--artefato-arquivo <arquivo>] [--json]",
+            "sema profile capabilities [--json]",
+            "sema rule-packs [--profile <profile>] [--json]",
         ]),
         "",
         renderizarSecaoAscii("Operacional", [
@@ -590,6 +596,7 @@ const OPCOES_COM_VALOR = new Set([
     "--endpoint",
     "--maturidade",
     "--preset",
+    "--profile",
     "--artefato",
     "--artifact",
     "--artefato-arquivo",
@@ -4208,6 +4215,335 @@ const PRESETS_PROFILE = {
     research: ["rapida", "tecnica", "decisoria", "critica"],
     game: ["casual", "arcade", "rpg", "economia", "playtest"],
 };
+const CAPABILITY_MATRIX_GOVERNANCA = {
+    author: {
+        profile: "author",
+        detectaLiteral: true,
+        detectaSemantico: "parcial",
+        detectaOrdemExecucao: false,
+        detectaDriftReal: "parcial",
+        validaArtefatoReal: true,
+        interpretaNegacao: true,
+        confianca: "media",
+        limites: [
+            "validacao semantica profunda segue heuristica e precisa de texto alvo",
+            "continuidade longa depende de texto anterior ou memoria canonica fornecida",
+        ],
+        rulePacksSugeridos: ["author-quality", "brand-voice", "campaign-continuity"],
+    },
+    software: {
+        profile: "software",
+        detectaLiteral: true,
+        detectaSemantico: "parcial",
+        detectaOrdemExecucao: "parcial",
+        detectaDriftReal: "parcial",
+        validaArtefatoReal: true,
+        interpretaNegacao: true,
+        confianca: "media",
+        limites: [
+            "artefato inline nao substitui SAST completo",
+            "drift real melhora quando contrato e codigo vivo estao vinculados",
+        ],
+        rulePacksSugeridos: ["owasp", "openapi", "saas"],
+    },
+    workflow: {
+        profile: "workflow",
+        detectaLiteral: true,
+        detectaSemantico: "parcial",
+        detectaOrdemExecucao: true,
+        detectaDriftReal: "parcial",
+        validaArtefatoReal: true,
+        interpretaNegacao: true,
+        confianca: "media",
+        limites: [
+            "ordem real exige etapas nomeadas no contrato e no artefato",
+            "adaptadores de runtime ainda devem declarar lacunas honestas",
+        ],
+        rulePacksSugeridos: ["n8n", "event-driven", "approval-flow"],
+    },
+    ops: {
+        profile: "ops",
+        detectaLiteral: true,
+        detectaSemantico: "parcial",
+        detectaOrdemExecucao: "parcial",
+        detectaDriftReal: "parcial",
+        validaArtefatoReal: true,
+        interpretaNegacao: true,
+        confianca: "media",
+        limites: [
+            "validacao nao executa rollback real sem comandos externos",
+            "modo critical deve escalar humano quando falta runbook ou reversibilidade",
+        ],
+        rulePacksSugeridos: ["kubernetes", "sre", "incident-response"],
+    },
+    legal: {
+        profile: "legal",
+        detectaLiteral: true,
+        detectaSemantico: "parcial",
+        detectaOrdemExecucao: false,
+        detectaDriftReal: "parcial",
+        validaArtefatoReal: true,
+        interpretaNegacao: true,
+        confianca: "media",
+        limites: [
+            "nao substitui revisao humana por profissional habilitado",
+            "fontes normativas devem ser fornecidas ou citadas pelo agente",
+        ],
+        rulePacksSugeridos: ["lgpd", "dpa", "privacy-policy", "soc2"],
+    },
+    research: {
+        profile: "research",
+        detectaLiteral: true,
+        detectaSemantico: "parcial",
+        detectaOrdemExecucao: false,
+        detectaDriftReal: "parcial",
+        validaArtefatoReal: true,
+        interpretaNegacao: true,
+        confianca: "media",
+        limites: [
+            "nao verifica fontes externas sem ferramenta de busca ou dataset anexado",
+            "confianca aumenta quando evidencia, metodo e incerteza estao separados",
+        ],
+        rulePacksSugeridos: ["decision-research", "contradictory-review", "evidence-matrix"],
+    },
+    game: {
+        profile: "game",
+        detectaLiteral: true,
+        detectaSemantico: "parcial",
+        detectaOrdemExecucao: "parcial",
+        detectaDriftReal: "parcial",
+        validaArtefatoReal: true,
+        interpretaNegacao: true,
+        confianca: "media",
+        limites: [
+            "playtest simulado nao substitui telemetria de jogador real",
+            "balanceamento numerico profundo depende de parametros e sessoes",
+        ],
+        rulePacksSugeridos: ["playtest", "economy-balance", "progression"],
+    },
+};
+const RULE_PACKS_SEMA = [
+    {
+        id: "owasp",
+        nome: "OWASP Application Security",
+        categoria: "premium",
+        profiles: ["software"],
+        maturidadeMinima: "production",
+        controles: ["input_validation", "safe_output", "no_eval", "no_dynamic_sql", "secret_handling"],
+        monetizacao: "cloud",
+        status: "premium",
+    },
+    {
+        id: "openapi",
+        nome: "OpenAPI Contract Surface",
+        categoria: "oss",
+        profiles: ["software", "workflow"],
+        maturidadeMinima: "prototype",
+        controles: ["endpoint_shape", "request_response", "auth_surface", "error_contract"],
+        monetizacao: "aberto",
+        status: "base",
+    },
+    {
+        id: "lgpd",
+        nome: "LGPD Privacy Governance",
+        categoria: "premium",
+        profiles: ["legal", "ops", "workflow"],
+        maturidadeMinima: "production",
+        controles: ["data_inventory", "legal_basis", "retention", "data_subject_rights", "human_review"],
+        monetizacao: "cloud",
+        status: "premium",
+    },
+    {
+        id: "dpa",
+        nome: "Data Processing Agreement",
+        categoria: "premium",
+        profiles: ["legal"],
+        maturidadeMinima: "production",
+        controles: ["controller_processor", "subprocessors", "transfer", "security_measures", "audit"],
+        monetizacao: "cloud",
+        status: "premium",
+    },
+    {
+        id: "soc2",
+        nome: "SOC2 Operational Evidence",
+        categoria: "enterprise",
+        profiles: ["ops", "workflow", "software", "legal"],
+        maturidadeMinima: "critical",
+        controles: ["audit_trail", "approval_gate", "incident_evidence", "access_review"],
+        monetizacao: "enterprise",
+        status: "planejado",
+    },
+    {
+        id: "kubernetes",
+        nome: "Kubernetes Change Safety",
+        categoria: "premium",
+        profiles: ["ops"],
+        maturidadeMinima: "production",
+        controles: ["deployment_healthcheck", "rollback", "migration_guard", "resource_limits"],
+        monetizacao: "cloud",
+        status: "planejado",
+    },
+    {
+        id: "n8n",
+        nome: "n8n Workflow Runtime",
+        categoria: "premium",
+        profiles: ["workflow"],
+        maturidadeMinima: "prototype",
+        controles: ["node_surface", "credential_boundary", "retry", "idempotency", "dlq"],
+        monetizacao: "cloud",
+        status: "planejado",
+    },
+    {
+        id: "saas",
+        nome: "Startup SaaS Governance",
+        categoria: "premium",
+        profiles: ["software", "workflow", "ops", "legal", "research"],
+        maturidadeMinima: "production",
+        controles: ["authz", "billing_risk", "data_retention", "release_gate", "audit"],
+        monetizacao: "cloud",
+        status: "planejado",
+    },
+    {
+        id: "author-quality",
+        nome: "Author Quality Gate",
+        categoria: "oss",
+        profiles: ["author"],
+        maturidadeMinima: "draft",
+        controles: ["forbidden_literals", "cliche_review", "narrative_conflict", "tone_drift"],
+        monetizacao: "aberto",
+        status: "base",
+    },
+    {
+        id: "brand-voice",
+        nome: "Brand Voice Guardrails",
+        categoria: "premium",
+        profiles: ["author", "legal", "research"],
+        maturidadeMinima: "prototype",
+        controles: ["tone_drift", "style_policy", "forbidden_claims", "approval_review"],
+        monetizacao: "cloud",
+        status: "planejado",
+    },
+    {
+        id: "campaign-continuity",
+        nome: "Campaign Continuity",
+        categoria: "premium",
+        profiles: ["author", "game"],
+        maturidadeMinima: "production",
+        controles: ["canon_memory", "character_state", "promise_tracking", "chapter_drift"],
+        monetizacao: "cloud",
+        status: "planejado",
+    },
+    {
+        id: "event-driven",
+        nome: "Event Driven Workflow",
+        categoria: "premium",
+        profiles: ["workflow", "ops"],
+        maturidadeMinima: "production",
+        controles: ["event_schema", "idempotency", "retry_policy", "dlq", "compensation"],
+        monetizacao: "cloud",
+        status: "planejado",
+    },
+    {
+        id: "approval-flow",
+        nome: "Human Approval Flow",
+        categoria: "enterprise",
+        profiles: ["workflow", "ops", "legal"],
+        maturidadeMinima: "critical",
+        controles: ["human_gate", "rbac", "audit_trail", "decision_retention"],
+        monetizacao: "enterprise",
+        status: "planejado",
+    },
+    {
+        id: "sre",
+        nome: "SRE Operational Gate",
+        categoria: "premium",
+        profiles: ["ops"],
+        maturidadeMinima: "production",
+        controles: ["slo", "error_budget", "runbook", "rollback", "oncall"],
+        monetizacao: "cloud",
+        status: "planejado",
+    },
+    {
+        id: "incident-response",
+        nome: "Incident Response",
+        categoria: "enterprise",
+        profiles: ["ops", "legal"],
+        maturidadeMinima: "critical",
+        controles: ["severity", "communication", "owner", "postmortem", "evidence_retention"],
+        monetizacao: "enterprise",
+        status: "planejado",
+    },
+    {
+        id: "privacy-policy",
+        nome: "Privacy Policy Review",
+        categoria: "premium",
+        profiles: ["legal"],
+        maturidadeMinima: "production",
+        controles: ["data_purpose", "legal_basis", "retention", "dpo_contact", "subject_rights"],
+        monetizacao: "cloud",
+        status: "premium",
+    },
+    {
+        id: "decision-research",
+        nome: "Decision Research",
+        categoria: "oss",
+        profiles: ["research"],
+        maturidadeMinima: "prototype",
+        controles: ["question", "method", "criteria", "weights", "alternatives"],
+        monetizacao: "aberto",
+        status: "base",
+    },
+    {
+        id: "contradictory-review",
+        nome: "Contradictory Evidence Review",
+        categoria: "premium",
+        profiles: ["research", "legal"],
+        maturidadeMinima: "production",
+        controles: ["counter_evidence", "uncertainty", "source_rejection", "confidence_level"],
+        monetizacao: "cloud",
+        status: "planejado",
+    },
+    {
+        id: "evidence-matrix",
+        nome: "Evidence Matrix",
+        categoria: "premium",
+        profiles: ["research", "legal"],
+        maturidadeMinima: "production",
+        controles: ["source_weight", "fact_inference", "reproducibility", "decision_trace"],
+        monetizacao: "cloud",
+        status: "planejado",
+    },
+    {
+        id: "playtest",
+        nome: "Simulated Playtest",
+        categoria: "oss",
+        profiles: ["game"],
+        maturidadeMinima: "prototype",
+        controles: ["first_10_seconds", "first_minute", "tension_point", "reward", "retry_reason"],
+        monetizacao: "aberto",
+        status: "base",
+    },
+    {
+        id: "economy-balance",
+        nome: "Game Economy Balance",
+        categoria: "premium",
+        profiles: ["game"],
+        maturidadeMinima: "production",
+        controles: ["currency_source", "sink", "soft_cap", "exploit", "session_curve"],
+        monetizacao: "cloud",
+        status: "planejado",
+    },
+    {
+        id: "progression",
+        nome: "Progression And Pacing",
+        categoria: "premium",
+        profiles: ["game", "author"],
+        maturidadeMinima: "production",
+        controles: ["difficulty_curve", "session_time", "mastery", "frustration", "reward_cadence"],
+        monetizacao: "cloud",
+        status: "planejado",
+    },
+];
 const REQUISITOS_PRESET_PROFILE = {
     security: [
         { id: "security_entrada_saida", descricao: "declara validacao de entrada e saida segura", termos: [/entrada|input/i, /saida|output|retorno/i, /segur|sanitiz|valid/i], obrigatorio: true, severidade: "blocking" },
@@ -4311,16 +4647,33 @@ function severidadeRequisitoProfile(requisito, profile, maturidade) {
     }
     return maturidade === "draft" ? "warning" : "blocking";
 }
+function riscoAchadoProfile(severidade, fonte) {
+    if (severidade === "critical")
+        return fonte === "artefato" ? "violacao_critica_no_artefato" : "risco_critico_de_governanca";
+    if (severidade === "blocking")
+        return fonte === "artefato" ? "artefato_nao_aderente" : "contrato_nao_pronto";
+    if (severidade === "warning")
+        return "ressalva_operacional";
+    return "informativo";
+}
 function avaliarRequisitosProfile(conteudo, requisitos, profile, maturidade, fonte = "contrato") {
-    return requisitos.map((requisito) => ({
-        id: requisito.id,
-        descricao: requisito.descricao,
-        obrigatorio: requisito.obrigatorio,
-        atendido: requisito.termos.every((termo) => termo.test(conteudo)),
-        severidade: severidadeRequisitoProfile(requisito, profile, maturidade),
-        termos: requisito.termos.map((termo) => termo.source),
-        fonte,
-    }));
+    return requisitos.map((requisito) => {
+        const severidade = severidadeRequisitoProfile(requisito, profile, maturidade);
+        const atendido = requisito.termos.every((termo) => termo.test(conteudo));
+        return {
+            id: requisito.id,
+            descricao: requisito.descricao,
+            obrigatorio: requisito.obrigatorio,
+            atendido,
+            severidade,
+            termos: requisito.termos.map((termo) => termo.source),
+            fonte,
+            regra: requisito.id,
+            motivo: atendido ? undefined : `requisito ${fonte} nao foi demonstrado no contrato.`,
+            risco: atendido ? undefined : riscoAchadoProfile(severidade, fonte),
+            sugestao: atendido ? undefined : "declare o requisito com entradas, efeitos, garantias e checks rastreaveis.",
+        };
+    });
 }
 function decidirAcaoAgenteProfile(contratoValido, achados) {
     if (!contratoValido)
@@ -4353,6 +4706,62 @@ function penalidadeAchadoProfile(achado) {
 function calcularScoreAchadosProfile(base, achados) {
     return Math.max(0, base - achados.reduce((total, achado) => total + penalidadeAchadoProfile(achado), 0));
 }
+function calcularScoreRiscoProfile(achados) {
+    const pendentes = achados.filter((achado) => !achado.atendido);
+    return Math.min(100, pendentes.reduce((total, achado) => {
+        if (achado.severidade === "critical")
+            return total + 35;
+        if (achado.severidade === "blocking")
+            return total + 22;
+        if (achado.severidade === "warning")
+            return total + 8;
+        return total + 2;
+    }, 0));
+}
+function severidadeMaximaProfile(achados) {
+    const pendentes = achados.filter((achado) => !achado.atendido);
+    if (pendentes.some((achado) => achado.severidade === "critical"))
+        return "critical";
+    if (pendentes.some((achado) => achado.severidade === "blocking"))
+        return "blocking";
+    if (pendentes.some((achado) => achado.severidade === "warning"))
+        return "warning";
+    if (pendentes.some((achado) => achado.severidade === "info"))
+        return "info";
+    return null;
+}
+function calcularConfiancaValidacaoProfile(artefatoRecebido, achadosArtefato, scoreRisco) {
+    if (!artefatoRecebido)
+        return "parcial";
+    if (scoreRisco >= 70)
+        return "media";
+    if (achadosArtefato.some((achado) => !achado.atendido && achado.trecho && achado.linha))
+        return "alta";
+    if (achadosArtefato.length > 0)
+        return "media";
+    return "media";
+}
+function criarRuntimeGateProfile(decisao, maturidade, achados, scoreRisco) {
+    const severidadeMaxima = severidadeMaximaProfile(achados);
+    const exigeHumano = decisao === "chamar_humano" || severidadeMaxima === "critical";
+    const podeExecutar = decisao === "continuar" || decisao === "continuar_com_ressalva";
+    return {
+        decisao,
+        maturidade,
+        podeExecutar,
+        exigeHumano,
+        scoreRisco,
+        severidadeMaxima,
+        motivo: podeExecutar
+            ? "gate permite continuidade com as ressalvas declaradas."
+            : exigeHumano
+                ? "gate bloqueia e exige humano por risco critico ou maturidade critica."
+                : "gate bloqueia ate resolver requisitos obrigatorios.",
+    };
+}
+function selecionarRulePacksProfile(profile) {
+    return RULE_PACKS_SEMA.filter((pack) => pack.profiles.includes(profile));
+}
 function contratoProibeTermoProfile(contrato, termo) {
     const escaped = termo.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
     const padroes = [
@@ -4361,7 +4770,7 @@ function contratoProibeTermoProfile(contrato, termo) {
     ];
     return padroes.some((padrao) => padrao.test(contrato));
 }
-function criarAchadoArtefatoProfile(id, descricao, atendido, severidade, trecho, sugestao, motivo) {
+function criarAchadoArtefatoProfile(id, descricao, atendido, severidade, trecho, sugestao, motivo, detalhes) {
     return {
         id,
         descricao,
@@ -4370,8 +4779,14 @@ function criarAchadoArtefatoProfile(id, descricao, atendido, severidade, trecho,
         severidade,
         termos: [],
         fonte: "artefato",
+        regra: detalhes?.regra ?? id,
         trecho,
+        linha: detalhes?.linha,
+        coluna: detalhes?.coluna,
+        inicio: detalhes?.inicio,
+        fim: detalhes?.fim,
         motivo,
+        risco: detalhes?.risco ?? (atendido ? undefined : riscoAchadoProfile(severidade, "artefato")),
         sugestao,
     };
 }
@@ -4396,6 +4811,25 @@ function trechoDoMatchProfile(texto, indice, tamanho) {
     const fim = Math.min(texto.length, indice + tamanho + 60);
     return texto.slice(inicio, fim).replace(/\s+/g, " ").trim();
 }
+function localizacaoDoMatchProfile(texto, indice, tamanho) {
+    const antes = texto.slice(0, indice);
+    const linhas = antes.split(/\r?\n/);
+    return {
+        trecho: trechoDoMatchProfile(texto, indice, tamanho),
+        linha: linhas.length,
+        coluna: (linhas.at(-1) ?? "").length + 1,
+        inicio: indice,
+        fim: indice + tamanho,
+    };
+}
+function localizarRegexProfile(texto, regex) {
+    const flags = regex.flags.replace(/g/g, "");
+    const busca = new RegExp(regex.source, flags);
+    const match = busca.exec(texto);
+    if (!match)
+        return undefined;
+    return localizacaoDoMatchProfile(texto, match.index, match[0].length);
+}
 function termoNegadoNoArtefato(texto, indice, tamanho) {
     const antes = texto.slice(Math.max(0, indice - 90), indice);
     const depois = texto.slice(indice + tamanho, Math.min(texto.length, indice + tamanho + 90));
@@ -4420,7 +4854,7 @@ function avaliarPresencaPositivaArtefato(texto, regex) {
     if (primeiroNegado) {
         return {
             atendido: false,
-            trecho: trechoDoMatchProfile(texto, primeiroNegado.indice, primeiroNegado.tamanho),
+            ...localizacaoDoMatchProfile(texto, primeiroNegado.indice, primeiroNegado.tamanho),
             motivo: "termo encontrado em contexto de negacao/ausencia; mencao negativa nao satisfaz requisito.",
         };
     }
@@ -4429,7 +4863,13 @@ function avaliarPresencaPositivaArtefato(texto, regex) {
 function validarTermosObrigatoriosArtefato(texto, checks) {
     return checks.map((check) => {
         const presenca = avaliarPresencaPositivaArtefato(texto, check.regex);
-        return criarAchadoArtefatoProfile(check.id, check.descricao, presenca.atendido, check.severidade ?? "blocking", presenca.trecho, check.sugestao, presenca.motivo);
+        return criarAchadoArtefatoProfile(check.id, check.descricao, presenca.atendido, check.severidade ?? "blocking", presenca.trecho, check.sugestao, presenca.motivo, {
+            linha: presenca.linha,
+            coluna: presenca.coluna,
+            inicio: presenca.inicio,
+            fim: presenca.fim,
+            regra: check.id,
+        });
     });
 }
 function avaliarArtefatoSoftwareProfile(contrato, artefato, maturidade, preset) {
@@ -4589,6 +5029,21 @@ async function validarProfileSemantico(entrada, profile, opcoes) {
     const decisaoAgente = decidirAcaoAgenteProfile(contratoValido, achados);
     const aprovado = contratoValido && obrigatoriosPendentes.length === 0 && scoreProntoParaAcao >= 80;
     const podeContinuar = decisaoAgente === "continuar" || decisaoAgente === "continuar_com_ressalva";
+    const scoreRisco = calcularScoreRiscoProfile(achados);
+    const confiancaValidacao = calcularConfiancaValidacaoProfile(Boolean(opcoes.artefatoTexto), achadosArtefato, scoreRisco);
+    const prontoParaAcao = aprovado && podeContinuar;
+    const confidenceEngine = {
+        scoreContratoFormal: scoreContrato,
+        scoreAderenciaSemantica: scoreArtefato,
+        scoreRisco,
+        prontoParaAcao,
+        confiancaValidacao,
+        comparacaoArtefatoReal: Boolean(opcoes.artefatoTexto),
+        heuristicaParcial: confiancaValidacao === "parcial" || confiancaValidacao === "baixa",
+    };
+    const runtimeGate = criarRuntimeGateProfile(decisaoAgente, maturidade, achados, scoreRisco);
+    const capabilityMatrix = CAPABILITY_MATRIX_GOVERNANCA[profile];
+    const rulePacksSugeridos = selecionarRulePacksProfile(profile);
     return {
         comando: "profile validar",
         sucesso: aprovado,
@@ -4608,6 +5063,15 @@ async function validarProfileSemantico(entrada, profile, opcoes) {
         scoreContrato,
         scoreArtefato,
         scoreProntoParaAcao,
+        scoreContratoFormal: scoreContrato,
+        scoreAderenciaSemantica: scoreArtefato,
+        scoreRisco,
+        prontoParaAcao,
+        confiancaValidacao,
+        confidenceEngine,
+        capabilityMatrix,
+        runtimeGate,
+        rulePacksSugeridos,
         achados,
         achadosArtefato,
         requisitosAtendidos: achados.filter((achado) => achado.atendido).map((achado) => achado.id),
@@ -4636,31 +5100,110 @@ function renderizarProfileValidarTexto(resultado) {
         `SCORE_CONTRATO: ${resultado.scoreContrato}`,
         `SCORE_ARTEFATO: ${resultado.scoreArtefato ?? "nao_avaliado"}`,
         `SCORE_PRONTO_PARA_ACAO: ${resultado.scoreProntoParaAcao}`,
+        `SCORE_RISCO: ${resultado.scoreRisco}`,
+        `CONFIANCA_VALIDACAO: ${resultado.confiancaValidacao}`,
+        `RUNTIME_GATE: ${resultado.runtimeGate.decisao}`,
     ];
     for (const achado of resultado.achados) {
         linhas.push(`- ${achado.id}: ${achado.atendido ? "ok" : "pendente"} ${achado.severidade}${achado.obrigatorio ? " obrigatorio" : " recomendado"} ${achado.fonte} - ${achado.descricao}`);
+        if (achado.linha && achado.coluna)
+            linhas.push(`  posicao: linha ${achado.linha}, coluna ${achado.coluna}`);
         if (achado.trecho)
             linhas.push(`  trecho: ${achado.trecho}`);
         if (achado.motivo)
             linhas.push(`  motivo: ${achado.motivo}`);
+        if (achado.risco)
+            linhas.push(`  risco: ${achado.risco}`);
         if (achado.sugestao)
             linhas.push(`  sugestao: ${achado.sugestao}`);
     }
     return linhas.join("\n");
 }
+function criarPayloadCapabilityMatrix() {
+    const profiles = Object.values(CAPABILITY_MATRIX_GOVERNANCA);
+    return {
+        comando: "profile capabilities",
+        sucesso: true,
+        profiles,
+        resumo: {
+            profiles: profiles.length,
+            validaArtefatoReal: profiles.filter((profile) => profile.validaArtefatoReal).map((profile) => profile.profile),
+            interpretaNegacao: profiles.filter((profile) => profile.interpretaNegacao).map((profile) => profile.profile),
+        },
+    };
+}
+function renderizarCapabilityMatrixTexto(payload) {
+    return [
+        "CAPABILITY_MATRIX",
+        ...payload.profiles.map((profile) => [
+            `- ${profile.profile}: confianca=${profile.confianca}`,
+            `  literal=${profile.detectaLiteral ? "sim" : "nao"} semantico=${profile.detectaSemantico} ordem=${profile.detectaOrdemExecucao} artefato=${profile.validaArtefatoReal} negacao=${profile.interpretaNegacao ? "sim" : "nao"}`,
+            `  packs=${profile.rulePacksSugeridos.join(", ")}`,
+            `  limites=${profile.limites.join(" | ")}`,
+        ].join("\n")).join("\n"),
+    ].join("\n");
+}
+function criarPayloadRulePacks(profileFiltro = null) {
+    const packs = profileFiltro
+        ? RULE_PACKS_SEMA.filter((pack) => pack.profiles.includes(profileFiltro))
+        : RULE_PACKS_SEMA;
+    return {
+        comando: "rule-packs",
+        sucesso: true,
+        profile: profileFiltro,
+        packs,
+        resumo: {
+            total: packs.length,
+            abertos: packs.filter((pack) => pack.monetizacao === "aberto").map((pack) => pack.id),
+            pagos: packs.filter((pack) => pack.monetizacao !== "aberto").map((pack) => pack.id),
+            enterprise: packs.filter((pack) => pack.categoria === "enterprise").map((pack) => pack.id),
+        },
+    };
+}
+function renderizarRulePacksTexto(payload) {
+    return [
+        "RULE_PACKS",
+        ...payload.packs.map((pack) => [
+            `- ${pack.id}: ${pack.nome}`,
+            `  profiles=${pack.profiles.join(", ")} maturidade_minima=${pack.maturidadeMinima} monetizacao=${pack.monetizacao} status=${pack.status}`,
+            `  controles=${pack.controles.join(", ")}`,
+        ].join("\n")),
+    ].join("\n");
+}
+function normalizarProfileGovernanca(valor) {
+    if (!valor)
+        return null;
+    const chave = valor.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+    if (chave === "author" || chave === "autor" || chave === "escrita")
+        return "author";
+    return normalizarProfileSemantico(valor);
+}
 async function comandoProfile(posicionais, args, emJson) {
     const subcomando = posicionais[0];
     if (!subcomando || subcomando === "help" || subcomando === "ajuda") {
         console.log([
-            "Uso: sema profile <validar>",
+            "Uso: sema profile <validar|capabilities|rule-packs>",
             "",
             "Comandos:",
             "  sema profile validar <software|workflow|ops|game|legal|research> <arquivo-ou-pasta> [--maturidade draft|prototype|production|critical] [--preset <preset>] [--artefato <texto>|--artefato-arquivo <arquivo>] [--json]",
+            "  sema profile capabilities [--json]",
+            "  sema profile rule-packs [--profile <author|software|workflow|ops|game|legal|research>] [--json]",
             "",
             "O profile e um gate semantico: se requisito obrigatorio faltar, a saida bloqueia.",
         ].join("\n"));
         return subcomando ? 0 : 1;
     }
+    if (subcomando === "capabilities" || subcomando === "capability-matrix" || subcomando === "matrix") {
+        const payload = criarPayloadCapabilityMatrix();
+        console.log(emJson ? JSON.stringify(payload, null, 2) : renderizarCapabilityMatrixTexto(payload));
+        return 0;
+    }
+    if (subcomando === "rule-packs" || subcomando === "packs") {
+        const profileFiltro = normalizarProfileGovernanca(obterOpcao(args, "--profile"));
+        const payload = criarPayloadRulePacks(profileFiltro);
+        console.log(emJson ? JSON.stringify(payload, null, 2) : renderizarRulePacksTexto(payload));
+        return 0;
+    }
     if (subcomando !== "validar") {
         console.error(`Subcomando profile desconhecido: ${subcomando}`);
         return 1;
@@ -6169,6 +6712,14 @@ async function principal() {
         case "profile":
             codigoSaida = await comandoProfile(posicionais, resto, possuiFlag(resto, "--json"));
             break;
+        case "rule-packs":
+            {
+                const profileFiltro = normalizarProfileGovernanca(obterOpcao(resto, "--profile") ?? posicionais[0]);
+                const payload = criarPayloadRulePacks(profileFiltro);
+                console.log(possuiFlag(resto, "--json") ? JSON.stringify(payload, null, 2) : renderizarRulePacksTexto(payload));
+                codigoSaida = 0;
+            }
+            break;
         case "validar":
             codigoSaida = possuiFlag(resto, "--json")
                 ? await comandoValidarJson(posicionais[0])