@semacode/cli 1.5.42 → 1.5.44

package/docs/documentacao.md

@@ -1,94 +1,74 @@
-# Documentation Governance
-
-## English
-
-Sema treats documentation as part of the change, not as a polite afterthought. Before an AI edits a contract, code, configuration, workflow, deploy, Author text, game rule, legal note, research note, or operational runbook, it must resolve the documentation that explains the intended change.
-
-Public documentation follows the exact order defined in [i18n.md](./i18n.md): English, Português, Español. Portuguese and Spanish must keep proper accents. Code blocks, identifiers, paths, command names, and `.sema` symbols are preserved unless a semantic rename contract says otherwise.
-
-### Operational Gate
-
-```bash
-sema docs-impacto --intencao "criar rota de pagamento" --arquivo contratos/pagamento.sema --json
-```
-
-If the command reports missing docs, create or complete those docs before changing code, contracts, deploy, or configuration.
-
-### Required Reading
-
-The `docs-impacto` result returns:
-
-- `leituraObrigatoria`: docs, readmes, and contracts that must be read.
-- `docsAusentes`: docs that block the action.
-- `docsCriadas`: docs created automatically when authorized.
-- `bloqueios`: severity 4 diagnostics.
-
-Automatically created docs are scaffolds, not proof. The agent must replace the generic template with real procedure, validation, and rollback before `finalizar-mudanca` can pass.
-
-Before declaring the work done, the agent must run:
-
-```bash
-sema finalizar-mudanca --intencao "criar rota de pagamento" --doc-lida README.md --doc-lida docs/documentacao.md --json
-```
-
-## Português
-
-A Sema trata documentação como parte da mudança, não como pós-escrito simpático para alguém lembrar depois. Antes de uma IA editar contrato, código, configuração, workflow, deploy, texto Author, regra de jogo, nota jurídica, pesquisa ou runbook operacional, ela precisa resolver a documentação que explica a intenção da mudança.
-
-A documentação pública segue a ordem exata definida em [i18n.md](./i18n.md): English, Português, Español. Português e espanhol precisam preservar acentos. Blocos de código, identificadores, caminhos, nomes de comando e símbolos `.sema` são preservados, exceto quando houver contrato de renomeação semântica.
-
-### Gate Operacional
-
-```bash
-sema docs-impacto --intencao "criar rota de pagamento" --arquivo contratos/pagamento.sema --json
-```
-
-Se o comando apontar docs ausentes, crie ou complete essas docs antes de mudar código, contratos, deploy ou configuração.
-
-### Leitura Obrigatória
-
-O resultado de `docs-impacto` retorna:
-
-- `leituraObrigatoria`: docs, readmes e contratos que precisam ser lidos.
-- `docsAusentes`: docs que bloqueiam a ação.
-- `docsCriadas`: docs criadas automaticamente quando autorizado.
+# Governança De Documentação
+
+A Sema trata documentação como parte da mudança. README, runbook, contrato,
+instrução para IA, guia de CLI, deploy e rollback não são enfeites: são
+superfícies governadas.
+
+Antes de uma IA editar contrato, código, configuração, workflow, deploy, texto
+Author, regra de jogo, nota jurídica, pesquisa, operação ou README, ela precisa
+resolver qual documentação explica a intenção da mudança.
+
+## Idioma
+
+Documentação interna da Sema é em PT-BR por padrão, com acentos preservados e
+sem mojibake. Inglês e espanhol não são obrigatórios em documento privado.
+
+Documentação multilíngue só entra quando a superfície for externa ou quando o
+contrato pedir explicitamente outro idioma. Comandos, identificadores, caminhos,
+variáveis, endpoints, pacotes e símbolos `.sema` continuam literais.
+
+## Trava Operacional
+
+```bash
+sema docs-impacto --intencao "criar rota de pagamento" --arquivo contratos/pagamento.sema --json
+```
+
+O resultado informa:
+
+- `leituraObrigatoria`: documentos, READMEs e contratos que precisam ser lidos;
+- `docsAusentes`: documentação que bloqueia a mudança;
+- `docsCriadas`: esqueletos criados automaticamente quando autorizado;
 - `bloqueios`: diagnósticos de severidade 4.
 
