@semacode/cli 2.2.0 → 2.3.0

package/dist/sistemasInterativos/types.d.ts

@@ -0,0 +1,215 @@
+export type JsonPrimitivoSistemaInterativo = string | number | boolean | null;
+export type JsonValorSistemaInterativo = JsonPrimitivoSistemaInterativo | JsonObjetoSistemaInterativo | readonly JsonValorSistemaInterativo[];
+export interface JsonObjetoSistemaInterativo {
+    readonly [chave: string]: JsonValorSistemaInterativo;
+}
+export type KindSistemaInterativo = "GAME" | "SIMULATION" | "HYBRID";
+export type ModeloEspacialSistemaInterativo = "NON_SPATIAL" | "TWO_D" | "TWO_POINT_FIVE_D" | "THREE_D";
+export type ModoRenderSistemaInterativo = "HEADLESS" | "TEXT" | "VISUAL" | "XR";
+export type PerfilVisualSistemaInterativo = "NONE" | "PIXEL_8_BIT" | "PIXEL_16_BIT" | "RASTER" | "VECTOR" | "STYLIZED" | "REALISTIC";
+export type FidelidadeSistemaInterativo = "ARCADE" | "STYLIZED" | "SYSTEMIC" | "REALISTIC" | "CALIBRATED";
+export type ModoControleSistemaInterativo = "HUMAN" | "SCRIPTED" | "AI" | "HYBRID" | "AUTONOMOUS" | "UNCONTROLLED";
+export type ModeloTempoSistemaInterativo = "TURN_BASED" | "FIXED_STEP" | "VARIABLE_STEP" | "REAL_TIME" | "EVENT_DRIVEN" | "BATCH" | "ACCELERATED";
+export type DeterminismoSistemaInterativo = "NONE" | "BEST_EFFORT" | "STOCHASTIC" | "SEEDED" | "STRICT";
+export interface DefinicaoSistemaInterativo {
+    readonly schemaVersion: string;
+    readonly systemId: string;
+    readonly version: string;
+    readonly kind: KindSistemaInterativo;
+    readonly spatialModel: ModeloEspacialSistemaInterativo;
+    readonly renderMode: ModoRenderSistemaInterativo;
+    readonly visualProfile: PerfilVisualSistemaInterativo;
+    readonly fidelity: FidelidadeSistemaInterativo;
+    readonly controlModes: readonly ModoControleSistemaInterativo[];
+    readonly timeModel: ModeloTempoSistemaInterativo;
+    readonly determinism: DeterminismoSistemaInterativo;
+    readonly capabilities: readonly string[];
+    readonly pipelines: readonly string[];
+    readonly adapterTargets: readonly string[];
+    readonly world: JsonObjetoSistemaInterativo;
+    readonly budgets?: JsonObjetoSistemaInterativo;
+    readonly acceptance: JsonObjetoSistemaInterativo;
+}
+export interface ResultadoValidacaoDefinicaoSistemaInterativo {
+    readonly valida: boolean;
+    readonly definitionDigest: string;
+    readonly capabilitiesRequeridas: readonly string[];
+    readonly bloqueios: readonly string[];
+}
+export interface EtapaPipelineSistemaInterativo {
+    readonly stageId: string;
+    readonly capability: string;
+    readonly dependsOn: readonly string[];
+    readonly produces: readonly string[];
+    readonly requiredEvidence: readonly string[];
+}
+export interface PipelineSistemaInterativo {
+    readonly pipelineId: string;
+    readonly version: string;
+    readonly label: string;
+    readonly summary: string;
+    readonly kinds: readonly KindSistemaInterativo[];
+    readonly spatialModels: readonly ModeloEspacialSistemaInterativo[];
+    readonly renderModes: readonly ModoRenderSistemaInterativo[];
+    readonly visualProfiles: readonly PerfilVisualSistemaInterativo[];
+    readonly controlModes: readonly ModoControleSistemaInterativo[];
+    readonly fidelities: readonly FidelidadeSistemaInterativo[];
+    readonly capabilities: readonly string[];
+    readonly stages: readonly EtapaPipelineSistemaInterativo[];
+    readonly requiredEvidence: readonly string[];
+    readonly useWhen: readonly string[];
+    readonly avoidWhen: readonly string[];
+}
+export interface CapabilitySistemaInterativo {
+    readonly capability: string;
+    readonly label: string;
+    readonly summary: string;
+    readonly kinds: readonly KindSistemaInterativo[];
+}
+export type PapelAdaptadorSistemaInterativo = "ENGINE" | "RUNTIME" | "EDITOR" | "ASSET" | "BUILD" | "TELEMETRY" | "VALIDATOR" | "CUSTOM";
+export type FaseProtocoloAdaptador = "DETECT" | "PROBE" | "SNAPSHOT" | "PLAN" | "APPLY" | "VALIDATE" | "EVIDENCE" | "ROLLBACK";
+export interface AdaptadorSistemaInterativo {
+    readonly adapterId: string;
+    readonly version: string;
+    readonly role: PapelAdaptadorSistemaInterativo;
+    readonly engine: string;
+    readonly kinds: readonly KindSistemaInterativo[];
+    readonly spatialModels: readonly ModeloEspacialSistemaInterativo[];
+    readonly renderModes: readonly ModoRenderSistemaInterativo[];
+    readonly visualProfiles: readonly PerfilVisualSistemaInterativo[];
+    readonly controlModes: readonly ModoControleSistemaInterativo[];
+    readonly timeModels: readonly ModeloTempoSistemaInterativo[];
+    readonly fidelities: readonly FidelidadeSistemaInterativo[];
+    readonly capabilities: readonly string[];
+    readonly protocol: readonly FaseProtocoloAdaptador[];
+    readonly readOnlyProbe: true;
+    readonly mutatesWorkspace: boolean;
+    readonly supportsRollback: boolean;
+    readonly executionBoundary: "EXTERNAL";
+}
+export interface FiltrosAdaptadoresSistemasInterativos {
+    readonly kind?: KindSistemaInterativo;
+    readonly spatialModel?: ModeloEspacialSistemaInterativo;
+    readonly renderMode?: ModoRenderSistemaInterativo;
+    readonly visualProfile?: PerfilVisualSistemaInterativo;
+    readonly role?: PapelAdaptadorSistemaInterativo;
+    readonly controlMode?: ModoControleSistemaInterativo;
+    readonly timeModel?: ModeloTempoSistemaInterativo;
+    readonly fidelity?: FidelidadeSistemaInterativo;
+}
+export interface ResultadoListagemAdaptadoresSistemasInterativos {
+    readonly adapters: readonly AdaptadorSistemaInterativo[];
+    readonly filtrosAplicados: FiltrosAdaptadoresSistemasInterativos;
+    readonly executed: false;
+}
+export interface ResultadoValidacaoAdaptadorSistemaInterativo {
+    readonly valido: boolean;
+    readonly bloqueios: readonly string[];
+}
+export interface FaseExecutadaProtocoloAdapter {
+    readonly phaseId: string;
+    readonly phase: FaseProtocoloAdaptador;
+    readonly semanticTargetId: string;
+    readonly inputDigest: string;
+    readonly outputDigest: string;
+    readonly success: boolean;
+}
+export interface RegistroProtocoloAdapter {
+    readonly runId: string;
+    readonly adapterId: string;
+    readonly adapterVersion: string;
+    readonly semanticTargetId: string;
+    readonly phases: readonly FaseExecutadaProtocoloAdapter[];
+    readonly mutated: boolean;
+    readonly success: boolean;
+    readonly rollbackEvidenceId?: string;
+}
+export interface ResultadoValidacaoProtocoloAdapter {
+    readonly valido: boolean;
+    readonly faseAtual: FaseProtocoloAdaptador | "NOT_STARTED";
+    readonly bloqueios: readonly string[];
+    readonly exigeRollback: boolean;
+}
+export interface InstanciaEtapaSistemaInterativo extends EtapaPipelineSistemaInterativo {
+    readonly pipelineId: string;
+    readonly stageInstanceId: string;
+}
+export interface InstanciaPipelineSistemaInterativo {
+    readonly pipelineId: string;
+    readonly version: string;
+    readonly stageInstanceIds: readonly string[];
+    readonly requiredEvidence: readonly string[];
+}
+export interface ProvedorEtapaSistemaInterativo {
+    readonly stageInstanceId: string;
+    readonly capability: string;
+    readonly candidateAdapterIds: readonly string[];
+    readonly selectedAdapterIds: readonly string[];
+    readonly coveredBySelection: boolean;
+}
+export interface PlanoSistemaInterativo {
+    readonly systemId: string;
+    readonly definitionDigest: string;
+    readonly planDigest: string;
+    readonly capabilitiesRequeridas: readonly string[];
+    readonly capabilitiesAusentes: readonly string[];
+    readonly pipelines: readonly InstanciaPipelineSistemaInterativo[];
+    readonly adaptersCompativeis: readonly string[];
+    readonly adaptersSelecionados: readonly string[];
+    readonly adapterSelectionExplicit: boolean;
+    readonly adapterCoverageComplete: boolean;
+    readonly capabilitiesSemAdapter: readonly string[];
+    readonly stageProviderMap: readonly ProvedorEtapaSistemaInterativo[];
+    readonly stages: readonly InstanciaEtapaSistemaInterativo[];
+    readonly nextActions: readonly string[];
+    readonly executed: false;
+}
+export interface ResultadoPlanejamentoSistemaInterativo {
+    readonly plano: PlanoSistemaInterativo;
+    readonly bloqueios: readonly string[];
+}
+export interface ObservacaoSistemaInterativo {
+    readonly evidenceId: string;
+    readonly evidenceType: string;
+    readonly stageId: string;
+    readonly semanticTargetId: string;
+    readonly producerAdapterId: string;
+    readonly producerAdapterVersion: string;
+    readonly artifactDigest: string;
+    readonly observedAt: string;
+    readonly source: string;
+    readonly data: JsonObjetoSistemaInterativo;
+}
+export interface BundleEvidenciasSistemaInterativo {
+    readonly schemaVersion: string;
+    readonly runId: string;
+    readonly systemId: string;
+    readonly definitionDigest: string;
+    readonly planDigest: string;
+    readonly observations: readonly ObservacaoSistemaInterativo[];
+}
+export interface ResultadoValidacaoBundleEvidenciasSistemaInterativo {
+    readonly valido: boolean;
+    readonly evidenciasAceitas: readonly string[];
+    readonly evidenciasAusentes: readonly string[];
+    readonly bloqueios: readonly string[];
+}
+export type StatusSistemaInterativo = "INVALID" | "PLANNED" | "READY" | "RUNNING" | "WAITING_EVIDENCE" | "BLOCKED" | "STRUCTURALLY_COMPLETE";
+export interface EstadoEtapaSistemaInterativo {
+    readonly stageId: string;
+    readonly status: "WAITING_EVIDENCE" | "STRUCTURALLY_COMPLETE";
+    readonly evidenciasAusentes: readonly string[];
+}
+export interface EstadoSistemaInterativo {
+    readonly status: StatusSistemaInterativo;
+    readonly stages: readonly EstadoEtapaSistemaInterativo[];
+    readonly evidenciasAceitas: readonly string[];
+    readonly evidenciasAusentes: readonly string[];
+    readonly bloqueios: readonly string[];
+    readonly nextActions: readonly string[];
+    readonly completed: false;
+    readonly localCoverageComplete: boolean;
+    readonly awaitingExternalAttestation: true;
+    readonly completionScope: "STRUCTURAL_LOCAL";
+    readonly authoritative: false;
+}

