@semacode/cli 2.1.0 → 2.3.0

package/dist/pipelineConteudo/types.d.ts

@@ -0,0 +1,331 @@
+export type JsonPrimitivo = string | number | boolean | null;
+export type JsonValor = JsonPrimitivo | JsonObjeto | readonly JsonValor[];
+export interface JsonObjeto {
+    readonly [chave: string]: JsonValor;
+}
+export interface MetadataPublicaConteudo {
+    readonly [chave: string]: JsonPrimitivo;
+}
+export type VereditoConteudo = "NAO_AVALIADO" | "APROVADO" | "REPROVADO" | "INCONCLUSIVO";
+export type EstadoEvidenciaConteudo = "DECLARADA" | "ACEITA" | "REJEITADA" | "EXPIRADA" | "REVOGADA" | "SUPERADA";
+export type ModoAvaliacaoConteudo = "DETERMINISTICA" | "IA_ESPECIALIZADA" | "HIBRIDA";
+export type CondicaoOperacionalConteudo = "PENDENTE" | "PRONTA" | "EXECUTANDO" | "AGUARDANDO_EVIDENCIA" | "AGUARDANDO_EVENTO_EXTERNO" | "FERRAMENTA_INDISPONIVEL" | "CAPACIDADE_AUSENTE" | "AUTORIZACAO_AUSENTE" | "FALHA_TRANSITORIA" | "FALHA_TERMINAL" | "EXECUCAO_ENCERRADA";
+export type EscopoEtapaConteudo = "GLOBAL" | "POR_ALVO";
+export type ResultadoAvaliacaoConteudo = "APROVADO" | "REPROVADO" | "INCONCLUSIVO";
+export interface PrincipalConteudo {
+    readonly principalId: string;
+    readonly keyId: string;
+    readonly controlDomain: string;
+    readonly papeis: readonly string[];
+    readonly capabilities: readonly string[];
+    readonly scopes: readonly string[];
+    readonly publicKeyPem: string;
+}
+/**
+ * Raiz publica de confianca. Chaves privadas nunca pertencem a esta configuracao
+ * nem ao workspace canonico do pipeline.
+ */
+export interface ConfiguracaoConfiancaConteudo {
+    readonly trustDomainId: string;
+    readonly principals: readonly PrincipalConteudo[];
+    readonly revokedKeyIds: readonly string[];
+    readonly maxEnvelopeAgeMs?: number;
+    readonly maxFutureSkewMs?: number;
+    readonly schemaVersionsAceitas?: readonly string[];
+}
+export interface ResultadoValidacaoConfiguracaoConfiancaConteudo {
+    readonly valida: boolean;
+    readonly trustRootDigest: string;
+    readonly revocationDigest: string;
+    readonly fingerprints: readonly string[];
+    readonly bloqueios: readonly string[];
+}
+export interface EnvelopeAssinavelConteudo<TPayload = JsonValor> {
+    readonly schemaVersion: string;
+    readonly payloadType: string;
+    readonly payload: TPayload;
+    readonly principalId: string;
+    readonly keyId: string;
+    readonly issuedAt: string;
+    readonly nonce: string;
+    readonly signatureAlgorithm: "Ed25519";
+}
+export interface EnvelopeAssinadoConteudo<TPayload = JsonValor> extends EnvelopeAssinavelConteudo<TPayload> {
+    /** Assinatura Ed25519 em base64 do JSON canonico de EnvelopeAssinavelConteudo. */
+    readonly signature: string;
+}
+export interface OpcoesVerificacaoEnvelopeConteudo {
+    /** Pins fornecidos por uma fronteira externa; nunca podem ser derivados da configuracao recebida. */
+    readonly trustRootDigestEsperado: string;
+    readonly revocationDigestEsperado: string;
+    readonly payloadTypeEsperado: string;
+    readonly capabilityRequerida?: string;
+    readonly scopeRequerido?: string;
+    readonly papelRequerido?: string;
+    readonly papeisPermitidos?: readonly string[];
+    readonly agora?: string | Date | number;
+    readonly maxEnvelopeAgeMs?: number;
+    readonly maxFutureSkewMs?: number;
+    /** Nonces ja observados. A verificacao e pura e nao altera este conjunto. */
+    readonly noncesUsados?: ReadonlySet<string>;
+}
+export interface EnvelopeVerificadoConteudo<TPayload = JsonValor> {
+    readonly estado: "ACEITA";
+    readonly digest: string;
+    readonly principal: PrincipalConteudo;
+    readonly envelope: EnvelopeAssinadoConteudo<TPayload>;
+    readonly payload: TPayload;
+}
+export interface ResultadoVerificacaoEnvelopeConteudo<TPayload = JsonValor> {
+    readonly valido: boolean;
+    readonly digest: string;
+    readonly principal?: PrincipalConteudo;
+    readonly envelopeVerificado?: EnvelopeVerificadoConteudo<TPayload>;
+    readonly bloqueios: readonly string[];
+}
+/** Contexto anti-replay que faz parte do payload assinado de todo evento. */
+export interface ContextoAssinadoEventoConteudo {
+    readonly runId: string;
+    readonly trustDomainId: string;
+    readonly trustRootDigest: string;
+    readonly ledgerId: string;
+    readonly policyDigest: string;
+    readonly definitionDigest: string;
+}
+/** Eventos ligados a um alvo/conta carregam tambem o escopo derivado pelo planner. */
+export interface ContextoAutorizadoEventoConteudo extends ContextoAssinadoEventoConteudo {
+    readonly authorizationScope: string;
+}
+/** Declaracao do runner/produtor. So vira evidencia depois de um atestado confiavel. */
+export interface AlegacaoEvidenciaConteudo extends ContextoAutorizadoEventoConteudo {
+    readonly kind: "EVIDENCE_CLAIMED";
+    readonly claimId: string;
+    readonly stageId: string;
+    readonly targetId?: string;
+    readonly artifactDigest: string;
+    readonly evidenceType: string;
+    readonly producerId: string;
+    readonly claimedAt: string;
+    readonly data?: JsonObjeto;
+}
+/** Observacao assinada por um verificador/adapter autorizado, nunca pelo recibo em si. */
+export interface AtestadoEvidenciaConteudo extends ContextoAutorizadoEventoConteudo {
+    readonly kind: "EVIDENCE_ATTESTED";
+    readonly evidenceId: string;
+    readonly claimId?: string;
+    readonly gateId: string;
+    readonly stageId: string;
+    readonly targetId?: string;
+    readonly artifactDigest: string;
+    readonly evidenceType: string;
+    readonly producerId: string;
+    readonly attesterId: string;
+    readonly result: ResultadoAvaliacaoConteudo;
+    readonly observedAt: string;
+    readonly data?: JsonObjeto;
+}
+export interface ParecerIAConteudo extends ContextoAutorizadoEventoConteudo {
+    readonly kind: "AI_ASSESSMENT";
+    readonly assessmentId: string;
+    readonly gateId: string;
+    readonly targetId?: string;
+    readonly artifactDigest: string;
+    readonly rubricDigest: string;
+    readonly evaluatorId: string;
+    /** Capability especializada concreta exercida neste parecer. */
+    readonly capability: string;
+    readonly result: ResultadoAvaliacaoConteudo;
+    readonly assessedAt: string;
+    readonly rationaleDigest?: string;
+    readonly data?: JsonObjeto;
+}
+export interface PoliticaGateConteudo {
+    readonly gateId: string;
+    readonly stageId: string;
+    readonly scope: EscopoEtapaConteudo;
+    readonly evaluationMode: ModoAvaliacaoConteudo;
+    readonly requiredEvidence: readonly string[];
+    readonly evaluatorCapabilities: readonly string[];
+    /** Quorum independente exigido para cada tipo de evidencia deterministica. */
+    readonly minAttestationsPerEvidence: number;
+    readonly minDistinctAttesterControlDomains: number;
+    readonly minApprovals: number;
+    readonly minDistinctControlDomains: number;
+    readonly producerDisjoint: boolean;
+    readonly rejectionIsBinding: boolean;
+    readonly rubricDigest: string;
+}
+export interface PoliticaConfiancaConteudo {
+    readonly policyId: string;
+    readonly version: string;
+    readonly runId: string;
+    readonly trustDomainId: string;
+    readonly trustRootDigest: string;
+    readonly definitionDigest: string;
+    readonly targetSetDigest: string;
+    readonly ledgerId: string;
+    readonly gates: readonly PoliticaGateConteudo[];
+    readonly issuedAt: string;
+    readonly expiresAt: string;
+}
+export interface EntradaAvaliacaoGateConteudo {
+    /** Politica assinada que vincula o gate base; requisitos adicionais so podem endurece-lo. */
+    readonly envelopePolitica: EnvelopeAssinadoConteudo<PoliticaConfiancaConteudo>;
+    readonly gate: PoliticaGateConteudo;
+    readonly requiredEvidenceAdicional?: readonly string[];
+    /** Requisitos adicionais derivados do adapter; so endurecem a policy assinada. */
+    readonly attesterCapabilitiesAdicionais?: Readonly<Record<string, string>>;
+    readonly artifactDigest: string;
+    readonly targetId?: string;
+    readonly runId: string;
+    readonly trustDomainId: string;
+    readonly trustRootDigest: string;
+    readonly revocationDigestEsperado: string;
+    readonly ledgerId: string;
+    readonly policyDigest: string;
+    readonly definitionDigest: string;
+    readonly authorizationScope: string;
+    readonly producerId: string;
+    readonly producerLineageIds: readonly string[];
+    readonly evidenciasAceitas: readonly EnvelopeVerificadoConteudo<AtestadoEvidenciaConteudo>[];
+    readonly pareceresIa: readonly EnvelopeVerificadoConteudo<ParecerIAConteudo>[];
+    readonly configuracaoConfianca: ConfiguracaoConfiancaConteudo;
+}
+export interface ResultadoAvaliacaoGateConteudo {
+    readonly veredito: VereditoConteudo;
+    readonly aprovacoesValidas: number;
+    readonly controlDomainsDistintos: number;
+    readonly evidenceIds: readonly string[];
+    readonly assessmentIds: readonly string[];
+    readonly bloqueios: readonly string[];
+}
+export interface RestricaoDeterministicaConteudo {
+    readonly constraintId: string;
+    readonly kind: string;
+    readonly config?: JsonObjeto;
+}
+export interface AdaptadorConteudo {
+    readonly adapterId: string;
+    readonly version: string;
+    readonly capabilities: readonly string[];
+    readonly acceptedMediaTypes: readonly string[];
+    readonly formatProfiles: readonly string[];
+    readonly deterministicConstraints: readonly RestricaoDeterministicaConteudo[];
+    readonly requiredMetadata: readonly string[];
+    readonly optionalMetadata: readonly string[];
+    readonly confirmationPredicates: readonly string[];
+}
+export interface AlvoConteudo {
+    readonly targetId: string;
+    readonly adapterId: string;
+    readonly accountScope: string;
+    readonly formatProfileId: string;
+    readonly locale: string;
+    readonly metadata: MetadataPublicaConteudo;
+}
+export interface EtapaPipelineConteudo {
+    readonly stageId: string;
+    readonly capability: string;
+    readonly scope: EscopoEtapaConteudo;
+    readonly adapterPolicy: "NONE" | "CONSTRAINTS" | "CONFIRMATION";
+    readonly dependsOn: readonly string[];
+    readonly produces: readonly string[];
+    readonly gateIds: readonly string[];
+}
+export interface DefinicaoPipelineConteudo {
+    readonly schemaVersion: string;
+    readonly pipelineId: string;
+    readonly version: string;
+    readonly stages: readonly EtapaPipelineConteudo[];
+    readonly gates: readonly PoliticaGateConteudo[];
+    readonly adapters: readonly AdaptadorConteudo[];
+    readonly requiredCompletionGates: readonly string[];
+}
+export interface InstanciaEtapaConteudo {
+    readonly stageInstanceId: string;
+    readonly stageId: string;
+    readonly targetId?: string;
+    readonly capability: string;
+    readonly dependsOn: readonly string[];
+    readonly produces: readonly string[];
+    readonly gateIds: readonly string[];
+}
+export interface SlotArtefatoConteudo {
+    readonly slotId: string;
+    readonly stageInstanceId: string;
+    readonly artifactType: string;
+    readonly targetId?: string;
+}
+export interface InstanciaGateConteudo {
+    readonly gateInstanceId: string;
+    readonly gateId: string;
+    readonly stageInstanceId: string;
+    readonly targetId?: string;
+}
+export interface PlanoPipelineConteudo {
+    readonly pipelineId: string;
+    readonly definitionDigest: string;
+    readonly targetIds: readonly string[];
+    readonly stageInstances: readonly InstanciaEtapaConteudo[];
+    readonly artifactSlots: readonly SlotArtefatoConteudo[];
+    readonly gateInstances: readonly InstanciaGateConteudo[];
+    readonly nextActions: readonly string[];
+}
+export interface ArtefatoConteudo extends ContextoAutorizadoEventoConteudo {
+    readonly kind: "ARTIFACT_REGISTERED";
+    readonly artifactId: string;
+    readonly stageId: string;
+    readonly targetId?: string;
+    readonly producerId: string;
+    readonly producerLineageIds: readonly string[];
+    readonly version: string;
+    readonly artifactType: string;
+    readonly mediaType: string;
+    readonly digest: string;
+    readonly lineageDigests: readonly string[];
+}
+export interface InicioExecucaoConteudo extends ContextoAssinadoEventoConteudo {
+    readonly kind: "RUN_STARTED";
+    readonly targets: readonly AlvoConteudo[];
+    readonly startedAt: string;
+}
+export interface CondicaoOperacionalReportadaConteudo extends ContextoAutorizadoEventoConteudo {
+    readonly kind: "OPERATIONAL_CONDITION";
+    readonly gateId: string;
+    readonly targetId?: string;
+    readonly condition: CondicaoOperacionalConteudo;
+    readonly reason: string;
+    readonly reportedAt: string;
+}
+export type EventoPayloadConteudo = InicioExecucaoConteudo | CondicaoOperacionalReportadaConteudo | ArtefatoConteudo | AlegacaoEvidenciaConteudo | AtestadoEvidenciaConteudo | ParecerIAConteudo;
+export interface EventoLedgerConteudo<TPayload = JsonValor> {
+    readonly schemaVersion: string;
+    readonly ledgerId: string;
+    readonly sequence: number;
+    readonly eventId: string;
+    readonly recordedAt: string;
+    readonly previousHash: string;
+    readonly envelope: EnvelopeAssinadoConteudo<TPayload>;
+    readonly hash: string;
+}
+export interface EstadoGateConteudo {
+    readonly gateId: string;
+    readonly targetId?: string;
+    readonly artifactDigest: string;
+    readonly veredito: VereditoConteudo;
+    readonly condition: CondicaoOperacionalConteudo;
+    readonly evidenceIds: readonly string[];
+    readonly assessmentIds: readonly string[];
+    readonly blockers: readonly string[];
+}
+export interface ProjecaoPipelineConteudo {
+    readonly authoritative: false;
+    readonly ledgerId: string;
+    readonly ledgerHead: string;
+    readonly runId: string;
+    readonly generatedAt: string;
+    readonly gates: readonly EstadoGateConteudo[];
+    readonly targets: readonly AlvoConteudo[];
+    readonly artifacts: readonly ArtefatoConteudo[];
+    readonly nextActions: readonly string[];
+}

