@semacode/cli 1.5.34 → 1.5.36

package/dist/index.js

@@ -37,8 +37,9 @@ Importante:
 - a Sema usa \`execucao\` para explicitar timeout, retry, compensacao e criticidade
 - a Sema usa \`drift\` para medir diferenca entre contrato e codigo vivo com score, confianca e lacunas
 - a Sema usa \`resumo\` e \`prompt-curto\` para IA fraca, gratuita ou com pouco contexto
-- a Sema usa \`contexto-ia\` para gerar \`ast.json\`, \`ir.json\`, \`drift.json\`, \`briefing.json\` e artefatos compactos antes da edicao
-- a Sema pode servir de base para interfaces graficas elegantes e coerentes
+- a Sema usa \`contexto-ia\` para gerar \`ast.json\`, \`ir.json\`, \`drift.json\`, \`briefing.json\` e artefatos compactos antes da edicao
+- timeout definido pelo agente nao e falha do Sema; aumente o timeout e tente de novo antes de concluir falha
+- a Sema pode servir de base para interfaces graficas elegantes e coerentes
 - a Sema nao gera uma interface completa sozinha no estado atual
 - trate a Sema como cerebro semantico da aplicacao, nao como gerador magico de front-end pronto
 - se a tarefa envolver UI, prefira pedir Sema + React + TypeScript ou Sema + arquitetura de front-end
@@ -48,8 +49,9 @@ Regras:
 - nao invente sintaxe fora da gramatica e dos exemplos oficiais
 - antes de qualquer acao, crie, edite ou remova o contrato .sema aplicavel; isso vale para Software, Author, Workflow, Ops, Game, Legal e Research
 - se a IA for fraca, nao tente abrir tudo de uma vez
-- use \`sema resumo\` e \`briefing.min.json\` antes de subir para o pacote completo
-- trate \`ir --json\` como fonte de verdade semantica
+- use \`sema resumo\` e \`briefing.min.json\` antes de subir para o pacote completo
+- se \`sema resumo . --micro\` estourar timeout local, repita com timeout maior ou escopo menor; nao avance com codigo
+- trate \`ir --json\` como fonte de verdade semantica
 - trate \`briefing.json\` como plano de intervencao antes de editar projeto vivo
 - trate \`diagnosticos --json\` como fonte de correcao
 - use \`sema formatar\` como fonte unica de estilo
@@ -74,10 +76,11 @@ Comandos essenciais:
 - geracao de codigo: \`sema compilar <arquivo-ou-pasta> --alvo <typescript|python|dart|lua> --saida <diretorio>\`
 - verificacao final: \`sema verificar <arquivo-ou-pasta> [--json]\`
 
-Antes de editar:
-1. leia README, docs de IA e um exemplo oficial parecido
+Antes de editar:
+1. leia README, docs de IA e um exemplo oficial parecido
 2. se a IA for fraca, rode \`sema resumo <arquivo> --micro\` e leia \`briefing.min.json\`
-3. se a IA aguentar mais, rode \`sema drift\` para medir impls, vinculos, rotas, score e lacunas
+   - se timeout local estourar, aumente o timeout e tente de novo; timeout nao significa Sema inativo
+3. se a IA aguentar mais, rode \`sema drift\` para medir impls, vinculos, rotas, score e lacunas
 4. se a tarefa for pesada, rode \`sema contexto-ia\` e leia \`briefing.json\`
 5. consulte AST e IR do modulo alvo so quando a capacidade realmente aguentar
 
@@ -1575,6 +1578,89 @@ function criarPoliticaIdiomaAgentContext() {
         comandosESimbolos: "Não traduza comandos, nomes de arquivos, rotas, símbolos de código ou palavras-chave da DSL.",
     };
 }
+function criarPoliticaCodigoGovernadoAgentContext() {
+    return {
+        marcador: "SEMA-GOVERNED",
+        regra: "Arquivos de código gerados ou governados pela Sema devem manter um cabeçalho curto com módulo de origem, lembrete para consultar o contrato .sema e descrição humana no idioma do usuário.",
+        descricaoHumana: "O comentário deve orientar humanos e IAs sem duplicar o contrato inteiro dentro do código.",
+        porCapacidade: {
+            fraca: "Se abrir código com SEMA-GOVERNED, pare, leia SEMA_SMALL_MODEL.md e chame Sema antes de editar.",
+            media: "Se abrir código com SEMA-GOVERNED, rode docs-impacto e drift antes de alterar comportamento.",
+            forte: "Se abrir código com SEMA-GOVERNED, pode inspecionar AST/IR e código completo, mas mantém contrato primeiro, drift e finalizar-mudanca.",
+        },
+        formatosPorAlvo: {
+            typescript: "// SEMA-GOVERNED",
+            javascript: "// SEMA-GOVERNED",
+            python: "# SEMA-GOVERNED",
+            dart: "// SEMA-GOVERNED",
+            lua: "-- SEMA-GOVERNED",
+            html: "<!-- SEMA-GOVERNED -->",
+            css: "/* SEMA-GOVERNED */",
+        },
+    };
+}
+function criarPoliticaTimeoutResumoAgentContext() {
+    return {
+        regra: "Timeout definido pelo agente não é falha do Sema. Se `sema resumo`, `inspecionar`, `drift` ou `sync-ai-entrypoints` estourar por timeout local, aumente o timeout e tente de novo com escopo menor quando possível.",
+        timeoutInicialSegundos: 120,
+        escalonamentoSegundos: [120, 300, 600],
+        timeoutDoAgenteNaoEhFalhaSema: true,
+        ateQuandoTentar: "Tente de novo com timeouts maiores enquanto houver execução disponível; se o ambiente impedir continuar, pare bloqueado e não avance com código sem Sema.",
+        porCapacidade: {
+            fraca: "Se `resumo . --micro` estourar, tente `resumo <arquivo.sema> --micro`, depois repita com timeout maior. Timeout não autoriza editar.",
+            media: "Prefira resumo escopado; se um gate Sema estourar, aumente timeout e repita antes de concluir falha.",
+            forte: "Pode rodar projeto inteiro com timeout alto, mas deve distinguir lentidão de falha real e registrar evidência.",
+        },
+    };
+}
+function criarPoliticaDesignVisualAgentContext() {
+    return {
+        regra: "Quando a tarefa envolve interface, app, site, dashboard, painel, formulário, landing, jogo ou artefato visual, o Sema governa também qualidade visual. Modernidade, identidade, responsividade, estados e evidência visual não são extras opcionais.",
+        modernoObrigatorio: true,
+        aplicarQuando: "site, app, dashboard, painel, admin, onboarding, formulário, modal, jogo, material visual ou qualquer entrega com UI.",
+        proibicoes: [
+            "interface_generica_2010",
+            "formularios_sem_hierarquia_visual",
+            "cards_cinzas_sem_identidade",
+            "layout_sem_responsividade_real",
+            "texto_estourando_ou_sobreposto",
+            "sem_estados_de_hover_focus_loading_erro_vazio",
+            "sem_assets_quando_o_dominio_pede_visual",
+            "copiar_estetica_do_contrato_para_ui",
+        ],
+        porCapacidade: {
+            fraca: "Use um padrão moderno seguro: hierarquia clara, espaçamento consistente, paleta com contraste, estados básicos, responsivo mobile/desktop e nada de formulário cinza genérico. Se não conseguir validar visualmente, pare e peça revisão.",
+            media: "Defina intenção visual antes de codar: público, domínio, densidade, tokens, componentes, estados, responsividade e anti-2010. Rode ou peça screenshot/browser check quando houver UI.",
+            forte: "Crie direção visual específica do domínio, use assets reais/gerados quando fizer sentido, refine microinterações e faça verificação visual em desktop/mobile com screenshot e correção de overlap.",
+        },
+        evidencias: {
+            fraca: [
+                "descrever padrão visual escolhido",
+                "confirmar responsividade básica",
+                "listar estados essenciais",
+            ],
+            media: [
+                "registrar tokens e componentes usados",
+                "validar desktop e mobile",
+                "corrigir texto sobreposto",
+            ],
+            forte: [
+                "screenshot desktop/mobile",
+                "verificação de assets e renderização",
+                "auditoria de contraste, hierarquia e estado vazio",
+            ],
+        },
+        criteriosMinimos: [
+            "não parecer template de 2010",
+            "hierarquia visual clara",
+            "paleta com contraste e identidade do domínio",
+            "responsividade mobile e desktop",
+            "estados de hover, focus, loading, erro e vazio quando aplicáveis",
+            "texto sem overlap ou estouro",
+            "componentes coerentes com o workflow real",
+        ],
+    };
+}
 function criarEntrypointsClientesIa() {
     return [
         {
@@ -1616,6 +1702,9 @@ function criarFailClosedAgentContext() {
         "Se o MCP remoto não tiver projeto sincronizado, use sema_chat_contexto e sema_sync/conteúdo inline; não peça para ler C:\\GitHub\\Sema.",
         "Se for criar ou corrigir .sema, use sema_exemplos antes de escrever sintaxe.",
         "Se a resposta humana estiver em PT-BR, preserve acentos e símbolos mesmo que a DSL use ASCII.",
+        "Se um arquivo de código tiver SEMA-GOVERNED, consulte Sema e o contrato aplicável antes de editar.",
+        "Se uma chamada Sema estourar por timeout local, aumente o timeout e tente de novo; timeout do agente não libera ação sem Sema.",
+        "Se a tarefa tiver UI e você não conseguir garantir um padrão visual moderno mínimo, pare e peça revisão em vez de entregar interface genérica.",
     ];
 }
 function criarAgentContextPack(guiaPorCapacidade) {
@@ -1727,7 +1816,7 @@ function criarAgentContextPack(guiaPorCapacidade) {
     ];
     return {
         nome: "Agent Context Pack",
-        versao: 2,
+        versao: 4,
         objetivo: "Dar a agentes IA uma entrada curta, estruturada e auditável antes de abrir código cru ou inventar contexto.",
         ordemLeitura: [
             ARQUIVO_SEMA_BOOT,
@@ -1748,20 +1837,29 @@ function criarAgentContextPack(guiaPorCapacidade) {
             "Valide .sema alterado e rode drift antes de concluir.",
             "Quando faltar contrato aplicável, crie ou edite o contrato antes do código.",
             "Responda no idioma do usuário e preserve acentos, cedilha, pontuação e símbolos humanos.",
+            "Mantenha o cabeçalho SEMA-GOVERNED em código gerado ou governado e volte ao contrato antes de editar.",
+            "Se uma chamada Sema estourar por timeout local, aumente o timeout e tente novamente; não trate lentidão como sessão inativa.",
+            "Se a tarefa tiver UI, trate design moderno como requisito governado por capacidade.",
         ],
         proibicoes: [
             "Não inventar sintaxe Sema fora da gramática e dos exemplos oficiais.",
             "Não tratar README, texto livre ou código como fonte superior ao contrato.",
             "Não sincronizar segredos, .env, node_modules, builds, caches, uploads ou artefatos privados fora do escopo.",
             "Não publicar, deployar ou remover capacidade sem contrato, drift e verificação.",
-            "Não misturar repositório público e privado sem conferir docs de repositórios e AGENTS.md.",
+            "Não assumir repositório público, GitHub Release pública ou leitura local pelo MCP; confira docs de repositórios e AGENTS.md.",
             "Não usar a estética ASCII da DSL como desculpa para escrever PT-BR sem acentos.",
+            "Não remover SEMA-GOVERNED nem substituir drift por comentário dentro do código.",
+            "Não copiar o contrato inteiro para comentário de código; mantenha descrição humana curta.",
+            "Não tratar timeout definido pelo agente como falha do Sema ou permissão para pular gate.",
+            "Não entregar interface genérica, cinza, com cara de template antigo ou sem estados visuais quando a tarefa envolve UI.",
         ],
         prioridades: [
             "Menor artefato suficiente primeiro.",
             "Contrato, índice e AGENTS antes de código cru.",
             "Exemplos oficiais antes de nova sintaxe.",
             "Diagnóstico estruturado antes de opinião livre.",
+            "Retry progressivo em timeout antes de declarar bloqueio.",
+            "Design visual por capacidade quando houver UI.",
             "Se risco ou escopo estiver ambíguo, parar e pedir contrato/contexto.",
         ],
         fontes,
@@ -1777,11 +1875,17 @@ function criarAgentContextPack(guiaPorCapacidade) {
         aliasesCapacidade: { ...ALIASES_CAPACIDADE_IA },
         entrypointsClientes: criarEntrypointsClientesIa(),
         politicaIdioma: criarPoliticaIdiomaAgentContext(),
+        politicaCodigoGovernado: criarPoliticaCodigoGovernadoAgentContext(),
+        politicaTimeoutResumo: criarPoliticaTimeoutResumoAgentContext(),
+        politicaDesignVisual: criarPoliticaDesignVisualAgentContext(),
         failClosed: criarFailClosedAgentContext(),
     };
 }
 function renderizarSemaBoot(agentContextPack) {
     const politica = agentContextPack.politicaIdioma;
+    const politicaCodigo = agentContextPack.politicaCodigoGovernado;
+    const politicaTimeout = agentContextPack.politicaTimeoutResumo;
+    const politicaDesign = agentContextPack.politicaDesignVisual;
     return `# SEMA_BOOT
 
 Você está em um projeto governado por Sema. O contrato semântico vem antes de qualquer ação.