package/dist/sistemasInterativos/types.js

@@ -0,0 +1,4 @@
+// SEMA-GOVERNED: sema.produto.sistemas_interativos + adaptadores + evidencias
+// Descricao: tipos publicos do control plane declarativo para jogos e simulacoes.
+export {};
+//# sourceMappingURL=types.js.map

package/dist/sistemasInterativos/validator.d.ts

@@ -0,0 +1,2 @@
+import type { DefinicaoSistemaInterativo, ResultadoValidacaoDefinicaoSistemaInterativo } from "./types.js";
+export declare function validarDefinicaoSistemaInterativo(definicao: DefinicaoSistemaInterativo): ResultadoValidacaoDefinicaoSistemaInterativo;

package/dist/sistemasInterativos/validator.js

@@ -0,0 +1,305 @@
+// SEMA-GOVERNED: sema.produto.sistemas_interativos
+// Descricao: validacao deterministica de definicoes sem executar engine, editor, runner ou adapter.
+import { digestJsonSistemaInterativo } from "./canonical.js";
+import { MATRIZ_DOMINIO_SISTEMAS_INTERATIVOS, obterAdaptadorSistemaInterativo, obterPipelineSistemaInterativo, } from "./catalog.js";
+const VERSOES_FLUTUANTES = new Set(["latest", "next", "dev", "main", "master", "*"]);
+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 identificadorSeguro(valor) {
+    return textoOpaco(valor)
+        && valor.length <= 128
+        && /^[A-Za-z0-9][A-Za-z0-9._:-]*$/.test(valor)
+        && !VALOR_SENSIVEL.test(valor);
+}
+function objeto(valor) {
+    return valor !== null && typeof valor === "object" && !Array.isArray(valor);
+}
+function valorDeclarado(valor) {
+    if (typeof valor === "string")
+        return valor.trim().length > 0;
+    if (Array.isArray(valor))
+        return valor.length > 0;
+    if (objeto(valor))
+        return Object.keys(valor).length > 0;
+    return valor !== undefined && valor !== null;
+}
+function campoDeclarado(alvo, campo) {
+    return valorDeclarado(alvo[campo]);
+}
+function inteiroPositivo(valor) {
+    return typeof valor === "number" && Number.isSafeInteger(valor) && valor > 0;
+}
+function dimensaoPixelValida(valor) {
+    if (inteiroPositivo(valor))
+        return true;
+    if (typeof valor === "string") {
+        return /^[1-9]\d{0,4}x[1-9]\d{0,4}(?:\s+(?:and|to)\s+[1-9]\d{0,4}x[1-9]\d{0,4})?$/i.test(valor);
+    }
+    if (Array.isArray(valor))
+        return valor.length === 2 && valor.every(inteiroPositivo);
+    if (objeto(valor))
+        return inteiroPositivo(valor.width) && inteiroPositivo(valor.height);
+    return false;
+}
+function listaTextosUnicos(valor, permiteVazia = true) {
+    if (!Array.isArray(valor) || (!permiteVazia && valor.length === 0))
+        return false;
+    if (!valor.every(textoOpaco))
+        return false;
+    return new Set(valor).size === valor.length;
+}
+function slugCapability(valor) {
+    return valor.toLowerCase().replace(/two_point_five/g, "2_5").replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+}
+function capabilitiesEstruturais(definicao) {
+    const capabilities = ["interactive.world.model", "interactive.state.model"];
+    const eixos = [
+        ["kind", definicao.kind, MATRIZ_DOMINIO_SISTEMAS_INTERATIVOS.kinds],
+        ["spatial", definicao.spatialModel, MATRIZ_DOMINIO_SISTEMAS_INTERATIVOS.spatialModels],
+        ["render", definicao.renderMode, MATRIZ_DOMINIO_SISTEMAS_INTERATIVOS.renderModes],
+        ["visual", definicao.visualProfile, MATRIZ_DOMINIO_SISTEMAS_INTERATIVOS.visualProfiles],
+        ["fidelity", definicao.fidelity, MATRIZ_DOMINIO_SISTEMAS_INTERATIVOS.fidelities],
+        ["time", definicao.timeModel, MATRIZ_DOMINIO_SISTEMAS_INTERATIVOS.timeModels],
+        ["determinism", definicao.determinism, MATRIZ_DOMINIO_SISTEMAS_INTERATIVOS.determinisms],
+    ];
+    for (const [eixo, valor, permitidos] of eixos) {
+        if (typeof valor === "string" && permitidos.includes(valor))
+            capabilities.push(`interactive.${eixo}.${slugCapability(valor)}`);
+    }
+    for (const modo of Array.isArray(definicao.controlModes) ? definicao.controlModes : []) {
+        if (!MATRIZ_DOMINIO_SISTEMAS_INTERATIVOS.controlModes.includes(modo))
+            continue;
+        capabilities.push(`interactive.control.${slugCapability(modo)}`);
+    }
+    for (const pipelineId of Array.isArray(definicao.pipelines) ? definicao.pipelines : []) {
+        const pipeline = obterPipelineSistemaInterativo(pipelineId);
+        if (pipeline)
+            capabilities.push(...pipeline.capabilities);
+    }
+    return [...new Set(capabilities)].sort();
+}
+function validarBase(definicao, bloqueios) {
+    if (definicao.schemaVersion !== "1.0")
+        adicionar(bloqueios, "schema_version_nao_suportada");
+    if (!identificadorSeguro(definicao.systemId))
+        adicionar(bloqueios, "system_id_invalido");
+    if (!textoOpaco(definicao.version) || VERSOES_FLUTUANTES.has(definicao.version.toLowerCase())) {
+        adicionar(bloqueios, "version_nao_fixada");
+    }
+    if (!MATRIZ_DOMINIO_SISTEMAS_INTERATIVOS.kinds.includes(definicao.kind))
+        adicionar(bloqueios, "kind_invalido");
+    if (!MATRIZ_DOMINIO_SISTEMAS_INTERATIVOS.spatialModels.includes(definicao.spatialModel))
+        adicionar(bloqueios, "spatial_model_invalido");
+    if (!MATRIZ_DOMINIO_SISTEMAS_INTERATIVOS.renderModes.includes(definicao.renderMode))
+        adicionar(bloqueios, "render_mode_invalido");
+    if (!MATRIZ_DOMINIO_SISTEMAS_INTERATIVOS.visualProfiles.includes(definicao.visualProfile))
+        adicionar(bloqueios, "visual_profile_invalido");
+    if (!MATRIZ_DOMINIO_SISTEMAS_INTERATIVOS.fidelities.includes(definicao.fidelity))
+        adicionar(bloqueios, "fidelity_invalida");
+    if (!MATRIZ_DOMINIO_SISTEMAS_INTERATIVOS.timeModels.includes(definicao.timeModel))
+        adicionar(bloqueios, "time_model_invalido");
+    if (!MATRIZ_DOMINIO_SISTEMAS_INTERATIVOS.determinisms.includes(definicao.determinism))
+        adicionar(bloqueios, "determinism_invalido");
+    if (!listaTextosUnicos(definicao.controlModes, false))
+        adicionar(bloqueios, "control_modes_invalidos");
+    else if (!definicao.controlModes.every((modo) => MATRIZ_DOMINIO_SISTEMAS_INTERATIVOS.controlModes.includes(modo))) {
+        adicionar(bloqueios, "control_mode_fora_do_vocabulario");
+    }
+    if (!listaTextosUnicos(definicao.capabilities))
+        adicionar(bloqueios, "capabilities_invalidas");
+    if (!listaTextosUnicos(definicao.pipelines, false))
+        adicionar(bloqueios, "pipelines_invalidos_ou_ausentes");
+    if (!listaTextosUnicos(definicao.adapterTargets))
+        adicionar(bloqueios, "adapter_targets_invalidos");
+    if (!objeto(definicao.world))
+        adicionar(bloqueios, "world_invalido");
+    if (!objeto(definicao.acceptance))
+        adicionar(bloqueios, "acceptance_invalida");
+    if (definicao.budgets !== undefined && !objeto(definicao.budgets))
+        adicionar(bloqueios, "budgets_invalidos");
+}
+function validarEixos(definicao, bloqueios) {
+    const visual = definicao.visualProfile;
+    if ((definicao.renderMode === "HEADLESS" || definicao.renderMode === "TEXT") && visual !== "NONE") {
+        adicionar(bloqueios, "render_nao_visual_exige_visual_profile_none");
+    }
+    if ((definicao.renderMode === "VISUAL" || definicao.renderMode === "XR") && visual === "NONE") {
+        adicionar(bloqueios, "render_visual_exige_visual_profile");
+    }
+    if (definicao.renderMode === "XR" && definicao.spatialModel !== "THREE_D") {
+        adicionar(bloqueios, "render_xr_exige_spatial_model_three_d");
+    }
+    if (visual === "PIXEL_8_BIT" || visual === "PIXEL_16_BIT") {
+        const budgets = definicao.budgets;
+        if (!objeto(budgets)) {
+            adicionar(bloqueios, "pixel_profile_exige_budgets");
+            return;
+        }
+        for (const campo of ["paletteColors", "baseResolution", "tileSize", "spriteSize", "memoryBudgetBytes", "audioProfile"]) {
+            if (!campoDeclarado(budgets, campo))
+                adicionar(bloqueios, `pixel_budget_ausente:${campo}`);
+        }
+        const paletteColors = budgets.paletteColors;
+        if (typeof paletteColors !== "number" || !Number.isInteger(paletteColors) || paletteColors <= 0) {
+            adicionar(bloqueios, "pixel_palette_invalida");
+        }
+        else if (visual === "PIXEL_8_BIT" && paletteColors > 256) {
+            adicionar(bloqueios, "pixel_8_bit_palette_excede_256");
+        }
+        else if (visual === "PIXEL_16_BIT" && paletteColors > 65_536) {
+            adicionar(bloqueios, "pixel_16_bit_palette_excede_65536");
+        }
+        if (!dimensaoPixelValida(budgets.baseResolution))
+            adicionar(bloqueios, "pixel_base_resolution_invalida");
+        if (!dimensaoPixelValida(budgets.tileSize))
+            adicionar(bloqueios, "pixel_tile_size_invalido");
+        if (!dimensaoPixelValida(budgets.spriteSize))
+            adicionar(bloqueios, "pixel_sprite_size_invalido");
+        if (!inteiroPositivo(budgets.memoryBudgetBytes))
+            adicionar(bloqueios, "pixel_memory_budget_invalido");
+        if (!textoOpaco(budgets.audioProfile))
+            adicionar(bloqueios, "pixel_audio_profile_invalido");
+    }
+    if (objeto(definicao.world) && definicao.spatialModel === "THREE_D") {
+        for (const campo of ["units", "scale", "coordinateSystem"]) {
+            if (!campoDeclarado(definicao.world, campo))
+                adicionar(bloqueios, `world_3d_ausente:${campo}`);
+        }
+    }
+    if (objeto(definicao.world) && (definicao.spatialModel === "TWO_D" || definicao.spatialModel === "TWO_POINT_FIVE_D")) {
+        if (!campoDeclarado(definicao.world, "grid") && !campoDeclarado(definicao.world, "coordinateSystem")) {
+            adicionar(bloqueios, "world_2d_exige_grid_ou_coordinate_system");
+        }
+    }
+}
+function validarWorld(definicao, bloqueios) {
+    if (!objeto(definicao.world))
+        return;
+    for (const campo of ["identity", "state", "time", "events", "initialConditions"]) {
+        if (!campoDeclarado(definicao.world, campo))
+            adicionar(bloqueios, `world_campo_ausente:${campo}`);
+    }
+    if (definicao.kind === "GAME" || definicao.kind === "HYBRID") {
+        for (const campo of ["loop", "objective", "successConditions", "failureConditions", "rules"]) {
+            if (!campoDeclarado(definicao.world, campo))
+                adicionar(bloqueios, `game_world_ausente:${campo}`);
+        }
+    }
+    if (definicao.kind === "SIMULATION" || definicao.kind === "HYBRID") {
+        for (const campo of ["model", "assumptions", "boundaryConditions", "outputs", "validation"]) {
+            if (!campoDeclarado(definicao.world, campo))
+                adicionar(bloqueios, `simulation_world_ausente:${campo}`);
+        }
+    }
+    if (definicao.determinism === "SEEDED" || definicao.determinism === "STRICT") {
+        for (const campo of ["seed", "snapshot", "replay", "step"]) {
+            if (!campoDeclarado(definicao.world, campo))
+                adicionar(bloqueios, `determinism_world_ausente:${campo}`);
+        }
+    }
+    if (Array.isArray(definicao.controlModes) && definicao.controlModes.some((modo) => modo === "AUTONOMOUS" || modo === "UNCONTROLLED")) {
+        for (const campo of ["stopCriteria", "safetyConstraints"]) {
+            if (!campoDeclarado(definicao.world, campo))
+                adicionar(bloqueios, `autonomia_world_ausente:${campo}`);
+        }
+    }
+}
+function validarAceitacao(definicao, bloqueios) {
+    if (!objeto(definicao.acceptance))
+        return;
+    if (definicao.fidelity === "REALISTIC" || definicao.fidelity === "CALIBRATED") {
+        for (const campo of ["reference", "calibration", "tolerances", "uncertainty", "telemetry"]) {
+            if (!campoDeclarado(definicao.acceptance, campo))
+                adicionar(bloqueios, `realistic_acceptance_ausente:${campo}`);
+        }
+    }
+}
+function validarPipelinesEAdapters(definicao, bloqueios) {
+    const pipelines = Array.isArray(definicao.pipelines) ? definicao.pipelines : [];
+    for (const [indice, pipelineId] of pipelines.entries()) {
+        const pipeline = obterPipelineSistemaInterativo(pipelineId);
+        if (!pipeline) {
+            adicionar(bloqueios, `pipeline_desconhecido_indice:${indice}`);
+            continue;
+        }
+        if (!pipeline.kinds.includes(definicao.kind))
+            adicionar(bloqueios, `pipeline_kind_incompativel_indice:${indice}`);
+        if (!pipeline.spatialModels.includes(definicao.spatialModel))
+            adicionar(bloqueios, `pipeline_spatial_model_incompativel_indice:${indice}`);
+        if (!pipeline.renderModes.includes(definicao.renderMode))
+            adicionar(bloqueios, `pipeline_render_mode_incompativel_indice:${indice}`);
+        if (!pipeline.visualProfiles.includes(definicao.visualProfile))
+            adicionar(bloqueios, `pipeline_visual_profile_incompativel_indice:${indice}`);
+        const modos = Array.isArray(definicao.controlModes) ? definicao.controlModes : [];
+        if (!modos.some((modo) => pipeline.controlModes.includes(modo)))
+            adicionar(bloqueios, `pipeline_control_mode_incompativel_indice:${indice}`);
+        if (!pipeline.fidelities.includes(definicao.fidelity))
+            adicionar(bloqueios, `pipeline_fidelity_incompativel_indice:${indice}`);
+    }
+    for (const [indice, adapterId] of (Array.isArray(definicao.adapterTargets) ? definicao.adapterTargets : []).entries()) {
+        if (!obterAdaptadorSistemaInterativo(adapterId))
+            adicionar(bloqueios, `adapter_target_desconhecido_indice:${indice}`);
+    }
+    const exigeSafety = Array.isArray(definicao.controlModes)
+        && definicao.controlModes.some((modo) => modo === "AUTONOMOUS" || modo === "UNCONTROLLED");
+    const pipelinesSafety = definicao.kind === "GAME"
+        ? ["interactive.safety"]
+        : ["interactive.safety", "simulation.safety"];
+    if (exigeSafety && !pipelinesSafety.some((pipelineId) => pipelines.includes(pipelineId))) {
+        adicionar(bloqueios, "autonomia_exige_pipeline_safety_compativel");
+    }
+    const exigeCalibracao = definicao.fidelity === "REALISTIC" || definicao.fidelity === "CALIBRATED";
+    const pipelinesCalibracao = definicao.kind === "GAME"
+        ? ["interactive.calibrate"]
+        : ["interactive.calibrate", "simulation.calibrate"];
+    if (exigeCalibracao && !pipelinesCalibracao.some((pipelineId) => pipelines.includes(pipelineId))) {
+        adicionar(bloqueios, "fidelity_exige_pipeline_calibrate_compativel");
+    }
+    if ((definicao.determinism === "SEEDED" || definicao.determinism === "STRICT")
+        && !pipelines.includes("interactive.replay")) {
+        adicionar(bloqueios, "determinism_exige_pipeline_interactive_replay");
+    }
+}
+function validarCapabilitiesControle(definicao, bloqueios) {
+    const declaradas = new Set(Array.isArray(definicao.capabilities) ? definicao.capabilities : []);
+    for (const modo of Array.isArray(definicao.controlModes) ? definicao.controlModes : []) {
+        if (!MATRIZ_DOMINIO_SISTEMAS_INTERATIVOS.controlModes.includes(modo))
+            continue;
+        const capability = `interactive.control.${slugCapability(modo)}`;
+        if (!declaradas.has(capability))
+            adicionar(bloqueios, "capability_controle_ausente");
+    }
+}
+export function validarDefinicaoSistemaInterativo(definicao) {
+    const bloqueios = [];
+    let definitionDigest;
+    try {
+        definitionDigest = digestJsonSistemaInterativo(definicao);
+    }
+    catch {
+        definitionDigest = digestJsonSistemaInterativo({ definicaoInvalida: true });
+        adicionar(bloqueios, "definicao_nao_canonica");
+    }
+    const entrada = objeto(definicao) ? definicao : {};
+    if (entrada !== definicao)
+        adicionar(bloqueios, "definicao_invalida");
+    validarBase(entrada, bloqueios);
+    validarEixos(entrada, bloqueios);
+    validarWorld(entrada, bloqueios);
+    validarAceitacao(entrada, bloqueios);
+    validarPipelinesEAdapters(entrada, bloqueios);
+    validarCapabilitiesControle(entrada, bloqueios);
+    return {
+        valida: bloqueios.length === 0,
+        definitionDigest,
+        capabilitiesRequeridas: capabilitiesEstruturais(entrada),
+        bloqueios: [...bloqueios].sort(),
+    };
+}
+//# sourceMappingURL=validator.js.map