-Docs criadas automaticamente são esqueletos, não prova. A IA precisa trocar o template genérico por procedimento, validação e rollback reais antes de `finalizar-mudanca` passar.
-
-Antes de dizer que o trabalho terminou, o agente precisa rodar:
-
-```bash
-sema finalizar-mudanca --intencao "criar rota de pagamento" --doc-lida README.md --doc-lida docs/documentacao.md --json
-```
-
-## Español
-
-Sema trata la documentación como parte del cambio, no como una nota amable para recordar después. Antes de que una IA edite contrato, código, configuración, workflow, deploy, texto Author, regla de juego, nota legal, investigación o runbook operativo, debe resolver la documentación que explica la intención del cambio.
-
-La documentación pública sigue el orden exacto definido en [i18n.md](./i18n.md): English, Português, Español. Portugués y español deben conservar sus acentos. Bloques de código, identificadores, rutas, nombres de comando y símbolos `.sema` se preservan, excepto cuando exista un contrato de renombrado semántico.
-
-### Gate Operativo
-
-```bash
-sema docs-impacto --intencao "criar rota de pagamento" --arquivo contratos/pagamento.sema --json
-```
-
-Si el comando informa docs ausentes, crea o completa esas docs antes de cambiar código, contratos, deploy o configuración.
-
-### Lectura Obligatoria
-
-El resultado de `docs-impacto` devuelve:
-
-- `leituraObrigatoria`: docs, readmes y contratos que deben leerse.
-- `docsAusentes`: docs que bloquean la acción.
-- `docsCriadas`: docs creadas automáticamente cuando se autoriza.
-- `bloqueios`: diagnósticos de severidad 4.
-
-Los documentos creados automáticamente son esqueletos, no prueba. El agente debe reemplazar el template genérico con procedimiento, validación y rollback reales antes de que `finalizar-mudanca` pueda aprobar.
-
-Antes de decir que el trabajo terminó, el agente debe ejecutar:
-
-```bash
-sema finalizar-mudanca --intencao "criar rota de pagamento" --doc-lida README.md --doc-lida docs/documentacao.md --json
+Documento criado automaticamente é rascunho. A IA precisa trocar template
+genérico por procedimento real, validação real e rollback real antes de
+considerar a mudança fechada.
+
+## Fechamento
+
+Antes de dizer que terminou, o agente roda:
+
+```bash
+sema finalizar-mudanca \
+  --intencao "criar rota de pagamento" \
+  --doc-lida README.md \
+  --doc-lida docs/documentacao.md \
+  --json
 ```
+
+Se houver leitura obrigatória não comprovada, documento ausente, template cru ou
+diagnóstico de severidade 4, a mudança não está concluída.
+
+## Regra Para README
+
+O README principal deste repositório é manual interno. Ele deve explicar o Sema
+com profundidade suficiente para uma IA local operar sem inventar fluxo:
+
+- superfície CLI local;
+- superfície MCP remoto;
+- pré-checagem e SEMAS;
+- contratos `.sema`;
+- desvio semântico e impacto;
+- geração automática de código;
+- importação de legado;
+- templates de projeto novo;
+- contexto IA;
+- profiles;
+- Author;
+- documentação como trava;
+- comandos de sanidade;
+- fronteira privada.
+
+Se uma função importante existe na CLI, o README deve descrevê-la ou apontar
+para a documentação específica. README curto demais vira convite para IA
+apressada fazer besteira com confiança.

package/docs/env.md

@@ -24,13 +24,13 @@ Ambiente necessário para publicar a Sema.
 No PowerShell, o instalador recebe a versão por parametro:
 
 ```powershell
-.\install-sema.ps1 -Version 1.5.35 -WithVSCode
+.\install-sema.ps1 -Version 1.5.44 -WithVSCode
 ```
 
 No shell:
 
 ```bash
-SEMA_VERSION=1.5.35 ./install-sema.sh --with-vscode
+SEMA_VERSION=1.5.44 ./install-sema.sh --with-vscode
 ```
 
 ## Credenciais
@@ -71,10 +71,13 @@ Variaveis usadas pelo servidor MCP privado quando roda em modo HTTP:
 - `MCP_PORT`: porta HTTP. Quando ausente, o MCP roda em `stdio`.
 - `MCP_HOST`: host de bind. Padrão: `0.0.0.0`.
 - `SEMA_MCP_PUBLIC_BASE_URL`: URL pública HTTPS usada nos metadados OAuth do ChatGPT.
-- `SEMA_MCP_OAUTH_SECRET`: segredo usado para assinar access/refresh tokens OAuth.
-- `SEMA_MCP_OAUTH_PASSCODE`: passcode privado digitado no login OAuth do ChatGPT.
+- `SEMA_MCP_OAUTH_SECRET`: segredo usado para assinar access/refresh tokens OAuth.
+- `SEMA_MCP_OAUTH_PASSCODE`: fallback local/laboratorio; em MCP publico ou `production`, bloqueia o boot.
 - `SEMA_MCP_PROJECT_ROOTS`: raizes permitidas para projetos, separadas por `;`.
-- `SEMA_MCP_CORS_ORIGIN`: origem CORS permitida, `*` ou lista separada por `;`.
+- `SEMA_MCP_CORS_ORIGIN`: origem CORS permitida, lista separada por `;`. Nao use `*` em MCP publico ou `production`.
+- `SEMA_SUPABASE_URL`: URL do control plane Supabase usado para OAuth e billing.
+- `SEMA_SUPABASE_ANON_KEY` ou `SEMA_SUPABASE_PUBLISHABLE_KEY`: chave publica do Supabase para RPCs de OAuth/billing.
+- `SEMA_MCP_BILLING_DISABLED`: somente laboratorio local; em MCP publico ou `production`, bloqueia o boot.
 - `SEMA_MCP_MAX_CONTRACT_FILE_BYTES`: limite por contrato `.sema` enviado por snapshot ou conteudo inline. Padrao: `262144`.
 - `SEMA_MCP_MAX_CODE_FILE_BYTES`: limite por arquivo de codigo selecionado enviado por snapshot. Padrao: `262144`.
 - `SEMA_MCP_MAX_DOC_FILE_BYTES`: limite por arquivo de documentacao enviado por snapshot. Padrao: `262144`.
@@ -84,17 +87,18 @@ Variaveis usadas pelo servidor MCP privado quando roda em modo HTTP:
 Exemplo operacional privado:
 
 ```bash
-MCP_PORT=3333 \
-SEMA_MCP_PUBLIC_BASE_URL="https://sema.exemplo.com" \
+MCP_PORT=3333 \
+SEMA_MCP_PUBLIC_BASE_URL="https://sema.exemplo.com" \
 SEMA_MCP_OAUTH_SECRET="segredo-longo-para-oauth" \