@@ -1800,6 +1904,36 @@ Você está em um projeto governado por Sema. O contrato semântico vem antes de
 - Média: leia este boot, \`${ARQUIVO_AGENT_CONTEXT_PACK}\`, \`SEMA_BRIEF.curto.txt\`, \`SEMA_INDEX.json\` e a doc indicada pelo Sema.
 - Forte: leia este boot, \`${ARQUIVO_AGENT_CONTEXT_PACK}\`, \`SEMA_BRIEF.md\`, \`SEMA_INDEX.json\`, \`AGENTS.md\` e rode os gates completos.
 
+## Código governado
+
+${politicaCodigo.regra}
+
+- Marcador: \`${politicaCodigo.marcador}\`.
+- IA fraca: ${politicaCodigo.porCapacidade.fraca}
+- IA média: ${politicaCodigo.porCapacidade.media}
+- IA forte: ${politicaCodigo.porCapacidade.forte}
+
+## Design visual quando houver UI
+
+${politicaDesign.regra}
+
+- Aplicar quando: ${politicaDesign.aplicarQuando}
+- IA fraca: ${politicaDesign.porCapacidade.fraca}
+- IA média: ${politicaDesign.porCapacidade.media}
+- IA forte: ${politicaDesign.porCapacidade.forte}
+- Proibido: ${politicaDesign.proibicoes.slice(0, 5).join(", ")}.
+
+## Timeout e retry
+
+${politicaTimeout.regra}
+
+- Timeout inicial recomendado para projeto inteiro: ${politicaTimeout.timeoutInicialSegundos}s.
+- Escalonamento: ${politicaTimeout.escalonamentoSegundos.map((segundos) => `${segundos}s`).join(" -> ")}.
+- IA fraca: ${politicaTimeout.porCapacidade.fraca}
+- IA média: ${politicaTimeout.porCapacidade.media}
+- IA forte: ${politicaTimeout.porCapacidade.forte}
+- ${politicaTimeout.ateQuandoTentar}
+
 ## Idioma humano
 
 ${politica.regra}
@@ -1815,6 +1949,8 @@ ${agentContextPack.failClosed.map((regra) => `- ${regra}`).join("\n")}
 `;
 }
 function renderizarSemaSmallModel(agentContextPack) {
+    const politicaTimeout = agentContextPack.politicaTimeoutResumo;
+    const politicaDesign = agentContextPack.politicaDesignVisual;
     return `# SEMA_SMALL_MODEL
 
 Leia isto primeiro se você tem pouco contexto, pouca memória, pouco tool use ou tendência a ignorar instruções longas.
@@ -1826,6 +1962,9 @@ Leia isto primeiro se você tem pouco contexto, pouca memória, pouco tool use o
 5. Se não houver contrato: crie ou edite o contrato antes do código.
 6. Se não conseguir chamar Sema: pare e declare bloqueio.
 7. Responda no idioma do usuário. Em PT-BR, use acentos e símbolos normais.
+8. Se abrir código com \`${agentContextPack.politicaCodigoGovernado.marcador}\`: volte ao contrato, chame Sema e só então edite.
+9. Se Sema estourar por timeout local: aumente o timeout e tente de novo. Não trate isso como falha do Sema.
+10. Se a tarefa tiver UI: aplique design moderno mínimo, responsivo, com hierarquia clara e estados visuais. Não entregue formulário cinza genérico.
 
 Ordem curta:
 
@@ -1835,16 +1974,53 @@ Ordem curta:
 - \`SEMA_INDEX.json\`
 - \`AGENTS.md\`
 
+Timeout:
+
+- Timeout local do agente não é falha do Sema.
+- Projeto inteiro: comece com ${politicaTimeout.timeoutInicialSegundos}s ou mais.
+- Escalonamento: ${politicaTimeout.escalonamentoSegundos.map((segundos) => `${segundos}s`).join(" -> ")}.
+- Se o projeto inteiro for lento, escopar para \`sema resumo <arquivo.sema> --micro --para mudanca\`.
+- ${politicaTimeout.ateQuandoTentar}
+
+Design visual:
+
+- ${politicaDesign.regra}
+- IA fraca: ${politicaDesign.porCapacidade.fraca}
+- Evidência mínima: ${politicaDesign.evidencias.fraca.join(", ")}.
+- Proibido: ${politicaDesign.proibicoes.slice(0, 5).join(", ")}.
+
 Fail-closed:
 
 ${agentContextPack.failClosed.map((regra) => `- ${regra}`).join("\n")}
 `;
 }
 function renderizarDocumentoAgentesPorCapacidade(agentContextPack) {
+    const politicaDesign = agentContextPack.politicaDesignVisual;
     return `# Agentes por capacidade
 
 Sema deve funcionar em agentes fortes, médios e fracos. A diferença não é só tamanho de contexto; é disciplina operacional.
 
+## Código Governado
+
+Arquivos gerados ou governados pela Sema devem manter o marcador \`${agentContextPack.politicaCodigoGovernado.marcador}\`.
+
+- Fraca: ${agentContextPack.politicaCodigoGovernado.porCapacidade.fraca}
+- Média: ${agentContextPack.politicaCodigoGovernado.porCapacidade.media}
+- Forte: ${agentContextPack.politicaCodigoGovernado.porCapacidade.forte}
+
+## Design Visual
+
+${politicaDesign.regra}
+
+- Fraca: ${politicaDesign.porCapacidade.fraca}
+  Evidência: ${politicaDesign.evidencias.fraca.join(", ")}.
+- Média: ${politicaDesign.porCapacidade.media}
+  Evidência: ${politicaDesign.evidencias.media.join(", ")}.
+- Forte: ${politicaDesign.porCapacidade.forte}
+  Evidência: ${politicaDesign.evidencias.forte.join(", ")}.
+- Proibido: ${politicaDesign.proibicoes.join(", ")}.
+- Critérios mínimos: ${politicaDesign.criteriosMinimos.join(", ")}.
+
 ## Fraca
 
 Use para Copilot em modo simples, Cline/Roo com pouco contexto, modelos locais pequenos e agentes que ignoram instrução longa.
@@ -1870,6 +2046,17 @@ Use para Codex, Claude e agentes com tool use confiável.
 - Pode consumir AST/IR/drift completos.
 - Ainda deve respeitar contrato primeiro e falha fechada.
 
+## Timeout e Retry
+
+${agentContextPack.politicaTimeoutResumo.regra}
+
+- Timeout inicial para resumo de projeto inteiro: ${agentContextPack.politicaTimeoutResumo.timeoutInicialSegundos}s.
+- Escalonamento recomendado: ${agentContextPack.politicaTimeoutResumo.escalonamentoSegundos.map((segundos) => `${segundos}s`).join(" -> ")}.
+- Fraca: ${agentContextPack.politicaTimeoutResumo.porCapacidade.fraca}
+- Média: ${agentContextPack.politicaTimeoutResumo.porCapacidade.media}
+- Forte: ${agentContextPack.politicaTimeoutResumo.porCapacidade.forte}
+- ${agentContextPack.politicaTimeoutResumo.ateQuandoTentar}
+
 ## Idioma
 
 ${agentContextPack.politicaIdioma.regra}
@@ -1883,6 +2070,8 @@ ${agentContextPack.entrypointsClientes.map((cliente) => `- ${cliente.cliente}: $
 }
 function renderizarInstrucaoClienteSema(cliente, capacidade, agentContextPack) {
     const guia = agentContextPack.guiaPorCapacidade[capacidade];
+    const politicaTimeout = agentContextPack.politicaTimeoutResumo;
+    const politicaDesign = agentContextPack.politicaDesignVisual;
     const tituloCliente = cliente === "generico" ? "agente" : cliente;
     return `# Sema para ${tituloCliente}
 
@@ -1901,6 +2090,23 @@ Ordem de leitura: ${guia.join(" -> ")}.
 Falha fechada:
 ${agentContextPack.failClosed.map((regra) => `- ${regra}`).join("\n")}
 
+Timeout:
+- Timeout local do agente não é falha do Sema.
+- Se uma chamada Sema estourar, aumente o timeout e tente de novo antes de declarar bloqueio.
+- Para projeto inteiro, comece com ${politicaTimeout.timeoutInicialSegundos}s ou mais; se for lento, escale ${politicaTimeout.escalonamentoSegundos.map((segundos) => `${segundos}s`).join(" -> ")}.
+- Se possível, reduza escopo para \`sema resumo <arquivo.sema> --micro --para mudanca\`.
+
+Código governado:
+- Mantenha o marcador \`${agentContextPack.politicaCodigoGovernado.marcador}\` em código gerado ou governado.
+- Ao encontrar esse marcador, volte ao contrato .sema aplicável e chame Sema antes de editar.
+- Comentário de código é lembrete curto; não substitui drift, docs-impacto nem finalizar-mudanca.
+
+Design visual:
+- Se houver UI, design moderno é requisito governado, não enfeite.
+- Capacidade ${capacidade}: ${politicaDesign.porCapacidade[capacidade]}
+- Evidências: ${politicaDesign.evidencias[capacidade].join(", ")}.
+- Proibido: ${politicaDesign.proibicoes.slice(0, 5).join(", ")}.
+
 Idioma:
 - Responda no idioma do usuário.
 - Em PT-BR, use acentos, cedilha, pontuação e símbolos normais.
@@ -2243,6 +2449,7 @@ Regras:
 - use este resumo como fonte compacta inicial
 - se a tarefa pedir mais contexto, suba para \`briefing.min.json\`, \`drift.json\` e depois \`ir.json\`
 - não saia editando software vivo sem olhar risco, lacuna e checks sugeridos
+- se abrir código com \`SEMA-GOVERNED\`, volte ao contrato e chame Sema antes de editar
 ${resumo.consumerFramework ? "- se for tarefa visual consumer, priorize `appRoutes`, `consumerSurfaces` e `consumerBridges` antes de abrir arquivos aleatórios" : ""}
 
 Contexto compacto:
@@ -2275,6 +2482,30 @@ function renderizarResumoProjetoMarkdown(geradoEm, modulos, guiaPorCapacidade) {
         `- Regras: ${agentContextPack.regrasObrigatorias.slice(0, 4).join(" | ")}`,
         `- Fontes brutas sob demanda: ${agentContextPack.fontes.map((fonte) => fonte.caminho).slice(0, 7).join(", ")}`,
         "",
+        "## Código governado",
+        "",
+        `- Marcador: \`${agentContextPack.politicaCodigoGovernado.marcador}\``,
+        `- Regra: ${agentContextPack.politicaCodigoGovernado.regra}`,
+        `- IA fraca: ${agentContextPack.politicaCodigoGovernado.porCapacidade.fraca}`,
+        `- IA média: ${agentContextPack.politicaCodigoGovernado.porCapacidade.media}`,
+        `- IA forte: ${agentContextPack.politicaCodigoGovernado.porCapacidade.forte}`,
+        "",
+        "## Design visual",
+        "",
+        `- Regra: ${agentContextPack.politicaDesignVisual.regra}`,
+        `- Aplicar quando: ${agentContextPack.politicaDesignVisual.aplicarQuando}`,
+        `- IA fraca: ${agentContextPack.politicaDesignVisual.porCapacidade.fraca}`,
+        `- IA média: ${agentContextPack.politicaDesignVisual.porCapacidade.media}`,
+        `- IA forte: ${agentContextPack.politicaDesignVisual.porCapacidade.forte}`,
+        `- Proibido: ${agentContextPack.politicaDesignVisual.proibicoes.slice(0, 5).join(", ")}`,
+        "",
+        "## Timeout e retry",
+        "",
+        `- Regra: ${agentContextPack.politicaTimeoutResumo.regra}`,
+        `- Timeout inicial para projeto inteiro: ${agentContextPack.politicaTimeoutResumo.timeoutInicialSegundos}s`,
+        `- Escalonamento: ${agentContextPack.politicaTimeoutResumo.escalonamentoSegundos.map((segundos) => `${segundos}s`).join(" -> ")}`,
+        `- Bloqueio: ${agentContextPack.politicaTimeoutResumo.ateQuandoTentar}`,
+        "",
         "## Guia por capacidade",
         "",
     ];