package/docs/README.md

@@ -17,6 +17,12 @@ Start here:
 - [Commands](./commands.md)
 - [Syntax](./syntax.md)
 - [Profiles](./profiles.md)
+- [Capability Discovery](./descoberta-capacidades.md) — one explainable catalog
+  for governance flows, profiles, specialized workflows, pipelines, generators,
+  capability tokens, and adapters.
+- [AI-native Interactive Systems](./sistemas-interativos.md) — declarative
+  control plane for games, simulations, and hybrids across 3D, 2D, retro,
+  text, XR, and headless execution.
 - [AI-native Content Pipeline](./pipeline-conteudo.md) — signed-policy,
   multi-channel and multi-format orchestration for external AI runners, with
   canonical ledger replay and no native human-review path.

package/docs/ai-integration.md

@@ -73,6 +73,12 @@ Generated or governed code should keep a short `SEMA-GOVERNED` marker that
 points back to the applicable contract. The marker is not a substitute for
 validation, drift, impact, or finalization gates.
 
+Generated Lua tests preserve the contract's failure shape. A case whose only
+expectation is `sucesso: falso` may terminate without an output, while a case
+that also declares observable output fields must return a structured failure
+result. The generator keeps these paths distinct instead of forcing every
+failure into one representation.
+
 Governed code above 1000 lines requires a
 split plan. Governed code above 2000
 lines blocks closure. Markdown documentation is not counted as governed code