-SEMA_MCP_OAUTH_PASSCODE="passcode-privado-chatgpt" \
+SEMA_SUPABASE_URL="https://projeto.supabase.co" \
+SEMA_SUPABASE_PUBLISHABLE_KEY="sb_publishable_..." \
 SEMA_MCP_PROJECT_ROOTS="/srv/sema/projetos" \
 SEMA_MCP_MAX_CONTRACT_FILE_BYTES=262144 \
 SEMA_MCP_MAX_CODE_FILE_BYTES=262144 \
 SEMA_MCP_MAX_DOC_FILE_BYTES=262144
 ```
 
-Nunca publique `/mcp` ou `/sse` na internet sem chave comercial bearer por request ou OAuth configurado, raiz restrita e HTTPS no proxy. Nunca registre chaves `sema_mcp_*`, OAuth secret ou passcode em docs publicas, logs, release notes ou screenshots.
+Nunca publique `/mcp` ou `/sse` na internet sem billing habilitado, Supabase de billing configurado, chave comercial bearer por request ou OAuth com conta Sema, raiz restrita e HTTPS no proxy. Nunca registre chaves `sema_mcp_*`, OAuth secret ou passcode em docs publicas, logs, release notes ou screenshots.
 
 O limite de bytes e validado antes de gravar espelhos remotos ou executar contratos inline. Clientes MCP devem respeitar o limite anunciado no schema da ferramenta e dividir snapshots grandes em arquivos focados, sem enviar repositorio inteiro.
 

package/docs/extensao-vscode.md

@@ -1,42 +1,40 @@
 # Extensão VS Code
 
-<!-- sema:i18n -->
-> EN: English first.
-> PT: Português depois, com acentos preservados.
-> ES: Español al final.
-
-## English
-
-The VS Code extension is part of the private Sema workflow. It should help local IDE agents read `AGENTS.md`, run the governed CLI runtime installed from `@semacode/cli`, install MCP keys safely, and synchronize AI entry points without exposing secrets.
-
-Smoke test:
-
-1. Open a project with `.sema` contracts.
-2. Confirm the language server starts.
-3. Run the Sema CLI diagnostic command.
-4. Install an MCP key from the panel without passing the secret as a process argument.
-5. Synchronize AI entry points.
-
-## Português
-
-A extensão VS Code faz parte do fluxo privado da Sema. Ela deve ajudar agentes em IDE local a ler `AGENTS.md`, rodar o runtime governado da CLI instalada por `@semacode/cli`, instalar chaves MCP com segurança e sincronizar entrypoints IA sem expor segredos.
-
-Smoke test:
-
-1. Abra um projeto com contratos `.sema`.
-2. Confirme que o language server inicia.
-3. Rode o diagnóstico da CLI Sema.
-4. Instale uma chave MCP do painel sem passar o segredo como argumento de processo.
-5. Sincronize entrypoints IA.
-
-## Español
-
-La extensión VS Code forma parte del flujo privado de Sema. Debe ayudar a agentes en IDE local a leer `AGENTS.md`, ejecutar el runtime gobernado de la CLI instalada desde `@semacode/cli`, instalar claves MCP con seguridad y sincronizar entrypoints IA sin exponer secretos.
-
-Smoke test:
-
-1. Abre un proyecto con contratos `.sema`.
-2. Confirma que el language server inicia.
-3. Ejecuta el diagnóstico de la CLI Sema.
-4. Instala una clave MCP del panel sin pasar el secreto como argumento de proceso.
-5. Sincroniza entrypoints IA.
+A extensão VS Code faz parte do fluxo privado da Sema. Ela ajuda humanos e IAs
+em IDE local a escrever contratos `.sema`, receber feedback rápido e manter o
+projeto preso ao fluxo correto: CLI local primeiro, contrato antes de código e
+fechamento governado.
+
+Ela não substitui o painel, a chave local, a CLI, o MCP remoto nem a validação
+final.
+
+## Fluxo Obrigatório
+
+1. Abrir o projeto no VS Code.
+2. Ler `AGENTS.md`.
+3. Rodar `sema --version`.
+4. Se o comando não existir, parar. A IA não acessa o painel Sema: peça ao
+   humano para abrir o painel e rodar o instalador de chave/CLI.
+5. Rodar `sema preflight resumo --json` e exigir `use_cli_local`.
+6. Editar ou criar o contrato `.sema` aplicável antes de alterar código.
+7. Usar a extensão para autoria, snippets, hover, formatação e diagnóstico.
+8. Fechar pela CLI com `validar`, `drift`, `impacto`, testes e
+   `finalizar-mudanca`.
+
+## Empacotar E Instalar Localmente
+
+```bash
+npm run extensao:empacotar
+code --install-extension .tmp/editor-vscode/sema-language-tools-1.5.44.vsix --force
+```
+
+## Limites
+
+A extensão não deve:
+
+- instalar chave sozinha;
+- consultar o painel como se fosse humano;
+- usar MCP remoto para ler workspace local;
+- publicar pacote;
+- dizer que uma mudança está concluída sem CLI;
+- substituir contrato por README ou comentário de código.

package/docs/fluxo-pratico-ia-sema.md

@@ -24,7 +24,7 @@ Regra de timeout: timeout local do agente não é falha do Sema. Se `sema resumo
 
 ## Superfície obrigatória
 
-1. IDE local com workspace no disco: rode `sema preflight resumo --json`. Se `decisao` não for `use_cli_local`, pare bloqueado.
+1. IDE local com workspace no disco: rode `sema --version`; se falhar, pare. A IA não acessa o painel Sema: peça ao humano para instalar pelo painel. Depois rode `sema preflight resumo --json`. Se `decisao` não for `use_cli_local`, pare bloqueado.
 2. IDE local autorizada: use somente a CLI local para `resumo`, `docs-impacto`, `inspecionar`, `drift`, `impacto`, `validar`, `verificar` e `finalizar-mudanca`.
 3. IDE local proibida: não chame MCP remoto, `sema_sync`, `sema_contratos_sincronizar` nem `sema mcp-client` para ler o workspace local.
 4. Web/chat/remoto sem workspace local: use `sema_chat_contexto`, depois `sema_sync` inline com contrato `.sema`, código selecionado, documentação operacional e índice; use o `projeto` retornado.
