@semacode/cli 2.2.0 → 2.3.0

package/dist/profileAuthorTipos.d.ts

@@ -1,12 +1,13 @@
 import type { compilarCodigo } from "@sema/nucleo";
 export type PerfilSemantico = "software" | "workflow" | "ops" | "game" | "legal" | "research" | "redacao" | "propostas" | "conversas";
-export type ProfileGovernanca = PerfilSemantico | "author";
+export type PerfilSemanticoValidavel = PerfilSemantico | "simulation";
+export type ProfileGovernanca = PerfilSemanticoValidavel | "author";
 export type SeveridadeProfile = "info" | "warning" | "blocking" | "critical";
 export type MaturidadeProfile = "draft" | "prototype" | "production" | "critical";
 export type DecisaoAgenteProfile = "continuar" | "continuar_com_ressalva" | "parar" | "chamar_humano";
 export type FonteAchadoProfile = "contrato" | "artefato" | "preset";
 export type ConfiancaValidacaoProfile = "alta" | "media" | "parcial" | "baixa";
-export type PresetProfile = "api" | "modulo" | "refactor" | "persistencia" | "security" | "webhook" | "fila" | "n8n" | "cron" | "integracao" | "deploy" | "migration" | "incidente" | "rollback" | "critical" | "lgpd" | "contrato" | "dpa" | "termos_uso" | "privacidade" | "due_diligence" | "compliance" | "rapida" | "tecnica" | "decisoria" | "critica" | "editorial" | "materia" | "blog" | "seo" | "reescrita" | "marketplace" | "freela" | "consultiva" | "diagnostico" | "score90" | "casual" | "arcade" | "rpg" | "economia" | "playtest" | "atendimento" | "vendas" | "suporte" | "qualificacao" | "retencao" | "cobranca";
+export type PresetProfile = "api" | "modulo" | "refactor" | "persistencia" | "security" | "webhook" | "fila" | "n8n" | "cron" | "integracao" | "deploy" | "migration" | "incidente" | "rollback" | "critical" | "lgpd" | "contrato" | "dpa" | "termos_uso" | "privacidade" | "due_diligence" | "compliance" | "rapida" | "tecnica" | "decisoria" | "critica" | "editorial" | "materia" | "blog" | "seo" | "reescrita" | "marketplace" | "freela" | "consultiva" | "diagnostico" | "score90" | "casual" | "arcade" | "rpg" | "economia" | "playtest" | "model" | "scenario" | "calibration" | "deterministic" | "batch" | "safety" | "atendimento" | "vendas" | "suporte" | "qualificacao" | "retencao" | "cobranca";
 export interface RequisitoProfile {
     id: string;
     descricao: string;
@@ -81,7 +82,7 @@ export interface OpcoesProfileValidar {
 export interface ResultadoProfileValidar {
     comando: "profile validar";
     sucesso: boolean;
-    profile: PerfilSemantico;
+    profile: PerfilSemanticoValidavel;
     arquivo: string;
     modulo: string | null;
     maturidade: MaturidadeProfile;

package/dist/profileCatalogo.d.ts

@@ -1,8 +1,8 @@
-import type { CapabilityProfile, MaturidadeProfile, PerfilSemantico, PresetProfile, ProfileGovernanca, RequisitoProfile } from "./profileAuthorTipos.js";
-export declare const REQUISITOS_PROFILE: Record<PerfilSemantico, RequisitoProfile[]>;
+import type { CapabilityProfile, MaturidadeProfile, PerfilSemanticoValidavel, PresetProfile, ProfileGovernanca, RequisitoProfile } from "./profileAuthorTipos.js";
+export declare const REQUISITOS_PROFILE: Record<PerfilSemanticoValidavel, RequisitoProfile[]>;
 export declare const REQUISITOS_PROFILE_COMUNS: RequisitoProfile[];
-export declare const ALIASES_PROFILE: Record<string, PerfilSemantico>;
-export declare function normalizarProfileSemantico(valor: string | undefined): PerfilSemantico | null;
+export declare const ALIASES_PROFILE: Record<string, PerfilSemanticoValidavel>;
+export declare function normalizarProfileSemantico(valor: string | undefined): PerfilSemanticoValidavel | null;
 export declare function normalizarMaturidadeProfile(valor: string | undefined): MaturidadeProfile;
-export declare const PRESETS_PROFILE: Record<PerfilSemantico, PresetProfile[]>;
+export declare const PRESETS_PROFILE: Record<PerfilSemanticoValidavel, PresetProfile[]>;
 export declare const CAPABILITY_MATRIX_GOVERNANCA: Record<ProfileGovernanca, CapabilityProfile>;

package/dist/profileCatalogo.js

@@ -27,6 +27,14 @@ export const REQUISITOS_PROFILE = {
         { id: "falha_balanceamento", descricao: "modela falha, balanceamento e abuso", termos: [/falha|derrota|erro/i, /balanceamento|abuso|exploit/i], obrigatorio: true },
         { id: "telemetria_jogo", descricao: "define telemetria ou replay de decisao", termos: [/telemetria|replay|metricas/i], obrigatorio: false },
     ],
+    simulation: [
+        { id: "modelo_e_assumptions", descricao: "declara modelo testavel e assumptions explicitas", termos: [/modelo|model/i, /assumptions?|premissas?|hipoteses?/i], obrigatorio: true },
+        { id: "condicoes_outputs_unidades", descricao: "declara condicoes iniciais, contorno, outputs e unidades", termos: [/condicoes?_iniciais|initial[_ -]?conditions?/i, /condicoes?_contorno|boundary[_ -]?conditions?/i, /outputs?|saidas?|resultados?/i, /unidades?|units?/i], obrigatorio: true },
+        { id: "spatial_render_visual_separados", descricao: "separa modelo espacial, modo de renderizacao e visual profile", termos: [/spatial[_ -]?model|modelo[_ -]?espacial/i, /render[_ -]?mode|modo[_ -]?(?:de[_ -]?)?render/i, /visual[_ -]?profile|perfil[_ -]?visual/i], obrigatorio: true },
+        { id: "controle_e_tempo", descricao: "declara modo de controle e modelo de tempo", termos: [/controle|control(?:[_ -]?modes?)?/i, /tempo|time[_ -]?model|fixed[_ -]?step|real[_ -]?time|event[_ -]?driven/i], obrigatorio: true },
+        { id: "fidelidade_calibracao_incerteza", descricao: "declara fidelidade, referencia, calibracao, tolerancia e incerteza", termos: [/fidelity|fidelidade/i, /referencia|reference|dataset/i, /calibracao|calibration/i, /tolerancias?|tolerances?/i, /incerteza|uncertainty/i], obrigatorio: true },
+        { id: "telemetria_e_replay_simulacao", descricao: "define telemetria, seed, snapshot ou replay reproduzivel", termos: [/telemetria|telemetry|metricas?/i, /seed|snapshot|replay|event[_ -]?log/i], obrigatorio: false },
+    ],
     legal: [
         { id: "jurisdicao_e_escopo", descricao: "declara jurisdicao, escopo e limite de uso", termos: [/jurisdicao/i, /escopo|limite/i], obrigatorio: true },
         { id: "fontes_normativas", descricao: "exige fontes normativas ou base documental", termos: [/fonte|norma|lei|regulamento/i, /citacao|evidencia|documento/i], obrigatorio: true },
@@ -89,6 +97,12 @@ export const ALIASES_PROFILE = {
     game: "game",
     jogo: "game",
     games: "game",
+    simulation: "simulation",
+    simulations: "simulation",
+    simulacao: "simulation",
+    simulacoes: "simulation",
+    simulador: "simulation",
+    simuladores: "simulation",
     legal: "legal",
     juridico: "legal",
     research: "research",
@@ -140,6 +154,7 @@ export const PRESETS_PROFILE = {
     redacao: ["editorial", "materia", "blog", "seo", "reescrita"],
     propostas: ["marketplace", "freela", "consultiva", "diagnostico", "score90"],
     game: ["casual", "arcade", "rpg", "economia", "playtest"],
+    simulation: ["model", "scenario", "calibration", "deterministic", "batch", "safety"],
     conversas: ["atendimento", "vendas", "suporte", "qualificacao", "retencao", "cobranca"],
 };
 export const CAPABILITY_MATRIX_GOVERNANCA = {
@@ -278,6 +293,21 @@ export const CAPABILITY_MATRIX_GOVERNANCA = {
         ],
         rulePacksSugeridos: ["playtest", "economy-balance", "progression"],
     },
+    simulation: {
+        profile: "simulation",
+        detectaLiteral: true,
+        detectaSemantico: "parcial",
+        detectaOrdemExecucao: "parcial",
+        detectaDriftReal: "parcial",
+        validaArtefatoReal: "parcial",
+        interpretaNegacao: true,
+        confianca: "media",
+        limites: [
+            "validacao textual nao executa engine, solver ou runtime externo",
+            "aparencia visual nao prova fidelidade sem referencia, calibracao, tolerancia e evidencia observada",
+        ],
+        rulePacksSugeridos: ["simulation-model", "simulation-calibration", "simulation-determinism", "simulation-batch", "simulation-safety"],
+    },
     conversas: {
         profile: "conversas",
         detectaLiteral: true,

package/dist/profileCommand.d.ts

@@ -1,16 +1,22 @@
-import type { CapabilityProfile, OpcoesProfileValidar, PerfilSemantico, ProfileGovernanca, ResultadoProfileValidar, RulePackSema } from "./profileAuthorTipos.js";
+import type { CapabilityProfile, OpcoesProfileValidar, PerfilSemanticoValidavel, ProfileGovernanca, ResultadoProfileValidar, RulePackSema } from "./profileAuthorTipos.js";
 export declare function carregarArtefatoProfile(args: string[]): Promise<{
     texto: string | null;
     arquivo: string | null;
 }>;
-export declare function validarProfileSemantico(entrada: string | undefined, profile: PerfilSemantico, opcoes: OpcoesProfileValidar): Promise<ResultadoProfileValidar>;
+export declare function validarProfileSemantico(entrada: string | undefined, profile: PerfilSemanticoValidavel, opcoes: OpcoesProfileValidar): Promise<ResultadoProfileValidar>;
 export declare function renderizarProfileValidarTexto(resultado: ResultadoProfileValidar): string;
 export declare function criarPayloadCapabilityMatrix(): {
     comando: string;
     sucesso: boolean;
     profiles: CapabilityProfile[];
+    workflowsEspecializados: readonly [{
+        readonly id: "workflow.author";
+        readonly comando: "sema author <subcomando>";
+        readonly resumo: "Workflow narrativo especializado; não é um profile validável.";
+    }];
     resumo: {
         profiles: number;
+        workflowsEspecializados: 1;
         validaArtefatoReal: ProfileGovernanca[];
         interpretaNegacao: ProfileGovernanca[];
     };

package/dist/profileCommand.js

@@ -24,7 +24,7 @@ export async function carregarArtefatoProfile(args) {
 }
 export async function validarProfileSemantico(entrada, profile, opcoes) {
     if (!entrada) {
-        throw new Error("Uso: sema profile validar <software|workflow|ops|game|legal|research|redacao|propostas|conversas> <arquivo-ou-pasta> [--maturidade draft|prototype|production|critical] [--preset <preset>] [--artefato <texto>|--artefato-arquivo <arquivo>] [--json]");
+        throw new Error("Uso: sema profile validar <software|workflow|ops|game|simulation|legal|research|redacao|propostas|conversas> <arquivo-ou-pasta> [--maturidade draft|prototype|production|critical] [--preset <preset>] [--artefato <texto>|--artefato-arquivo <arquivo>] [--json]");
     }
     const modulos = await carregarModulos(entrada);
     const escolhido = modulos.find((item) => moduloCombinaComProfile(item.resultado.modulo?.nome, item.caminho, profile)) ?? modulos[0];
@@ -139,13 +139,21 @@ export function renderizarProfileValidarTexto(resultado) {
     return linhas.join("\n");
 }
 export function criarPayloadCapabilityMatrix() {
-    const profiles = Object.values(CAPABILITY_MATRIX_GOVERNANCA);
+    const profiles = Object.values(CAPABILITY_MATRIX_GOVERNANCA)
+        .filter((profile) => profile.profile !== "author");
+    const workflowsEspecializados = [{
+            id: "workflow.author",
+            comando: "sema author <subcomando>",
+            resumo: "Workflow narrativo especializado; não é um profile validável.",
+        }];
     return {
         comando: "profile capabilities",
         sucesso: true,
         profiles,
+        workflowsEspecializados,
         resumo: {
             profiles: profiles.length,
+            workflowsEspecializados: workflowsEspecializados.length,
             validaArtefatoReal: profiles.filter((profile) => profile.validaArtefatoReal).map((profile) => profile.profile),
             interpretaNegacao: profiles.filter((profile) => profile.interpretaNegacao).map((profile) => profile.profile),
         },
@@ -160,6 +168,8 @@ export function renderizarCapabilityMatrixTexto(payload) {
             `  packs=${profile.rulePacksSugeridos.join(", ")}`,
             `  limites=${profile.limites.join(" | ")}`,
         ].join("\n")).join("\n"),
+        "SPECIALIZED_WORKFLOWS",
+        ...payload.workflowsEspecializados.map((workflow) => (`- ${workflow.id}: ${workflow.resumo}\n  comando=${workflow.comando}`)),
     ].join("\n");
 }
 export function criarPayloadRulePacks(profileFiltro = null) {
@@ -204,9 +214,9 @@ export async function comandoProfile(posicionais, args, emJson) {
             "Uso: sema profile <validar|capabilities|rule-packs>",
             "",
             "Comandos:",
-            "  sema profile validar <software|workflow|ops|game|legal|research|redacao|propostas|conversas> <arquivo-ou-pasta> [--maturidade draft|prototype|production|critical] [--preset <preset>] [--artefato <texto>|--artefato-arquivo <arquivo>] [--json]",
+            "  sema profile validar <software|workflow|ops|game|simulation|legal|research|redacao|propostas|conversas> <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|redacao|propostas|conversas>] [--json]",
+            "  sema profile rule-packs [--profile <author|software|workflow|ops|game|simulation|legal|research|redacao|propostas|conversas>] [--json]",
             "",
             "O profile e um gate semantico: se requisito obrigatorio faltar, a saida bloqueia.",
         ].join("\n"));
@@ -230,7 +240,7 @@ export async function comandoProfile(posicionais, args, emJson) {
     const profile = normalizarProfileSemantico(posicionais[1] ?? obterOpcao(args, "--profile"));
     const entrada = posicionais[2] ?? obterOpcao(args, "--arquivo");
     if (!profile) {
-        console.error("Profile invalido. Use software, workflow, ops, game, legal, research, redacao, propostas ou conversas.");
+        console.error("Profile invalido. Use software, workflow, ops, game, simulation, legal, research, redacao, propostas ou conversas.");
         return 1;
     }
     const preset = normalizarPresetProfile(profile, obterOpcao(args, "--preset"));

package/dist/profileRegras.d.ts

@@ -1,9 +1,9 @@
-import type { AchadoProfile, ConfiancaValidacaoProfile, DecisaoAgenteProfile, FonteAchadoProfile, MaturidadeProfile, PerfilSemantico, PresetProfile, ProfileGovernanca, RequisitoProfile, RulePackSema, RuntimeGateProfile, SeveridadeProfile } from "./profileAuthorTipos.js";
-export declare function normalizarPresetProfile(profile: PerfilSemantico, valor: string | undefined): PresetProfile | null;
-export declare function moduloCombinaComProfile(modulo: string | null | undefined, caminho: string, profile: PerfilSemantico): boolean;
-export declare function severidadeRequisitoProfile(requisito: RequisitoProfile, profile: PerfilSemantico, maturidade: MaturidadeProfile): SeveridadeProfile;
+import type { AchadoProfile, ConfiancaValidacaoProfile, DecisaoAgenteProfile, FonteAchadoProfile, MaturidadeProfile, PerfilSemanticoValidavel, PresetProfile, ProfileGovernanca, RequisitoProfile, RulePackSema, RuntimeGateProfile, SeveridadeProfile } from "./profileAuthorTipos.js";
+export declare function normalizarPresetProfile(profile: PerfilSemanticoValidavel, valor: string | undefined): PresetProfile | null;
+export declare function moduloCombinaComProfile(modulo: string | null | undefined, caminho: string, profile: PerfilSemanticoValidavel): boolean;
+export declare function severidadeRequisitoProfile(requisito: RequisitoProfile, profile: PerfilSemanticoValidavel, maturidade: MaturidadeProfile): SeveridadeProfile;
 export declare function riscoAchadoProfile(severidade: SeveridadeProfile, fonte: FonteAchadoProfile): string;
-export declare function avaliarRequisitosProfile(conteudo: string, requisitos: RequisitoProfile[], profile: PerfilSemantico, maturidade: MaturidadeProfile, fonte?: FonteAchadoProfile): AchadoProfile[];
+export declare function avaliarRequisitosProfile(conteudo: string, requisitos: RequisitoProfile[], profile: PerfilSemanticoValidavel, maturidade: MaturidadeProfile, fonte?: FonteAchadoProfile): AchadoProfile[];
 export declare function decidirAcaoAgenteProfile(contratoValido: boolean, achados: AchadoProfile[]): DecisaoAgenteProfile;
 export declare function calcularScoreProfile(contratoValido: boolean, achados: AchadoProfile[]): number;
 export declare function penalidadeAchadoProfile(achado: AchadoProfile): number;

package/dist/profileRegras.js

@@ -46,7 +46,16 @@ export function normalizarPresetProfile(profile, valor) {
         retencao_cliente: "retencao",
         cobrar: "cobranca",
     };
-    const preset = alias[chave] ?? chave;
+    const aliasSimulation = {
+        modelo: "model",
+        cenario: "scenario",
+        calibracao: "calibration",
+        deterministico: "deterministic",
+        deterministica: "deterministic",
+        lote: "batch",
+        seguranca: "safety",
+    };
+    const preset = (profile === "simulation" ? aliasSimulation[chave] : undefined) ?? alias[chave] ?? chave;
     return PRESETS_PROFILE[profile].includes(preset) ? preset : null;
 }
 export function moduloCombinaComProfile(modulo, caminho, profile) {
@@ -57,6 +66,9 @@ export function moduloCombinaComProfile(modulo, caminho, profile) {
     if (profile === "conversas") {
         return /conversas|conversa|atendimento|chatbot|bot/.test(alvo);
     }
+    if (profile === "simulation") {
+        return /simulation|simulacao|simulador/.test(alvo);
+    }
     if (profile === "redacao") {
         return /redacao|redator|materia|editorial|seo/.test(alvo);
     }

package/dist/profileRulePacks.js

@@ -293,6 +293,56 @@ export const RULE_PACKS_SEMA = [
         monetizacao: "cloud",
         status: "planejado",
     },
+    {
+        id: "simulation-model",
+        nome: "Simulation Model Contract",
+        categoria: "oss",
+        profiles: ["simulation"],
+        maturidadeMinima: "draft",
+        controles: ["model", "assumptions", "initial_conditions", "boundary_conditions", "outputs", "units"],
+        monetizacao: "aberto",
+        status: "base",
+    },
+    {
+        id: "simulation-calibration",
+        nome: "Simulation Calibration Evidence",
+        categoria: "oss",
+        profiles: ["simulation"],
+        maturidadeMinima: "prototype",
+        controles: ["reference", "calibration", "tolerance", "uncertainty", "telemetry"],
+        monetizacao: "aberto",
+        status: "base",
+    },
+    {
+        id: "simulation-determinism",
+        nome: "Simulation Determinism And Replay",
+        categoria: "oss",
+        profiles: ["simulation"],
+        maturidadeMinima: "prototype",
+        controles: ["seed", "fixed_step", "snapshot", "event_log", "replay", "result_digest"],
+        monetizacao: "aberto",
+        status: "base",
+    },
+    {
+        id: "simulation-batch",
+        nome: "Simulation Batch Runs",
+        categoria: "oss",
+        profiles: ["simulation"],
+        maturidadeMinima: "prototype",
+        controles: ["replications", "seed_strategy", "aggregation", "resource_budget", "stop_condition"],
+        monetizacao: "aberto",
+        status: "base",
+    },
+    {
+        id: "simulation-safety",
+        nome: "Autonomous Simulation Safety",
+        categoria: "oss",
+        profiles: ["simulation"],
+        maturidadeMinima: "prototype",
+        controles: ["authority_boundary", "resource_budget", "stop_condition", "fail_safe", "human_takeover", "isolation"],
+        monetizacao: "aberto",
+        status: "base",
+    },
 ];
 export const REQUISITOS_PRESET_PROFILE = {
     security: [
@@ -382,6 +432,24 @@ export const REQUISITOS_PRESET_PROFILE = {
     economia: [
         { id: "game_economia_balanceada", descricao: "economia declara moeda, fonte, gasto e exploit", termos: [/moeda|economia/i, /fonte/i, /gasto|sink/i, /exploit/i], obrigatorio: true, severidade: "blocking" },
     ],
+    model: [
+        { id: "simulation_model_core", descricao: "modelo declara assumptions, condicoes, outputs e unidades", termos: [/modelo|model/i, /assumptions?|premissas?/i, /condicoes?_iniciais|initial[_ -]?conditions?/i, /condicoes?_contorno|boundary[_ -]?conditions?/i, /outputs?|saidas?/i, /unidades?|units?/i], obrigatorio: true, severidade: "blocking" },
+    ],
+    scenario: [
+        { id: "simulation_scenario_acceptance", descricao: "cenario declara identidade, condicoes e criterios de aceitacao", termos: [/scenario|cenario/i, /condicoes?_iniciais|initial[_ -]?conditions?/i, /condicoes?_contorno|boundary[_ -]?conditions?/i, /acceptance|aceitacao|resultado_esperado/i], obrigatorio: true, severidade: "blocking" },
+    ],
+    calibration: [
+        { id: "simulation_calibration_evidence", descricao: "calibracao declara referencia, metodo, tolerancia, incerteza e telemetria", termos: [/referencia|reference|dataset/i, /calibracao|calibration/i, /tolerancias?|tolerances?/i, /incerteza|uncertainty/i, /telemetria|telemetry/i], obrigatorio: true, severidade: "critical" },
+    ],
+    deterministic: [
+        { id: "simulation_deterministic_replay", descricao: "determinismo declara seed, passo, snapshot e replay", termos: [/determinism|determinismo|deterministic/i, /seed/i, /fixed[_ -]?step|passo_reprodutivel/i, /snapshot|state[_ -]?digest/i, /replay|event[_ -]?log/i], obrigatorio: true, severidade: "blocking" },
+    ],
+    batch: [
+        { id: "simulation_batch_budget", descricao: "batch declara repeticoes, estrategia de seeds, agregacao, budget e parada", termos: [/batch|lote|ensemble/i, /replications?|repeticoes?|scenarios?/i, /seed[_ -]?strategy|estrategia[_ -]?seed/i, /aggregation|agregacao|metricas?/i, /budget|orcamento|limite/i, /stop[_ -]?condition|criterio[_ -]?parada/i], obrigatorio: true, severidade: "blocking" },
+    ],
+    safety: [
+        { id: "simulation_autonomous_safety", descricao: "autonomia declara fronteira, budget, parada, fail-safe e tomada humana", termos: [/autonomous|uncontrolled|autonom/i, /authority[_ -]?boundary|fronteira[_ -]?autoridade/i, /resource[_ -]?budget|orcamento[_ -]?recursos|limite/i, /stop[_ -]?condition|criterio[_ -]?parada|kill[_ -]?switch/i, /fail[_ -]?safe|human[_ -]?takeover|isolamento/i], obrigatorio: true, severidade: "critical" },
+    ],
     atendimento: [
         { id: "conversas_atendimento_estado", descricao: "atendimento declara estado do cliente e proxima acao", termos: [/estado|etapa|sentimento/i, /proxima_acao|proxima acao|encaminhar|resolver/i], obrigatorio: true, severidade: "blocking" },
     ],

package/dist/sistemasInterativos/adapterProtocol.d.ts

@@ -0,0 +1,3 @@
+import type { AdaptadorSistemaInterativo, RegistroProtocoloAdapter, ResultadoValidacaoAdaptadorSistemaInterativo, ResultadoValidacaoProtocoloAdapter } from "./types.js";
+export declare function validarAdaptadorSistemaInterativo(adapter: AdaptadorSistemaInterativo): ResultadoValidacaoAdaptadorSistemaInterativo;
+export declare function validarProtocoloAdapterSistemaInterativo(registro: RegistroProtocoloAdapter): ResultadoValidacaoProtocoloAdapter;

package/dist/sistemasInterativos/adapterProtocol.js

@@ -0,0 +1,240 @@
+// SEMA-GOVERNED: sema.produto.sistemas_interativos.adaptadores
+// Descricao: valida descriptors e registros detect-probe-snapshot-plan sem executar qualquer fase.
+import { digestSha256Valido } from "./canonical.js";
+import { MATRIZ_DOMINIO_SISTEMAS_INTERATIVOS, obterAdaptadorSistemaInterativo } from "./catalog.js";
+const ORDEM_FASES = [
+    "DETECT", "PROBE", "SNAPSHOT", "PLAN", "APPLY", "VALIDATE", "EVIDENCE", "ROLLBACK",
+];
+const BASE_FASES = [
+    "DETECT", "PROBE", "SNAPSHOT", "PLAN", "VALIDATE", "EVIDENCE",
+];
+const VERSOES_FLUTUANTES = new Set(["latest", "next", "dev", "main", "master", "*"]);
+const MARCADOR_CHAVE_SENSIVEL = /password|passwd|senha|secret|token|privatekey|apikey|credential|credencial|chaveprivada|chavesecreta/;
+const VALOR_SENSIVEL = /-----BEGIN (?:RSA |EC |OPENSSH )?PRIVATE KEY-----|\bBearer\s+[A-Za-z0-9._~+/=-]+|\b(?:sk|ghp|github_pat)_[A-Za-z0-9_-]{12,}/i;
+function adicionar(bloqueios, valor) {
+    if (!bloqueios.includes(valor))
+        bloqueios.push(valor);
+}
+function textoOpaco(valor) {
+    return typeof valor === "string" && valor.trim().length > 0 && !/[\u0000-\u001f\u007f]/.test(valor);
+}
+function registroObjeto(valor) {
+    return typeof valor === "object" && valor !== null && !Array.isArray(valor);
+}
+function listaUnicaNaoVazia(valor) {
+    return Array.isArray(valor)
+        && valor.length > 0
+        && valor.every(textoOpaco)
+        && new Set(valor).size === valor.length;
+}
+function chaveSensivel(chave) {
+    const normalizada = chave
+        .normalize("NFKD")
+        .replace(/[\u0300-\u036f]/gu, "")
+        .replace(/[^a-z0-9]/giu, "")
+        .toLowerCase();
+    return MARCADOR_CHAVE_SENSIVEL.test(normalizada);
+}
+function contemDadoSensivel(valor, visitados = new Set()) {
+    if (typeof valor === "string")
+        return VALOR_SENSIVEL.test(valor);
+    if (valor === null || typeof valor !== "object")
+        return false;
+    if (visitados.has(valor))
+        return true;
+    visitados.add(valor);
+    try {
+        if (Array.isArray(valor))
+            return valor.some((item) => contemDadoSensivel(item, visitados));
+        return Object.entries(valor).some(([chave, item]) => chaveSensivel(chave) || contemDadoSensivel(item, visitados));
+    }
+    finally {
+        visitados.delete(valor);
+    }
+}
+function fasesEmOrdem(protocol) {
+    let ultima = -1;
+    for (const fase of protocol) {
+        const indice = ORDEM_FASES.indexOf(fase);
+        if (indice < 0 || indice <= ultima)
+            return false;
+        ultima = indice;
+    }
+    return true;
+}
+export function validarAdaptadorSistemaInterativo(adapter) {
+    const bloqueios = [];
+    const entrada = registroObjeto(adapter) ? adapter : {};
+    if (entrada !== adapter)
+        adicionar(bloqueios, "adapter_invalido");
+    if (!textoOpaco(entrada.adapterId))
+        adicionar(bloqueios, "adapter_id_invalido");
+    if (!textoOpaco(entrada.version) || VERSOES_FLUTUANTES.has(entrada.version.toLowerCase()))
+        adicionar(bloqueios, "adapter_version_nao_fixada");
+    if (!textoOpaco(entrada.engine))
+        adicionar(bloqueios, "adapter_engine_invalida");
+    if (!MATRIZ_DOMINIO_SISTEMAS_INTERATIVOS.adapterRoles.includes(entrada.role))
+        adicionar(bloqueios, "adapter_role_invalido");
+    if (entrada.readOnlyProbe !== true)
+        adicionar(bloqueios, "adapter_probe_deve_ser_read_only");
+    if (typeof entrada.mutatesWorkspace !== "boolean")
+        adicionar(bloqueios, "adapter_mutates_workspace_deve_ser_booleano");
+    if (typeof entrada.supportsRollback !== "boolean")
+        adicionar(bloqueios, "adapter_supports_rollback_deve_ser_booleano");
+    if (entrada.executionBoundary !== "EXTERNAL")
+        adicionar(bloqueios, "adapter_execution_boundary_deve_ser_external");
+    for (const [campo, lista] of [
+        ["kinds", entrada.kinds],
+        ["spatial_models", entrada.spatialModels],
+        ["render_modes", entrada.renderModes],
+        ["visual_profiles", entrada.visualProfiles],
+        ["control_modes", entrada.controlModes],
+        ["time_models", entrada.timeModels],
+        ["fidelities", entrada.fidelities],
+        ["capabilities", entrada.capabilities],
+        ["protocol", entrada.protocol],
+    ]) {
+        if (!listaUnicaNaoVazia(lista))
+            adicionar(bloqueios, `adapter_${campo}_invalidos`);
+    }
+    const vocabularios = [
+        [entrada.kinds, MATRIZ_DOMINIO_SISTEMAS_INTERATIVOS.kinds, "adapter_kind_fora_do_vocabulario"],
+        [entrada.spatialModels, MATRIZ_DOMINIO_SISTEMAS_INTERATIVOS.spatialModels, "adapter_spatial_model_fora_do_vocabulario"],
+        [entrada.renderModes, MATRIZ_DOMINIO_SISTEMAS_INTERATIVOS.renderModes, "adapter_render_mode_fora_do_vocabulario"],
+        [entrada.visualProfiles, MATRIZ_DOMINIO_SISTEMAS_INTERATIVOS.visualProfiles, "adapter_visual_profile_fora_do_vocabulario"],
+        [entrada.controlModes, MATRIZ_DOMINIO_SISTEMAS_INTERATIVOS.controlModes, "adapter_control_mode_fora_do_vocabulario"],
+        [entrada.timeModels, MATRIZ_DOMINIO_SISTEMAS_INTERATIVOS.timeModels, "adapter_time_model_fora_do_vocabulario"],
+        [entrada.fidelities, MATRIZ_DOMINIO_SISTEMAS_INTERATIVOS.fidelities, "adapter_fidelity_fora_do_vocabulario"],
+    ];
+    for (const [valores, permitidos, codigo] of vocabularios) {
+        if (Array.isArray(valores) && !valores.every((valor) => typeof valor === "string" && permitidos.includes(valor))) {
+            adicionar(bloqueios, codigo);
+        }
+    }
+    if (Array.isArray(entrada.protocol)) {
+        if (!fasesEmOrdem(entrada.protocol))
+            adicionar(bloqueios, "adapter_protocol_ordem_invalida");
+        for (const fase of BASE_FASES) {
+            if (!entrada.protocol.includes(fase))
+                adicionar(bloqueios, `adapter_protocol_fase_ausente:${fase}`);
+        }
+        if (entrada.mutatesWorkspace === true) {
+            if (!entrada.protocol.includes("APPLY"))
+                adicionar(bloqueios, "adapter_mutante_sem_apply");
+            if (!entrada.protocol.includes("ROLLBACK"))
+                adicionar(bloqueios, "adapter_mutante_sem_rollback");
+            if (!entrada.supportsRollback)
+                adicionar(bloqueios, "adapter_mutante_sem_suporte_rollback");
+        }
+        else {
+            if (entrada.protocol.includes("APPLY"))
+                adicionar(bloqueios, "adapter_read_only_nao_pode_declarar_apply");
+            if (entrada.protocol.includes("ROLLBACK"))
+                adicionar(bloqueios, "adapter_read_only_nao_pode_declarar_rollback");
+            if (entrada.supportsRollback)
+                adicionar(bloqueios, "adapter_read_only_nao_deve_declarar_rollback");
+        }
+    }
+    if (contemDadoSensivel(entrada))
+        adicionar(bloqueios, "adapter_contem_dado_sensivel");
+    return { valido: bloqueios.length === 0, bloqueios: bloqueios.sort() };
+}
+export function validarProtocoloAdapterSistemaInterativo(registro) {
+    const bloqueios = [];
+    const entrada = registroObjeto(registro) ? registro : {};
+    if (entrada !== registro)
+        adicionar(bloqueios, "registro_protocolo_invalido");
+    if (!textoOpaco(entrada.runId))
+        adicionar(bloqueios, "run_id_invalido");
+    if (!textoOpaco(entrada.adapterId))
+        adicionar(bloqueios, "adapter_id_invalido");
+    if (!textoOpaco(entrada.adapterVersion) || VERSOES_FLUTUANTES.has(entrada.adapterVersion.toLowerCase()))
+        adicionar(bloqueios, "adapter_version_invalida");
+    if (!textoOpaco(entrada.semanticTargetId))
+        adicionar(bloqueios, "semantic_target_id_invalido");
+    if (typeof entrada.mutated !== "boolean")
+        adicionar(bloqueios, "mutated_deve_ser_booleano");
+    if (typeof entrada.success !== "boolean")
+        adicionar(bloqueios, "success_deve_ser_booleano");
+    const phases = Array.isArray(entrada.phases) ? entrada.phases : [];
+    if (phases.length === 0)
+        adicionar(bloqueios, "phases_ausentes_ou_malformadas");
+    const descriptor = textoOpaco(entrada.adapterId) ? obterAdaptadorSistemaInterativo(entrada.adapterId) : undefined;
+    if (!descriptor)
+        adicionar(bloqueios, "registro_adapter_desconhecido");
+    else if (entrada.adapterVersion !== descriptor.version)
+        adicionar(bloqueios, "registro_adapter_version_divergente");
+    const ids = new Set();
+    const fases = [];
+    for (const [indice, itemBruto] of phases.entries()) {
+        if (!registroObjeto(itemBruto)) {
+            adicionar(bloqueios, `phase_malformada_indice:${indice}`);
+            continue;
+        }
+        const item = itemBruto;
+        if (!textoOpaco(item.phaseId))
+            adicionar(bloqueios, "phase_id_invalido");
+        else if (ids.has(item.phaseId))
+            adicionar(bloqueios, `phase_id_duplicado_indice:${indice}`);
+        else
+            ids.add(item.phaseId);
+        if (!ORDEM_FASES.includes(item.phase))
+            adicionar(bloqueios, `phase_invalida_indice:${indice}`);
+        else {
+            fases.push(item.phase);
+            if (descriptor && !descriptor.protocol.includes(item.phase)) {
+                adicionar(bloqueios, `phase_nao_permitida_pelo_adapter_indice:${indice}`);
+            }
+        }
+        if (item.semanticTargetId !== entrada.semanticTargetId)
+            adicionar(bloqueios, `semantic_target_divergente_indice:${indice}`);
+        if (!digestSha256Valido(item.inputDigest))
+            adicionar(bloqueios, `phase_input_digest_invalido_indice:${indice}`);
+        if (!digestSha256Valido(item.outputDigest))
+            adicionar(bloqueios, `phase_output_digest_invalido_indice:${indice}`);
+        if (typeof item.success !== "boolean")
+            adicionar(bloqueios, `phase_success_deve_ser_booleano_indice:${indice}`);
+    }
+    if (fases[0] !== "DETECT")
+        adicionar(bloqueios, "protocolo_deve_iniciar_em_detect");
+    if (new Set(fases).size !== fases.length)
+        adicionar(bloqueios, "phase_tipo_duplicado");
+    if (!fasesEmOrdem(fases))
+        adicionar(bloqueios, "phases_fora_da_ordem_canonica");
+    for (const fase of BASE_FASES) {
+        if (!fases.includes(fase))
+            adicionar(bloqueios, `protocolo_fase_base_ausente:${fase}`);
+    }
+    if (descriptor && !descriptor.mutatesWorkspace && entrada.mutated === true) {
+        adicionar(bloqueios, "adapter_read_only_nao_pode_mutar");
+    }
+    if (entrada.mutated === false && (fases.includes("APPLY") || fases.includes("ROLLBACK"))) {
+        adicionar(bloqueios, "registro_nao_mutante_com_fase_mutante");
+    }
+    const faseSucesso = (fase) => phases.some((item) => (registroObjeto(item) && item.phase === fase && item.success === true));
+    const exigeRollback = entrada.mutated === true && entrada.success === false && !faseSucesso("ROLLBACK");
+    if (entrada.mutated === true && !faseSucesso("APPLY"))
+        adicionar(bloqueios, "mutated_sem_apply_bem_sucedido");
+    if (entrada.success === true) {
+        if (!faseSucesso("VALIDATE"))
+            adicionar(bloqueios, "sucesso_sem_validate");
+        if (!faseSucesso("EVIDENCE"))
+            adicionar(bloqueios, "sucesso_sem_evidence");
+        if (phases.some((item) => !registroObjeto(item) || item.success !== true))
+            adicionar(bloqueios, "sucesso_global_com_fase_falha");
+    }
+    if (exigeRollback)
+        adicionar(bloqueios, "falha_mutante_exige_rollback");
+    if (entrada.mutated === true && entrada.success === false && faseSucesso("ROLLBACK") && !textoOpaco(entrada.rollbackEvidenceId)) {
+        adicionar(bloqueios, "rollback_sem_evidence_id");
+    }
+    if (contemDadoSensivel(entrada))
+        adicionar(bloqueios, "registro_contem_dado_sensivel");
+    return {
+        valido: bloqueios.length === 0,
+        faseAtual: fases.at(-1) ?? "NOT_STARTED",
+        bloqueios: bloqueios.sort(),
+        exigeRollback,
+    };
+}
+//# sourceMappingURL=adapterProtocol.js.map

package/dist/sistemasInterativos/advancedCatalog.d.ts

@@ -0,0 +1,5 @@
+import type { AdaptadorSistemaInterativo, PipelineSistemaInterativo } from "./types.js";
+export declare const CATALOGO_PIPELINES_INTERATIVOS_AVANCADOS: readonly PipelineSistemaInterativo[];
+export declare const CATALOGO_ADAPTADORES_INTERATIVOS_AVANCADOS: readonly AdaptadorSistemaInterativo[];
+export declare function listarPipelinesInterativosAvancados(): readonly PipelineSistemaInterativo[];
+export declare function listarAdaptadoresInterativosAvancados(): readonly AdaptadorSistemaInterativo[];