@@ -106,4 +112,4 @@ user-facing experience, closure requires evidence:
 ## Platform Policy
 
 Sema governs contract, scope, drift, evidence, and quality. It does not bypass
-platform policies, terms of use, permissions, security controls, or laws.
+platform policies, terms of use, permissions, security controls, or laws.

package/docs/ai-workflow.md

@@ -9,10 +9,11 @@ This is the minimum workflow for Codex in a local workspace.
 4. Run `sema docs-impacto --intencao "<change>" --json`.
 5. Read every required document returned by the command.
 6. Read `docs/commands.md` before selecting a command or interpreting `--saida`.
-7. Use `exemplos/` and `docs/syntax.md` before creating or editing a contract.
-8. Run `sema drift` and `sema impacto` before editing existing code.
-9. Run `sema formatar` and `sema validar` after changing a `.sema` contract.
-10. Run `sema finalizar-mudanca` with the documents read before closure.
+7. If the right capability is unclear, run `sema descobrir recomendar --intencao "<goal>" --json`; do not auto-run ambiguous recommendations.
+8. Use `exemplos/` and `docs/syntax.md` before creating or editing a contract.
+9. Run `sema drift` and `sema impacto` before editing existing code.
+10. Run `sema formatar` and `sema validar` after changing a `.sema` contract.
+11. Run `sema finalizar-mudanca` with the documents read before closure.
 
 Contract edit rule: `.sema` has its own size budget. Above 300 lines, plan a split by domain/capability; above 500, do not create or edit before splitting. Do not use parte_1/parte_2 and do not force a 1:1 contract-to-file relationship; several contracts can govern the same file through `vinculos`.
 

