@semacode/cli 2.1.0 → 2.3.0

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[];