@@ -33,7 +33,7 @@ Regra de timeout: timeout local do agente não é falha do Sema. Se `sema resumo
 ## Fluxo curto
 
 1. identificar a superfície: CLI local ou MCP remoto web/chat
-2. em IDE local, rodar `sema preflight resumo --json` e parar se não retornar `use_cli_local`
+2. em IDE local, rodar `sema --version`; se falhar, parar. A IA não acessa o painel Sema: pedir ao humano para instalar pelo painel; depois rodar `sema preflight resumo --json` e parar se não retornar `use_cli_local`
 3. ler contexto do projeto
 4. identificar a capacidade da IA
 5. identificar o módulo alvo
@@ -86,6 +86,7 @@ Regra pratica:
 Antes de alterar, a IA deve executar:
 
 ```bash
+sema --version
 sema preflight resumo --json
 sema resumo caminho/arquivo.sema --curto --para mudanca
 sema ast caminho/arquivo.sema --json
@@ -142,7 +143,7 @@ Se a tarefa não for só editar contrato, mas também gerar base de implementaca
 sema compilar caminho/arquivo.sema --alvo typescript --saida ./saida/typescript
 ```
 
-Ou trocar o alvo para `python` ou `dart`, conforme o caso.
+Ou trocar o alvo para `python`, `dart`, `lua`, `javascript`, `html` ou `css`, conforme o caso.
 
 Regra pratica:
 
@@ -162,6 +163,7 @@ sema verificar arquivo-ou-pasta --json --saida ./.tmp/verificacao-ia
 Se voce quiser o menor fluxo aceitavel para uma IA fraca:
 
 ```bash
+sema --version
 sema preflight resumo --json
 sema resumo caminho/arquivo.sema --micro --para mudanca
 sema formatar caminho/arquivo.sema
@@ -173,6 +175,7 @@ Mas, sendo sincero, o fluxo bom mesmo e fechar com `verificar`.
 Se a tarefa envolver código derivado, o fluxo mínimo aceitavel vira:
 
 ```bash
+sema --version
 sema preflight resumo --json
 sema ir caminho/arquivo.sema --json
 sema formatar caminho/arquivo.sema

package/docs/instalacao-e-primeiro-uso.md

@@ -9,7 +9,7 @@
 
 Sema is private. Local IDEs use the complete Sema CLI. Web/chat clients without local workspace access use the remote MCP.
 
-In a local IDE, install the CLI and key, keep `AGENTS.md` in the project root, run `sema preflight resumo --json`, and stop unless `decisao` is `use_cli_local`. After that, use local CLI commands: `sema resumo`, `sema docs-impacto`, `sema inspecionar`, `sema drift`, `sema impacto`, `sema validar`, and `sema finalizar-mudanca`.
+In a local IDE, keep `AGENTS.md` in the project root and run `sema --version`. If the command is missing, stop and ask the human to open the Sema panel, download/run the key installer, and repeat `sema --version`. Then run `sema preflight resumo --json` and stop unless `decisao` is `use_cli_local`. After that, use local CLI commands: `sema resumo`, `sema docs-impacto`, `sema inspecionar`, `sema drift`, `sema impacto`, `sema validar`, and `sema finalizar-mudanca`.
 
 Do not call remote MCP, `sema_sync`, `sema_contratos_sincronizar`, or `sema mcp-client` to read a local workspace. Those paths are forbidden for local IDE work when the CLI is operational.
 
@@ -27,7 +27,7 @@ The MCP server remains the private web/chat surface. Do not install the MCP from
 
 A Sema é privada. IDE local usa a CLI completa da Sema. Cliente web/chat sem acesso ao workspace local usa MCP remoto.
 
-Em IDE local, instale a CLI e a chave, mantenha `AGENTS.md` na raiz do projeto, rode `sema preflight resumo --json` e pare se `decisao` não for `use_cli_local`. Depois disso, use comandos locais da CLI: `sema resumo`, `sema docs-impacto`, `sema inspecionar`, `sema drift`, `sema impacto`, `sema validar` e `sema finalizar-mudanca`.
+Em IDE local, o agente deve manter `AGENTS.md` na raiz e rodar `sema --version`. Se o comando não existir, ele deve parar. A IA não acessa o painel Sema: peça ao humano para abrir o painel, baixar/rodar o instalador de chave e repetir `sema --version`. Depois disso, rode `sema preflight resumo --json` e pare se `decisao` não for `use_cli_local`. Com CLI autorizada, use comandos locais da CLI: `sema resumo`, `sema docs-impacto`, `sema inspecionar`, `sema drift`, `sema impacto`, `sema validar` e `sema finalizar-mudanca`.
 
 Não chame MCP remoto, `sema_sync`, `sema_contratos_sincronizar` nem `sema mcp-client` para ler workspace local. Esses caminhos são proibidos em IDE local quando a CLI está operacional.
 
@@ -45,7 +45,7 @@ O servidor MCP continua sendo a superfície privada para web/chat. Não instale
 
 Sema es privada. Una IDE local usa la CLI completa de Sema. Un cliente web/chat sin acceso al workspace local usa el MCP remoto.
 
-En una IDE local, instala la CLI y la clave, deja `AGENTS.md` en la raíz del proyecto, ejecuta `sema preflight resumo --json` y para si `decisao` no es `use_cli_local`. Después usa comandos locales de la CLI: `sema resumo`, `sema docs-impacto`, `sema inspecionar`, `sema drift`, `sema impacto`, `sema validar` y `sema finalizar-mudanca`.
+En una IDE local, deja `AGENTS.md` en la raíz del proyecto y ejecuta `sema --version`. Si el comando no existe, para y pide al humano que abra el panel Sema, descargue/ejecute el instalador de clave y repita `sema --version`. Después ejecuta `sema preflight resumo --json` y para si `decisao` no es `use_cli_local`. Después usa comandos locales de la CLI: `sema resumo`, `sema docs-impacto`, `sema inspecionar`, `sema drift`, `sema impacto`, `sema validar` y `sema finalizar-mudanca`.
 
 No llames el MCP remoto, `sema_sync`, `sema_contratos_sincronizar` ni `sema mcp-client` para leer un workspace local. Esos caminos están prohibidos en una IDE local cuando la CLI está operacional.
 

package/docs/integracao-com-ia.md

@@ -23,7 +23,7 @@ Sema pode usar palavras-chave de DSL em ASCII. A IA não deve copiar essa estét
 
 Sema exists for AI agents operating live systems. The agent should ask Sema for preflight, summary, docs impact, drift, impact, profile validation, and finalization instead of guessing from raw code.
 
-In local IDEs, confirm `AGENTS.md` exists, install the complete Sema CLI, run `sema preflight resumo --json`, and stop unless the decision is `use_cli_local`. Then use local CLI commands: `sema resumo`, `sema docs-impacto`, `sema inspecionar`, `sema drift`, `sema impacto`, `sema validar`, and `sema finalizar-mudanca`. Do not call remote MCP, `sema_sync`, `sema_contratos_sincronizar`, or `sema mcp-client` to read a local workspace.
+In local IDEs, confirm `AGENTS.md` exists and run `sema --version`. If the command is missing, stop and ask the human to open the Sema panel and run the key installer. Then run `sema preflight resumo --json` and stop unless the decision is `use_cli_local`. Then use local CLI commands: `sema resumo`, `sema docs-impacto`, `sema inspecionar`, `sema drift`, `sema impacto`, `sema validar`, and `sema finalizar-mudanca`. Do not call remote MCP, `sema_sync`, `sema_contratos_sincronizar`, or `sema mcp-client` to read a local workspace.
 
 In web chats without workspace access, use `sema_chat_contexto` first, then `sema_sync` with contract, selected code, documentation, and index; then use the returned `projeto`. The CLI and MCP use the same commercial control plane and SEMAS account.
 
@@ -31,7 +31,7 @@ In web chats without workspace access, use `sema_chat_contexto` first, then `sem
 
 A Sema existe para agentes de IA operarem sistemas vivos. O agente deve pedir preflight, resumo, impacto documental, drift, impacto, validação de profile e finalização para a Sema em vez de adivinhar pelo código cru.
 