package/docs/commands.md

@@ -22,6 +22,10 @@ Then read every required doc returned by `docs-impacto`.
 - `sema inspecionar <arquivo-ou-pasta> --json`: shows modules, tasks, routes, entities, links, and expected files.
 - `sema ast <arquivo.sema> --json`: shows AST for syntax debugging.
 - `sema ir <arquivo.sema> --json`: shows the IR used by gates and generators.
+- `sema descobrir catalogo --json`: lists governance flows, profiles, specialized workflows, pipelines, generators, capability tokens, and adapters from their canonical registries.
+- `sema descobrir recomendar --intencao "<goal>" --json`: ranks compatible capabilities deterministically without executing the selected command.
+- `sema descobrir explicar <id> --json`: explains inputs, boundaries, reasons, and the command template for one capability.
+- `sema pipeline listar|descrever <id> --json` and `sema capabilities --json`: compact projections of the same discovery catalog.
 
 ## Change and Closure
 
@@ -67,10 +71,48 @@ Ready UI rule: if the task generates an app, site, dashboard, form, or static HT
 ## Profiles and Author
 
 - `sema author iniciar|validar|briefing|revisar-cliches|validar-narrativa|validar-proibicoes`: governs authorial writing.
-- `sema profile validar <software|workflow|ops|game|legal|research|redacao|propostas|conversas> <arquivo> --json`: validates an artifact by profile.
+- `sema profile validar <software|workflow|ops|game|simulation|legal|research|redacao|propostas|conversas> <arquivo> --json`: validates an artifact by profile.
 - `sema profile capabilities --json`: lists profiles/capabilities.
 - `sema rule-packs --profile <profile> --json`: lists rule packs.
 
