@semacode/cli 2.3.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/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

package/dist/projetoCatalogo.d.ts

@@ -0,0 +1,7 @@
+import { type FonteProjeto } from "@sema/nucleo";
+export interface FechamentoContratosSema {
+    fontes: FonteProjeto[];
+    dependenciasNaoResolvidas: string[];
+}
+export declare function carregarFontesContratos(arquivos: string[]): Promise<FonteProjeto[]>;
+export declare function carregarFechamentoContratosSema(arquivosAlvo: string[], arquivosDescobertos: string[]): Promise<FechamentoContratosSema>;

package/dist/projetoCatalogo.js

@@ -0,0 +1,125 @@
+// SEMA-GOVERNED: sema.produto.governanca_ia.contexto
+// Descricao: descobre contratos por caminho e carrega apenas o fechamento transitivo de uses do alvo.
+import path from "node:path";
+import { lerArquivoTexto, parsear, tokenizar, } from "@sema/nucleo";
+function normalizarChaveArquivo(valor) {
+    return valor
+        .normalize("NFD")
+        .replace(/[\u0300-\u036f]/g, "")
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "_")
+        .replace(/^_+|_+$/g, "");
+}
+function chavesSufixoModulo(nomeModulo) {
+    const partes = nomeModulo.split(".").map(normalizarChaveArquivo).filter(Boolean);
+    return partes.map((_, indice) => partes.slice(indice).join("_"));
+}
+function criarIndiceSufixos(arquivos) {
+    const indice = new Map();
+    for (const arquivo of arquivos) {
+        const chave = normalizarChaveArquivo(path.basename(arquivo, path.extname(arquivo)));
+        const atuais = indice.get(chave) ?? [];
+        atuais.push(path.resolve(arquivo));
+        indice.set(chave, atuais);
+    }
+    for (const caminhos of indice.values()) {
+        caminhos.sort((a, b) => a.localeCompare(b, "pt-BR"));
+    }
+    return indice;
+}
+export async function carregarFontesContratos(arquivos) {
+    const fontes = [];
+    for (const arquivo of arquivos) {
+        const caminho = path.resolve(arquivo);
+        fontes.push({ caminho, codigo: await lerArquivoTexto(caminho) });
+    }
+    return fontes;
+}
+export async function carregarFechamentoContratosSema(arquivosAlvo, arquivosDescobertos) {
+    const descobertos = [...new Set(arquivosDescobertos.map((arquivo) => path.resolve(arquivo)))]
+        .sort((a, b) => a.localeCompare(b, "pt-BR"));
+    const indiceSufixos = criarIndiceSufixos(descobertos);
+    const leituras = new Map();
+    const caminhoPorModulo = new Map();
+    const lerContrato = (arquivo) => {
+        const caminho = path.resolve(arquivo);
+        const existente = leituras.get(caminho);
+        if (existente) {
+            return existente;
+        }
+        const leitura = (async () => {
+            const codigo = await lerArquivoTexto(caminho);
+            const resultadoLexer = tokenizar(codigo, caminho);
+            const resultadoParser = parsear(resultadoLexer.tokens);
+            if (resultadoParser.modulo) {
+                caminhoPorModulo.set(resultadoParser.modulo.nome, caminho);
+            }
+            return {
+                fonte: { caminho, codigo },
+                modulo: resultadoParser.modulo,
+            };
+        })();
+        leituras.set(caminho, leitura);
+        return leitura;
+    };
+    const resolverArquivoModulo = async (nomeModulo) => {
+        const jaConhecido = caminhoPorModulo.get(nomeModulo);
+        if (jaConhecido) {
+            return jaConhecido;
+        }
+        const tentados = new Set();
+        for (const chave of chavesSufixoModulo(nomeModulo)) {
+            for (const candidato of indiceSufixos.get(chave) ?? []) {
+                tentados.add(candidato);
+                const contrato = await lerContrato(candidato);
+                if (contrato.modulo?.nome === nomeModulo) {
+                    return candidato;
+                }
+            }
+        }
+        // Fallback raro para workspaces que nao seguem a convencao modulo -> nome do arquivo.
+        // Ele so acontece depois que todos os sufixos deterministas falharam.
+        for (const candidato of descobertos) {
+            if (tentados.has(candidato)) {
+                continue;
+            }
+            const contrato = await lerContrato(candidato);
+            if (contrato.modulo?.nome === nomeModulo) {
+                return candidato;
+            }
+        }
+        return undefined;
+    };
+    const fila = arquivosAlvo.map((arquivo) => path.resolve(arquivo));
+    const carregados = new Set();
+    const fontes = [];
+    const dependenciasNaoResolvidas = new Set();
+    while (fila.length > 0) {
+        const arquivo = fila.shift();
+        if (carregados.has(arquivo)) {
+            continue;
+        }
+        carregados.add(arquivo);
+        const contrato = await lerContrato(arquivo);
+        fontes.push(contrato.fonte);
+        const usesSema = contrato.modulo?.uses
+            .filter((use) => use.origem === "sema")
+            .map((use) => use.caminho) ?? [];
+        for (const use of usesSema) {
+            const dependencia = await resolverArquivoModulo(use);
+            if (!dependencia) {
+                dependenciasNaoResolvidas.add(use);
+                continue;
+            }
+            if (!carregados.has(dependencia)) {
+                fila.push(dependencia);
+            }
+        }
+    }
+    return {
+        fontes,
+        dependenciasNaoResolvidas: [...dependenciasNaoResolvidas]
+            .sort((a, b) => a.localeCompare(b, "pt-BR")),
+    };
+}
+//# sourceMappingURL=projetoCatalogo.js.map

