@semacode/cli 4.0.0 → 4.1.1

package/dist/cliGrammar.js

@@ -428,11 +428,10 @@ function validarResumo(args, promptCurto) {
     const pacote = parsed.flags.has("--pacote");
     const somentePacote = parsed.flags.has("--somente-pacote");
     const pedido = valorOpcao(parsed, "--pedido");
-    const combinacaoPacoteValida = pacote === Boolean(pedido);
     return tamanhos.length <= 1
         && (!modo || MODOS_RESUMO.has(modo))
         && (promptCurto || validarModoCache(parsed, "--drift"))
-        && (promptCurto ? !pacote && !pedido && !somentePacote : combinacaoPacoteValida && (!somentePacote || pacote));
+        && (promptCurto ? !pacote && !pedido && !somentePacote : true);
 }
 function validarComandoBasico(comando, args) {
     const aliasesGeracao = { "-a": "--alvo", "-s": "--saida" };

package/dist/cliHelpTexto.js

@@ -102,7 +102,7 @@ export function criarAjudaRaiz(versao) {
             "fraca: sema resumo <arquivo> --micro --drift none --json (contrato compacto; implementação não avaliada)",
             "média: sema resumo <arquivo> --curto --drift none --json + sema drift <arquivo> --cache fresh --json",
             "forte: sema contexto-ia <arquivo.sema> --saida <diretorio> --json",
-            "context-pack: sema resumo <arquivo.sema> --micro --para mudanca --drift none --pacote --pedido \"<intenção>\" --json (seleção determinística para a IA)",
+            "context-pack: sema resumo <arquivo.sema> --micro --para mudanca --drift none --json (compactação determinística automática; use --pedido para focar a seleção)",
         ]),
         "",
         renderizarSecaoAscii("Comandos principais", [
@@ -134,7 +134,7 @@ export function criarAjudaRaiz(versao) {
         renderizarSecaoAscii("Ajuda IA-first", [
             "sema ajuda-ia",
             "sema starter-ia",
-            "sema resumo <arquivo-ou-pasta> [--micro|--curto|--medio] [--para <resumo|onboarding|review|mudanca|bug|arquitetura>] [--drift <none|cache|fresh>] [--saida <diretorio>] [--raiz] [--pacote --somente-pacote --pedido <intencao>] [--json]",
+            "sema resumo <arquivo-ou-pasta> [--micro|--curto|--medio] [--para <resumo|onboarding|review|mudanca|bug|arquitetura>] [--drift <none|cache|fresh>] [--saida <diretorio>] [--raiz] [--pedido <intencao>] [--somente-pacote] [--json]",
             "sema prompt-curto <arquivo-ou-pasta> [--micro|--curto|--medio] [--para <resumo|onboarding|review|mudanca|bug|arquitetura>] [--json]",
             "sema prompt-ia",
             "sema prompt-ia-ui",

package/dist/contextPack.d.ts

@@ -65,7 +65,7 @@ export type ContextPackResult = {
 export declare function selecionarContexto(payload: ContextPackPayload, request: string): ContextPackResult;
 export declare function criarContextPackAPartirDoResumo(input: {
     resumo: ResumoSemanticoModuloIa;
-    pedido: string;
+    pedido?: string;
     modo: string;
     tamanho: TamanhoResumoIa;
     analiseDrift: ContextPackPayload["analiseDrift"];

package/dist/contextPack.js

@@ -15,6 +15,8 @@ function normalizedTokens(value) {
         .filter((token) => token.length >= 4);
 }
 function selectRelevantTasks(tasks, request) {
+    if (request.startsWith("resumo:"))
+        return tasks.slice(0, 8);
     const requestTokens = new Set(normalizedTokens(request));
     const intentRoots = ["cancel", "notific", "export", "reagend", "registr", "consult"];
     const rootedMatches = intentRoots
@@ -115,6 +117,7 @@ export function selecionarContexto(payload, request) {
     };
 }
 export function criarContextPackAPartirDoResumo(input) {
+    const pedido = input.pedido?.trim() || `resumo:${input.tamanho}`;
     return selecionarContexto({
         geradoEm: input.resumo.geradoEm,
         arquivo: input.resumo.arquivo,
@@ -125,6 +128,6 @@ export function criarContextPackAPartirDoResumo(input) {
         guiaPorCapacidade: input.guiaPorCapacidade,
         texto: input.texto,
         resumo: input.resumo,
-    }, input.pedido);
+    }, pedido);
 }
 //# sourceMappingURL=contextPack.js.map

package/dist/geracaoCore.d.ts

@@ -18,6 +18,8 @@ export interface ResumoAlvoVerificacao {
     estrutura: EstruturaSaida;
     testesExecutados: boolean;
     origem?: "executado" | "cache";
+    tipoEvidencia?: "andaime_demonstrativo";
+    implementacaoExternaExecutada?: boolean;
 }
 export interface ResumoModuloVerificacao {
     modulo: string;

package/dist/index.part06.js

@@ -202,8 +202,8 @@ export async function comandoAjudaIa() {
     ]));
     console.log("");
     console.log(renderizarSecaoAscii("Capacidade de IA", [
-        "fraca: `sema resumo <arquivo> --micro --drift none --json` usa stdout compacto sem inventar evidência de implementação",
-        "média: `sema resumo <arquivo> --curto --drift none --json` + `sema drift <arquivo> --cache fresh --json`",
+        "fraca: `sema resumo <arquivo> --micro --drift none --json` já devolve o context-pack compacto sem inventar evidência de implementação",
+        "média: `sema resumo <arquivo> --curto --drift none --json` já compacta o resumo; use `sema drift <arquivo> --cache fresh --json` quando precisar de evidência do código",
         "forte: `sema contexto-ia <arquivo.sema> --saida <diretorio> --json` materializa o pacote completo",
     ]));
     console.log("");
@@ -214,7 +214,7 @@ export async function comandoAjudaIa() {
         "Use `sema interativo pipelines --json` para jogos, simulações e híbridos 3D, 2D, retro, texto, XR ou headless.",
         "Use `sema sync-codex` para regenerar o contexto governado do Codex na raiz.",
         "Use `sema instalar-exemplos` para materializar `exemplos/` oficiais sem sobrescrever arquivos locais.",
-        "Use `sema resumo <arquivo> --micro --para onboarding --drift none --json` para IA fraca; o resumo contratual vem no stdout e campos derivados ficam não avaliados.",
+        "Use `sema resumo <arquivo> --micro --para onboarding --drift none --json` para IA fraca; o context-pack é automático e campos derivados ficam não avaliados.",
         "Se `sema resumo` ou outro gate estourar timeout local, aumente o timeout e tente de novo; timeout do agente nao e falha do Sema.",
         "Use `sema prompt-curto <arquivo> --curto --para mudanca` para colar contexto em modelo gratuito.",
         "Use `sema prompt-ia`, `sema prompt-ia-ui`, `sema prompt-ia-react` e `sema prompt-ia-sema-primeiro` conforme a tarefa.",
@@ -290,8 +290,8 @@ export async function comandoResumo(entrada, args, emJson) {
     const tamanho = normalizarTamanhoResumo(args);
     const modo = normalizarModoResumo(obterOpcao(args, "--para"));
     const pedido = obterOpcao(args, "--pedido");
-    const pacoteSolicitado = possuiFlag(args, "--pacote");
     const somentePacote = possuiFlag(args, "--somente-pacote");
+    const pedidoExplícito = obterOpcao(args, "--pedido")?.trim();
     const pastaSaida = obterOpcao(args, "--saida");
     const escreverNaRaiz = possuiFlag(args, "--raiz");
     const alvo = entrada ? path.resolve(process.cwd(), entrada) : process.cwd();
@@ -304,22 +304,20 @@ export async function comandoResumo(entrada, args, emJson) {
         const texto = tamanho === "medio"
             ? renderizarResumoModuloMarkdown(resumoSemantico, modo, guiaPorCapacidade)
             : renderizarResumoModuloTexto(resumoSemantico, tamanho, modo);
-        const contextPack = pacoteSolicitado && pedido
-            ? criarContextPackAPartirDoResumo({
-                resumo: resumoSemantico,
-                pedido,
-                modo,
-                tamanho,
-                analiseDrift: {
-                    modo: contexto.drift.modo,
-                    executada: contexto.drift.executada,
-                    sucesso: contexto.drift.sucesso,
-                    aviso: contexto.drift.aviso,
-                },
-                guiaPorCapacidade,
-                texto,
-            })
-            : null;
+        const contextPack = criarContextPackAPartirDoResumo({
+            resumo: resumoSemantico,
+            pedido: pedidoExplícito,
+            modo,
+            tamanho,
+            analiseDrift: {
+                modo: contexto.drift.modo,
+                executada: contexto.drift.executada,
+                sucesso: contexto.drift.sucesso,
+                aviso: contexto.drift.aviso,
+            },
+            guiaPorCapacidade,
+            texto,
+        });
         let pastaResumo;
         let artefatosCompactos = [];
         if (pastaSaida) {
@@ -333,6 +331,10 @@ export async function comandoResumo(entrada, args, emJson) {
                 console.log(JSON.stringify(contextPack, null, 2));
                 return contexto.drift.sucesso === false ? 1 : 0;
             }
+            if (somentePacote) {
+                console.log(JSON.stringify(contextPack, null, 2));
+                return contexto.drift.sucesso === false ? 1 : 0;
+            }
             console.log(JSON.stringify({
                 comando: "resumo",
                 modo,
@@ -350,10 +352,7 @@ export async function comandoResumo(entrada, args, emJson) {
                     avisos: analiseDrift.avisos,
                     cache: contexto.drift.drift?.escopo_aplicado.cache ?? null,
                 },
-                guiaPorCapacidade,
-                resumo: resumoSemantico,
-                texto,
-                ...(contextPack ? { contextPack } : {}),
+                contextPack,
             }, null, 2));
             return contexto.drift.sucesso === false ? 1 : 0;
         }
@@ -361,34 +360,22 @@ export async function comandoResumo(entrada, args, emJson) {
             console.log(`Resumo IA-first gerado em ${pastaResumo}`);
             console.log("");
         }
-        if (contextPack) {
-            console.log(JSON.stringify(contextPack, null, 2));
-            return contexto.drift.sucesso === false ? 1 : 0;
-        }
-        console.log(texto);
+        console.log(JSON.stringify(contextPack, null, 2));
         return contexto.drift.sucesso === false ? 1 : 0;
     }
     const resumoProjeto = await gerarResumoProjetoIa(alvo, pastaSaida, escreverNaRaiz, analiseDrift);
-    const arquivoResumo = tamanho === "micro"
-        ? "SEMA_BRIEF.micro.txt"
-        : tamanho === "curto"
-            ? "SEMA_BRIEF.curto.txt"
-            : "SEMA_BRIEF.md";
-    const texto = await readFile(path.join(resumoProjeto.pastaSaida, arquivoResumo), "utf8");
     const indexTexto = await readFile(path.join(resumoProjeto.pastaSaida, "SEMA_INDEX.json"), "utf8").catch(() => "");
-    const indexPack = pacoteSolicitado && pedido
-        ? selecionarIndiceContexto({
-            modulos: resumoProjeto.modulos,
-            request: pedido,
-            baseProject: resumoProjeto.baseProjeto,
-            generatedAt: resumoProjeto.geradoEm,
-            mode: modo,
-            drift: resumoProjeto.analiseDrift.modo,
-            sourceIndexChars: indexTexto.length,
-        })
-        : null;
+    const indexPack = selecionarIndiceContexto({
+        modulos: resumoProjeto.modulos,
+        request: pedidoExplícito ?? `resumo:${tamanho}`,
+        baseProject: resumoProjeto.baseProjeto,
+        generatedAt: resumoProjeto.geradoEm,
+        mode: modo,
+        drift: resumoProjeto.analiseDrift.modo,
+        sourceIndexChars: indexTexto.length,
+    });
     if (emJson) {
-        if (somentePacote && indexPack) {
+        if (somentePacote) {
             console.log(JSON.stringify(indexPack, null, 2));
             return resumoProjeto.analiseDrift.sucesso === false ? 1 : 0;
         }
@@ -404,20 +391,13 @@ export async function comandoResumo(entrada, args, emJson) {
                 ...resumoProjeto.analiseDrift,
                 avisos: analiseDrift.avisos,
             },
-            guiaPorCapacidade: resumoProjeto.guiaPorCapacidade,
-            modulos: resumoProjeto.modulos,
-            texto,
-            ...(indexPack ? { indexPack } : {}),
+            indexPack,
         }, null, 2));
         return resumoProjeto.analiseDrift.sucesso === false ? 1 : 0;
     }
     console.log(`Resumo IA-first do projeto gerado em ${resumoProjeto.pastaSaida}`);
     console.log("");
-    if (indexPack) {
-        console.log(JSON.stringify(indexPack, null, 2));
-        return resumoProjeto.analiseDrift.sucesso === false ? 1 : 0;
-    }
-    console.log(texto);
+    console.log(JSON.stringify(indexPack, null, 2));
     return resumoProjeto.analiseDrift.sucesso === false ? 1 : 0;
 }
 //# sourceMappingURL=index.part06.js.map

package/dist/index.part07.js

@@ -226,6 +226,11 @@ export async function comandoVerificar(entrada, baseSaida, cwd = process.cwd(),
     const alvos = opcoes.alvo
         ? [opcoes.alvo]
         : resolverAlvosVerificacao(contextoProjeto.configCarregada);
+    const testesNaoExecutaveis = diagnosticos.filter(item => item.codigo === "SEM125");
+    if (alvos.includes("python") && testesNaoExecutaveis.length > 0) {
+        console.error(formatarDiagnosticos(testesNaoExecutaveis));
+        return 1;
+    }
     const avisoEscopo = avisoEscopoStackVerificacao(contextoProjeto.configCarregada?.config.fontesLegado, alvos);
     if (avisoEscopo) {
         console.warn(avisoEscopo);
@@ -279,6 +284,7 @@ export async function comandoVerificar(entrada, baseSaida, cwd = process.cwd(),
                     estrutura,
                     testesExecutados: false,
                     origem: "cache",
+                    ...(alvo === "python" ? { tipoEvidencia: "andaime_demonstrativo", implementacaoExternaExecutada: false } : {}),
                 });
                 if (!emCache.sucesso) {
                     imprimirResumoVerificacao([...resumos, resumoModulo]);
@@ -313,6 +319,7 @@ export async function comandoVerificar(entrada, baseSaida, cwd = process.cwd(),
                 estrutura,
                 testesExecutados,
                 origem: "executado",
+                ...(alvo === "python" ? { tipoEvidencia: "andaime_demonstrativo", implementacaoExternaExecutada: false } : {}),
             });
             if (execucao.codigoSaida !== 0) {
                 imprimirResumoVerificacao([...resumos, resumoModulo]);
@@ -347,6 +354,18 @@ export async function comandoVerificarJson(entrada, baseSaida, cwd = process.cwd
     const alvos = opcoes.alvo
         ? [opcoes.alvo]
         : resolverAlvosVerificacao(contextoProjeto.configCarregada);
+    const testesNaoExecutaveis = diagnosticos.filter(item => item.codigo === "SEM125");
+    if (alvos.includes("python") && testesNaoExecutaveis.length > 0) {
+        console.log(JSON.stringify({
+            comando: "verificar",
+            sucesso: false,
+            erro: "Casos de teste não executáveis em Python: substitua texto descritivo por entidades estruturadas.",
+            diagnosticos: testesNaoExecutaveis,
+            modulos: [],
+            totais: { modulos: 0, alvos: 0, arquivos: 0, testes: 0 },
+        }, null, 2));
+        return 1;
+    }
     const avisoEscopo = avisoEscopoStackVerificacao(contextoProjeto.configCarregada?.config.fontesLegado, alvos);
     const configuracoesAlvo = alvos.map((alvo) => ({
         alvo,
@@ -411,6 +430,7 @@ export async function comandoVerificarJson(entrada, baseSaida, cwd = process.cwd
                     estrutura,
                     testesExecutados: false,
                     origem: "cache",
+                    ...(alvo === "python" ? { tipoEvidencia: "andaime_demonstrativo", implementacaoExternaExecutada: false } : {}),
                 });
                 resumoModulo.saidaTestes.push({ alvo, stdout: "", stderr: `resultado reutilizado do cache de verificacao (chave ${chave.slice(0, 12)})` });
                 if (!emCache.sucesso) {
@@ -444,6 +464,7 @@ export async function comandoVerificarJson(entrada, baseSaida, cwd = process.cwd
                 estrutura,
                 testesExecutados,
                 origem: "executado",
+                ...(alvo === "python" ? { tipoEvidencia: "andaime_demonstrativo", implementacaoExternaExecutada: false } : {}),
             });
             resumoModulo.saidaTestes.push({ alvo, stdout: execucao.saidaPadrao, stderr: execucao.saidaErro });
             if (execucao.codigoSaida !== 0) {

package/dist/indexPack.d.ts

@@ -2,7 +2,7 @@ import type { ResumoSemanticoModuloIa } from "./index.part01.js";
 type EntradaIndice = Pick<ResumoSemanticoModuloIa, "arquivo" | "modulo" | "faz" | "tarefasPrincipais" | "regrasCriticas" | "efeitos" | "riscosPrincipais" | "lacunas" | "arquivosProvaveis" | "checksSugeridos" | "testesMinimos" | "arquivosProvaveisEditar">;
 export type IndexPack = {
     schema: "sema.ai.index-pack/v1";
-    selection: "deterministic_weighted_match";
+    selection: "deterministic_weighted_match" | "deterministic_summary_projection";
     request: string;
     source: {
         command: "resumo-projeto";

package/dist/indexPack.js

@@ -17,7 +17,9 @@ function tokens(value) {
 function correspondeToken(campo, pedido) {
     return tokens(campo).some((token) => [...pedido].some((alvo) => token.startsWith(alvo) || alvo.startsWith(token)));
 }
-function selecionarValores(values, requestTokens, maximo) {
+function selecionarValores(values, requestTokens, maximo, projetarResumoInteiro) {
+    if (projetarResumoInteiro)
+        return values.slice(0, maximo);
     return values
         .map((value, index) => ({
         value,
@@ -32,7 +34,7 @@ function selecionarValores(values, requestTokens, maximo) {
 function estimarTokens(chars) {
     return Math.ceil(chars / 4);
 }
-function compactarModulo(modulo, requestTokens) {
+function compactarModulo(modulo, requestTokens, projetarResumoInteiro) {
     const tarefas = lista(modulo.tarefasPrincipais);
     const regras = lista(modulo.regrasCriticas);
     const efeitos = lista(modulo.efeitos);
@@ -52,36 +54,40 @@ function compactarModulo(modulo, requestTokens) {
         ["lacunas", lacunas, 1],
         ["arquivos", [...arquivos, ...arquivosEditar], 1],
     ];
-    const relevanceScore = camposComPeso.reduce((total, [, values, weight]) => total + values.reduce((subtotal, value) => subtotal + (correspondeToken(value, requestTokens) ? weight : 0), 0), 0);
-    if (relevanceScore === 0)
+    const relevanceScore = projetarResumoInteiro ? 1 : camposComPeso.reduce((total, [, values, weight]) => total + values.reduce((subtotal, value) => subtotal + (correspondeToken(value, requestTokens) ? weight : 0), 0), 0);
+    if (!projetarResumoInteiro && relevanceScore === 0)
         return null;
     return {
         module: texto(modulo.modulo),
         contract: texto(modulo.arquivo),
         relevanceScore,
         purpose: texto(modulo.faz),
-        relevantTasks: selecionarValores(tarefas, requestTokens, 8),
-        criticalRules: selecionarValores(regras, requestTokens, 8),
-        effects: selecionarValores(efeitos, requestTokens, 6),
-        risks: selecionarValores(riscos, requestTokens, 6),
-        knownGaps: selecionarValores(lacunas, requestTokens, 6),
-        likelyFiles: selecionarValores(arquivos, requestTokens, 8),
-        filesToEdit: selecionarValores(arquivosEditar, requestTokens, 8),
-        requiredChecks: selecionarValores(checks, requestTokens, 6),
-        minimumTests: selecionarValores(testes, requestTokens, 6),
+        relevantTasks: selecionarValores(tarefas, requestTokens, 8, projetarResumoInteiro),
+        criticalRules: selecionarValores(regras, requestTokens, 8, projetarResumoInteiro),
+        effects: selecionarValores(efeitos, requestTokens, 6, projetarResumoInteiro),
+        risks: selecionarValores(riscos, requestTokens, 6, projetarResumoInteiro),
+        knownGaps: selecionarValores(lacunas, requestTokens, 6, projetarResumoInteiro),
+        likelyFiles: selecionarValores(arquivos, requestTokens, 8, projetarResumoInteiro),
+        filesToEdit: selecionarValores(arquivosEditar, requestTokens, 8, projetarResumoInteiro),
+        requiredChecks: selecionarValores(checks, requestTokens, 6, projetarResumoInteiro),
+        minimumTests: selecionarValores(testes, requestTokens, 6, projetarResumoInteiro),
     };
 }
 export function selecionarIndiceContexto(input) {
     const request = input.request.trim();
     const requestTokens = new Set(tokens(request));
+    const projetarResumoInteiro = request.length === 0 || request.startsWith("resumo:");
+    const selection = projetarResumoInteiro
+        ? "deterministic_summary_projection"
+        : "deterministic_weighted_match";
     const matches = input.modulos
-        .map((modulo) => compactarModulo(modulo, requestTokens))
+        .map((modulo) => compactarModulo(modulo, requestTokens, projetarResumoInteiro))
         .filter((item) => item !== null)
         .sort((a, b) => b.relevanceScore - a.relevanceScore || a.module.localeCompare(b.module, "pt-BR"))
-        .slice(0, 8);
+        .slice(0, projetarResumoInteiro ? input.modulos.length : 8);
     const base = {
         schema: "sema.ai.index-pack/v1",
-        selection: "deterministic_weighted_match",
+        selection,
         request,
         source: {
             command: "resumo-projeto",
@@ -99,7 +105,7 @@ export function selecionarIndiceContexto(input) {
             omitted: [
                 "SEMA_INDEX.json completo",
                 "agentContextPack duplicado",
-                "módulos sem correspondência literal ou estrutural no pedido",
+                "módulos e campos fora do orçamento da projeção compacta",
                 "catálogo e arquivos não relacionados ao pedido",
             ],
         },

package/docs/testing.md

@@ -148,3 +148,24 @@ Native generator evidence is mandatory when changing C#/.NET or C++ support.
 The `dotnet` smoke must compile and execute through the local .NET SDK. The
 `cpp` smoke must compile and execute through GCC, Clang, or MSVC; checking only
 for generated files is not sufficient.
+
+Python verification must execute the generated code and inspect every declared
+output expectation, including nested fields. A mismatching `expect` must fail;
+the generator must never initialize an output from that expectation. Numeric
+demonstration values respect comparison operators and simultaneous bounds.
+Contradictory guarantees fail explicitly instead of being removed. Nested
+paths preserve every segment and work with both JSON dictionaries and entities.
+
+`SEM125` identifies descriptive scalar fixtures used where an entity or
+structured type is declared. Contract analysis emits a compatibility warning
+for historical declarative examples; executable Python generation rejects
+them before running tests. Replace the scalar with a structured `given` block.
+The regression suite is `testes/integracao/gerador-python-verificacao.test.ts`.
+
+Generated Python functions are demonstration scaffolds. Their metadata declares
+`origem_execucao: andaime_demonstrativo` and
+`implementacao_externa_executada: false`. A linked `impl` is not executed by
+this scaffold: its tests and guarantees cannot establish production behavior.
+Use the application's real tests and drift evidence for that claim. Generated
+failure cases currently retain the explicit synthetic error context and are
+not evidence that the real implementation produces those errors.

package/exemplos/python_verificacao.sema

@@ -0,0 +1,68 @@
+module exemplos.python_verificacao {
+  docs {
+    resumo: "Regressao executavel Python para garantias numericas, formulario tipado, status e metadados aninhados."
+  }
+  entity FormularioEntrega {
+    fields {
+      tipo: Texto
+    }
+  }
+  entity MetaTemplate {
+    fields {
+      original_campaign_id: Texto
+    }
+  }
+  entity Template {
+    fields {
+      _template_meta: MetaTemplate
+    }
+  }
+  entity Status {
+    fields {
+      desired_action: Texto
+    }
+  }
+  task preparar {
+    input {
+      formulario: FormularioEntrega required
+    }
+    output {
+      poolSize: Inteiro
+      workersAplicados: Inteiro
+      template: Template
+      status: Status
+    }
+    rules {
+      formulario.tipo existe
+    }
+    guarantees {
+      poolSize > 0
+      workersAplicados >= 2
+      template._template_meta existe
+      template._template_meta.original_campaign_id em ["campanha_1"]
+      status.desired_action em ["iniciar", "parar"]
+    }
+    tests {
+      caso "verifica cada saida" {
+        given {
+          formulario {
+            tipo: "entrega"
+          }
+        }
+        expect {
+          sucesso: verdadeiro
+          poolSize: 1
+          workersAplicados: 2
+          template {
+            _template_meta {
+              original_campaign_id: "campanha_1"
+            }
+          }
+          status {
+            desired_action: "iniciar"
+          }
+        }
+      }
+    }
+  }
+}

package/node_modules/@sema/gerador-python/dist/expectativas.d.ts

@@ -0,0 +1,3 @@
+import type { IrBlocoDeclarativo, IrTask } from "@sema/nucleo";
+export declare function validarEntradasTestePython(bloco: IrBlocoDeclarativo, campos: Map<string, string>, tipos: Map<string, Map<string, string>>, contexto: string): void;
+export declare function gerarExpectativasPython(task: IrTask, bloco: IrBlocoDeclarativo, tipos: Map<string, Map<string, string>>, prefixo?: string): string[];

package/node_modules/@sema/gerador-python/dist/expectativas.js

@@ -0,0 +1,37 @@
+import { formatarLiteralTestePython } from "./index.part01.js";
+import { acessoPython } from "./valores.js";
+export function validarEntradasTestePython(bloco, campos, tipos, contexto) {
+    for (const campo of bloco.campos) {
+        const tipo = campos.get(campo.nome);
+        if (tipo && tipos.has(tipo) && campo.tipo !== "nulo") {
+            throw new Error(`SEM125: ${contexto}.${campo.nome} exige ${tipo}; forneça bloco estruturado, não texto descritivo.`);
+        }
+    }
+    for (const filho of bloco.blocos) {
+        const tipo = campos.get(filho.nome);
+        if (tipo && tipos.has(tipo))
+            validarEntradasTestePython(filho.conteudo, tipos.get(tipo), tipos, `${contexto}.${filho.nome}`);
+    }
+}
+export function gerarExpectativasPython(task, bloco, tipos, prefixo = "") {
+    const linhas = [];
+    for (const campo of bloco.campos) {
+        const caminho = prefixo ? `${prefixo}.${campo.nome}` : campo.nome;
+        const raiz = caminho.split(".")[0];
+        const saida = task.output.find(item => item.nome === raiz);
+        if (!saida && caminho === "sucesso") {
+            linhas.push(`    assert (resultado is not None) == ${formatarLiteralTestePython(campo.tipo, "Booleano")}, "Expectativa de sucesso divergente"`);
+            continue;
+        }
+        if (!saida)
+            throw new Error(`Expectativa "${caminho}" da task "${task.nome}" não corresponde a campo do output.`);
+        let tipo = saida.tipo;
+        for (const filho of caminho.split(".").slice(1))
+            tipo = tipos.get(tipo)?.get(filho) ?? "Json";
+        linhas.push(`    assert ${acessoPython("resultado", caminho)} == ${formatarLiteralTestePython(campo.tipo, tipo)}, ${JSON.stringify(`Expectativa divergente: ${caminho}`)}`);
+    }
+    for (const filho of bloco.blocos)
+        linhas.push(...gerarExpectativasPython(task, filho.conteudo, tipos, prefixo ? `${prefixo}.${filho.nome}` : filho.nome));
+    return linhas;
+}
+//# sourceMappingURL=expectativas.js.map

package/node_modules/@sema/gerador-python/dist/index.part01.d.ts

@@ -25,4 +25,4 @@ export declare function gerarMapaLiteralPython(campos: Array<{
 export declare function coletarTiposCompostos(modulo: IrModulo): Map<string, Map<string, string>>;
 export declare function gerarLiteralBlocoTestePython(bloco: IrBlocoDeclarativo, tiposCompostos?: Map<string, Map<string, string>>, tiposDeclarados?: Map<string, string>, tipoAtual?: string): string;
 export declare function paraPascalCase(valor: string): string;
-export declare function gerarPreparacaoSaida(task: IrTask): string;
+export declare function gerarPreparacaoSaida(task: IrTask, tipos?: Map<string, Map<string, string>>): string;

package/node_modules/@sema/gerador-python/dist/index.part01.js

@@ -1,5 +1,6 @@
 // SEMA-GOVERNED: sema.geradores_codigo_governado
 // Descricao: modulo particionado; consulte contratos/sema/geradores_codigo_governado.sema antes de editar.
+import { acessoPython, prepararSaidaPython } from "./valores.js";
 import { extrairTiposNomeados, mapearTipoParaPython, } from "@sema/padroes";
 export function mapearCampoParaPython(campo) {
     let anotacao;
@@ -79,7 +80,7 @@ export function gerarMapaErrosPython(erros) {
     return `{\n${entradas.map(([nome, mensagem]) => `    ${JSON.stringify(nome)}: ${JSON.stringify(mensagem)},`).join("\n")}\n}`;
 }
 export function formatarValorPython(valor, camposConhecidos, variavel) {
-    const texto = valor.trim();
+    const texto = valor.trim().replace(/^-\s+(?=\d)/u, "-").replace(/^(-?\d+)\s*\.\s*(\d+)$/u, "$1.$2");
     if (/^-?\d+(?:\.\d+)?$/.test(texto)) {
         return texto;
     }
@@ -93,7 +94,7 @@ export function formatarValorPython(valor, camposConhecidos, variavel) {
         return "None";
     }
     if (camposConhecidos.has(texto.split(".")[0] ?? texto)) {
-        return `${variavel}.${texto}`;
+        return acessoPython(variavel, texto);
     }
     return JSON.stringify(texto);
 }
@@ -106,23 +107,20 @@ export function extrairReferenciaCampoConhecido(valor, camposConhecidos) {
     return camposConhecidos.has(partes[0] ?? "") ? partes : null;
 }
 export function gerarInicializacaoReferenciaSaida(partes) {
-    const [raiz, filho] = partes;
-    if (!raiz || !filho) {
+    if (partes.length === 0)
         return [];
-    }
     return [
-        `    if saida.${raiz} is None:\n        saida.${raiz} = SimpleNamespace()`,
-        `    if getattr(saida.${raiz}, "${filho}", None) is None:\n        saida.${raiz}.${filho} = "valor_garantido"`,
+        `    if ${acessoPython("saida", partes.join("."))} is None:\n        sema_set(saida, ${JSON.stringify(partes)}, "valor_garantido")`,
     ];
 }
 export function resolverExpressaoPython(expressao, camposConhecidos, variavel) {
     switch (expressao.tipo) {
         case "existe":
-            return `${variavel}.${expressao.alvo} is not None`;
+            return `${acessoPython(variavel, expressao.alvo)} is not None`;
         case "comparacao":
-            return `${variavel}.${expressao.alvo} ${expressao.operador} ${formatarValorPython(expressao.valor, camposConhecidos, variavel)}`;
+            return `${acessoPython(variavel, expressao.alvo)} ${expressao.operador} ${formatarValorPython(expressao.valor, camposConhecidos, variavel)}`;
         case "pertencimento":
-            return `${variavel}.${expressao.alvo} in [${(expressao.valores ?? []).map((valor) => formatarValorPython(valor, camposConhecidos, variavel)).join(", ")}]`;
+            return `${acessoPython(variavel, expressao.alvo)} in [${(expressao.valores ?? []).map((valor) => formatarValorPython(valor, camposConhecidos, variavel)).join(", ")}]`;
         case "predicado":
             return "True";
         case "composta":
@@ -253,7 +251,7 @@ export function resolverTipoItemTeste(tipoDeclarado) {
     return undefined;
 }
 export function formatarLiteralTestePython(valor, tipoDeclarado) {
-    const bruto = valor.trim();
+    const bruto = valor.trim().replace(/^-\s+(?=\d)/u, "-").replace(/^(-?\d+)\s*\.\s*(\d+)$/u, "$1.$2");
     if (bruto.startsWith("[") && bruto.endsWith("]")) {
         const interior = bruto.slice(1, -1).trim();
         const tipoItem = resolverTipoItemTeste(tipoDeclarado);
@@ -348,36 +346,7 @@ export function paraPascalCase(valor) {
         .map((parte) => parte[0].toUpperCase() + parte.slice(1))
         .join("");
 }
-export function gerarPreparacaoSaida(task) {
-    const camposSaida = new Set(task.output.map((campo) => campo.nome));
-    const argumentos = task.output.map((campo) => `${campo.nome}=${valorPadraoPython(campo)}`).join(", ");
-    const ajustes = [];
-    for (const garantia of task.garantiasEstruturadas) {
-        if (garantia.tipo === "pertencimento" && garantia.valores && camposSaida.has(garantia.alvo)) {
-            ajustes.push(`    saida.${garantia.alvo} = ${formatarValorPython(garantia.valores[0] ?? "", camposSaida, "saida")}`);
-        }
-        if (garantia.tipo === "comparacao" && garantia.valor && camposSaida.has(garantia.alvo.split(".")[0] ?? garantia.alvo) && !garantia.alvo.includes(".")) {
-            ajustes.push(`    saida.${garantia.alvo} = ${formatarValorPython(garantia.valor, camposSaida, "saida")}`);
-        }
-        if (garantia.tipo === "comparacao" && garantia.valor && garantia.alvo.includes(".")) {
-            const [raiz, filho] = garantia.alvo.split(".", 2);
-            if (raiz && filho && camposSaida.has(raiz)) {
-                const referenciaValor = extrairReferenciaCampoConhecido(garantia.valor, camposSaida);
-                if (referenciaValor) {
-                    ajustes.push(...gerarInicializacaoReferenciaSaida(referenciaValor));
-                }
-                ajustes.push(`    if saida.${raiz} is None:\n        saida.${raiz} = SimpleNamespace()`);
-                ajustes.push(`    saida.${raiz}.${filho} = ${formatarValorPython(garantia.valor, camposSaida, "saida")}`);
-            }
-        }
-        if (garantia.tipo === "existe" && garantia.alvo.includes(".")) {
-            const [raiz, filho] = garantia.alvo.split(".", 2);
-            if (raiz && filho && camposSaida.has(raiz)) {
-                ajustes.push(`    if saida.${raiz} is None:\n        saida.${raiz} = SimpleNamespace()`);
-                ajustes.push(`    if getattr(saida.${raiz}, "${filho}", None) is None:\n        saida.${raiz}.${filho} = "valor_garantido"`);
-            }
-        }
-    }
-    return `    saida = ${task.nome}Saida(${argumentos})\n${ajustes.join("\n")}`;
+export function gerarPreparacaoSaida(task, tipos = new Map()) {
+    return prepararSaidaPython(task, tipos);
 }
 //# sourceMappingURL=index.part01.js.map

package/node_modules/@sema/gerador-python/dist/index.part02.js

@@ -1,8 +1,11 @@
 // SEMA-GOVERNED: sema.geradores_codigo_governado
 // Descricao: modulo particionado; consulte contratos/sema/geradores_codigo_governado.sema antes de editar.
 import path from "node:path";
+import { prepararSaidaPython } from "./valores.js";
+import { RUNTIME_PYTHON } from "./runtime.js";
+import { gerarExpectativasPython, validarEntradasTestePython } from "./expectativas.js";
 import { descreverEstruturaModulo, normalizarNomeModulo, normalizarNomeParaSimbolo, } from "@sema/padroes";
-import { coletarTiposCompostos, coletarTiposExternos, formatarLiteralTestePython, gerarComentarioInvariantesPython, gerarDataclass, gerarListaCamposPython, gerarLiteralBlocoTestePython, gerarMapaErrosPython, gerarPreparacaoSaida, mapearCampoParaPython, paraPascalCase, resolverExpressaoPython } from "./index.part01.js";
+import { coletarTiposCompostos, coletarTiposExternos, formatarLiteralTestePython, gerarComentarioInvariantesPython, gerarDataclass, gerarListaCamposPython, gerarLiteralBlocoTestePython, gerarMapaErrosPython, mapearCampoParaPython, paraPascalCase, resolverExpressaoPython } from "./index.part01.js";
 export function finalizarBlocoPython(linhas) {
     if (linhas.length === 0) {
         return "    pass";
@@ -48,6 +51,8 @@ export function gerarMetadadosTask(task) {
     "impl": ${implementacoes},
     "errors": ${gerarMapaErrosPython(task.errors)},
     "guarantees": ${JSON.stringify(task.guarantees, null, 2)},
+    "origem_execucao": "andaime_demonstrativo",
+    "implementacao_externa_executada": False,
 }
 `;
 }
@@ -191,7 +196,7 @@ ${erroAutorizacao ? `    if contexto_execucao["erro_esperado"] == "${erroAutoriz
 ${task.stateContract ? `    # Vinculo de estado: ${task.stateContract.nomeEstado ?? "nao_definido"}\n    # Transicoes declaradas pela task: ${task.stateContract.transicoes.map((transicao) => `${transicao.origem}->${transicao.destino}`).join(", ") || "nenhuma"}` : ""}
 ${implementacoes}
 ${efeitos}
-${gerarPreparacaoSaida(task)}
+${prepararSaidaPython(task, tiposCompostos)}
 ${garantias}
 `;
 }
@@ -202,6 +207,7 @@ export function gerarTestes(modulo) {
         const nomeFuncao = `executar_${normalizarNomeParaSimbolo(task.nome)}`;
         const tiposEntrada = new Map(task.input.map((campo) => [campo.nome, campo.tipo]));
         for (const caso of task.tests) {
+            validarEntradasTestePython(caso.given, tiposEntrada, tiposCompostos, `given da task ${task.nome}, caso ${caso.nome}`);
             const argumentos = [
                 ...caso.given.campos
                     .filter((campo) => tiposEntrada.has(campo.nome))
@@ -222,14 +228,15 @@ export function gerarTestes(modulo) {
                 linhas.push(`def test_${normalizarNomeParaSimbolo(task.nome)}_${normalizarNomeParaSimbolo(caso.nome)}() -> None:\n    entrada = ${task.nome}Entrada(${argumentos})\n    contexto = { ${contextoLinhas.join(", ")} }\n    with pytest.raises(${task.nome}_${tipoErro}Erro):\n        ${nomeFuncao}(entrada, contexto)\n`);
                 continue;
             }
-            linhas.push(`def test_${normalizarNomeParaSimbolo(task.nome)}_${normalizarNomeParaSimbolo(caso.nome)}() -> None:\n    entrada = ${task.nome}Entrada(${argumentos})\n    resultado = ${nomeFuncao}(entrada)\n    assert resultado is not None\n`);
+            const expectativas = gerarExpectativasPython(task, caso.expect, tiposCompostos);
+            linhas.push(`def test_${normalizarNomeParaSimbolo(task.nome)}_${normalizarNomeParaSimbolo(caso.nome)}() -> None:\n    entrada = ${task.nome}Entrada(${argumentos})\n    resultado = ${nomeFuncao}(entrada)\n${expectativas.length ? expectativas.join("\n") : "    assert resultado is not None"}\n`);
         }
     }
     return linhas.join("\n");
 }
 export function gerarCabecalhoSemaPython(modulo, tipo = "contrato") {
     const descricoes = {
-        contrato: "artefato Python gerado para executar e revisar as regras declaradas no contrato Sema.",
+        contrato: "andaime Python demonstrativo para revisar regras; não constitui prova de execução da implementação externa.",
         teste: "testes Python gerados a partir dos casos do contrato Sema.",
         schemas: "schemas FastAPI derivados do contrato Sema para entrada e saída públicas.",
         service: "service FastAPI que conecta o scaffold do framework às tasks governadas pelo contrato Sema.",
@@ -262,7 +269,7 @@ export function gerarPythonBase(modulo) {
     const tiposCompostos = coletarTiposCompostos(modulo);
     const tasks = modulo.tasks.map((task) => gerarTask(task, tiposCompostos)).join("\n");
     const contratosPublicos = gerarRotas(modulo);
-    const codigo = `${gerarCabecalhoSemaPython(modulo)}from __future__ import annotations\n${interoperabilidades ? `${interoperabilidades}\n` : ""}\nfrom dataclasses import dataclass\nfrom types import SimpleNamespace\n\n${tiposExternos}\n${tipos}\n${enums}\n${entidades}\n${states}\n${flows}\n${routes}\n${tasks}\n${contratosPublicos}\n`;
+    const codigo = `${gerarCabecalhoSemaPython(modulo)}from __future__ import annotations\n${interoperabilidades ? `${interoperabilidades}\n` : ""}\nfrom dataclasses import dataclass\nfrom types import SimpleNamespace\n${RUNTIME_PYTHON}\n${tiposExternos}\n${tipos}\n${enums}\n${entidades}\n${states}\n${flows}\n${routes}\n${tasks}\n${contratosPublicos}\n`;
     const testes = `${gerarCabecalhoSemaPython(modulo, "teste")}${gerarTestes(modulo)}`;
     return [
         { caminhoRelativo: `${nomeBase}.py`, conteudo: codigo },

package/node_modules/@sema/gerador-python/dist/runtime.d.ts

@@ -0,0 +1 @@
+export declare const RUNTIME_PYTHON = "\nimport math\n\ndef sema_get(objeto, caminho):\n    for campo in caminho:\n        if objeto is None:\n            return None\n        objeto = objeto.get(campo) if isinstance(objeto, dict) else getattr(objeto, campo, None)\n    return objeto\n\ndef sema_set(objeto, caminho, valor):\n    for campo in caminho[:-1]:\n        filho = sema_get(objeto, [campo])\n        if filho is None:\n            filho = {} if isinstance(objeto, dict) else SimpleNamespace()\n            if isinstance(objeto, dict):\n                objeto[campo] = filho\n            else:\n                setattr(objeto, campo, filho)\n        if not isinstance(filho, dict) and not hasattr(filho, \"__dict__\"):\n            raise ValueError(f\"Caminho de objeto incompat\u00EDvel: {campo}\")\n        objeto = filho\n    if isinstance(objeto, dict):\n        objeto[caminho[-1]] = valor\n    else:\n        setattr(objeto, caminho[-1], valor)\n\ndef sema_sintetizar(atual, restricoes, inteiro=False):\n    # Apenas valores demonstrativos: expect nunca participa desta s\u00EDntese.\n    def aceita(valor):\n        for operador, limite in restricoes:\n            if operador == \"existe\" and valor is None:\n                return False\n            if operador == \"in\" and valor not in limite:\n                return False\n            try:\n                if operador == \"==\" and valor != limite: return False\n                if operador == \"!=\" and valor == limite: return False\n                if operador == \">\" and not valor > limite: return False\n                if operador == \">=\" and not valor >= limite: return False\n                if operador == \"<\" and not valor < limite: return False\n                if operador == \"<=\" and not valor <= limite: return False\n            except TypeError:\n                return False\n        return True\n\n    candidatos = [atual]\n    numeros = []\n    for operador, limite in restricoes:\n        if operador == \"in\":\n            candidatos.extend(limite)\n        elif operador != \"existe\":\n            candidatos.append(limite)\n            if isinstance(limite, (int, float)) and not isinstance(limite, bool):\n                numeros.append(limite)\n                candidatos.extend([limite - 1, limite + 1, math.floor(limite), math.ceil(limite)])\n    numeros.sort()\n    candidatos.extend((a + b) / 2 for a, b in zip(numeros, numeros[1:]))\n    candidatos.extend([1, 0, -1, True, False, \"valor_garantido\", \"outro_valor\"])\n    for candidato in candidatos:\n        if inteiro and (not isinstance(candidato, int) or isinstance(candidato, bool)):\n            continue\n        if aceita(candidato):\n            return candidato\n    raise ValueError(\"N\u00E3o foi poss\u00EDvel sintetizar sa\u00EDda demonstrativa compat\u00EDvel com as garantias; forne\u00E7a implementa\u00E7\u00E3o real.\")\n";

package/node_modules/@sema/gerador-python/dist/runtime.js

@@ -0,0 +1,70 @@
+// SEMA-GOVERNED: sema.produto.gerador_python_verificacao
+// Contrato: contratos/sema/gerador_python_verificacao.sema
+// Descrição: acesso uniforme a mapas e entidades e síntese demonstrativa de garantias.
+export const RUNTIME_PYTHON = `
+import math
+
+def sema_get(objeto, caminho):
+    for campo in caminho:
+        if objeto is None:
+            return None
+        objeto = objeto.get(campo) if isinstance(objeto, dict) else getattr(objeto, campo, None)
+    return objeto
+
+def sema_set(objeto, caminho, valor):
+    for campo in caminho[:-1]:
+        filho = sema_get(objeto, [campo])
+        if filho is None:
+            filho = {} if isinstance(objeto, dict) else SimpleNamespace()
+            if isinstance(objeto, dict):
+                objeto[campo] = filho
+            else:
+                setattr(objeto, campo, filho)
+        if not isinstance(filho, dict) and not hasattr(filho, "__dict__"):
+            raise ValueError(f"Caminho de objeto incompatível: {campo}")
+        objeto = filho
+    if isinstance(objeto, dict):
+        objeto[caminho[-1]] = valor
+    else:
+        setattr(objeto, caminho[-1], valor)
+
+def sema_sintetizar(atual, restricoes, inteiro=False):
+    # Apenas valores demonstrativos: expect nunca participa desta síntese.
+    def aceita(valor):
+        for operador, limite in restricoes:
+            if operador == "existe" and valor is None:
+                return False
+            if operador == "in" and valor not in limite:
+                return False
+            try:
+                if operador == "==" and valor != limite: return False
+                if operador == "!=" and valor == limite: return False
+                if operador == ">" and not valor > limite: return False
+                if operador == ">=" and not valor >= limite: return False
+                if operador == "<" and not valor < limite: return False
+                if operador == "<=" and not valor <= limite: return False
+            except TypeError:
+                return False
+        return True
+
+    candidatos = [atual]
+    numeros = []
+    for operador, limite in restricoes:
+        if operador == "in":
+            candidatos.extend(limite)
+        elif operador != "existe":
+            candidatos.append(limite)
+            if isinstance(limite, (int, float)) and not isinstance(limite, bool):
+                numeros.append(limite)
+                candidatos.extend([limite - 1, limite + 1, math.floor(limite), math.ceil(limite)])
+    numeros.sort()
+    candidatos.extend((a + b) / 2 for a, b in zip(numeros, numeros[1:]))
+    candidatos.extend([1, 0, -1, True, False, "valor_garantido", "outro_valor"])
+    for candidato in candidatos:
+        if inteiro and (not isinstance(candidato, int) or isinstance(candidato, bool)):
+            continue
+        if aceita(candidato):
+            return candidato
+    raise ValueError("Não foi possível sintetizar saída demonstrativa compatível com as garantias; forneça implementação real.")
+`;
+//# sourceMappingURL=runtime.js.map

package/node_modules/@sema/gerador-python/dist/valores.d.ts

@@ -0,0 +1,4 @@
+import type { IrTask } from "@sema/nucleo";
+export declare function acessoPython(variavel: string, caminho: string): string;
+export declare function valorCompostoPython(tipo: string, tipos: Map<string, Map<string, string>>, vistos?: Set<string>): string;
+export declare function prepararSaidaPython(task: IrTask, tipos: Map<string, Map<string, string>>): string;

package/node_modules/@sema/gerador-python/dist/valores.js

@@ -0,0 +1,72 @@
+import { formatarValorPython } from "./index.part01.js";
+export function acessoPython(variavel, caminho) {
+    return `sema_get(${variavel}, ${JSON.stringify(caminho.split("."))})`;
+}
+export function valorCompostoPython(tipo, tipos, vistos = new Set()) {
+    if (/^(Lista|Mapa)</u.test(tipo) || /\[\]$/u.test(tipo))
+        return tipo.startsWith("Mapa") ? "{}" : "[]";
+    if (tipo.startsWith("Opcional<") || tipo.endsWith("?"))
+        return "None";
+    if (["Numero", "Inteiro", "Decimal"].includes(tipo))
+        return "1";
+    if (tipo === "Booleano")
+        return "False";
+    if (["Json", "Objeto"].includes(tipo))
+        return "{}";
+    if (!tipos.has(tipo))
+        return ["Texto", "Id", "Email", "Url", "Data", "DataHora", "Timestamp"].includes(tipo) ? '"valor_garantido"' : "SimpleNamespace()";
+    if (vistos.has(tipo))
+        return "None";
+    const proximos = new Set(vistos).add(tipo);
+    return `${tipo}(${[...tipos.get(tipo)].map(([nome, filho]) => `${nome}=${valorCompostoPython(filho, tipos, proximos)}`).join(", ")})`;
+}
+function termosConjuntos(expressao) {
+    return expressao.tipo === "composta" && expressao.operadorLogico === "e"
+        ? expressao.termos.flatMap(termosConjuntos) : [expressao];
+}
+export function prepararSaidaPython(task, tipos) {
+    const campos = new Set(task.output.map(campo => campo.nome));
+    const grupos = new Map();
+    for (const regra of task.garantiasEstruturadas.flatMap(termosConjuntos)) {
+        if (!("alvo" in regra) || !campos.has(regra.alvo.split(".")[0]))
+            continue;
+        if (!["comparacao", "pertencimento", "existe"].includes(regra.tipo))
+            continue;
+        grupos.set(regra.alvo, [...(grupos.get(regra.alvo) ?? []), regra]);
+    }
+    const argumentos = task.output.map(campo => `${campo.nome}=${campo.opcional ? "None" : valorCompostoPython(campo.tipo, tipos)}`);
+    const linhas = [`    # Andaime demonstrativo; não executa a implementação externa vinculada.`, `    saida = ${task.nome}Saida(${argumentos.join(", ")})`];
+    // Inicialize folhas antes de suas referências e preserve nós que são pais.
+    const referencias = new Set();
+    for (const regras of grupos.values())
+        for (const regra of regras) {
+            if (regra.tipo === "comparacao" && campos.has(regra.valor.split(".")[0]))
+                referencias.add(regra.valor);
+        }
+    for (const referencia of referencias) {
+        if (!grupos.has(referencia))
+            grupos.set(referencia, [{ tipo: "existe", alvo: referencia, textoOriginal: `${referencia} existe` }]);
+    }
+    const caminhos = [...grupos.keys()].sort((a, b) => Number(referencias.has(b)) - Number(referencias.has(a)) || a.split(".").length - b.split(".").length);
+    for (const caminho of caminhos) {
+        const regras = grupos.get(caminho);
+        let tipo = task.output.find(campo => campo.nome === caminho.split(".")[0])?.tipo ?? "Json";
+        for (const segmento of caminho.split(".").slice(1))
+            tipo = tipos.get(tipo)?.get(segmento) ?? "Json";
+        const restricoes = regras.map(regra => {
+            if (regra.tipo === "comparacao")
+                return `(${JSON.stringify(regra.operador)}, ${formatarValorPython(regra.valor, campos, "saida")})`;
+            if (regra.tipo === "pertencimento")
+                return `("in", [${(regra.valores ?? []).map(valor => formatarValorPython(valor, campos, "saida")).join(", ")}])`;
+            return '("existe", None)';
+        });
+        if (regras.every(regra => regra.tipo === "existe") && caminhos.some(outro => outro.startsWith(`${caminho}.`))) {
+            linhas.push(`    if ${acessoPython("saida", caminho)} is None:`, `        sema_set(saida, ${JSON.stringify(caminho.split("."))}, ${valorCompostoPython(tipo, tipos) === "None" ? "SimpleNamespace()" : valorCompostoPython(tipo, tipos)})`);
+        }
+        else {
+            linhas.push(`    sema_set(saida, ${JSON.stringify(caminho.split("."))}, sema_sintetizar(${acessoPython("saida", caminho)}, [${restricoes.join(", ")}], inteiro=${tipo === "Inteiro" ? "True" : "False"}))`);
+        }
+    }
+    return linhas.join("\n");
+}
+//# sourceMappingURL=valores.js.map

package/node_modules/@sema/nucleo/dist/semantico/analisador.part08.js

@@ -8,6 +8,7 @@ import { validarFlow, validarInvariantesDeCampos, validarState } from "./analisa
 import { validarStatusTextoComState, validarTask } from "./analisador.part07.js";
 import { validarGuardrailsSeguranca, validarRoute } from "./analisador.part06.js";
 import { validarDatabase } from "./analisador.part02.js";
+import { validarTiposEstruturadosTestes } from "./testesTipos.js";
 export function analisarSemantica(modulo, opcoes = {}) {
     const diagnosticos = [];
     const simbolos = new Map();
@@ -177,6 +178,7 @@ export function analisarSemantica(modulo, opcoes = {}) {
     for (const task of modulo.tasks) {
         validarTask(task, tiposConhecidos, statesConhecidos, diagnosticos);
     }
+    validarTiposEstruturadosTestes(modulo, diagnosticos);
     for (const flow of modulo.flows) {
         validarFlow(flow, tasksConhecidas, tarefasDetalhadas, diagnosticos);
     }

package/node_modules/@sema/nucleo/dist/semantico/testesTipos.d.ts

@@ -0,0 +1,3 @@
+import type { ModuloAst } from "../ast/tipos.js";
+import { type Diagnostico } from "../diagnosticos/index.js";
+export declare function validarTiposEstruturadosTestes(modulo: ModuloAst, diagnosticos: Diagnostico[]): void;

package/node_modules/@sema/nucleo/dist/semantico/testesTipos.js

@@ -0,0 +1,35 @@
+import { criarDiagnostico } from "../diagnosticos/index.js";
+export function validarTiposEstruturadosTestes(modulo, diagnosticos) {
+    const tipos = new Map();
+    for (const item of [...modulo.types, ...modulo.entities]) {
+        const fields = item.corpo.blocos.find(bloco => bloco.tipo === "bloco_generico" && bloco.palavraChave === "fields");
+        tipos.set(item.nome, fields?.tipo === "bloco_generico" ? fields.campos : item.corpo.campos);
+    }
+    function conferir(bloco, campos, contexto) {
+        for (const valor of bloco.campos) {
+            const declarado = campos.find(campo => campo.nome === valor.nome);
+            if (!declarado || !tipos.has(declarado.valor))
+                continue;
+            if (valor.valor === "nulo" && !declarado.modificadores.includes("required"))
+                continue;
+            diagnosticos.push(criarDiagnostico("SEM125", `${contexto}: "${valor.nome}" exige ${declarado.valor}, mas recebeu literal escalar; caso não executável.`, "aviso", valor.intervalo, `Use ${valor.nome} { ... } com os campos de ${declarado.valor}; texto descritivo não é uma entidade.`));
+        }
+        for (const filho of bloco.blocos) {
+            if (filho.tipo !== "bloco_generico")
+                continue;
+            const tipo = campos.find(campo => campo.nome === filho.nome)?.valor;
+            if (tipo && tipos.has(tipo))
+                conferir(filho, tipos.get(tipo), `${contexto}.${filho.nome}`);
+        }
+    }
+    for (const task of modulo.tasks)
+        for (const caso of task.tests?.blocos ?? []) {
+            if (caso.tipo !== "caso_teste")
+                continue;
+            if (caso.given)
+                conferir(caso.given, task.input?.campos ?? [], `given do caso "${caso.nome}" da task "${task.nome}"`);
+            if (caso.expect)
+                conferir(caso.expect, task.output?.campos ?? [], `expect do caso "${caso.nome}" da task "${task.nome}"`);
+        }
+}
+//# sourceMappingURL=testesTipos.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@semacode/cli",
-  "version": "4.0.0",
+  "version": "4.1.1",
   "description": "Local-first semantic governance CLI for AI agents, proven with Claude, Codex, zCode (GLM) and Kimi: contracts, drift, impact, docs gates, and code generation.",
   "type": "module",
   "icon": "logo.png",