+`author` is a specialized `sema author` workflow, not a `profile validar` alias. Discovery exposes that distinction explicitly.
+
+## AI-native Content Pipeline
+
+- `sema conteudo capabilities --json`: lists generic producer, evaluator, and adapter capabilities without fixing a platform.
+- `sema conteudo validar <definition.json> --json`: validates the content DAG, gates, and open adapters.
+- `sema conteudo planejar <definition.json> --alvos-arquivo <targets.json> --json`: creates a declarative multi-target plan for an external runner.
+- `sema conteudo validar-envelope --envelope-arquivo <envelope.json> --confianca-arquivo <trust.json> --trust-root-digest <sha256:...> --revocation-digest <sha256:...> --payload-type <type> --json`: verifies Ed25519 identity, authorization, freshness, scope, and the separately pinned trust root and current revocation overlay.
+- `sema conteudo registrar <ledger.ndjson> --envelope-arquivo <envelope.json> --politica-arquivo <policy-envelope.json> --confianca-arquivo <trust.json> --trust-root-digest <sha256:...> --revocation-digest <sha256:...> --ledger-id <id> --expected-head <sha256:...> --json`: appends a verified envelope under the signed run policy to the local replay ledger at an externally retained head.
+- `sema conteudo status <definition.json> --politica-arquivo <policy-envelope.json> --confianca-arquivo <trust.json> --trust-root-digest <sha256:...> --revocation-digest <sha256:...> --ledger-arquivo <ledger.ndjson> --expected-head <sha256:...> --json`: verifies the signed policy and its `targetSetDigest`, then derives verdicts, operational conditions, completion, and next actions from canonical events.
+- `sema conteudo projetar <definition.json> --politica-arquivo <policy-envelope.json> --confianca-arquivo <trust.json> --trust-root-digest <sha256:...> --revocation-digest <sha256:...> --ledger-arquivo <ledger.ndjson> --expected-head <sha256:...> --saida <manifest.json> --json`: regenerates a non-authoritative manifest bound to the ledger head.
+
+The content command is an AI-native, multi-channel, multi-format control plane. It never runs producers, evaluators, creative tools, or publication adapters; those belong to an external runner. It has no native human-review transition. A signed policy binds `runId`, definition, ledger, trust root, gates, complete target set, and the full `issuedAt`/`expiresAt` authorization window; no event may be recorded outside it. Stages select `adapterPolicy` as `NONE`, `CONSTRAINTS`, or `CONFIRMATION`; definition v1 accepts one output per stage. Constraint results must come from independent signed observations, including independently observed media type, not artifact metadata or executor claims. Target metadata is an exact scalar allowlist from `requiredMetadata + optionalMetadata`; `accountScope` is a credential-free `account:<alias>` reference, and artifact metadata is prohibited in v1. Deterministic evidence and AI opinions have separate quorum fields. Evidence requires an exact `content.evidence.attest:<evidenceType>` capability; adapter evidence requires `content.adapter.attest:<adapterId>@<version>:<evidenceType>` plus signed adapter binding.
+
+Verdicts such as `APROVADO`, `REPROVADO`, and `INCONCLUSIVO` remain separate from operational conditions such as `AGUARDANDO_EVENTO_EXTERNO` and `FERRAMENTA_INDISPONIVEL`. A generated manifest is only a projection and cannot alter canonical state.
+
+Local NDJSON plus a hash chain is portable evidence for replay, not a strong append-only trust boundary. Retain `expectedHead`, the canonical trust-root digest, and the current revocation digest externally, or use protected storage for high assurance. The trust-root pin identifies the authority snapshot independently from the revocation overlay. A workspace-local trust file additionally requires `--development-local-trust`; the flag does not disable digest pinning. Append freshness uses the platform clock rather than caller-provided `recordedAt`, and an authority in the current revocation overlay cannot sign an accepted policy.
+
+## AI-native Interactive Systems
+
+- `sema interativo capabilities --json`: lists the canonical interactive capability vocabulary.
+- `sema interativo schema --json`: exposes the stable read-only definition schema, enum matrix, constraints, extension-command and data-schema shapes, plus canonical example paths for AI clients.
+- `sema interativo pipelines --json`: lists reusable game, simulation, and hybrid pipelines.
+- `sema interativo adapters [--spatial-model <NON_SPATIAL|TWO_D|TWO_POINT_FIVE_D|THREE_D>] [--render-mode <HEADLESS|TEXT|VISUAL|XR>] --json`: lists compatible external adapter descriptors.
+- `sema interativo validar <definition.json> --json`: validates independent kind, spatial model, render mode, visual profile, fidelity, control, time, world, budget, pipeline, and acceptance axes.
+- `sema interativo planejar <definition.json> --json`: expands compatible stages and required evidence without running an engine.
+- `sema interativo validar-evidencias|status <definition.json> [--plano-arquivo <plan.json>] --bundle-arquivo <bundle.json> --json`: validates a portable evidence bundle or derives non-authoritative status; `--evidencias-arquivo` is an alias and an omitted plan is recomputed deterministically.
+- `sema interativo validar-protocolo <adapter-run.json> --json`: checks DETECT/PROBE/SNAPSHOT/PLAN/APPLY/VALIDATE/EVIDENCE/ROLLBACK ordering and stable target binding.
+- Experience IR: `validar-ir`, `indexar-ir`, `consultar-ir --semantic-id <id>`, `chunk-ir --semantic-id <id> [--raso]`, and `descrever-ir`.
+- Operational state: `validar-engine-snapshot`, `diff-engine-snapshots`, `validar-asset-provenance`, `validar-editor-state`, `planejar-jobs`, `validar-acceptance`, `operar-acceptance --operation <VALIDATE|EVALUATE|INVALIDATE> --context-file <file>`, and `validar-multimodal`.
+- Temporal, autonomy, and testing: `validar-temporal`, `validar-evidencia-temporal --bundle-arquivo <file>`, `validar-autonomia`, `validar-playtest-fuzz`, and `validar-multiplayer`.
+- Portability and workers: `analisar-portabilidade` and `validar-workers`.
+- `sema interativo validar-control-run <control-run.json> --definition-arquivo <definition.json> --plano-arquivo <plan.json> --contrato-arquivo <validation-contract.json> --entrada-arquivo <input.json> [--entrada-auxiliar-arquivo <supporting-input.json>] --evidencia-arquivo <evidence.json> --resultado-arquivo <result.json> --json`: binds one advanced validation to its complete local digest chain instead of trusting a standalone result.
+
+The control-run command recomputes the canonical plan and selected pure validator, then verifies the definition, pipeline descriptor, validation contract, schema-declared inputs, evidence, and result digests. Prefix advanced items with `sema interativo` and pass the documented JSON file as the positional argument; an agent does not have to infer the validator or payload shape from a filename or visual style. The machine-readable schema publishes command maps, input/output schema links, required top-level fields, `outputTargets` path segments from the payload root, at least one real output shape per command, and official fixtures for all 20 advanced commands. Validation-result shapes describe `payload.resultado`; projected IR values use `indice`, `entry`, `chunk`, or `descriptor`; operation projections such as `engineDiff` and `jobOrchestrationPlan` live under `payload.resultado.value`; the job plan's ordered `queue` is the assignment list and exposes kind, priority, adapter, dependencies, locks, budgets, heartbeat, checkpoint, and recovery data.
+
+Spatial model and render mode are orthogonal: `THREE_D + HEADLESS` is valid, while XR requires `THREE_D`. `PIXEL_8_BIT` and `PIXEL_16_BIT` are independent visual profiles available to games and simulations. Every command above rejects unknown, duplicate, missing-value, or invalid-enum arguments, remains local, read-only, and non-authoritative, and leaves engine/editor execution, authorization, mutation, rollback, migration, rendering, playtest, and worker scheduling to external runners. Full local coverage is `STRUCTURALLY_COMPLETE`, never authoritative completion, and a local evidence bundle is never presented as authoritative trust.
+
 ## Operational
 
 - `sema doctor`: diagnoses local installation.