package/dist/projetoTipos.d.ts

@@ -1,6 +1,10 @@
 import type { EngineBanco, ResultadoCompilacaoProjetoModulo } from '@sema/nucleo';
 import type { AlvoGeracao, FrameworkGeracao } from '@sema/padroes';
 import type { EstruturaSaida, FonteLegado, ModoAdocao } from './tipos.js';
+export type EscopoCarregamentoProjeto = "arquivo" | "modulo" | "projeto";
+export interface OpcoesCarregarProjeto {
+    escopo?: EscopoCarregamentoProjeto;
+}
 export interface ConfiguracaoPersistenciaProjeto {
     enginesHabilitados?: EngineBanco[];
     adaptersPorEngine?: Partial<Record<EngineBanco, string>>;
@@ -30,18 +34,23 @@ export interface ConfiguracaoProjetoCarregada {
     baseDiretorio: string;
     config: SemaConfigProjeto;
 }
+export interface ModuloProjetoCarregado {
+    caminho: string;
+    codigo: string;
+    resultado: ResultadoCompilacaoProjetoModulo;
+}
 export interface ContextoProjetoCarregado {
     entradaResolvida: string;
     baseProjeto: string;
     configCarregada?: ConfiguracaoProjetoCarregada;
+    /** Contratos efetivamente lidos e compilados nesta execucao. */
     arquivosProjeto: string[];
+    /** Contratos encontrados nas origens, inclusive os que ficaram fora do escopo carregado. */
+    arquivosDescobertos: string[];
     origensProjeto: string[];
     diretoriosCodigo: string[];
     fontesLegado: FonteLegado[];
     modoAdocao: ModoAdocao;
-    modulosSelecionados: Array<{
-        caminho: string;
-        codigo: string;
-        resultado: ResultadoCompilacaoProjetoModulo;
-    }>;
+    modulosCarregados: ModuloProjetoCarregado[];
+    modulosSelecionados: ModuloProjetoCarregado[];
 }

package/dist/sync/index.js

@@ -46,25 +46,25 @@ export async function gerarSchemaPrisma(pastaContratos, saidaSchema, datasourceP
     for (const contrato of contratos) {
         const nomeModel = path.basename(contrato, '.sema').replace(/\./g, '_');
         // Schema simplificado - em producao, fazer parsing real do contrato
-        models += `\nmodel ${nomeModel.charAt(0).toUpperCase() + nomeModel.slice(1)} {
-  id        String   @id @default(uuid())
-  criadoEm  DateTime @default(now())
-  // Gerado a partir de: ${contrato}
-  // TODO: Adicionar campos do contrato Sema
+        models += `\nmodel ${nomeModel.charAt(0).toUpperCase() + nomeModel.slice(1)} {
+  id        String   @id @default(uuid())
+  criadoEm  DateTime @default(now())
+  // Gerado a partir de: ${contrato}
+  // TODO: Adicionar campos do contrato Sema
 }\n`;
         modelCount++;
     }
-    const schema = `// Gerado automaticamente pelo Sema
-// Fonte: ${pastaContratos}
-
-generator client {
-  provider = "prisma-client-js"
-}
-
-datasource db {
-  provider = "${datasourceProvider}"
-  url      = env("SEMA_PRISMA_URL")
-}
+    const schema = `// Gerado automaticamente pelo Sema
+// Fonte: ${pastaContratos}
+
+generator client {
+  provider = "prisma-client-js"
+}
+
+datasource db {
+  provider = "${datasourceProvider}"
+  url      = env("SEMA_PRISMA_URL")
+}
 ${models}`;
     // Salvar
     fs.writeFileSync(saidaSchema, schema, 'utf-8');
@@ -90,25 +90,25 @@ export async function importarSchemaPrisma(caminhoSchema, pastaSaida, nomeModulo
         const nomeContrato = `${nomeModel.toLowerCase()}.sema`;
         const caminhoContrato = path.join(pastaSaida, nomeContrato);
         // Gerar contrato basico
-        const conteudo = `module ${nomeModulo}.${nomeModel.toLowerCase()} {
-  entity ${nomeModel} {
-    fields {
-      id: Id
-      // TODO: Mapear campos do schema Prisma
-    }
-  }
-
-  task criar_${nomeModel.toLowerCase()} {
-    input {
-      // TODO: Definir inputs
-    }
-    output {
-      ${nomeModel.toLowerCase()}: ${nomeModel}
-    }
-    effects {
-      persistencia ${nomeModel}
-    }
-  }
+        const conteudo = `module ${nomeModulo}.${nomeModel.toLowerCase()} {
+  entity ${nomeModel} {
+    fields {
+      id: Id
+      // TODO: Mapear campos do schema Prisma
+    }
+  }
+
+  task criar_${nomeModel.toLowerCase()} {
+    input {
+      // TODO: Definir inputs
+    }
+    output {
+      ${nomeModel.toLowerCase()}: ${nomeModel}
+    }
+    effects {
+      persistencia ${nomeModel}
+    }
+  }
 }`;
         fs.writeFileSync(caminhoContrato, conteudo, 'utf-8');
         contratos.push(caminhoContrato);

package/docs/README.md

@@ -1,34 +1,34 @@
-# Sema Documentation
-
-These docs describe the public Codex-native local CLI distribution of Sema.
-
-Sema is local-first: Codex runs the CLI inside a project folder, reads `.sema`
-contracts, checks drift, maps impact, and closes changes with documentation
-evidence. `AGENTS.md` is the official Codex entrypoint. Public docs are written
-in English.
-
-Sema is an independent product and is not affiliated with or endorsed by
-OpenAI. Codex-native describes Sema's product direction, not an official OpenAI
-program or submission.
-
-Start here:
-
-- [CLI](./cli.md)
-- [Commands](./commands.md)
-- [Syntax](./syntax.md)
-- [Profiles](./profiles.md)
-- [Capability Discovery](./descoberta-capacidades.md) — one explainable catalog
-  for governance flows, profiles, specialized workflows, pipelines, generators,
-  capability tokens, and adapters.
-- [AI-native Interactive Systems](./sistemas-interativos.md) — declarative
-  control plane for games, simulations, and hybrids across 3D, 2D, retro,
-  text, XR, and headless execution.
-- [AI-native Content Pipeline](./pipeline-conteudo.md) — signed-policy,
-  multi-channel and multi-format orchestration for external AI runners, with
-  canonical ledger replay and no native human-review path.
-- [Documentation Governance](./documentation.md)
-- [Repository Boundary](./repositories.md)
-- [Security](./security.md)
-- [Codex Integration](./ai-integration.md)
-
-Official support: [suporte@otimitare.online](mailto:suporte@otimitare.online)
+# Sema Documentation
+
+These docs describe the public Codex-native local CLI distribution of Sema.
+
+Sema is local-first: Codex runs the CLI inside a project folder, reads `.sema`
+contracts, checks drift, maps impact, and closes changes with documentation
+evidence. `AGENTS.md` is the official Codex entrypoint. Public docs are written
+in English.
+
+Sema is an independent product and is not affiliated with or endorsed by
+OpenAI. Codex-native describes Sema's product direction, not an official OpenAI
+program or submission.
+
+Start here:
+
+- [CLI](./cli.md)
+- [Commands](./commands.md)
+- [Syntax](./syntax.md)
+- [Profiles](./profiles.md)
+- [Capability Discovery](./descoberta-capacidades.md) — one explainable catalog
+  for governance flows, profiles, specialized workflows, pipelines, generators,
+  capability tokens, and adapters.
+- [AI-native Interactive Systems](./sistemas-interativos.md) — declarative
+  control plane for games, simulations, and hybrids across 3D, 2D, retro,
+  text, XR, and headless execution.
+- [AI-native Content Pipeline](./pipeline-conteudo.md) — signed-policy,
+  multi-channel and multi-format orchestration for external AI runners, with
+  canonical ledger replay and no native human-review path.
+- [Documentation Governance](./documentation.md)
+- [Repository Boundary](./repositories.md)
+- [Security](./security.md)
+- [Codex Integration](./ai-integration.md)
+
+Official support: [suporte@otimitare.online](mailto:suporte@otimitare.online)

package/docs/ai-integration.md

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

package/docs/ai-onboarding.md

@@ -1,62 +1,62 @@
-# Codex Onboarding
-
-The official Sema skill is required for Codex to recognize and initialize Sema
-before a project has its own protocol:
-
-```bash
-codex plugin marketplace add gerlanss/Sema
-codex plugin add sema@sema
-```
-
-Open a new Codex task in the target repository after installation. Codex loads
-the plugin/skill catalog at task start, so `$sema` is not added retroactively to
-an already-open task. Invoke `$sema` in the new task; it bootstraps the project,
-reads the generated `AGENTS.md`, and later tasks load that protocol
-automatically.
-
-`AGENTS.md` is the official Sema entrypoint for Codex. It gives Codex the durable
-repository rule that contracts come first and the local CLI is the source of
-truth. Once the file exists, the skill delegates to it instead of carrying a
-second copy of the governed workflow.
-
-Create or refresh the entrypoint with:
-
-```bash
-sema sync-codex --json
-```
-
-## Minimal Prompt
-
-```text
-This workspace is governed by Sema. Before editing code, contracts, docs,
-workflows, profiles, or release scripts, run:
-
-1. sema --version
-2. sema resumo
-3. sema docs-impacto --intencao "<change>" --json
-4. sema inspecionar on the applicable .sema contract
-5. sema drift before editing existing code
-6. sema impacto before changing behavior
-7. sema finalizar-mudanca before closing
-
-If the CLI is unavailable, stop and install or repair @semacode/cli. There is
-no separate Sema login, license activation, or authorization gate. Do not
-replace Sema with manual search or guessed contracts.
-```
-
-## What Codex Should Not Do
-
-- Do not invent `.sema` contracts.
-- Do not implement code without an applicable contract.
-- Do not ignore severity 4+ warnings.
-- Do not publish private or sensitive operational material.
-- Do not replace the local CLI when the local workspace is available.
-
-Other AI clients can invoke the public CLI manually, but Sema does not ship or
-manage an official repository entrypoint for them. The supported product path
-is Codex plus `AGENTS.md`.
-
-Sema is an independent product and is not affiliated with or endorsed by
-OpenAI.
-
-Support: suporte@otimitare.online
+# Codex Onboarding
+
+The official Sema skill is required for Codex to recognize and initialize Sema
+before a project has its own protocol:
+
+```bash
+codex plugin marketplace add gerlanss/Sema
+codex plugin add sema@sema
+```
+
+Open a new Codex task in the target repository after installation. Codex loads
+the plugin/skill catalog at task start, so `$sema` is not added retroactively to
+an already-open task. Invoke `$sema` in the new task; it bootstraps the project,
+reads the generated `AGENTS.md`, and later tasks load that protocol
+automatically.
+
+`AGENTS.md` is the official Sema entrypoint for Codex. It gives Codex the durable
+repository rule that contracts come first and the local CLI is the source of
+truth. Once the file exists, the skill delegates to it instead of carrying a
+second copy of the governed workflow.
+
+Create or refresh the entrypoint with:
+
+```bash
+sema sync-codex --json
+```
+
+## Minimal Prompt
+
+```text
+This workspace is governed by Sema. Before editing code, contracts, docs,
+workflows, profiles, or release scripts, run:
+
+1. sema --version
+2. sema resumo
+3. sema docs-impacto --intencao "<change>" --json
+4. sema inspecionar on the applicable .sema contract
+5. sema drift before editing existing code
+6. sema impacto before changing behavior
+7. sema finalizar-mudanca before closing
+
+If the CLI is unavailable, stop and install or repair @semacode/cli. There is
+no separate Sema login, license activation, or authorization gate. Do not
+replace Sema with manual search or guessed contracts.
+```
+
+## What Codex Should Not Do
+
+- Do not invent `.sema` contracts.
+- Do not implement code without an applicable contract.
+- Do not ignore severity 4+ warnings.
+- Do not publish private or sensitive operational material.
+- Do not replace the local CLI when the local workspace is available.
+
+Other AI clients can invoke the public CLI manually, but Sema does not ship or
+manage an official repository entrypoint for them. The supported product path
+is Codex plus `AGENTS.md`.
+
+Sema is an independent product and is not affiliated with or endorsed by
+OpenAI.
+
+Support: suporte@otimitare.online