@@ -2638,6 +2869,9 @@ async function gerarResumoProjetoIa(entrada, pastaSaidaOpcional, escreverNaRaiz
         `MODO_CODIGO: ${modoVerificacaoCodigo}`,
         `FONTES_CONCLUSAO: ${resumirListaTexto(fontesConclusao, 4)}`,
         `ENTRADA_IA: ${entradaCanonica.porCapacidade.fraca.join(" -> ")}`,
+        `TIMEOUT_SEMA: timeout local nao e falha; retry progressivo ${agentContextPack.politicaTimeoutResumo.escalonamentoSegundos.map((segundos) => `${segundos}s`).join(" -> ")}; escopar arquivo se projeto inteiro for lento`,
+        `CODIGO_GOVERNADO: ${agentContextPack.politicaCodigoGovernado.marcador} -> chamar Sema antes de editar codigo gerado`,
+        `DESIGN_VISUAL: se houver UI, moderno obrigatorio; fraca=padrao seguro responsivo; media=tokens+estados; forte=screenshot+assets+microinteracoes`,
         `TOP_MODULOS: ${resumirListaTexto(modulos.map((modulo) => modulo.modulo), 3)}`,
         `TOP_RISCOS: ${resumirListaTexto(unicosOrdenados(modulos.flatMap((modulo) => modulo.riscosPrincipais)), 3)}`,
         `TOP_LACUNAS: ${resumirListaTexto(unicosOrdenados(modulos.flatMap((modulo) => modulo.lacunas)), 3)}`,
@@ -2656,6 +2890,9 @@ async function gerarResumoProjetoIa(entrada, pastaSaidaOpcional, escreverNaRaiz
                 : []),
         `FONTES_CONCLUSAO: ${resumirListaTexto(fontesConclusao, 6)}`,
         `ENTRADA_IA: ${entradaCanonica.porCapacidade.media.join(" -> ")}`,
+        `TIMEOUT_SEMA: ${agentContextPack.politicaTimeoutResumo.regra} Escale ${agentContextPack.politicaTimeoutResumo.escalonamentoSegundos.map((segundos) => `${segundos}s`).join(" -> ")} antes de declarar bloqueio.`,
+        `CODIGO_GOVERNADO: ${agentContextPack.politicaCodigoGovernado.marcador} -> docs-impacto e drift antes de alterar comportamento`,
+        `DESIGN_VISUAL: ${agentContextPack.politicaDesignVisual.regra} Fraca=${agentContextPack.politicaDesignVisual.porCapacidade.fraca} Media=${agentContextPack.politicaDesignVisual.porCapacidade.media} Forte=${agentContextPack.politicaDesignVisual.porCapacidade.forte}`,
         `TOP_MODULOS: ${resumirListaTexto(modulos.map((modulo) => modulo.modulo), 6)}`,
         `TOP_RISCOS: ${resumirListaTexto(unicosOrdenados(modulos.flatMap((modulo) => modulo.riscosPrincipais)), 6)}`,
         `TOP_LACUNAS: ${resumirListaTexto(unicosOrdenados(modulos.flatMap((modulo) => modulo.lacunas)), 6)}`,
@@ -2758,16 +2995,23 @@ Antes de escolher arquivo de código, leia \`${ARQUIVO_SEMA_BOOT}\` e \`agent-co
 - Em PT-BR, use acentos, cedilha, pontuação e símbolos normais.
 - A DSL \`.sema\` pode ser ASCII; texto humano não precisa ser.
 
-## Texto bruto sob demanda
-
+## Texto bruto sob demanda
+
 - Abra \`AGENTS.md\` antes de editar código, contrato, docs operacionais, release ou deploy.
-- Abra \`exemplos/\` antes de criar ou corrigir sintaxe \`.sema\`.
+- Abra \`exemplos/\` antes de criar ou corrigir sintaxe \`.sema\`.
 - Abra \`docs/sintaxe.md\` quando exemplos não bastarem para resolver a gramática.
 - Abra \`contratos/\` antes de qualquer implementação ou mudança de comportamento.
-
-## Fechamento
-
-1. Editar o arquivo \`.sema\`.
+
+## Timeout e retry
+
+- Timeout local do agente não é falha do Sema.
+- Se uma chamada Sema estourar, aumente o timeout e tente de novo.
+- Se o projeto inteiro for lento, escopar para \`sema resumo "${contexto.arquivo}" --micro --para mudanca\`.
+- Se o ambiente impedir continuar, pare bloqueado e não avance com código sem Sema.
+
+## Fechamento
+
+1. Editar o arquivo \`.sema\`.
 2. Rodar \`sema formatar "${contexto.arquivo}"\`.
 3. Rodar \`sema validar "${contexto.arquivo}" --json\`.
 4. Rodar \`sema drift "${contexto.arquivo}" --json\`.
@@ -7098,6 +7342,7 @@ async function comandoAjudaIa() {
         "Use `sema sync-ai-entrypoints` para regenerar `AGENT_CONTEXT_PACK.json`, `SEMA_BRIEF.*` e `SEMA_INDEX.json` na raiz.",
         "Use `sema instalar-exemplos` para materializar `exemplos/` oficiais sem sobrescrever arquivos locais.",
         "Use `sema resumo <arquivo> --micro --para onboarding` para IA fraca.",
+        "Se `sema resumo` ou outro gate estourar timeout local, aumente o timeout e tente de novo; timeout do agente nao e falha do Sema.",
         "Use `sema prompt-curto <arquivo> --curto --para mudanca` para colar contexto em modelo gratuito.",
         "Use `sema prompt-ia`, `sema prompt-ia-ui`, `sema prompt-ia-react` e `sema prompt-ia-sema-primeiro` conforme a tarefa.",
         "Use `sema exemplos-prompt-ia` para pegar modelos prontos de prompt.",
@@ -7117,6 +7362,7 @@ async function comandoAjudaIa() {
         "Peca `.sema` + arquitetura + React + TypeScript, ou use o modo `Sema primeiro`.",
         "Se o projeto ja existe, trate `importar` como rascunho e `drift` como juiz.",
         "IA fraca comeca no menor artefato que resolve a tarefa; nao enfie `ast.json` inteiro nela de bobeira.",
+        "Timeout local e so limite do agente: escale e tente de novo antes de chamar Sema de inativo.",
         "Antes de editar software vivo, leia `briefing.min.json` ou `briefing.json` em vez de sair cavando arquivo na fe.",
         "Trate `route`, `worker`, `evento`, `fila`, `cron`, `webhook`, `cache`, `storage` e `policy` como superficies de primeira classe.",
     ]));