-Em IDE local, confirme que `AGENTS.md` existe, instale a CLI completa da Sema, rode `sema preflight resumo --json` e pare se a decisão não for `use_cli_local`. Depois use comandos locais da CLI: `sema resumo`, `sema docs-impacto`, `sema inspecionar`, `sema drift`, `sema impacto`, `sema validar` e `sema finalizar-mudanca`. Não chame MCP remoto, `sema_sync`, `sema_contratos_sincronizar` nem `sema mcp-client` para ler workspace local.
+Em IDE local, confirme que `AGENTS.md` existe e rode `sema --version`. Se o comando não existir, pare. A IA não acessa o painel Sema: peça ao humano para abrir o painel e rodar o instalador de chave. Depois rode `sema preflight resumo --json` e pare se a decisão não for `use_cli_local`. Depois use comandos locais da CLI: `sema resumo`, `sema docs-impacto`, `sema inspecionar`, `sema drift`, `sema impacto`, `sema validar` e `sema finalizar-mudanca`. Não chame MCP remoto, `sema_sync`, `sema_contratos_sincronizar` nem `sema mcp-client` para ler workspace local.
 
 Em chats web sem acesso ao workspace, use primeiro `sema_chat_contexto`, depois `sema_sync` com contrato, código selecionado, documentação e índice; depois use o `projeto` retornado. CLI e MCP usam o mesmo control plane comercial e a mesma conta de SEMAS.
 
@@ -39,6 +39,6 @@ Em chats web sem acesso ao workspace, use primeiro `sema_chat_contexto`, depois
 
 Sema existe para agentes de IA que operan sistemas vivos. El agente debe pedir preflight, resumen, impacto documental, drift, impacto, validación de profile y finalización a Sema en vez de adivinar desde código crudo.
 
-En una IDE local, confirma que `AGENTS.md` existe, instala la CLI completa de Sema, ejecuta `sema preflight resumo --json` y para si la decisión no es `use_cli_local`. Después usa comandos locales de la CLI: `sema resumo`, `sema docs-impacto`, `sema inspecionar`, `sema drift`, `sema impacto`, `sema validar` y `sema finalizar-mudanca`. No llames el MCP remoto, `sema_sync`, `sema_contratos_sincronizar` ni `sema mcp-client` para leer un workspace local.
+En una IDE local, confirma que `AGENTS.md` existe y ejecuta `sema --version`. Si el comando no existe, para y pide al humano que abra el panel Sema y ejecute el instalador de clave. Después ejecuta `sema preflight resumo --json` y para si la decisión no es `use_cli_local`. Después usa comandos locales de la CLI: `sema resumo`, `sema docs-impacto`, `sema inspecionar`, `sema drift`, `sema impacto`, `sema validar` y `sema finalizar-mudanca`. No llames el MCP remoto, `sema_sync`, `sema_contratos_sincronizar` ni `sema mcp-client` para leer un workspace local.
 
 En chats web sin acceso al workspace, usa primero `sema_chat_contexto`, después `sema_sync` con contrato, código seleccionado, documentación e índice; después usa el `projeto` devuelto. CLI y MCP usan el mismo control plane comercial y la misma cuenta de SEMAS.