package/dist/pipelineConteudo/types.js

@@ -0,0 +1,4 @@
+// SEMA-GOVERNED: sema.produto.pipeline_conteudo + confianca + ledger + estado + adaptadores
+// Descricao: tipos abertos do pipeline AI-native de conteudo, sem enum de canal, marca ou formato.
+export {};
+//# sourceMappingURL=types.js.map

package/dist/profileArtefatoValidadores.d.ts

@@ -1,4 +1,4 @@
-import type { AchadoProfile, MaturidadeProfile, PerfilSemantico, PresetProfile } from "./profileAuthorTipos.js";
+import type { AchadoProfile, MaturidadeProfile, PerfilSemanticoValidavel, PresetProfile } from "./profileAuthorTipos.js";
 export declare function avaliarArtefatoSoftwareProfile(contrato: string, artefato: string, maturidade: MaturidadeProfile, preset: PresetProfile | null): AchadoProfile[];
 export declare function avaliarArtefatoWorkflowProfile(contrato: string, artefato: string, preset: PresetProfile | null): AchadoProfile[];
 export declare function avaliarArtefatoOpsProfile(artefato: string, preset: PresetProfile | null): AchadoProfile[];
@@ -7,5 +7,6 @@ export declare function avaliarArtefatoResearchProfile(artefato: string, preset:
 export declare function avaliarArtefatoRedacaoProfile(artefato: string, preset: PresetProfile | null): AchadoProfile[];
 export declare function avaliarArtefatoPropostasProfile(artefato: string, preset: PresetProfile | null): AchadoProfile[];
 export declare function avaliarArtefatoGameProfile(artefato: string, preset: PresetProfile | null): AchadoProfile[];
+export declare function avaliarArtefatoSimulationProfile(artefato: string, preset: PresetProfile | null): AchadoProfile[];
 export declare function avaliarArtefatoConversasProfile(artefato: string, preset: PresetProfile | null): AchadoProfile[];
-export declare function avaliarArtefatoProfile(profile: PerfilSemantico, contrato: string, artefato: string | null | undefined, maturidade: MaturidadeProfile, preset: PresetProfile | null): AchadoProfile[];
+export declare function avaliarArtefatoProfile(profile: PerfilSemanticoValidavel, contrato: string, artefato: string | null | undefined, maturidade: MaturidadeProfile, preset: PresetProfile | null): AchadoProfile[];

package/dist/profileArtefatoValidadores.js

@@ -281,6 +281,85 @@ export function avaliarArtefatoGameProfile(artefato, preset) {
     }
     return achados;
 }
