@semacode/cli 2.2.0 → 2.3.1

package/dist/pipelineConteudo/command.js

@@ -26,7 +26,6 @@ const OPCOES_COM_VALOR_CONTEUDO = new Set([
     "--revocation-digest",
 ]);
 const SUBCOMANDOS_CONTEUDO = new Set([
-    "ajuda",
     "capabilities",
     "validar",
     "planejar",
@@ -35,36 +34,6 @@ const SUBCOMANDOS_CONTEUDO = new Set([
     "status",
     "projetar",
 ]);
-const USOS_PIPELINE_CONTEUDO = [
-    "sema conteudo capabilities --json",
-    "sema conteudo validar <definition.json> --json",
-    "sema conteudo planejar <definition.json> --alvos-arquivo <targets.json> --json",
-    "sema conteudo validar-envelope --envelope-arquivo <envelope.json> --confianca-arquivo <trust.json> --trust-root-digest <sha256:...> --revocation-digest <sha256:...> --payload-type <type> --json",
-    "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",
-    "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",
-    "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",
-];
-function ajudaPipelineConteudo() {
-    const mensagem = [
-        "Sema Content Pipeline — controle AI-native multicanal e multiformato.",
-        "",
-        "Uso:",
-        ...USOS_PIPELINE_CONTEUDO.map((uso) => `  ${uso}`),
-        "",
-        "O runner é externo e avança somente pelos nextActions derivados pelo Sema.",
-        "Evidências entram como envelopes assinados; vereditos e transições não são escritos manualmente.",
-        "Não existe revisão humana nativa. Chaves privadas permanecem nos processos signatários independentes.",
-    ].join("\n");
-    return {
-        sucesso: true,
-        comando: "ajuda",
-        mensagem,
-        usos: USOS_PIPELINE_CONTEUDO,
-        nativeHumanReview: false,
-        runner: "external",
-        canonicalState: "signed_hash_chained_ledger",
-    };
-}
 const CAUSAS_PUBLICAS_CONTEUDO = [
     "expected_head_divergente",
     "trust_root_digest_divergente",
@@ -394,15 +363,11 @@ async function registrarEnvelopeLocal(args, ledgerArquivo) {
 }
 export async function comandoPipelineConteudo(_posicionaisGlobais, args, emJson) {
     const posicionais = posicionaisConteudo(args);
-    const solicitouAjuda = args.includes("--help") || args.includes("-h") || posicionais[0] === "help" || posicionais[0] === "ajuda";
-    const subcomando = solicitouAjuda ? "ajuda" : posicionais[0] ?? "capabilities";
+    const subcomando = posicionais[0] ?? "capabilities";
     const comandoPublico = SUBCOMANDOS_CONTEUDO.has(subcomando) ? subcomando : "desconhecido";
     try {
         let payload;
         switch (subcomando) {
-            case "ajuda":
-                payload = ajudaPipelineConteudo();
-                break;
             case "capabilities":
                 payload = {
                     sucesso: true,

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

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/projeto.d.ts

@@ -1,4 +1,4 @@
-export type { ConfiguracaoPersistenciaProjeto, ConfiguracaoProjetoCarregada, ContextoProjetoCarregado, SemaConfigProjeto, } from './projetoTipos.js';
+export type { ConfiguracaoPersistenciaProjeto, ConfiguracaoProjetoCarregada, ContextoProjetoCarregado, EscopoCarregamentoProjeto, ModuloProjetoCarregado, OpcoesCarregarProjeto, SemaConfigProjeto, } from './projetoTipos.js';
 export { carregarConfiguracaoProjeto, localizarConfiguracaoProjeto, normalizarEstruturaSaida, normalizarFrameworkGeracao, } from './projetoConfig.js';
 export { carregarProjeto } from './projetoCarregar.js';
 export { resolverAlvoPadrao, resolverAlvosVerificacao, resolverEstruturaSaidaPadrao, resolverFrameworkPadrao, resolverSaidaPadrao, } from './projetoResolucao.js';

package/dist/projetoCarregar.d.ts

@@ -1,2 +1,2 @@
-import type { ContextoProjetoCarregado } from './projetoTipos.js';
-export declare function carregarProjeto(entrada: string | undefined, cwd: string): Promise<ContextoProjetoCarregado>;
+import type { ContextoProjetoCarregado, OpcoesCarregarProjeto } from './projetoTipos.js';
+export declare function carregarProjeto(entrada: string | undefined, cwd: string, opcoes?: OpcoesCarregarProjeto): Promise<ContextoProjetoCarregado>;

package/dist/projetoCarregar.js

@@ -2,49 +2,72 @@
 // Descrição: orquestra leitura de contratos, compila??o e sele??o de m?dulos do projeto.
 import { stat } from 'node:fs/promises';
 import path from 'node:path';
-import { compilarProjeto, lerArquivoTexto, listarArquivosSema } from '@sema/nucleo';
+import { compilarProjeto, listarArquivosSema } from '@sema/nucleo';
+import { carregarFechamentoContratosSema, carregarFontesContratos } from './projetoCatalogo.js';
 import { carregarConfiguracaoProjeto, normalizarModoAdocao } from './projetoConfig.js';
 import { inferirFontesLegado } from './projetoLegado.js';
 import { inferirDiretoriosCodigo, listarArquivosDeOrigens, resolverBaseProjeto, resolverEntradaPadrao, resolverOrigensProjeto, } from './projetoOrigens.js';
-export async function carregarProjeto(entrada, cwd) {
+export async function carregarProjeto(entrada, cwd, opcoes = {}) {
     const entradaBase = entrada ? path.resolve(cwd, entrada) : cwd;
     const configCarregada = await carregarConfiguracaoProjeto(entradaBase);
     const entradaResolvida = entrada ? path.resolve(cwd, entrada) : await resolverEntradaPadrao(cwd, configCarregada);
     const baseProjeto = await resolverBaseProjeto(entradaResolvida, configCarregada);
     const infoEntrada = await stat(entradaResolvida);
-    const origensProjeto = await resolverOrigensProjeto(baseProjeto, entradaResolvida, configCarregada);
-    const arquivosProjeto = await listarArquivosDeOrigens(origensProjeto);
-    const diretoriosCodigo = await inferirDiretoriosCodigo(baseProjeto, configCarregada);
-    const fontesLegado = await inferirFontesLegado(diretoriosCodigo, baseProjeto, configCarregada);
-    const modoAdocao = normalizarModoAdocao(configCarregada?.config.modoAdocao);
-    const arquivosSelecionados = infoEntrada.isFile()
-        ? new Set([path.resolve(entradaResolvida)])
-        : new Set((configCarregada && path.resolve(entradaResolvida) === path.resolve(configCarregada.baseDiretorio)
-            ? arquivosProjeto
-            : await listarArquivosSema(entradaResolvida)).map((arquivo) => path.resolve(arquivo)));
-    const fontes = [];
-    for (const arquivo of arquivosProjeto) {
-        const codigo = await lerArquivoTexto(arquivo);
-        fontes.push({ caminho: arquivo, codigo });
+    const escopo = opcoes.escopo ?? (infoEntrada.isFile() ? "modulo" : "projeto");
+    const carregarProjetoCompleto = !infoEntrada.isFile() || escopo === "projeto";
+    const origensBase = infoEntrada.isFile()
+        ? await resolverOrigensProjeto(baseProjeto, baseProjeto, configCarregada)
+        : await resolverOrigensProjeto(baseProjeto, entradaResolvida, configCarregada);
+    const origensProjeto = [...new Set([
+            ...origensBase,
+            ...(infoEntrada.isFile() ? [path.dirname(entradaResolvida)] : []),
+        ].map((origem) => path.resolve(origem)))]
+        .sort((a, b) => a.localeCompare(b, "pt-BR"));
+    const arquivosDescobertosSet = new Set(await listarArquivosDeOrigens(origensProjeto));
+    if (infoEntrada.isFile()) {
+        arquivosDescobertosSet.add(path.resolve(entradaResolvida));
     }
+    const arquivosDescobertos = [...arquivosDescobertosSet]
+        .sort((a, b) => a.localeCompare(b, "pt-BR"));
+    const possuiDiretoriosCodigoExplicitos = Boolean(configCarregada?.config.diretoriosCodigo?.length);
+    const possuiFontesLegadoExplicitas = Boolean(configCarregada?.config.fontesLegado?.length);
+    const diretoriosCodigo = carregarProjetoCompleto || possuiDiretoriosCodigoExplicitos
+        ? await inferirDiretoriosCodigo(baseProjeto, configCarregada)
+        : [];
+    const fontesLegado = carregarProjetoCompleto || possuiFontesLegadoExplicitas
+        ? await inferirFontesLegado(diretoriosCodigo, baseProjeto, configCarregada)
+        : [];
+    const modoAdocao = normalizarModoAdocao(configCarregada?.config.modoAdocao);
+    const arquivosSelecionados = carregarProjetoCompleto && escopo === "projeto"
+        ? new Set(arquivosDescobertos.map((arquivo) => path.resolve(arquivo)))
+        : infoEntrada.isFile()
+            ? new Set([path.resolve(entradaResolvida)])
+            : new Set((configCarregada && path.resolve(entradaResolvida) === path.resolve(configCarregada.baseDiretorio)
+                ? arquivosDescobertos
+                : await listarArquivosSema(entradaResolvida)).map((arquivo) => path.resolve(arquivo)));
+    const fontes = carregarProjetoCompleto
+        ? await carregarFontesContratos(arquivosDescobertos)
+        : (await carregarFechamentoContratosSema([entradaResolvida], arquivosDescobertos)).fontes;
     const resultadoProjeto = compilarProjeto(fontes);
     const resultados = new Map(resultadoProjeto.modulos.map((modulo) => [path.resolve(modulo.caminho), modulo]));
+    const modulosCarregados = fontes.map((fonte) => ({
+        caminho: fonte.caminho,
+        codigo: fonte.codigo,
+        resultado: resultados.get(path.resolve(fonte.caminho)),
+    }));
     return {
         entradaResolvida,
         baseProjeto,
         configCarregada,
-        arquivosProjeto,
+        arquivosProjeto: fontes.map((fonte) => fonte.caminho),
+        arquivosDescobertos,
         origensProjeto,
         diretoriosCodigo,
         fontesLegado,
         modoAdocao,
-        modulosSelecionados: fontes
-            .filter((fonte) => arquivosSelecionados.has(path.resolve(fonte.caminho)))
-            .map((fonte) => ({
-            caminho: fonte.caminho,
-            codigo: fonte.codigo,
-            resultado: resultados.get(path.resolve(fonte.caminho)),
-        })),
+        modulosCarregados,
+        modulosSelecionados: modulosCarregados
+            .filter((modulo) => arquivosSelecionados.has(path.resolve(modulo.caminho))),
     };
 }
 //# sourceMappingURL=projetoCarregar.js.map