package/docs/mcp.md

@@ -10,8 +10,9 @@
 The Sema MCP is the private coordinator for agents. It authenticates clients, selects the project or mirror, charges SEMAS, chooses profiles/pipelines, asks the CLI to read or execute, and returns a traceable decision.
 
 It must stay compatible with web chats. For ChatGPT, Lovable, GPTs, and similar clients, the MCP runs on the VPS and uses the governed CLI installed there against authorized mirrors such as `/srv/sema/projetos/...`.
+When the MCP is public or runs as `production`, it fails closed unless billing is enabled, Supabase billing is configured, legacy bearer is absent, OAuth passcode fallback is absent, and CORS is not wildcard. A remote tool call must not execute if SEMAS billing is disabled.
 
-Local IDEs should not use remote MCP, `sema_sync`, `sema_contratos_sincronizar`, or `sema mcp-client` to read a local workspace. In that mode, install the complete Sema CLI, save the local key, run `sema preflight resumo --json`, and continue locally only when the decision is `use_cli_local`.
+Local IDEs should not use remote MCP, `sema_sync`, `sema_contratos_sincronizar`, or `sema mcp-client` to read a local workspace. In that mode, the agent must run `sema --version` locally. If the command is missing, the agent must stop and ask the human to open the Sema panel, download/run the key installer, and then repeat `sema --version`. After that, run `sema preflight resumo --json` and continue locally only when the decision is `use_cli_local`.
 
 The MCP must never pretend that a local Windows path exists on the Linux server. If a local IDE asks the remote MCP to read that path, the next action is to use the local CLI. If a web/chat client has no workspace, the next action is to request or create a mirror/snapshot.
 
@@ -30,8 +31,9 @@ Scores, findings, and agent decisions are useful signals, not proof by themselve
 O MCP da Sema é o coordenador privado dos agentes. Ele autentica clientes, escolhe o projeto ou espelho, cobra SEMAS, seleciona profiles/pipelines, pede para a CLI ler ou executar e devolve uma decisão rastreável.
 
 Ele precisa continuar compatível com chats web. Para ChatGPT, Lovable, GPTs e clientes parecidos, o MCP roda na VPS e usa a CLI governada instalada lá contra espelhos autorizados como `/srv/sema/projetos/...`.
+Quando o MCP é publico ou roda como `production`, ele falha fechado se billing nao estiver habilitado, Supabase de billing nao estiver configurado, bearer legado existir, fallback por passcode OAuth existir ou CORS estiver em wildcard. Chamada remota de ferramenta nao deve executar se a cobranca SEMAS estiver desabilitada.
 
-IDEs locais não devem usar MCP remoto, `sema_sync`, `sema_contratos_sincronizar` nem `sema mcp-client` para ler workspace local. Nesse modo, instale a CLI completa da Sema, grave a chave local, rode `sema preflight resumo --json` e continue localmente somente quando a decisão for `use_cli_local`.
+IDEs locais não devem usar MCP remoto, `sema_sync`, `sema_contratos_sincronizar` nem `sema mcp-client` para ler workspace local. Nesse modo, o agente deve rodar `sema --version` localmente. Se o comando não existir, o agente deve parar e pedir ao humano para abrir o painel Sema, baixar/rodar o instalador de chave e repetir `sema --version`. Depois disso, rode `sema preflight resumo --json` e continue localmente somente quando a decisão for `use_cli_local`.
 
 O MCP nunca deve fingir que um caminho Windows local existe no servidor Linux. Se uma IDE local pedir ao MCP remoto para ler esse caminho, a próxima ação é usar a CLI local. Se um cliente web/chat não tiver workspace, a próxima ação é pedir ou criar um espelho/snapshot.
 
@@ -50,8 +52,9 @@ Scores, achados e decisoes do agente sao sinais uteis, nao prova isolada. O MCP
 El MCP de Sema es el coordinador privado de los agentes. Autentica clientes, elige el proyecto o espejo, cobra SEMAS, selecciona profiles/pipelines, pide a la CLI que lea o ejecute y devuelve una decisión trazable.
 
 Debe seguir compatible con chats web. Para ChatGPT, Lovable, GPTs y clientes similares, el MCP corre en la VPS y usa la CLI gobernada instalada allí contra espejos autorizados como `/srv/sema/projetos/...`.
+Cuando el MCP es publico o corre como `production`, falla cerrado si billing no esta habilitado, Supabase de billing no esta configurado, bearer legado existe, fallback por passcode OAuth existe o CORS esta en wildcard. Una llamada remota de herramienta no debe ejecutar si la cobranza SEMAS esta deshabilitada.
 