+export function avaliarArtefatoSimulationProfile(artefato, preset) {
+    const achados = validarTermosObrigatoriosArtefato(artefato, [
+        { id: "simulation_modelo_artefato", descricao: "artefato declara modelo testavel", regex: /modelo|model/i, sugestao: "declare o modelo testavel do simulador." },
+        { id: "simulation_assumptions_artefato", descricao: "artefato declara assumptions ou premissas", regex: /assumptions?|premissas?/i, sugestao: "declare assumptions ou premissas e seus limites." },
+        { id: "simulation_condicoes_iniciais_artefato", descricao: "artefato declara condicoes iniciais", regex: /condicoes?[_ -]?iniciais|initial[_ -]?conditions?/i, sugestao: "declare o estado e os parametros iniciais do simulador." },
+        { id: "simulation_condicoes_contorno_artefato", descricao: "artefato declara condicoes de contorno", regex: /condicoes?[_ -]?contorno|boundary[_ -]?conditions?/i, sugestao: "declare limites, fronteiras e condicoes de contorno." },
+        { id: "simulation_outputs_unidades_artefato", descricao: "artefato declara outputs observaveis e unidades", regex: /(?:outputs?|saidas?|resultados?)[\s\S]{0,180}(?:unidades?|units?)|(?:unidades?|units?)[\s\S]{0,180}(?:outputs?|saidas?|resultados?)/i, sugestao: "declare outputs observaveis com unidades explicitas." },
+        { id: "simulation_spatial_model_artefato", descricao: "artefato declara modelo espacial", regex: /spatial[_ -]?model|modelo[_ -]?espacial/i, sugestao: "declare NON_SPATIAL, TWO_D, TWO_POINT_FIVE_D ou THREE_D como spatial_model." },
+        { id: "simulation_render_mode_artefato", descricao: "artefato declara modo de renderizacao", regex: /render[_ -]?mode|modo[_ -]?(?:de[_ -]?)?render/i, sugestao: "declare HEADLESS, TEXT, VISUAL ou XR como render_mode." },
+        { id: "simulation_visual_profile_artefato", descricao: "artefato declara visual profile separado", regex: /visual[_ -]?profile|perfil[_ -]?visual/i, sugestao: "declare o visual profile separadamente de spatial_model e render_mode; 8/16-bit pertencem ao visual profile." },
+        { id: "simulation_validation_artefato", descricao: "artefato declara metodo de validacao do modelo", regex: /validation|validacao|validar[_ -]?modelo/i, sugestao: "declare como outputs, invariantes e tolerancias validam o modelo." },
+        { id: "simulation_controle_tempo_artefato", descricao: "artefato declara controle e modelo de tempo", regex: /(?:controle|control(?:[_ -]?modes?)?)[\s\S]{0,180}(?:tempo|time[_ -]?model|fixed[_ -]?step|real[_ -]?time|event[_ -]?driven)|(?:tempo|time[_ -]?model)[\s\S]{0,180}(?:controle|control(?:[_ -]?modes?)?)/i, sugestao: "declare modo de controle e modelo de tempo de forma independente." },
+        { id: "simulation_fidelidade_artefato", descricao: "artefato declara nivel de fidelidade", regex: /fidelity|fidelidade|ARCADE|STYLIZED|SYSTEMIC|REALISTIC|CALIBRATED/i, sugestao: "declare o nivel de fidelidade sem inferi-lo da aparencia visual." },
+        { id: "simulation_incerteza_artefato", descricao: "artefato declara incerteza ou limites do modelo", regex: /incerteza|uncertainty|intervalo[_ -]?confianca|confidence[_ -]?interval/i, severidade: "warning", sugestao: "registre incerteza, limites e validade esperada do modelo." },
+        { id: "simulation_telemetria_replay_artefato", descricao: "artefato declara telemetria, snapshot ou replay", regex: /telemetria|telemetry|metricas?|snapshot|replay|event[_ -]?log|state[_ -]?digest/i, severidade: "warning", sugestao: "adicione evidencia observavel, snapshot e replay quando aplicavel." },
+    ]);
+    const representacaoLegada = /["']?(?:representation|representacao)["']?\s*[:=]/i;
+    if (contemArtefatoProfile(artefato, representacaoLegada)) {
+        achados.push(criarAchadoArtefatoProfile("simulation_representacao_legada", "campo unico de representacao conflita modelo espacial e renderizacao", false, "critical", trechoRegexProfile(artefato, representacaoLegada), "substitua por spatial_model e render_mode ortogonais.", "THREE_D com HEADLESS deve preservar ambos os eixos."));
+    }
+    const pixelComoEixo = /["']?(?:spatial[_ -]?model|modelo[_ -]?espacial|render[_ -]?mode|modo[_ -]?(?:de[_ -]?)?render)["']?\s*[:=]\s*["']?(?:PIXEL[_ -]?(?:8|16)[_ -]?BIT|(?:8|16)[_ -]?BIT)/i;
+    if (contemArtefatoProfile(artefato, pixelComoEixo)) {
+        achados.push(criarAchadoArtefatoProfile("simulation_pixel_como_eixo", "8/16-bit foi usado como eixo espacial ou de render em vez de visual profile", false, "critical", trechoRegexProfile(artefato, pixelComoEixo), "use um spatial_model e render_mode validos e mova PIXEL_8_BIT/PIXEL_16_BIT para visual_profile.", "estetica retro nao define a dimensionalidade nem o modo de execucao do simulador."));
+    }
+    const headless = avaliarPresencaPositivaArtefato(artefato, /["']?(?:render[_ -]?mode|modo[_ -]?(?:de[_ -]?)?render)["']?\s*[:=]\s*["']?HEADLESS/i).atendido;
+    if (headless) {
+        achados.push(...validarTermosObrigatoriosArtefato(artefato, [
+            { id: "simulation_headless_visual_none", descricao: "simulacao headless usa visual profile NONE", regex: /["']?(?:visual[_ -]?profile|perfil[_ -]?visual)["']?\s*[:=]\s*["']?NONE/i, sugestao: "defina visual_profile NONE quando render_mode for HEADLESS." },
+        ]));
+    }
+    const xr = avaliarPresencaPositivaArtefato(artefato, /["']?(?:render[_ -]?mode|modo[_ -]?(?:de[_ -]?)?render)["']?\s*[:=]\s*["']?XR/i).atendido;
+    if (xr) {
+        achados.push(...validarTermosObrigatoriosArtefato(artefato, [
+            { id: "simulation_xr_spatial_three_d", descricao: "render XR usa spatial model THREE_D", regex: /["']?(?:spatial[_ -]?model|modelo[_ -]?espacial)["']?\s*[:=]\s*["']?THREE_D/i, sugestao: "defina spatial_model THREE_D quando render_mode for XR." },
+        ]));
+    }
+    const exigeCalibracao = preset === "calibration" || avaliarPresencaPositivaArtefato(artefato, /fidelity["'\s:=]+(?:REALISTIC|CALIBRATED)|fidelidade["'\s:=]+(?:realista|calibrada)/i).atendido;
+    if (exigeCalibracao) {
+        achados.push(...validarTermosObrigatoriosArtefato(artefato, [
+            { id: "simulation_calibration_referencia_artefato", descricao: "calibracao declara referencia ou dataset rastreavel", regex: /referencia|reference|dataset|baseline/i, severidade: "critical", sugestao: "vincule dataset, baseline ou referencia versionada." },
+            { id: "simulation_calibration_metodo_artefato", descricao: "calibracao declara metodo reproduzivel", regex: /(?:calibracao|calibration)[\s\S]{0,140}(?:metodo|method|procedimento|procedure)|(?:metodo|method)[\s\S]{0,140}(?:calibracao|calibration)/i, severidade: "critical", sugestao: "declare metodo e parametros reproduziveis de calibracao." },
+            { id: "simulation_calibration_tolerancia_artefato", descricao: "calibracao declara tolerancia numerica com unidade", regex: /(?:tolerancias?|tolerances?|erro|error)[^\n\r]{0,120}(?:<=|>=|=|:)?\s*\d+(?:[.,]\d+)?\s*(?:%|percent|por cento|ms|s|m|km|kg|g|K|C|Hz|Pa|N)\b/i, severidade: "critical", sugestao: "declare tolerancia numerica, criterio de erro e unidade." },
+            { id: "simulation_calibration_incerteza_telemetria_artefato", descricao: "calibracao declara incerteza e telemetria observavel", regex: /(?:incerteza|uncertainty)[\s\S]{0,180}(?:telemetria|telemetry|metricas?)|(?:telemetria|telemetry)[\s\S]{0,180}(?:incerteza|uncertainty)/i, severidade: "blocking", sugestao: "registre incerteza e telemetria usadas para validar a calibracao." },
+        ]));
+    }
+    const exigeDeterminismo = preset === "deterministic" || avaliarPresencaPositivaArtefato(artefato, /["']?(?:determinism|determinismo)["']?\s*[:=]\s*["']?(?:STRICT|SEEDED|DETERMINISTIC)|\bdeterministic\b/i).atendido;
+    if (exigeDeterminismo) {
+        achados.push(...validarTermosObrigatoriosArtefato(artefato, [
+            { id: "simulation_deterministic_seed_artefato", descricao: "execucao deterministica declara seed", regex: /\bseed\b|semente[_ -]?aleatoria/i, sugestao: "declare a seed de cada execucao." },
+            { id: "simulation_deterministic_step_artefato", descricao: "execucao deterministica declara passo reproduzivel", regex: /fixed[_ -]?step|passo[_ -]?fixo|passo[_ -]?reprodutivel|time[_ -]?step/i, sugestao: "declare fixed step ou passo reproduzivel." },
+            { id: "simulation_deterministic_snapshot_artefato", descricao: "execucao deterministica declara snapshot ou digest de estado", regex: /snapshot|state[_ -]?digest|hash[_ -]?estado|estado[_ -]?hash/i, sugestao: "capture snapshot e digest do estado por etapa relevante." },
+            { id: "simulation_deterministic_replay_artefato", descricao: "execucao deterministica declara replay ou event log", regex: /replay|event[_ -]?log|result[_ -]?digest|log[_ -]?eventos/i, sugestao: "preserve replay/event log e digest do resultado." },
+        ]));
+    }
+    if (preset === "scenario") {
+        achados.push(...validarTermosObrigatoriosArtefato(artefato, [
+            { id: "simulation_scenario_id_artefato", descricao: "cenario possui identidade estavel", regex: /scenario[_ -]?id|cenario[_ -]?id|id[_ -]?cenario/i, sugestao: "declare scenario_id estavel." },
+            { id: "simulation_scenario_acceptance_artefato", descricao: "cenario possui resultado esperado e aceite", regex: /acceptance|aceitacao|resultado[_ -]?esperado|expected[_ -]?output/i, sugestao: "declare outputs esperados e criterios de aceitacao." },
+        ]));
+    }
+    if (preset === "batch") {
+        achados.push(...validarTermosObrigatoriosArtefato(artefato, [
+            { id: "simulation_batch_runs_artefato", descricao: "batch declara repeticoes ou ensemble", regex: /batch|lote|ensemble|replications?|repeticoes?/i, sugestao: "declare quantidade de runs ou replications do batch." },
+            { id: "simulation_batch_seed_strategy_artefato", descricao: "batch declara estrategia de seeds", regex: /seed[_ -]?strategy|estrategia[_ -]?(?:de[_ -]?)?seeds?/i, sugestao: "declare estrategia de seeds por run." },
+            { id: "simulation_batch_aggregation_artefato", descricao: "batch declara agregacao de outputs", regex: /aggregation|agregacao|percentil|media|mediana|distribution|distribuicao/i, sugestao: "declare como outputs dos runs serao agregados." },
+            { id: "simulation_batch_budget_stop_artefato", descricao: "batch declara budget e condicao de parada", regex: /(?:resource[_ -]?budget|time[_ -]?budget|orcamento|limite)[\s\S]{0,180}(?:stop[_ -]?condition|criterio[_ -]?parada|max[_ -]?runs)|(?:stop[_ -]?condition|criterio[_ -]?parada)[\s\S]{0,180}(?:budget|orcamento|limite)/i, sugestao: "declare limite de recursos/tempo e condicao de parada do batch." },
+        ]));
+    }
+    const exigeSafety = preset === "safety" || avaliarPresencaPositivaArtefato(artefato, /AUTONOMOUS|UNCONTROLLED|autonom[oa]/i).atendido;
+    if (exigeSafety) {
+        achados.push(...validarTermosObrigatoriosArtefato(artefato, [
+            { id: "simulation_safety_authority_artefato", descricao: "autonomia declara fronteira de autoridade", regex: /authority[_ -]?boundary|fronteira[_ -]?(?:de[_ -]?)?autoridade|escopo[_ -]?autonomia/i, severidade: "critical", sugestao: "delimite o que o controlador autonomo pode observar e alterar." },
+            { id: "simulation_safety_budget_artefato", descricao: "autonomia declara budget de recursos ou tempo", regex: /resource[_ -]?budget|time[_ -]?budget|orcamento[_ -]?(?:de[_ -]?)?recursos|limite[_ -]?(?:de[_ -]?)?(?:tempo|recursos)/i, severidade: "critical", sugestao: "declare limites de tempo, memoria, CPU, iteracoes ou custo." },
+            { id: "simulation_safety_stop_artefato", descricao: "autonomia declara condicao de parada ou kill switch", regex: /stop[_ -]?condition|criterio[_ -]?(?:de[_ -]?)?parada|kill[_ -]?switch|emergency[_ -]?stop/i, severidade: "critical", sugestao: "declare condicao de parada verificavel e mecanismo de interrupcao." },
+            { id: "simulation_safety_failsafe_artefato", descricao: "autonomia declara fail-safe, isolamento ou tomada humana", regex: /fail[_ -]?safe|failsafe|human[_ -]?takeover|tomada[_ -]?humana|isolamento|sandbox/i, severidade: "critical", sugestao: "declare fail-safe, isolamento e quando um humano assume o controle." },
+        ]));
+    }
+    return achados;
+}
 export function avaliarArtefatoConversasProfile(artefato, preset) {
     const achados = validarTermosObrigatoriosArtefato(artefato, [
         { id: "conversas_tom_artefato", descricao: "artefato declara tom/persona da conversa", regex: /tom|persona|voz|formalidade|comercial|persuasiv|serio|consultiv/i, sugestao: "declare o tom, persona e nivel de formalidade usados na resposta." },
@@ -366,6 +445,8 @@ export function avaliarArtefatoProfile(profile, contrato, artefato, maturidade,
             return avaliarArtefatoPropostasProfile(artefato, preset);
         case "game":
             return avaliarArtefatoGameProfile(artefato, preset);
+        case "simulation":
+            return avaliarArtefatoSimulationProfile(artefato, preset);
         case "conversas":
             return avaliarArtefatoConversasProfile(artefato, preset);
     }

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"));