@semacode/cli 4.1.1 → 4.1.3

package/dist/cliGrammar.js

@@ -461,7 +461,7 @@ function validarComandoBasico(comando, args) {
             const estrutura = valorOpcao(parsed, "--estrutura"), framework = valorOpcao(parsed, "--framework");
             return Boolean(alvo && ALVOS_GERACAO.has(alvo)) && (!estrutura || ESTRUTURAS.has(estrutura)) && (!framework || FRAMEWORKS.has(framework));
         }
-        case "verificar": return parsearArgumentos(args, { opcoes: ["--saida", "--alvo"], flags: ["--sem-cache"], maxPosicionais: 1 }) !== null;
+        case "verificar": return parsearArgumentos(args, { opcoes: ["--saida", "--alvo"], flags: ["--sem-cache", "--preservar-implementacao"], maxPosicionais: 1 }) !== null;
         case "sessao": return parsearArgumentos(args, { flags: ["--json"], maxPosicionais: 2 }) !== null;
         case "formatar": return parsearArgumentos(args, { flags: ["--check"], maxPosicionais: 1 }) !== null;
         case "inspecionar": {

package/dist/cliHelpTexto.js

@@ -29,7 +29,8 @@ export function criarAjudaRaiz(versao) {
             "Arquivos existentes são preservados; use --force somente para sobrescrita explícita. O starter de exemplos vem por padrão; --com-exemplos instala o pacote completo. Em subpasta de workspace já governado, a subpasta é registrada nos diretoriosCodigo do sema.config.json ancestral em vez de criar config local.",
             "sema validar contratos/<modulo>.sema --json",
             "sema compilar <arquivo-ou-pasta> --alvo <typescript|python|php|dart|lua|javascript|html|css|dotnet|cpp> --saida <diretorio>",
-            "sema verificar <arquivo-ou-pasta> [--saida <dir>] [--alvo <alvo>] [--sem-cache] --json",
+            "sema verificar <arquivo-ou-pasta> [--saida <dir>] [--alvo <alvo>] [--sem-cache] [--preservar-implementacao] --json",
+            "  --preservar-implementacao: somente Python base; preserva implementação local, regenera testes e ignora cache. Não comprova produção.",
             "",
             "[2] Editar projeto que já usa Sema",
             "sema inspecionar . [--drift <none|cache|fresh>] --json",
@@ -121,7 +122,7 @@ export function criarAjudaRaiz(versao) {
             "geração: sema compilar <arquivo-ou-pasta> --alvo <typescript|python|php|dart|lua|javascript|html|css|dotnet|cpp> --saida <diretorio> [--estrutura <flat|modulos|backend>] [--framework <base|nestjs|fastapi>]",
             "teste local: sema testar <arquivo.sema> --alvo <typescript|python|php|dart|lua|javascript|html|css|dotnet|cpp> --saida <diretorio-temporario> [--estrutura <flat|modulos|backend>] [--framework <base|nestjs|fastapi>]",
             "aliases nativos: cs|csharp -> dotnet; c++|cxx|cc -> cpp (CLI e sema.config.json)",
-            "verificação final: sema verificar <arquivo-ou-pasta> [--saida <diretorio-base>] [--alvo <alvo>] [--sem-cache] [--json]",
+            "verificação final: sema verificar <arquivo-ou-pasta> [--saida <diretorio-base>] [--alvo <alvo>] [--sem-cache] [--preservar-implementacao] [--json]",
             "formatação: sema formatar <arquivo-ou-pasta> [--check] [--json]",
             "author: sema author <iniciar|validar|briefing|revisar-cliches|validar-narrativa|validar-proibicoes> [arquivo] [--tema-sensivel] [--preset conto|romance|roteiro|lore|campanha] [--saida <arquivo>] [--texto <texto>] [--json]",
             "profile: 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]",

package/dist/geracaoCore.d.ts

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

package/dist/index.part07.d.ts

@@ -3,6 +3,7 @@ import type { EstruturaSaida } from "./tipos.js";
 export interface OpcoesVerificar {
     alvo?: string;
     semCache?: boolean;
+    preservarImplementacao?: boolean;
 }
 export declare function alvosSuportadosPelaStack(fontesLegado: string[] | undefined): AlvoGeracao[] | undefined;
 export declare function avisoEscopoStackVerificacao(fontesLegado: string[] | undefined, alvosEfetivos: AlvoGeracao[]): string | undefined;

package/dist/index.part07.js

@@ -6,6 +6,7 @@ import pacoteCli from "../package.json" with { type: "json" };
 import { compilarCodigo, formatarDiagnosticos, lerArquivoTexto, temErros, } from "@sema/nucleo";
 import { carregarProjeto, resolverAlvosVerificacao, } from "./projeto.js";
 import { SCHEMA_CACHE_VERIFICACAO, calcularChaveVerificacao, carregarCacheVerificacao, gravarCacheVerificacao, } from "./verificacaoCache.js";
+import { erroModoPreservacao, prepararImplementacaoPythonLocal, evidenciaPython } from "./verificacaoPythonLocal.js";
 const FONTES_POR_ALVO_SUPORTADO = {
     typescript: ["typescript", "javascript"],
     javascript: ["typescript", "javascript"],
@@ -210,7 +211,7 @@ export function imprimirResumoVerificacao(resumos) {
             totalArquivos += alvo.arquivosGerados;
             totalTestes += alvo.quantidadeTestes;
             totalAlvos += 1;
-            console.log(`  alvo=${alvo.alvo} framework=${alvo.framework} estrutura=${alvo.estrutura} status=${alvo.sucesso ? "ok" : "falhou"} arquivos=${alvo.arquivosGerados} testes=${alvo.quantidadeTestes}${alvo.testesExecutados ? "" : " (skip)"} saida=${alvo.pastaSaida}`);
+            console.log(`  alvo=${alvo.alvo} framework=${alvo.framework} estrutura=${alvo.estrutura} status=${alvo.sucesso ? "ok" : "falhou"} arquivos=${alvo.arquivosGerados} testes=${alvo.quantidadeTestes}${alvo.testesExecutados ? "" : " (skip)"}${alvo.tipoEvidencia ? ` evidencia=${alvo.tipoEvidencia} (não comprova produção)` : ""} saida=${alvo.pastaSaida}`);
         }
     }
     console.log(`Totais: modulos=${resumos.length} alvos=${totalAlvos} arquivos=${totalArquivos} testes=${totalTestes}`);
@@ -240,6 +241,11 @@ export async function comandoVerificar(entrada, baseSaida, cwd = process.cwd(),
         ...resolverConfiguracaoVerificacaoPorAlvo(alvo, contextoProjeto.configCarregada),
     }));
     const incompatibilidade = configuracoesAlvo.find((item) => item.incompatibilidade);
+    const erroPreservacao = erroModoPreservacao(opcoes.preservarImplementacao, configuracoesAlvo);
+    if (erroPreservacao) {
+        console.error(erroPreservacao);
+        return 1;
+    }
     if (incompatibilidade?.incompatibilidade) {
         console.error(incompatibilidade.incompatibilidade);
         return 1;
@@ -272,7 +278,7 @@ export async function comandoVerificar(entrada, baseSaida, cwd = process.cwd(),
                 estrutura,
                 conteudoContrato,
             });
-            const emCache = opcoes.semCache ? undefined : await carregarCacheVerificacao(chave, pastaAlvo);
+            const emCache = opcoes.semCache || opcoes.preservarImplementacao ? undefined : await carregarCacheVerificacao(chave, pastaAlvo);
             if (emCache) {
                 resumoModulo.alvos.push({
                     alvo,
@@ -294,21 +300,27 @@ export async function comandoVerificar(entrada, baseSaida, cwd = process.cwd(),
                 continue;
             }
             const arquivos = aplicarEstruturaSaida(gerarArquivosPorAlvo(ir, alvo, framework), ir, estrutura);
-            const escrita = await escreverArquivos(pastaAlvo, arquivos, { artefatoGerado: true });
+            const preparacao = opcoes.preservarImplementacao ? await prepararImplementacaoPythonLocal(pastaAlvo, arquivos) : { arquivosParaEscrita: arquivos };
+            if (preparacao.erro) {
+                console.error(preparacao.erro);
+                return 1;
+            }
+            const escrita = await escreverArquivos(pastaAlvo, preparacao.arquivosParaEscrita, { artefatoGerado: true });
             artefatosGeradosAcimaDoLimite.push(...escrita.artefatosGeradosAcimaDoLimite);
             const { execucao, testesExecutados } = executarTestesParaVerificacao(alvo, pastaAlvo, arquivos, framework);
-            await gravarCacheVerificacao({
-                schemaVersion: SCHEMA_CACHE_VERIFICACAO,
-                chave,
-                versaoCli: pacoteCli.version,
-                alvo,
-                modulo: ir.nome,
-                sucesso: execucao.codigoSaida === 0,
-                quantidadeTestes: execucao.quantidadeTestes,
-                testesExecutados,
-                arquivosGerados: arquivos.map((arquivo) => arquivo.caminhoRelativo),
-                geradoEm: new Date().toISOString(),
-            });
+            if (!opcoes.preservarImplementacao)
+                await gravarCacheVerificacao({
+                    schemaVersion: SCHEMA_CACHE_VERIFICACAO,
+                    chave,
+                    versaoCli: pacoteCli.version,
+                    alvo,
+                    modulo: ir.nome,
+                    sucesso: execucao.codigoSaida === 0,
+                    quantidadeTestes: execucao.quantidadeTestes,
+                    testesExecutados,
+                    arquivosGerados: arquivos.map((arquivo) => arquivo.caminhoRelativo),
+                    geradoEm: new Date().toISOString(),
+                });
             resumoModulo.alvos.push({
                 alvo,
                 arquivosGerados: arquivos.length,
@@ -319,7 +331,7 @@ export async function comandoVerificar(entrada, baseSaida, cwd = process.cwd(),
                 estrutura,
                 testesExecutados,
                 origem: "executado",
-                ...(alvo === "python" ? { tipoEvidencia: "andaime_demonstrativo", implementacaoExternaExecutada: false } : {}),
+                ...(alvo === "python" ? evidenciaPython(opcoes.preservarImplementacao) : {}),
             });
             if (execucao.codigoSaida !== 0) {
                 imprimirResumoVerificacao([...resumos, resumoModulo]);
@@ -372,6 +384,11 @@ export async function comandoVerificarJson(entrada, baseSaida, cwd = process.cwd
         ...resolverConfiguracaoVerificacaoPorAlvo(alvo, contextoProjeto.configCarregada),
     }));
     const incompatibilidade = configuracoesAlvo.find((item) => item.incompatibilidade);
+    const erroPreservacao = erroModoPreservacao(opcoes.preservarImplementacao, configuracoesAlvo);
+    if (erroPreservacao) {
+        console.log(JSON.stringify({ comando: "verificar", sucesso: false, erro: erroPreservacao, modulos: [], totais: { modulos: 0, alvos: 0, arquivos: 0, testes: 0 } }));
+        return 1;
+    }
     if (incompatibilidade?.incompatibilidade) {
         console.log(JSON.stringify({
             comando: "verificar",
@@ -418,7 +435,7 @@ export async function comandoVerificarJson(entrada, baseSaida, cwd = process.cwd
                 estrutura,
                 conteudoContrato,
             });
-            const emCache = opcoes.semCache ? undefined : await carregarCacheVerificacao(chave, pastaAlvo);
+            const emCache = opcoes.semCache || opcoes.preservarImplementacao ? undefined : await carregarCacheVerificacao(chave, pastaAlvo);
             if (emCache) {
                 resumoModulo.alvos.push({
                     alvo,
@@ -439,21 +456,27 @@ export async function comandoVerificarJson(entrada, baseSaida, cwd = process.cwd
                 continue;
             }
             const arquivos = aplicarEstruturaSaida(gerarArquivosPorAlvo(ir, alvo, framework), ir, estrutura);
-            const escrita = await escreverArquivos(pastaAlvo, arquivos, { artefatoGerado: true });
+            const preparacao = opcoes.preservarImplementacao ? await prepararImplementacaoPythonLocal(pastaAlvo, arquivos) : { arquivosParaEscrita: arquivos };
+            if (preparacao.erro) {
+                console.log(JSON.stringify({ comando: "verificar", sucesso: false, erro: preparacao.erro, modulos: resumos, totais: { modulos: resumos.length, alvos: 0, arquivos: 0, testes: 0 } }));
+                return 1;
+            }
+            const escrita = await escreverArquivos(pastaAlvo, preparacao.arquivosParaEscrita, { artefatoGerado: true });
             artefatosGeradosAcimaDoLimite.push(...escrita.artefatosGeradosAcimaDoLimite);
             const { execucao, testesExecutados } = executarTestesParaVerificacao(alvo, pastaAlvo, arquivos, framework, true);
-            await gravarCacheVerificacao({
-                schemaVersion: SCHEMA_CACHE_VERIFICACAO,
-                chave,
-                versaoCli: pacoteCli.version,
-                alvo,
-                modulo: ir.nome,
-                sucesso: execucao.codigoSaida === 0,
-                quantidadeTestes: execucao.quantidadeTestes,
-                testesExecutados,
-                arquivosGerados: arquivos.map((arquivo) => arquivo.caminhoRelativo),
-                geradoEm: new Date().toISOString(),
-            });
+            if (!opcoes.preservarImplementacao)
+                await gravarCacheVerificacao({
+                    schemaVersion: SCHEMA_CACHE_VERIFICACAO,
+                    chave,
+                    versaoCli: pacoteCli.version,
+                    alvo,
+                    modulo: ir.nome,
+                    sucesso: execucao.codigoSaida === 0,
+                    quantidadeTestes: execucao.quantidadeTestes,
+                    testesExecutados,
+                    arquivosGerados: arquivos.map((arquivo) => arquivo.caminhoRelativo),
+                    geradoEm: new Date().toISOString(),
+                });
             resumoModulo.alvos.push({
                 alvo,
                 arquivosGerados: arquivos.length,
@@ -464,7 +487,7 @@ export async function comandoVerificarJson(entrada, baseSaida, cwd = process.cwd
                 estrutura,
                 testesExecutados,
                 origem: "executado",
-                ...(alvo === "python" ? { tipoEvidencia: "andaime_demonstrativo", implementacaoExternaExecutada: false } : {}),
+                ...(alvo === "python" ? evidenciaPython(opcoes.preservarImplementacao) : {}),
             });
             resumoModulo.saidaTestes.push({ alvo, stdout: execucao.saidaPadrao, stderr: execucao.saidaErro });
             if (execucao.codigoSaida !== 0) {

package/dist/index.part08.js

@@ -105,8 +105,8 @@ export async function principal() {
             break;
         case "verificar":
             codigoSaida = possuiFlag(resto, "--json")
-                ? await comandoVerificarJson(posicionais[0], resolverSaidaPadrao(obterOpcao(resto, "--saida", "./.tmp/sema-verificar"), "typescript", await carregarConfiguracaoProjeto(posicionais[0] ? path.resolve(cwd, posicionais[0]) : cwd)), cwd, { alvo: obterOpcao(resto, "--alvo"), semCache: possuiFlag(resto, "--sem-cache") })
-                : await comandoVerificar(posicionais[0], resolverSaidaPadrao(obterOpcao(resto, "--saida", "./.tmp/sema-verificar"), "typescript", await carregarConfiguracaoProjeto(posicionais[0] ? path.resolve(cwd, posicionais[0]) : cwd)), cwd, { alvo: obterOpcao(resto, "--alvo"), semCache: possuiFlag(resto, "--sem-cache") });
+                ? await comandoVerificarJson(posicionais[0], resolverSaidaPadrao(obterOpcao(resto, "--saida", "./.tmp/sema-verificar"), "typescript", await carregarConfiguracaoProjeto(posicionais[0] ? path.resolve(cwd, posicionais[0]) : cwd)), cwd, { alvo: obterOpcao(resto, "--alvo"), semCache: possuiFlag(resto, "--sem-cache"), preservarImplementacao: possuiFlag(resto, "--preservar-implementacao") })
+                : await comandoVerificar(posicionais[0], resolverSaidaPadrao(obterOpcao(resto, "--saida", "./.tmp/sema-verificar"), "typescript", await carregarConfiguracaoProjeto(posicionais[0] ? path.resolve(cwd, posicionais[0]) : cwd)), cwd, { alvo: obterOpcao(resto, "--alvo"), semCache: possuiFlag(resto, "--sem-cache"), preservarImplementacao: possuiFlag(resto, "--preservar-implementacao") });
             break;
         case "inspecionar":
             codigoSaida = await comandoInspecionar(posicionais[0], possuiFlag(resto, "--json"), cwd, resto);

package/dist/verificacaoPythonLocal.d.ts

@@ -0,0 +1,17 @@
+type Arquivo = {
+    caminhoRelativo: string;
+    conteudo: string;
+};
+export declare function erroModoPreservacao(preservar: boolean | undefined, configuracoes: Array<{
+    alvo: string;
+    framework: string;
+}>): string | undefined;
+export declare function prepararImplementacaoPythonLocal(base: string, arquivos: Arquivo[]): Promise<{
+    arquivosParaEscrita: Arquivo[];
+    erro?: string;
+}>;
+export declare function evidenciaPython(preservar: boolean | undefined): {
+    tipoEvidencia: "andaime_demonstrativo" | "implementacao_local_preservada";
+    implementacaoExternaExecutada: boolean;
+};
+export {};

package/dist/verificacaoPythonLocal.js

@@ -0,0 +1,46 @@
+// SEMA-GOVERNED: sema.produto.cli_verificacao
+// Contrato: contratos/sema/cli_verificacao.sema
+// Descrição: preserva Python local explicitamente; testes continuam derivados do contrato, sem cache.
+import { lstat } from "node:fs/promises";
+import path from "node:path";
+export function erroModoPreservacao(preservar, configuracoes) {
+    if (preservar && (configuracoes.length !== 1 || configuracoes[0].alvo !== "python" || configuracoes[0].framework !== "base")) {
+        return "--preservar-implementacao exige --alvo python e framework base.";
+    }
+    return undefined;
+}
+export async function prepararImplementacaoPythonLocal(base, arquivos) {
+    const implementacoes = arquivos.filter(arquivo => arquivo.caminhoRelativo.endsWith(".py") && !path.basename(arquivo.caminhoRelativo).startsWith("test_"));
+    if (implementacoes.length === 0)
+        return { arquivosParaEscrita: [], erro: "Nenhuma implementação Python local prevista pelo contrato." };
+    try {
+        for (const arquivo of implementacoes) {
+            const destino = path.resolve(base, arquivo.caminhoRelativo);
+            const relativo = path.relative(path.resolve(base), destino);
+            if (path.isAbsolute(relativo) || relativo.split(path.sep).includes(".."))
+                throw new Error("escape");
+            let atual = destino;
+            while (true) {
+                const info = await lstat(atual);
+                if (info.isSymbolicLink() || (atual === destino ? !info.isFile() || info.nlink > 1 : !info.isDirectory()))
+                    throw new Error("link ou tipo inválido");
+                const pai = path.dirname(atual);
+                if (pai === atual)
+                    break;
+                atual = pai;
+            }
+        }
+        const preservados = new Set(implementacoes.map(arquivo => arquivo.caminhoRelativo));
+        return { arquivosParaEscrita: arquivos.filter(arquivo => !preservados.has(arquivo.caminhoRelativo)) };
+    }
+    catch {
+        return { arquivosParaEscrita: [], erro: "Implementação Python local ausente ou caminho não seguro. Gere e preencha a implementação antes de usar --preservar-implementacao." };
+    }
+}
+export function evidenciaPython(preservar) {
+    return {
+        tipoEvidencia: preservar ? "implementacao_local_preservada" : "andaime_demonstrativo",
+        implementacaoExternaExecutada: false,
+    };
+}
+//# sourceMappingURL=verificacaoPythonLocal.js.map

package/docs/testing.md

@@ -169,3 +169,21 @@ 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.
+
+To execute an explicitly filled local Python implementation without overwriting
+it, use the same verification output base that contains the generated module:
+
+```bash
+sema verificar contratos/app.sema --alvo python --saida .tmp/check --preservar-implementacao --json
+```
+
+This opt-in mode supports only Python with the base framework. All expected
+implementation files must already exist as regular files, without symlinks,
+junctions or hardlinks. It preserves those files byte for byte, regenerates the
+contract tests and support artifacts, and always runs the tests without reading
+or writing the verification cache. Missing implementations fail before writes;
+new expectations and incorrect implementation results still fail. The output
+reports `tipoEvidencia: implementacao_local_preservada` and
+`implementacaoExternaExecutada: false`: it proves execution of those local files,
+not automatic execution of a linked `impl`, a remote deployment or production.
+Normal verification retains the demonstration scaffold behavior.

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

@@ -8,7 +8,7 @@ export declare function gerarComentarioInvariantesTypeScript(invariantes: Expres
 export declare function gerarLiteralCamposTypeScript(campos: IrCampo[]): string;
 export declare function coletarTiposExternos(modulo: IrModulo): string[];
 export declare function gerarLiteralErrosTypeScript(erros: Record<string, string>): string;
-export declare function formatarValorTypeScript(valor: string, camposConhecidos: Set<string>, variavel: string): string;
+export declare function formatarValorTypeScript(valor: string, camposConhecidos: Set<string>, variavel: string, literal?: boolean): string;
 export declare function resolverReferenciaTypeScript(referencia: string, variavel: string): string;
 export declare function gerarExpressaoTypeScript(expressao: ExpressaoSemantica, camposConhecidos: Set<string>, variavel: string): string;
 export declare function valorPadraoTypeScript(tipo: string, nomeCampo: string): string;
@@ -17,7 +17,7 @@ export declare function dividirLiteralNoNivelRaiz(valor: string, separador: ","
 export declare function resolverTipoItemTeste(tipoDeclarado?: string): string | undefined;
 export declare function formatarLiteralTesteTypeScript(valor: string, tipoDeclarado?: string): unknown;
 export declare function converterBlocoTesteParaValorTypeScript(bloco: IrBlocoDeclarativo, tiposDeclarados?: Map<string, string>): Record<string, unknown>;
-export declare function gerarPreparacaoSaida(task: IrTask): string;
+export declare function gerarPreparacaoSaida(task: IrTask, tiposDeclarados?: Map<string, Map<string, string>>): string;
 export declare function gerarValidacoes(task: IrTask): string;
 export declare function gerarGarantias(task: IrTask): string;
 export declare function gerarFuncaoGarantias(task: IrTask): string;

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

@@ -48,7 +48,7 @@ export function gerarLiteralErrosTypeScript(erros) {
     }
     return `{\n${entradas.map(([nome, mensagem]) => `  ${JSON.stringify(nome)}: ${JSON.stringify(mensagem)},`).join("\n")}\n}`;
 }
-export function formatarValorTypeScript(valor, camposConhecidos, variavel) {
+export function formatarValorTypeScript(valor, camposConhecidos, variavel, literal = false) {
     const texto = valor.trim();
     if (/^-?\d+(?:\.\d+)?$/.test(texto)) {
         return texto;
@@ -62,7 +62,7 @@ export function formatarValorTypeScript(valor, camposConhecidos, variavel) {
     if (texto === "nulo") {
         return "null";
     }
-    if (camposConhecidos.has(texto.split(".")[0] ?? texto)) {
+    if (!literal && camposConhecidos.has(texto.split(".")[0] ?? texto)) {
         return `${variavel}.${texto}`;
     }
     return JSON.stringify(texto);
@@ -260,29 +260,131 @@ export function converterBlocoTesteParaValorTypeScript(bloco, tiposDeclarados) {
     }
     return literal;
 }
-export function gerarPreparacaoSaida(task) {
+function achatarGarantiasConjuntivasTypeScript(expressao) {
+    return expressao.tipo === "composta" && expressao.operadorLogico === "e"
+        ? expressao.termos.flatMap(achatarGarantiasConjuntivasTypeScript)
+        : [expressao];
+}
+function sugerirValoresTypeScript(tipo, tiposDeclarados) {
+    if (["Numero", "Inteiro", "Decimal"].includes(tipo))
+        return "[1, 0, -1]";
+    if (tipo === "Booleano")
+        return "[false, true]";
+    if (["Texto", "Id", "Email", "Url", "Data", "DataHora", "Timestamp"].includes(tipo)) {
+        return '["valor_garantido", "outro_valor"]';
+    }
+    if (/^Lista</u.test(tipo) || /\[\]$/u.test(tipo))
+        return "[[]]";
+    if (/^Mapa</u.test(tipo) || ["Json", "Objeto"].includes(tipo) || tiposDeclarados.has(tipo))
+        return "[{}]";
+    return "[1, 0, -1, true, false, \"valor_garantido\", \"outro_valor\", {}]";
+}
+export function gerarPreparacaoSaida(task, tiposDeclarados = new Map()) {
     const camposSaida = new Set(task.output.map((campo) => campo.nome));
     const linhas = [];
     for (const campo of task.output) {
         linhas.push(`    ${campo.nome}: ${valorPadraoTypeScript(campo.tipo, campo.nome)},`);
     }
-    const ajustes = [];
-    for (const garantia of task.garantiasEstruturadas) {
-        if (garantia.tipo === "pertencimento" && garantia.valores && camposSaida.has(garantia.alvo)) {
-            ajustes.push(`  saida.${garantia.alvo} = ${formatarValorTypeScript(garantia.valores[0] ?? "", camposSaida, "saida")} as any;`);
-        }
-        if (garantia.tipo === "comparacao" && garantia.valor && camposSaida.has(garantia.alvo.split(".")[0] ?? garantia.alvo)) {
-            ajustes.push(`  ${resolverReferenciaTypeScript(garantia.alvo, "saida")} = ${formatarValorTypeScript(garantia.valor, camposSaida, "saida")} as any;`);
+    const grupos = new Map();
+    for (const garantia of task.garantiasEstruturadas.flatMap(achatarGarantiasConjuntivasTypeScript)) {
+        if (!("alvo" in garantia) || !camposSaida.has(garantia.alvo.split(".")[0] ?? garantia.alvo))
+            continue;
+        if (garantia.tipo === "comparacao" || garantia.tipo === "pertencimento" || garantia.tipo === "existe") {
+            grupos.set(garantia.alvo, [...(grupos.get(garantia.alvo) ?? []), garantia]);
         }
-        if (garantia.tipo === "existe" && garantia.alvo.includes(".")) {
-            const [raiz, filho] = garantia.alvo.split(".", 2);
-            if (raiz && filho && camposSaida.has(raiz)) {
-                ajustes.push(`  saida.${raiz} = (saida.${raiz} ?? {}) as any;`);
-                ajustes.push(`  (saida.${raiz} as any).${filho} = (saida.${raiz} as any).${filho} ?? "valor_garantido";`);
+    }
+    const referencias = new Set();
+    for (const regras of grupos.values()) {
+        for (const regra of regras) {
+            if (regra.tipo === "comparacao" && !regra.valorLiteral && camposSaida.has(regra.valor.split(".")[0] ?? regra.valor)) {
+                referencias.add(regra.valor);
             }
         }
     }
-    return `  const saida = {\n${linhas.join("\n")}\n  } as ${task.nome}Saida;\n${ajustes.join("\n")}`;
+    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);
+    const ajustes = [];
+    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 = tiposDeclarados.get(tipo)?.get(segmento) ?? "Json";
+        }
+        const restricoes = regras.map((regra) => {
+            if (regra.tipo === "comparacao") {
+                return `[${JSON.stringify(regra.operador)}, ${formatarValorTypeScript(regra.valor, camposSaida, "saida", regra.valorLiteral)}]`;
+            }
+            if (regra.tipo === "pertencimento") {
+                const valores = (regra.valores ?? []).map((valor) => formatarValorTypeScript(valor, camposSaida, "saida", true));
+                return `["in", [${valores.join(", ")}]]`;
+            }
+            return '["existe", null]';
+        });
+        const caminhoLiteral = JSON.stringify(caminho.split("."));
+        const somenteExistencia = regras.every((regra) => regra.tipo === "existe");
+        const temDescendente = caminhos.some((outro) => outro.startsWith(`${caminho}.`));
+        if (somenteExistencia && temDescendente) {
+            ajustes.push(`  if (semaLerSaida(saida, ${caminhoLiteral}) == null) semaDefinirSaida(saida, ${caminhoLiteral}, {});`);
+            continue;
+        }
+        const inteiro = tipo === "Inteiro" ? "true" : "false";
+        ajustes.push(`  semaDefinirSaida(saida, ${caminhoLiteral}, semaSintetizarSaida(semaLerSaida(saida, ${caminhoLiteral}), [${restricoes.join(", ")}], ${inteiro}, ${sugerirValoresTypeScript(tipo, tiposDeclarados)}));`);
+    }
+    const helpers = grupos.size === 0 ? "" : `
+  const semaLerSaida = (objeto: any, caminho: string[]): any => caminho.reduce((atual, campo) => atual == null ? undefined : atual[campo], objeto);
+  const semaDefinirSaida = (objeto: any, caminho: string[], valor: any): void => {
+    let atual = objeto;
+    for (const campo of caminho.slice(0, -1)) {
+      if (atual[campo] === null || typeof atual[campo] !== "object") atual[campo] = {};
+      atual = atual[campo];
+    }
+    const ultimo = caminho[caminho.length - 1];
+    if (ultimo !== undefined) atual[ultimo] = valor;
+  };
+  const semaSintetizarSaida = (atual: any, restricoes: Array<[string, any]>, inteiro: boolean, sementes: any[]): any => {
+    const aceita = (valor: any): boolean => restricoes.every(([operador, limite]) => {
+      if (operador === "existe") return valor !== undefined && valor !== null;
+      if (operador === "in") return Array.isArray(limite) && limite.some((item: any) => Object.is(item, valor));
+      if (operador === "==") return valor === limite;
+      if (operador === "!=") return valor !== limite;
+      const esquerda: any = valor;
+      const direita: any = limite;
+      if (operador === ">") return esquerda > direita;
+      if (operador === ">=") return esquerda >= direita;
+      if (operador === "<") return esquerda < direita;
+      if (operador === "<=") return esquerda <= direita;
+      return false;
+    });
+    const candidatos: any[] = [atual, ...sementes];
+    const numeros: number[] = [];
+    for (const [operador, limite] of restricoes) {
+      if (operador === "in" && Array.isArray(limite)) candidatos.push(...limite);
+      else if (operador !== "existe") {
+        candidatos.push(limite);
+        if (typeof limite === "number" && Number.isFinite(limite)) {
+          numeros.push(limite);
+          candidatos.push(limite - 1, limite + 1, Math.floor(limite), Math.ceil(limite));
+        } else if (typeof limite === "string") {
+          candidatos.push(limite + "\\u0000", limite.slice(0, -1), "");
+        }
+      }
+    }
+    numeros.sort((a, b) => a - b);
+    for (let indice = 0; indice < numeros.length - 1; indice += 1) {
+      candidatos.push((numeros[indice]! + numeros[indice + 1]!) / 2);
+    }
+    for (const candidato of candidatos) {
+      if (inteiro && (typeof candidato !== "number" || !Number.isInteger(candidato))) continue;
+      if (aceita(candidato)) return candidato;
+    }
+    throw new Error("Nao foi possivel sintetizar uma saida demonstrativa compativel com as garantias.");
+  };
+`;
+    return `  const saida = {\n${linhas.join("\n")}\n  } as ${task.nome}Saida;${helpers}\n${ajustes.join("\n")}`;
 }
 export function gerarValidacoes(task) {
     const linhas = [];

package/node_modules/@sema/gerador-typescript/dist/index.part02.d.ts

@@ -1,7 +1,7 @@
 import type { IrModulo, IrTask } from "@sema/nucleo";
 import { type ArquivoGerado } from "@sema/padroes";
 export declare function gerarRotas(modulo: IrModulo): string;
-export declare function gerarTask(task: IrTask): string;
+export declare function gerarTask(task: IrTask, tiposDeclarados?: Map<string, Map<string, string>>): string;
 export declare function gerarTestes(modulo: IrModulo): string;
 export type TipoCabecalhoSemaTypeScript = "contrato" | "teste" | "dto" | "service" | "controller" | "spec";
 export declare function gerarCabecalhoSemaTypeScript(modulo: IrModulo, tipo?: TipoCabecalhoSemaTypeScript): string;

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

@@ -68,7 +68,7 @@ ${verificacoesErro || "    throw erro;"}
 `;
     }).join("\n");
 }
-export function gerarTask(task) {
+export function gerarTask(task, tiposDeclarados = new Map()) {
     const nomeSimbolo = normalizarNomeParaSimbolo(task.nome);
     const entradaNome = `${nomeSimbolo}_entrada`;
     const saidaNome = `${nomeSimbolo}_saida`;
@@ -130,7 +130,7 @@ ${task.stateContract ? `  // Vinculo de estado: ${task.stateContract.nomeEstado
 ${task.implementacoesExternas.length > 0 ? `  // Implementacoes externas vinculadas:\n${task.implementacoesExternas.map((impl) => `  // - ${impl.origem}: ${impl.caminho} [${impl.statusImpl ?? "nao_verificado"}]`).join("\n")}` : ""}
   // Efeitos declarados:
 ${task.efeitosEstruturados.map((efeito) => `  // - categoria=${efeito.categoria} alvo=${efeito.alvo}${efeito.detalhe ? ` detalhe=${efeito.detalhe}` : ""}${efeito.criticidade ? ` criticidade=${efeito.criticidade}` : ""}`).join("\n") || task.effects.map((efeito) => `  // - ${efeito}`).join("\n") || "  // - Nenhum efeito declarado."}
-${gerarPreparacaoSaida(task)}
+${gerarPreparacaoSaida(task, tiposDeclarados)}
 ${gerarGarantias(task)}
 }
 
@@ -211,6 +211,13 @@ export function gerarCabecalhoSemaTypeScript(modulo, tipo = "contrato") {
 }
 export function gerarTypeScriptBase(modulo) {
     const nomeBase = normalizarNomeModulo(modulo.nome).replace(/\./g, "_");
+    const mapaTiposDeclarados = new Map();
+    for (const entidade of modulo.entities) {
+        mapaTiposDeclarados.set(entidade.nome, new Map(entidade.campos.map((campo) => [campo.nome, campo.tipo])));
+    }
+    for (const tipo of modulo.types) {
+        mapaTiposDeclarados.set(tipo.nome, new Map(tipo.definicao.campos.map((campo) => [campo.nome, campo.tipo])));
+    }
     const interoperabilidades = modulo.interoperabilidades
         .map((interop) => `// Interop externo ${interop.origem}: ${interop.caminho}`)
         .join("\n");
@@ -235,7 +242,7 @@ export function gerarTypeScriptBase(modulo) {
     const routes = modulo.routes
         .map((route) => `// Route ${route.nome}: metodo=${route.metodo ?? "nao_definido"} caminho=${route.caminho ?? "nao_definido"} task=${route.task ?? "nao_definida"} input_publico=${route.inputPublico.map((campo) => campo.nome).join(", ") || "padrao_task"} output_publico=${route.outputPublico.map((campo) => campo.nome).join(", ") || "padrao_task"} erros_publicos=${route.errosPublicos.map((erro) => erro.nome).join(", ") || "padrao_task"} effects_publicos=${route.efeitosPublicos.map((efeito) => `${efeito.categoria}:${efeito.alvo}`).join(", ") || "nenhum"} garantias_publicas=${route.garantiasPublicasMinimas.length}`)
         .join("\n");
-    const tasks = modulo.tasks.map(gerarTask).join("\n");
+    const tasks = modulo.tasks.map((task) => gerarTask(task, mapaTiposDeclarados)).join("\n");
     const contratosPublicos = gerarRotas(modulo);
     const codigo = `${gerarCabecalhoSemaTypeScript(modulo)}${interoperabilidades ? `${interoperabilidades}\n` : ""}\n${tiposExternos}\n${tipos}\n${entidades}\n${enums}\n${states}\n${flows}\n${routes}\n${tasks}\n${contratosPublicos}\n`;
     const testes = `${gerarCabecalhoSemaTypeScript(modulo, "teste")}${gerarTestes(modulo)}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@semacode/cli",
-  "version": "4.1.1",
+  "version": "4.1.3",
   "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",