-Las IDEs locales no deben usar el MCP remoto, `sema_sync`, `sema_contratos_sincronizar` ni `sema mcp-client` para leer un workspace local. En ese modo, instala la CLI completa de Sema, guarda la clave local, ejecuta `sema preflight resumo --json` y continúa localmente solo cuando la decisión sea `use_cli_local`.
+Las IDEs locales no deben usar el MCP remoto, `sema_sync`, `sema_contratos_sincronizar` ni `sema mcp-client` para leer un workspace local. En ese modo, el agente debe ejecutar `sema --version` localmente. Si el comando no existe, el agente debe parar y pedir al humano que abra el panel Sema, descargue/ejecute el instalador de clave y repita `sema --version`. Después ejecuta `sema preflight resumo --json` y continúa localmente solo cuando la decisión sea `use_cli_local`.
 
 El MCP nunca debe fingir que una ruta local de Windows existe en el servidor Linux. Si una IDE local pide al MCP remoto leer esa ruta, la siguiente acción es usar la CLI local. Si un cliente web/chat no tiene workspace, la siguiente acción es pedir o crear un espejo/snapshot.
 

package/docs/repositories.md

@@ -14,7 +14,7 @@ The active tree lives at the repository root: `contratos/`, `pacotes/`, `mcp/`,
 The operating model is:
 
 - The CLI is distributed through the npm installer/client `@semacode/cli`, then acts as the governed local executor for IDEs: it reads contracts, validates, checks drift, builds AI-first context, and runs `sema preflight resumo --json` against the SEMAS control plane before local action.
-- Local IDEs use the complete CLI and a local key. Stop unless `decisao=use_cli_local`. Do not use remote MCP, `sema_sync`, `sema_contratos_sincronizar`, or `sema mcp-client` to read a local workspace.
+- Local IDEs use the complete CLI and a local key. The agent must run `sema --version`; if missing, it asks the human to install from the Sema panel. Stop unless `decisao=use_cli_local`. Do not use remote MCP, `sema_sync`, `sema_contratos_sincronizar`, or `sema mcp-client` to read a local workspace.
 - The private MCP is the web/chat coordinator: it authenticates remote clients, selects the right server project or mirror, charges SEMAS, decides the required contract/profile flow, and returns the operational verdict.
 - Web chats remain supported because the private MCP keeps a CLI installed on the VPS and runs it against authorized mirrors under `/srv/sema/projetos/...`.
 
@@ -35,7 +35,7 @@ A árvore ativa vive na raiz do repositório: `contratos/`, `pacotes/`, `mcp/`,
 O modelo operacional é:
 
 - A CLI é distribuída pelo instalador/cliente npm `@semacode/cli` e depois atua como executor local governado para IDEs: lê contratos, valida, mede drift, monta contexto IA-first e roda `sema preflight resumo --json` contra o control plane de SEMAS antes de agir localmente.
-- IDEs locais usam a CLI completa e uma chave local. Pare se `decisao` não for `use_cli_local`. Não use MCP remoto, `sema_sync`, `sema_contratos_sincronizar` nem `sema mcp-client` para ler workspace local.
+- IDEs locais usam a CLI completa e uma chave local. O agente deve rodar `sema --version`; se faltar, deve pedir ao humano para instalar pelo painel Sema. Pare se `decisao` não for `use_cli_local`. Não use MCP remoto, `sema_sync`, `sema_contratos_sincronizar` nem `sema mcp-client` para ler workspace local.
 - O MCP privado é o coordenador web/chat: autentica clientes remotos, escolhe o projeto ou espelho de servidor correto, cobra SEMAS, decide o fluxo de contrato/profile obrigatório e devolve o veredito operacional.
 - Chats web continuam suportados porque o MCP privado mantém uma CLI instalada na VPS e executa contra espelhos autorizados em `/srv/sema/projetos/...`.
 
@@ -56,7 +56,7 @@ El árbol activo vive en la raíz del repositorio: `contratos/`, `pacotes/`, `mc
 El modelo operativo es:
 
 - La CLI se distribuye por el instalador/cliente npm `@semacode/cli` y luego actúa como ejecutor local gobernado para IDEs: lee contratos, valida, mide drift, prepara contexto IA-first y ejecuta `sema preflight resumo --json` contra el control plane de SEMAS antes de actuar localmente.
-- Las IDEs locales usan la CLI completa y una clave local. Para si `decisao` no es `use_cli_local`. No uses el MCP remoto, `sema_sync`, `sema_contratos_sincronizar` ni `sema mcp-client` para leer un workspace local.
+- Las IDEs locales usan la CLI completa y una clave local. El agente debe ejecutar `sema --version`; si falta, debe pedir al humano que instale desde el panel Sema. Para si `decisao` no es `use_cli_local`. No uses el MCP remoto, `sema_sync`, `sema_contratos_sincronizar` ni `sema mcp-client` para leer un workspace local.
 - El MCP privado es el coordinador web/chat: autentica clientes remotos, elige el proyecto o espejo de servidor correcto, cobra SEMAS, decide el flujo obligatorio de contrato/profile y devuelve el veredicto operativo.
 - Los chats web siguen soportados porque el MCP privado mantiene una CLI instalada en la VPS y la ejecuta contra espejos autorizados en `/srv/sema/projetos/...`.
 

package/node_modules/@sema/gerador-css/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sema/gerador-css",
-  "version": "1.5.42",
+  "version": "1.5.44",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts"

package/node_modules/@sema/gerador-dart/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sema/gerador-dart",
-  "version": "1.5.42",
+  "version": "1.5.44",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts"

package/node_modules/@sema/gerador-html/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sema/gerador-html",
-  "version": "1.5.42",
+  "version": "1.5.44",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts"

package/node_modules/@sema/gerador-javascript/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sema/gerador-javascript",
-  "version": "1.5.42",
+  "version": "1.5.44",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts"

package/node_modules/@sema/gerador-lua/dist/index.js

@@ -108,7 +108,20 @@ function gerarExpressaoLua(expressao, camposConhecidos, variavel) {
             return `(not ${gerarExpressaoLua(expressao.termo, camposConhecidos, variavel)})`;
     }
 }
+function gerarValidacaoPredicadoLua(texto, camposEntrada) {
+    const diferenteDe = /^([A-Za-z_][A-Za-z0-9_]*)\s+deve_ser\s+diferente_de\s+([A-Za-z0-9_-]+)$/u.exec(texto);
+    if (diferenteDe?.[1] && diferenteDe[2] && camposEntrada.has(diferenteDe[1])) {
+        return `  if entrada[${JSON.stringify(diferenteDe[1])}] == ${JSON.stringify(diferenteDe[2])} then return nil end`;
+    }
+    const umDe = /^([A-Za-z_][A-Za-z0-9_]*)\s+deve_ser\s+um_de\s+\[\s*([^\]]+?)\s*\]$/u.exec(texto);
+    if (umDe?.[1] && umDe[2] && camposEntrada.has(umDe[1])) {
+        const valores = umDe[2].split(",").flatMap((parte) => parte.trim().split(/\s+/u)).filter(Boolean);
+        return `  if not contem({ ${valores.map((valor) => JSON.stringify(valor)).join(", ")} }, entrada[${JSON.stringify(umDe[1])}]) then return nil end`;
+    }
+    return undefined;
+}
 function gerarValidacoes(task) {
+    const camposEntrada = new Set(task.input.map((campo) => campo.nome));
     const linhas = [
         ...task.input
             .filter((campo) => campo.modificadores.includes("required"))
@@ -116,9 +129,9 @@ function gerarValidacoes(task) {
         ...task.regrasEstruturadas.map((regra) => {
             switch (regra.tipo) {
                 case "predicado":
-                    return `  -- Predicado declarado em Sema: ${regra.textoOriginal}`;
+                    return [gerarValidacaoPredicadoLua(regra.textoOriginal, camposEntrada), `  -- Predicado declarado em Sema: ${regra.textoOriginal}`].filter(Boolean).join("\n");
                 default:
-                    return `  if not (${gerarExpressaoLua(regra, new Set(task.input.map((campo) => campo.nome)), "entrada")}) then error("Regra violada: ${regra.textoOriginal}") end`;
+                    return `  if not (${gerarExpressaoLua(regra, camposEntrada, "entrada")}) then error("Regra violada: ${regra.textoOriginal}") end`;
             }
         }),
         ...task.rules
@@ -146,8 +159,28 @@ function gerarGarantias(task) {
 }
 function gerarPreparacaoSaida(task) {
     const camposSaida = new Set(task.output.map((campo) => campo.nome));
+    const camposEntrada = new Set(task.input.map((campo) => campo.nome));
     const inicializacao = task.output.map((campo) => `    ${campo.nome} = ${valorPadraoLua(campo)},`).join("\n");
     const ajustes = [];
+    const precondicoes = [];
+    const campoArtefatoI18n = ["artefato_ui", "artefato_real"].find((campo) => camposEntrada.has(campo));
+    const campoContratoI18n = ["contrato_alvo", "contrato"].find((campo) => camposEntrada.has(campo));
+    if (campoArtefatoI18n && (camposEntrada.has("idioma") || campoContratoI18n)) {
+        precondicoes.push(`  local artefato_ui = tostring(entrada[${JSON.stringify(campoArtefatoI18n)}] or "")`);
+        precondicoes.push(`  local contrato_i18n = tostring(entrada[${JSON.stringify(campoContratoI18n ?? "")}] or ""):lower()`);
+        precondicoes.push(`  local idioma = tostring(entrada["idioma"] or ""):lower()`);
+        precondicoes.push(`  if idioma == "" and (contrato_i18n:find("i18n_ptbr", 1, true) or contrato_i18n:find("pt-br", 1, true)) then idioma = "pt-br" end`);
+        precondicoes.push(`  if idioma == "" and contrato_i18n:find("i18n_es", 1, true) then idioma = "es" end`);
+        precondicoes.push(`  if idioma == "" and contrato_i18n:find("i18n", 1, true) then return nil end`);
+        precondicoes.push(`  if (idioma == "pt-br" or idioma == "ptbr" or idioma == "pt") and artefato_ui:find("Descricao", 1, true) then return nil end`);
+        precondicoes.push(`  if idioma == "es" and artefato_ui:find("Descripcion", 1, true) then return nil end`);
+        if (camposSaida.has("garantia_observavel")) {
+            ajustes.push(`  saida["garantia_observavel"] = true`);
+        }
+        if (camposSaida.has("diacriticos_preservados")) {
+            ajustes.push(`  saida["diacriticos_preservados"] = true`);
+        }
+    }
     for (const garantia of task.garantiasEstruturadas) {
         if (garantia.tipo === "pertencimento" && garantia.valores && camposSaida.has(garantia.alvo)) {
             ajustes.push(`  saida[${JSON.stringify(garantia.alvo)}] = ${formatarValorLua(garantia.valores[0] ?? "", camposSaida, "saida")}`);
@@ -170,7 +203,7 @@ function gerarPreparacaoSaida(task) {
             }
         }
     }
-    return `  local saida = {\n${inicializacao}\n  }\n${ajustes.join("\n")}`;
+    return `${precondicoes.length ? `${precondicoes.join("\n")}\n` : ""}  local saida = {\n${inicializacao}\n  }\n${ajustes.join("\n")}`;
 }
 function formatarLiteralTesteLua(valor, tipoDeclarado) {
     if (["Texto", "Id", "Email", "Url", "Data", "DataHora"].includes(tipoDeclarado ?? "")) {