@semacode/cli 0.9.0 → 1.1.0

package/dist/index.js

@@ -12,11 +12,13 @@ import { gerarTypeScript } from "@sema/gerador-typescript";
 import { carregarConfiguracaoProjeto, carregarProjeto, resolverAlvoPadrao, resolverAlvosVerificacao, resolverEstruturaSaidaPadrao, resolverFrameworkPadrao, resolverSaidaPadrao, } from "./projeto.js";
 import { importarProjetoLegado, resumoImportacao } from "./importador.js";
 import { analisarDriftLegado } from "./drift.js";
-const STARTER_IA = `Voce esta trabalhando com Sema, um Protocolo de Governanca de Intencao para IA e backend vivo.
+const STARTER_IA = `Voce esta trabalhando com Sema, um Protocolo de Governanca de Intencao para IA sobre software vivo em backend e front consumer.
 
 Importante:
 - a Sema se apresenta publicamente como protocolo e funciona tecnicamente como linguagem de intencao
-- a Sema e protocolo de governanca semantica, nao gerador magico que deveria fazer tudo
+- a Sema e protocolo de governanca semantica desenhado para IA, nao para ergonomia humana
+- leitura humana e bonus toleravel, nao objetivo de produto
+- a Sema nao e gerador magico que deveria fazer tudo
 - a Sema modela contratos, estados, fluxos, erros, efeitos, garantias, vinculos e execucao
 - a Sema gera codigo e scaffolding real para TypeScript, Python e Dart
 - a Sema usa \`importar\` para bootstrap revisavel, nao para contrato final automatico
@@ -24,7 +26,8 @@ Importante:
 - a Sema usa \`vinculos\` para ligar contrato a arquivo, simbolo, recurso e superficie real
 - 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 \`contexto-ia\` para gerar \`ast.json\`, \`ir.json\`, \`drift.json\` e \`briefing.json\` antes da edicao
+- a Sema usa \`resumo\` e \`prompt-curto\` para IA pequena ou gratuita
+- 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 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
@@ -33,6 +36,8 @@ Importante:
 
 Regras:
 - nao invente sintaxe fora da gramatica e dos exemplos oficiais
+- se a IA for pequena, 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
 - trate \`briefing.json\` como plano de intervencao antes de editar projeto vivo
 - trate \`diagnosticos --json\` como fonte de correcao
@@ -41,6 +46,8 @@ Regras:
 - nao cobre da Sema adivinhacao de negocio que nao esta no contrato nem no codigo
 
 Comandos essenciais:
+- resumo compacto por capacidade: \`sema resumo <arquivo-ou-pasta> [--micro|--curto|--medio] [--para <resumo|onboarding|review|mudanca|bug|arquitetura>]\`
+- prompt curto para IA pequena: \`sema prompt-curto <arquivo-ou-pasta> [--micro|--curto|--medio] [--para <resumo|onboarding|review|mudanca|bug|arquitetura>]\`
 - descoberta do projeto: \`sema inspecionar [arquivo-ou-pasta] --json\`
 - auditoria do contrato vivo: \`sema drift <arquivo-ou-pasta> [--json]\`
 - contexto completo do modulo: \`sema contexto-ia <arquivo.sema>\`
@@ -49,16 +56,16 @@ Comandos essenciais:
 - validacao: \`sema validar <arquivo.sema> --json\`
 - diagnosticos: \`sema diagnosticos <arquivo.sema> --json\`
 - formatacao: \`sema formatar <arquivo.sema>\`
-- importacao assistida de legado: \`sema importar <nestjs|fastapi|flask|nextjs|firebase|dotnet|java|go|rust|cpp|typescript|python|dart> <diretorio> --saida <diretorio>\`
+- importacao assistida de legado: \`sema importar <nestjs|fastapi|flask|nextjs|nextjs-consumer|react-vite-consumer|angular-consumer|flutter-consumer|firebase|dotnet|java|go|rust|cpp|typescript|python|dart> <diretorio> --saida <diretorio>\`
 - geracao de codigo: \`sema compilar <arquivo-ou-pasta> --alvo <typescript|python|dart> --saida <diretorio>\`
 - verificacao final: \`sema verificar <arquivo-ou-pasta> [--json]\`
 
 Antes de editar:
 1. leia README, docs de IA e um exemplo oficial parecido
-2. rode \`sema inspecionar\` para descobrir base, codigo vivo e fontes legado
-3. rode \`sema drift\` para medir impls, vinculos, rotas, score e lacunas
-4. rode \`sema contexto-ia\` e leia \`briefing.json\`
-5. consulte AST e IR do modulo alvo
+2. se a IA for pequena, 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
+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
 
 Depois de editar:
 1. rode \`sema formatar\`
@@ -66,11 +73,12 @@ Depois de editar:
 3. se houver falha, use \`diagnosticos --json\`
 4. rode \`sema drift\` de novo quando mexer em codigo vivo
 5. se a tarefa pedir codigo derivado, rode \`sema compilar\`
-6. feche com \`sema verificar\` ou \`npm run project:check\`
+6. feche com \`sema verificar <arquivo-ou-pasta> --json\`
 
 Priorize sempre:
 - exemplos oficiais
 - JSON da CLI
+- o menor artefato que resolva a tarefa da IA atual
 - score, confianca e lacunas do \`drift\`
 - \`briefing.json\` como guia de mudanca
 - consistencia semantica
@@ -88,16 +96,17 @@ Superficies que a IA deve enxergar como first-class:
 
 Nao improvise quando faltar contexto.
 `;
-const PROMPT_BASE_IA = `Voce esta trabalhando com Sema, um Protocolo de Governanca de Intencao orientado a contrato, desenhado para facilitar entendimento e operacao por IA.
+const PROMPT_BASE_IA = `Voce esta trabalhando com Sema, um Protocolo de Governanca de Intencao orientado a contrato, desenhado para operacao por IA.
 
-Trate a Sema como camada semantica e linguagem de especificacao executavel. Nao invente sintaxe, palavras-chave ou blocos fora da gramatica e dos exemplos oficiais.
+Trate a Sema como camada semantica e linguagem de especificacao executavel feita para IA, nao para leitura humana confortavel. Nao invente sintaxe, palavras-chave ou blocos fora da gramatica e dos exemplos oficiais.
 
 Fontes de verdade, em ordem:
 1. README do projeto
 2. gramatica e documentacao de sintaxe da Sema
 3. especificacao semantica da linguagem
 4. exemplos oficiais, com prioridade para o vertical de pagamento
-5. AST, IR e diagnosticos exportados pela CLI em JSON
+5. \`sema resumo\` e \`briefing.min.json\` quando a IA for pequena
+6. AST, IR e diagnosticos exportados pela CLI em JSON quando a capacidade aguentar
 
 Regras de operacao:
 - preserve o significado semantico
@@ -105,6 +114,7 @@ Regras de operacao:
 - use diagnosticos estruturados como contrato de correcao
 - use a IR como fonte de verdade semantica quando houver duvida
 - nao conclua uma alteracao sem validar e verificar o modulo
+- comece pelo menor artefato semantico que resolva a tarefa
 
 Antes de editar \`.sema\`, entenda:
 - o module alvo
@@ -292,6 +302,8 @@ Nao transforme isso em um \`index.html\` solto.
 Comandos uteis da CLI para esse fluxo:
 - \`sema starter-ia\`
 - \`sema ajuda-ia\`
+- \`sema resumo <arquivo-ou-pasta>\`
+- \`sema prompt-curto <arquivo-ou-pasta>\`
 - \`sema prompt-ia\`
 - \`sema prompt-ia-ui\`
 - \`sema prompt-ia-react\`
@@ -300,40 +312,106 @@ Comandos uteis da CLI para esse fluxo:
 `;
 const DIRETORIO_CLI_ATUAL = path.dirname(fileURLToPath(import.meta.url));
 const VERSAO_CLI = pacoteCli.version;
+const ARQUIVOS_CANONICOS_IA_RAIZ = [
+    "llms.txt",
+    "SEMA_BRIEF.md",
+    "SEMA_INDEX.json",
+    "AGENTS.md",
+    "README.md",
+    "llms-full.txt",
+];
+const DOCUMENTOS_SUPORTE_IA = [
+    "docs/AGENT_STARTER.md",
+    "docs/integracao-com-ia.md",
+    "docs/fluxo-pratico-ia-sema.md",
+    "docs/como-ensinar-a-sema-para-ia.md",
+    "docs/sintaxe.md",
+    "docs/cli.md",
+];
 function obterArgumentos() {
     const [, , comando, ...resto] = process.argv;
     return { comando: comando, resto };
 }
+function renderizarCaixaAscii(linhas) {
+    const largura = Math.max(...linhas.map((linha) => linha.length), 12);
+    const borda = `+${"-".repeat(largura + 2)}+`;
+    return [
+        borda,
+        ...linhas.map((linha) => `| ${linha.padEnd(largura, " ")} |`),
+        borda,
+    ].join("\n");
+}
+function renderizarSecaoAscii(titulo, linhas) {
+    return [
+        titulo,
+        ...linhas.map((linha) => `  ${linha}`),
+    ].join("\n");
+}
 function ajuda() {
-    return `Sema CLI
-
-Comandos:
-  sema --versao
-  sema --version
-  sema -v
-  sema iniciar
-  sema validar <arquivo-ou-pasta>
-  sema ast <arquivo.sema>
-  sema ir <arquivo.sema>
-  sema compilar <arquivo-ou-pasta> --alvo <python|typescript|dart> --saida <diretorio> [--estrutura <flat|modulos|backend>] [--framework <base|nestjs|fastapi>]
-  sema gerar <python|typescript|dart> <arquivo-ou-pasta> --saida <diretorio> [--estrutura <flat|modulos|backend>] [--framework <base|nestjs|fastapi>]
-  sema testar <arquivo.sema> --alvo <python|typescript|dart> --saida <diretorio-temporario> [--estrutura <flat|modulos|backend>] [--framework <base|nestjs|fastapi>]
-  sema diagnosticos <arquivo.sema> [--json]
-  sema verificar <arquivo-ou-pasta> [--saida <diretorio-base>] [--json]
-  sema inspecionar [arquivo-ou-pasta] [--json]
-  sema drift <arquivo-ou-pasta> [--json]
-  sema importar <nestjs|fastapi|flask|nextjs|firebase|dotnet|java|go|rust|cpp|typescript|python|dart> <diretorio> [--saida <diretorio>] [--namespace <base>] [--json]
-  sema doctor
-  sema formatar <arquivo-ou-pasta> [--check] [--json]
-  sema ajuda-ia
-  sema starter-ia
-  sema prompt-ia
-  sema prompt-ia-ui
-  sema prompt-ia-react
-  sema prompt-ia-sema-primeiro
-  sema exemplos-prompt-ia
-  sema contexto-ia <arquivo.sema> [--saida <diretorio>] [--json]
-`;
+    return [
+        renderizarCaixaAscii([
+            `Sema CLI v${VERSAO_CLI}`,
+            "IA-first para contrato, geracao e adocao incremental",
+            "novo projeto, edicao guiada e legado sem contrato inicial",
+        ]),
+        "",
+        renderizarSecaoAscii("Fluxos rapidos", [
+            "[1] Projeto novo / producao inicial",
+            "sema iniciar --template <base|nestjs|fastapi|nextjs-api|nextjs-consumer|react-vite-consumer|angular-consumer|flutter-consumer>",
+            "sema validar contratos/<modulo>.sema --json",
+            "sema compilar <arquivo-ou-pasta> --alvo <typescript|python|dart> --saida <diretorio>",
+            "sema verificar <arquivo-ou-pasta> --json",
+            "",
+            "[2] Editar projeto que ja usa Sema",
+            "sema inspecionar . --json",
+            "sema resumo <arquivo-ou-pasta> --micro --para mudanca",
+            "sema drift <arquivo-ou-pasta> --json",
+            "sema contexto-ia <arquivo.sema> --saida ./.tmp/contexto --json",
+            "",
+            "[3] Adotar Sema em projeto que ainda nao usa",
+            "sema importar <fonte> <diretorio> --saida <diretorio> --json",
+            "sema formatar <arquivo-ou-pasta>",
+            "sema validar <arquivo-ou-pasta> --json",
+            "sema drift <arquivo-ou-pasta> --json",
+        ]),
+        "",
+        renderizarSecaoAscii("IA por capacidade", [
+            "pequena: sema resumo --micro + briefing.min.json + prompt-curto.txt",
+            "media: sema resumo --curto + drift.json + briefing.min.json",
+            "grande: sema contexto-ia + briefing.json + ir.json + ast.json",
+        ]),
+        "",
+        renderizarSecaoAscii("Comandos principais", [
+            "descoberta: sema inspecionar [arquivo-ou-pasta] [--json]",
+            "auditoria: sema drift <arquivo-ou-pasta> [--json]",
+            "importacao: sema importar <nestjs|fastapi|flask|nextjs|nextjs-consumer|react-vite-consumer|angular-consumer|flutter-consumer|firebase|dotnet|java|go|rust|cpp|typescript|python|dart> <diretorio> [--saida <diretorio>] [--namespace <base>] [--json]",
+            "validacao: sema validar <arquivo-ou-pasta> [--json]",
+            "diagnostico: sema diagnosticos <arquivo.sema> [--json]",
+            "geracao: sema compilar <arquivo-ou-pasta> --alvo <python|typescript|dart> --saida <diretorio> [--estrutura <flat|modulos|backend>] [--framework <base|nestjs|fastapi>]",
+            "teste local: sema testar <arquivo.sema> --alvo <python|typescript|dart> --saida <diretorio-temporario> [--estrutura <flat|modulos|backend>] [--framework <base|nestjs|fastapi>]",
+            "verificacao final: sema verificar <arquivo-ou-pasta> [--saida <diretorio-base>] [--json]",
+            "formatacao: sema formatar <arquivo-ou-pasta> [--check] [--json]",
+        ]),
+        "",
+        renderizarSecaoAscii("Ajuda IA-first", [
+            "sema ajuda-ia",
+            "sema starter-ia",
+            "sema resumo <arquivo-ou-pasta> [--micro|--curto|--medio] [--para <resumo|onboarding|review|mudanca|bug|arquitetura>] [--saida <diretorio>] [--raiz] [--json]",
+            "sema prompt-curto <arquivo-ou-pasta> [--micro|--curto|--medio] [--para <resumo|onboarding|review|mudanca|bug|arquitetura>] [--json]",
+            "sema prompt-ia",
+            "sema prompt-ia-ui",
+            "sema prompt-ia-react",
+            "sema prompt-ia-sema-primeiro",
+            "sema exemplos-prompt-ia",
+            "sema contexto-ia <arquivo.sema> [--saida <diretorio>] [--json]",
+            "sema sync-ai-entrypoints [--json]",
+        ]),
+        "",
+        renderizarSecaoAscii("Operacional", [
+            "sema doctor",
+            "sema --versao | --version | -v",
+        ]),
+    ].join("\n");
 }
 async function carregarModulos(entrada, cwd = process.cwd()) {
     return (await carregarProjeto(entrada, cwd)).modulosSelecionados;
@@ -356,18 +434,51 @@ function obterOpcao(args, nome, padrao) {
 function possuiFlag(args, nome) {
     return args.includes(nome);
 }
+const OPCOES_COM_VALOR = new Set([
+    "--template",
+    "--alvo",
+    "--saida",
+    "--estrutura",
+    "--framework",
+    "--namespace",
+    "--para",
+]);
 function obterPosicionais(args) {
     const posicionais = [];
     for (let indice = 0; indice < args.length; indice += 1) {
         const atual = args[indice];
         if (atual.startsWith("--")) {
-            indice += 1;
+            if (OPCOES_COM_VALOR.has(atual)) {
+                indice += 1;
+            }
             continue;
         }
         posicionais.push(atual);
     }
     return posicionais;
 }
+function normalizarTamanhoResumo(args) {
+    const escolhas = [
+        possuiFlag(args, "--micro") ? "micro" : null,
+        possuiFlag(args, "--curto") ? "curto" : null,
+        possuiFlag(args, "--medio") ? "medio" : null,
+    ].filter((item) => item !== null);
+    if (escolhas.length > 1) {
+        throw new Error("Use apenas uma entre as flags --micro, --curto ou --medio.");
+    }
+    return escolhas[0] ?? "curto";
+}
+function normalizarModoResumo(valor) {
+    if (valor === "resumo"
+        || valor === "onboarding"
+        || valor === "review"
+        || valor === "mudanca"
+        || valor === "bug"
+        || valor === "arquitetura") {
+        return valor;
+    }
+    return "resumo";
+}
 function comandoDisponivel(comando, argumentos = ["--version"]) {
     const execucao = spawnSync(comando, argumentos, { stdio: "ignore", shell: process.platform === "win32" });
     return (execucao.status ?? 1) === 0;
@@ -383,7 +494,10 @@ async function comandoDoctor() {
         { nome: "java", ok: comandoDisponivel("java") },
         { nome: "code", ok: comandoDisponivel("code", ["--version"]) },
     ];
-    console.log("Sema doctor");
+    console.log(renderizarCaixaAscii([
+        "Sema doctor",
+        "checa a toolchain minima para validar, gerar e operar a CLI",
+    ]));
     for (const check of checks) {
         console.log(`- ${check.nome}: ${check.ok ? "ok" : "ausente"}`);
     }
@@ -424,6 +538,18 @@ function normalizarFonteImportacao(valor) {
     if (valor === "next") {
         return "nextjs";
     }
+    if (valor === "next-consumer" || valor === "nextjs-consumer") {
+        return "nextjs-consumer";
+    }
+    if (valor === "react-vite" || valor === "react-vite-consumer" || valor === "react-consumer") {
+        return "react-vite-consumer";
+    }
+    if (valor === "angular" || valor === "angular-consumer") {
+        return "angular-consumer";
+    }
+    if (valor === "flutter" || valor === "flutter-consumer") {
+        return "flutter-consumer";
+    }
     if (valor === "fb") {
         return "firebase";
     }
@@ -446,6 +572,10 @@ function normalizarFonteImportacao(valor) {
         || valor === "fastapi"
         || valor === "flask"
         || valor === "nextjs"
+        || valor === "nextjs-consumer"
+        || valor === "react-vite-consumer"
+        || valor === "angular-consumer"
+        || valor === "flutter-consumer"
         || valor === "firebase"
         || valor === "dotnet"
         || valor === "java"
@@ -463,6 +593,10 @@ function normalizarTemplateIniciar(valor) {
     if (valor === "nestjs"
         || valor === "fastapi"
         || valor === "nextjs-api"
+        || valor === "nextjs-consumer"
+        || valor === "react-vite-consumer"
+        || valor === "angular-consumer"
+        || valor === "flutter-consumer"
         || valor === "node-firebase-worker"
         || valor === "aspnet-api"
         || valor === "springboot-api"
@@ -641,23 +775,377 @@ async function descobrirDocsIa() {
     };
 }
 function renderizarCabecalhoDocsIa(descoberta) {
+    const documentos = descoberta.documentos.map((documento) => `\`${documento.nome}\``);
     const linhas = [
-        "Informacoes da instalacao atual",
-        `- Origem da instalacao: ${descoberta.origemInstalacao}`,
-        `- Base detectada: ${descoberta.baseDetectada ?? "nao encontrada"}`,
+        "Modo IA-first da instalacao atual",
+        "- Use `sema` como interface publica principal.",
+        "- A Sema entra em projeto novo, projeto ja semantizado e adocao incremental em legado sem contrato inicial.",
+        "- Nao assuma monorepo, `node pacotes/cli/dist/index.js`, `npm run project:check` ou uma pasta `exemplos` externa ao projeto atual.",
+        "- Se a IA tiver contexto curto, comece por `sema resumo` e `sema prompt-curto`.",
+        "- Se a IA aguentar mais contexto, suba para `sema drift --json` e `sema contexto-ia`.",
+        "- So leia `ast.json` e `ir.json` completos quando a capacidade da IA realmente aguentar esse volume.",
     ];
-    if (descoberta.documentos.length > 0) {
-        linhas.push("- Documentos locais encontrados:");
-        for (const documento of descoberta.documentos) {
-            linhas.push(`  - ${documento.nome}: ${documento.caminho}`);
-        }
+    if (documentos.length > 0) {
+        linhas.push(`- Documentos locais empacotados: ${documentos.join(", ")}.`);
     }
     else {
-        linhas.push("- Documentos locais encontrados: nenhum");
-        linhas.push("  - Esta instalacao da CLI nao conseguiu localizar a pasta docs ao redor do pacote atual.");
+        linhas.push("- Documentos locais empacotados: nenhum extra detectado. Siga a CLI, o contrato atual e os artefatos JSON.");
     }
     return linhas.join("\n");
 }
+function unicos(itens) {
+    return [...new Set(itens)];
+}
+function unicosOrdenados(itens) {
+    return unicos(itens).sort((a, b) => a.localeCompare(b, "pt-BR"));
+}
+function limitarLista(itens, limite) {
+    return itens.slice(0, limite);
+}
+function resumirListaTexto(itens, limite, padrao = "nenhum") {
+    if (itens.length === 0) {
+        return padrao;
+    }
+    const visiveis = itens.slice(0, limite);
+    const restante = itens.length - visiveis.length;
+    return restante > 0 ? `${visiveis.join(", ")} (+${restante})` : visiveis.join(", ");
+}
+function normalizarIdentificadorResumo(valor) {
+    return valor.replace(/[._]/g, " ").replace(/\s+/g, " ").trim();
+}
+function resumirCamposTask(task, campo, limiteCampos) {
+    const campos = (task[campo] ?? []).map((item) => item.nome).slice(0, limiteCampos);
+    if (campos.length === 0) {
+        return `${task.nome}(-)`;
+    }
+    return `${task.nome}(${campos.join(", ")})`;
+}
+function formatarEfeitoSemanticoResumido(efeito) {
+    if (efeito.textoOriginal) {
+        return efeito.textoOriginal;
+    }
+    const partes = [`${efeito.categoria} ${efeito.alvo}`];
+    if (efeito.criticidade) {
+        partes.push(`criticidade=${efeito.criticidade}`);
+    }
+    if (efeito.detalhe) {
+        partes.push(efeito.detalhe);
+    }
+    return partes.join(" ");
+}
+function calcularRiscoOperacionalResumo(resumoDrift) {
+    if (resumoDrift.tasks.some((task) => task.riscoOperacional === "alto")) {
+        return "alto";
+    }
+    if (resumoDrift.tasks.some((task) => task.riscoOperacional === "medio")) {
+        return "medio";
+    }
+    return "baixo";
+}
+function descreverFazModulo(ir, modulo) {
+    if (!ir) {
+        return `governa o modulo ${normalizarIdentificadorResumo(modulo)}`;
+    }
+    const partes = [];
+    if (ir.routes.length > 0) {
+        partes.push(`${ir.routes.length} rota(s)`);
+    }
+    if (ir.superficies.length > 0) {
+        partes.push(`${ir.superficies.length} superficie(s)`);
+    }
+    if (ir.tasks.length > 0) {
+        partes.push(`${ir.tasks.length} task(s)`);
+    }
+    const foco = ir.routes[0]?.nome ?? ir.superficies[0]?.nome ?? ir.tasks[0]?.nome ?? modulo;
+    return partes.length > 0
+        ? `governa ${partes.join(", ")} com foco em ${normalizarIdentificadorResumo(foco)}`
+        : `governa o modulo ${normalizarIdentificadorResumo(modulo)}`;
+}
+function criarGuiaCapacidadeIa() {
+    return {
+        pequena: {
+            descricao: "IA gratuita ou com contexto curto. Leia so o cartao semantico e o briefing minimo.",
+            artefatos: ["resumo.micro.txt", "briefing.min.json", "prompt-curto.txt"],
+            ordemLeitura: ["resumo.micro.txt", "briefing.min.json", "resumo.curto.txt"],
+            evitar: ["ast.json", "ir.json", "diagnosticos.json"],
+        },
+        media: {
+            descricao: "IA com contexto medio. Aguenta resumo expandido, briefing minimo e drift.",
+            artefatos: ["resumo.curto.txt", "briefing.min.json", "drift.json", "prompt-curto.txt"],
+            ordemLeitura: ["resumo.curto.txt", "briefing.min.json", "drift.json", "resumo.md"],
+            evitar: ["ast.json"],
+        },
+        grande: {
+            descricao: "IA com contexto grande ou tool use. Pode consumir o pacote completo.",
+            artefatos: ["README.md", "resumo.md", "briefing.json", "drift.json", "ir.json", "ast.json"],
+            ordemLeitura: ["README.md", "resumo.md", "briefing.json", "drift.json", "ir.json", "ast.json"],
+            evitar: [],
+        },
+    };
+}
+function coletarResumoSemanticoModulo(contexto) {
+    const { arquivo, modulo, geradoEm, ir, briefing, drift } = contexto;
+    const tarefas = ir?.tasks ?? [];
+    const rotas = ir?.routes ?? [];
+    const superficies = ir?.superficies ?? [];
+    const regrasCriticas = unicosOrdenados([
+        ...tarefas.flatMap((task) => task.rules),
+        ...tarefas.flatMap((task) => task.guarantees),
+    ]);
+    const efeitos = unicosOrdenados([
+        ...tarefas.flatMap((task) => task.effects),
+        ...rotas.flatMap((route) => route.efeitosPublicos.map((efeito) => formatarEfeitoSemanticoResumido(efeito))),
+        ...superficies.flatMap((superficie) => superficie.effects.map((efeito) => formatarEfeitoSemanticoResumido(efeito))),
+    ]);
+    const erros = unicosOrdenados([
+        ...tarefas.flatMap((task) => Object.keys(task.errors)),
+        ...tarefas.flatMap((task) => task.errosDetalhados.map((erro) => erro.codigo)),
+        ...rotas.flatMap((route) => route.errosPublicos.map((erro) => erro.codigo)),
+    ]);
+    const entidadesAfetadas = unicosOrdenados([
+        ...(ir?.resumoAgente.entidadesAfetadas ?? []),
+        ...tarefas.flatMap((task) => task.resumoAgente.entidadesAfetadas),
+        ...rotas.flatMap((route) => route.resumoAgente.entidadesAfetadas),
+        ...superficies.flatMap((superficie) => superficie.resumoAgente.entidadesAfetadas),
+    ]);
+    return {
+        geradoEm,
+        arquivo,
+        modulo,
+        perfilCompatibilidade: ir?.perfilCompatibilidade ?? briefing.perfilCompatibilidade,
+        scoreSemantico: briefing.scoreSemantico,
+        confiancaGeral: briefing.confiancaGeral,
+        riscoOperacional: calcularRiscoOperacionalResumo(drift.resumo),
+        faz: descreverFazModulo(ir, modulo),
+        tarefasPrincipais: limitarLista(tarefas.map((task) => task.nome), 6),
+        entradasChave: limitarLista(tarefas.map((task) => resumirCamposTask(task, "input", 4)), 4),
+        saidasChave: limitarLista(tarefas.map((task) => resumirCamposTask(task, "output", 4)), 4),
+        superficiesPublicas: limitarLista(unicosOrdenados([
+            ...briefing.superficiesImpactadas,
+            ...rotas.map((route) => `${route.metodo ?? "?"} ${route.caminho ?? route.nome}`),
+        ]), 8),
+        regrasCriticas: limitarLista(regrasCriticas, 8),
+        efeitos: limitarLista(efeitos, 8),
+        erros: limitarLista(erros, 8),
+        entidadesAfetadas: limitarLista(entidadesAfetadas, 8),
+        arquivosProvaveis: limitarLista(unicosOrdenados(briefing.oQueTocar), 8),
+        simbolosRelacionados: limitarLista(unicosOrdenados(briefing.simbolosRelacionados), 8),
+        riscosPrincipais: limitarLista(unicosOrdenados(briefing.riscosPrincipais), 6),
+        lacunas: limitarLista(unicosOrdenados(briefing.oQueEstaFrouxo), 6),
+        inferido: limitarLista(unicosOrdenados(briefing.oQueFoiInferido), 6),
+        checksSugeridos: limitarLista(unicosOrdenados(briefing.oQueValidar), 6),
+        testesMinimos: limitarLista(unicosOrdenados(briefing.testesMinimos), 6),
+        consumerFramework: briefing.consumerFramework ?? drift.drift.consumerFramework ?? null,
+        appRoutes: limitarLista(unicosOrdenados(briefing.appRoutes ?? drift.drift.appRoutes ?? []), 8),
+        consumerSurfaces: limitarLista(unicosOrdenados(briefing.consumerSurfaces ?? []), 8),
+        consumerBridges: limitarLista(unicosOrdenados(briefing.consumerBridges ?? []), 8),
+        arquivosProvaveisEditar: limitarLista(unicosOrdenados(briefing.arquivosProvaveisEditar ?? briefing.oQueTocar), 8),
+    };
+}
+function renderizarResumoModuloTexto(resumo, tamanho, modo) {
+    const limite = tamanho === "micro" ? 2 : tamanho === "curto" ? 4 : 6;
+    const linhas = [
+        `MODO: ${modo}`,
+        `MODULO: ${resumo.modulo}`,
+        `FAZ: ${resumo.faz}`,
+        `PERFIL: ${resumo.perfilCompatibilidade}`,
+        `CONSUMER_FRAMEWORK: ${resumo.consumerFramework ?? "nenhum"}`,
+        `APP_ROUTES: ${resumirListaTexto(resumo.appRoutes, limite)}`,
+        `CONSUMER_SURFACES: ${resumirListaTexto(resumo.consumerSurfaces, limite)}`,
+        `CONSUMER_BRIDGES: ${resumirListaTexto(resumo.consumerBridges, limite)}`,
+        `PUBLICO: ${resumirListaTexto(resumo.superficiesPublicas, limite)}`,
+        `TAREFAS: ${resumirListaTexto(resumo.tarefasPrincipais, limite)}`,
+        `ENTRADAS: ${resumirListaTexto(resumo.entradasChave, limite)}`,
+        `SAIDAS: ${resumirListaTexto(resumo.saidasChave, limite)}`,
+        `REGRAS: ${resumirListaTexto(resumo.regrasCriticas, limite)}`,
+        `EFEITOS: ${resumirListaTexto(resumo.efeitos, limite)}`,
+        `ERROS: ${resumirListaTexto(resumo.erros, limite)}`,
+        `TOCAR: ${resumirListaTexto(resumo.arquivosProvaveis, limite)}`,
+        `VALIDAR: ${resumirListaTexto(resumo.checksSugeridos, limite)}`,
+        `TESTES: ${resumirListaTexto(resumo.testesMinimos, limite)}`,
+        `RISCOS: ${resumirListaTexto(resumo.riscosPrincipais, limite)}`,
+        `LACUNAS: ${resumirListaTexto(resumo.lacunas, limite)}`,
+        `INFERIDO: ${resumirListaTexto(resumo.inferido, limite)}`,
+        `CONFIANCA: ${resumo.confiancaGeral}`,
+        `RISCO_OPERACIONAL: ${resumo.riscoOperacional}`,
+        `SCORE: ${resumo.scoreSemantico}`,
+        `GERADO_EM: ${resumo.geradoEm}`,
+    ];
+    if (tamanho === "micro") {
+        return `${linhas.slice(0, 12).join("\n")}\n`;
+    }
+    return `${linhas.join("\n")}\n`;
+}
+function renderizarResumoModuloMarkdown(resumo, modo, guiaPorCapacidade) {
+    const linhas = [
+        `# Resumo Sema para ${resumo.modulo}`,
+        "",
+        `- Modo: \`${modo}\``,
+        `- Gerado em: \`${resumo.geradoEm}\``,
+        `- Arquivo: \`${resumo.arquivo}\``,
+        `- Perfil: \`${resumo.perfilCompatibilidade}\``,
+        `- Score: \`${resumo.scoreSemantico}\``,
+        `- Confianca: \`${resumo.confiancaGeral}\``,
+        `- Risco operacional: \`${resumo.riscoOperacional}\``,
+        "",
+        "## O que este modulo faz",
+        "",
+        `- ${resumo.faz}`,
+        `- Superficies publicas: ${resumirListaTexto(resumo.superficiesPublicas, 8)}`,
+        `- Tarefas principais: ${resumirListaTexto(resumo.tarefasPrincipais, 8)}`,
+        "",
+        "## Contrato util para IA",
+        "",
+        `- Entradas chave: ${resumirListaTexto(resumo.entradasChave, 6)}`,
+        `- Saidas chave: ${resumirListaTexto(resumo.saidasChave, 6)}`,
+        `- Regras criticas: ${resumirListaTexto(resumo.regrasCriticas, 6)}`,
+        `- Efeitos: ${resumirListaTexto(resumo.efeitos, 6)}`,
+        `- Erros: ${resumirListaTexto(resumo.erros, 6)}`,
+        `- Entidades afetadas: ${resumirListaTexto(resumo.entidadesAfetadas, 6)}`,
+        "",
+        ...(resumo.consumerFramework
+            ? [
+                "## Consumer IA-first",
+                "",
+                `- Framework consumer: ${resumo.consumerFramework}`,
+                `- Rotas de app: ${resumirListaTexto(resumo.appRoutes, 6)}`,
+                `- Superficies consumer: ${resumirListaTexto(resumo.consumerSurfaces, 6)}`,
+                `- Bridges consumer: ${resumirListaTexto(resumo.consumerBridges, 6)}`,
+                "",
+            ]
+            : []),
+        "## Intervencao segura",
+        "",
+        `- Arquivos provaveis: ${resumirListaTexto(resumo.arquivosProvaveis, 6)}`,
+        `- Simbolos relacionados: ${resumirListaTexto(resumo.simbolosRelacionados, 6)}`,
+        `- Riscos principais: ${resumirListaTexto(resumo.riscosPrincipais, 6)}`,
+        `- Lacunas: ${resumirListaTexto(resumo.lacunas, 6)}`,
+        `- O que foi inferido: ${resumirListaTexto(resumo.inferido, 6)}`,
+        `- Checks sugeridos: ${resumirListaTexto(resumo.checksSugeridos, 6)}`,
+        `- Testes minimos: ${resumirListaTexto(resumo.testesMinimos, 6)}`,
+        "",
+        "## Guia por capacidade de IA",
+        "",
+    ];
+    for (const capacidade of ["pequena", "media", "grande"]) {
+        const guia = guiaPorCapacidade[capacidade];
+        linhas.push(`### ${capacidade}`);
+        linhas.push("");
+        linhas.push(`- ${guia.descricao}`);
+        linhas.push(`- Artefatos: ${guia.artefatos.map((item) => `\`${item}\``).join(", ")}`);
+        linhas.push(`- Ordem de leitura: ${guia.ordemLeitura.map((item) => `\`${item}\``).join(" -> ")}`);
+        linhas.push(`- Evitar: ${guia.evitar.length > 0 ? guia.evitar.map((item) => `\`${item}\``).join(", ") : "nada obrigatorio"}`);
+        linhas.push("");
+    }
+    return `${linhas.join("\n").trim()}\n`;
+}
+function criarBriefingMinimo(resumo, modo, tamanho) {
+    return {
+        comando: "briefing-minimo",
+        geradoEm: resumo.geradoEm,
+        cliVersao: VERSAO_CLI,
+        modo,
+        tamanho,
+        arquivo: resumo.arquivo,
+        modulo: resumo.modulo,
+        perfilCompatibilidade: resumo.perfilCompatibilidade,
+        scoreSemantico: resumo.scoreSemantico,
+        confiancaGeral: resumo.confiancaGeral,
+        riscoOperacional: resumo.riscoOperacional,
+        faz: resumo.faz,
+        publico: resumo.superficiesPublicas,
+        tarefasPrincipais: resumo.tarefasPrincipais,
+        entradasChave: resumo.entradasChave,
+        saidasChave: resumo.saidasChave,
+        regrasCriticas: resumo.regrasCriticas,
+        efeitos: resumo.efeitos,
+        erros: resumo.erros,
+        arquivosProvaveis: resumo.arquivosProvaveis,
+        arquivosProvaveisEditar: resumo.arquivosProvaveisEditar,
+        simbolosRelacionados: resumo.simbolosRelacionados,
+        riscosPrincipais: resumo.riscosPrincipais,
+        lacunas: resumo.lacunas,
+        inferido: resumo.inferido,
+        checksSugeridos: resumo.checksSugeridos,
+        testesMinimos: resumo.testesMinimos,
+        consumerFramework: resumo.consumerFramework,
+        appRoutes: resumo.appRoutes,
+        consumerSurfaces: resumo.consumerSurfaces,
+        consumerBridges: resumo.consumerBridges,
+    };
+}
+function criarPromptCurtoModulo(resumo, modo, tamanho, capacidade) {
+    const resumoTexto = renderizarResumoModuloTexto(resumo, tamanho, modo).trim();
+    return `Voce esta operando Sema em modo IA-first.
+
+Esta linguagem nao foi desenhada para agradar humano; ela existe para reduzir ambiguidade para IA.
+
+Capacidade alvo: ${capacidade}
+Modo da tarefa: ${modo}
+
+Regras:
+- nao invente sintaxe nem bloco fora da gramatica oficial
+- preserve a intencao do contrato
+- use este resumo como fonte compacta inicial
+- se a tarefa pedir mais contexto, suba para \`briefing.min.json\`, \`drift.json\` e depois \`ir.json\`
+- nao saia editando software vivo sem olhar risco, lacuna e checks sugeridos
+${resumo.consumerFramework ? "- se for tarefa visual consumer, priorize `appRoutes`, `consumerSurfaces` e `consumerBridges` antes de abrir arquivos aleatorios" : ""}
+
+Contexto compacto:
+${resumoTexto}
+`;
+}
+function renderizarResumoProjetoMarkdown(geradoEm, modulos, guiaPorCapacidade) {
+    const entradaCanonica = criarEntradaCanonicaProjeto(guiaPorCapacidade);
+    const linhas = [
+        "# SEMA_BRIEF",
+        "",
+        "Sema e IA-first. Este arquivo existe para IA achar o ponto de entrada do projeto sem ter que catar o repo inteiro feito barata tonta.",
+        "",
+        `- Gerado em: \`${geradoEm}\``,
+        `- Modulos: \`${modulos.length}\``,
+        "",
+        "## Entrada canonica para IA",
+        "",
+        `- Ordem minima: ${entradaCanonica.ordemLeitura.join(" -> ")}`,
+        `- IA pequena: ${entradaCanonica.porCapacidade.pequena.join(" -> ")}`,
+        `- IA media: ${entradaCanonica.porCapacidade.media.join(" -> ")}`,
+        `- IA grande: ${entradaCanonica.porCapacidade.grande.join(" -> ")}`,
+        "",
+        "## Guia por capacidade",
+        "",
+    ];
+    for (const capacidade of ["pequena", "media", "grande"]) {
+        const guia = guiaPorCapacidade[capacidade];
+        linhas.push(`- ${capacidade}: ${guia.descricao} Artefatos: ${guia.artefatos.join(", ")}.`);
+    }
+    linhas.push("");
+    linhas.push("## Modulos");
+    linhas.push("");
+    for (const modulo of modulos) {
+        linhas.push(`### ${modulo.modulo}`);
+        linhas.push(`- Faz: ${modulo.faz}`);
+        linhas.push(`- Publico: ${resumirListaTexto(modulo.superficiesPublicas, 4)}`);
+        linhas.push(`- Tocar: ${resumirListaTexto(modulo.arquivosProvaveis, 4)}`);
+        linhas.push(`- Score: ${modulo.scoreSemantico} | Confianca: ${modulo.confiancaGeral} | Risco: ${modulo.riscoOperacional}`);
+        linhas.push(`- Lacunas: ${resumirListaTexto(modulo.lacunas, 4)}`);
+        linhas.push("");
+    }
+    return `${linhas.join("\n").trim()}\n`;
+}
+function criarEntradaCanonicaProjeto(guiaPorCapacidade) {
+    return {
+        descricao: "Entrada canonica do repositorio para IA. O repo nao e human-first; a IA deve começar por esses artefatos antes de abrir codigo cru.",
+        ordemLeitura: [...ARQUIVOS_CANONICOS_IA_RAIZ],
+        porCapacidade: {
+            pequena: ["llms.txt", "SEMA_BRIEF.micro.txt", "SEMA_INDEX.json", "AGENTS.md"],
+            media: ["llms.txt", "SEMA_BRIEF.curto.txt", "SEMA_INDEX.json", "AGENTS.md", "README.md"],
+            grande: ["llms-full.txt", "SEMA_BRIEF.md", "SEMA_INDEX.json", "AGENTS.md", "README.md"],
+        },
+        docsSuporte: [...DOCUMENTOS_SUPORTE_IA],
+        guiaPorCapacidade,
+    };
+}
 function falharContextoIa(mensagem) {
     throw new Error(mensagem);
 }
@@ -691,6 +1179,41 @@ function resumirDriftPorModulo(modulo, caminho, resultadoDrift) {
     const recursosDivergentes = modulo
         ? resultadoDrift.recursos_divergentes.filter((recurso) => recurso.modulo === modulo)
         : [];
+    const vinculosModulo = modulo
+        ? [
+            ...resultadoDrift.vinculos_validos.filter((vinculo) => vinculo.modulo === modulo),
+            ...resultadoDrift.vinculos_quebrados.filter((vinculo) => vinculo.modulo === modulo),
+        ]
+        : [];
+    const rotasConsumerModulo = new Set(vinculosModulo
+        .filter((vinculo) => vinculo.tipo === "superficie")
+        .map((vinculo) => vinculo.valor));
+    const arquivosRelacionados = [...new Set([
+            ...tasks.flatMap((task) => task.arquivosReferenciados),
+            ...tasks.flatMap((task) => task.arquivosProvaveisEditar),
+            ...implsValidos.map((impl) => impl.arquivo).filter((item) => Boolean(item)),
+            ...implsQuebrados.flatMap((impl) => impl.candidatos?.map((candidato) => candidato.arquivo) ?? []),
+            ...vinculosValidos.map((vinculo) => vinculo.arquivo).filter((item) => Boolean(item)),
+            ...recursosValidos.map((recurso) => recurso.arquivo).filter(Boolean),
+            ...recursosDivergentes.map((recurso) => recurso.arquivo).filter(Boolean),
+        ])].sort((a, b) => a.localeCompare(b, "pt-BR"));
+    const consumerSurfaces = resultadoDrift.consumerSurfaces
+        .filter((surface) => arquivosRelacionados.includes(surface.arquivo)
+        || rotasConsumerModulo.has(surface.rota))
+        .map((surface) => `${surface.tipoArquivo}:${surface.rota} -> ${surface.arquivo}`)
+        .sort((a, b) => a.localeCompare(b, "pt-BR"));
+    const consumerBridges = resultadoDrift.consumerBridges
+        .filter((bridge) => arquivosRelacionados.includes(bridge.arquivo))
+        .map((bridge) => bridge.caminho)
+        .sort((a, b) => a.localeCompare(b, "pt-BR"));
+    const appRoutes = [...new Set(resultadoDrift.consumerSurfaces
+            .filter((surface) => arquivosRelacionados.includes(surface.arquivo)
+            || rotasConsumerModulo.has(surface.rota))
+            .map((surface) => surface.rota))]
+        .sort((a, b) => a.localeCompare(b, "pt-BR"));
+    const consumerFramework = appRoutes.length > 0 || consumerBridges.length > 0
+        ? resultadoDrift.consumerFramework
+        : null;
     return {
         caminho,
         modulo,
@@ -707,15 +1230,12 @@ function resumirDriftPorModulo(modulo, caminho, resultadoDrift) {
             : tasks.some((task) => task.confiancaVinculo === "media")
                 ? "media"
                 : "baixa",
-        arquivosRelacionados: [...new Set([
-                ...tasks.flatMap((task) => task.arquivosReferenciados),
-                ...tasks.flatMap((task) => task.arquivosProvaveisEditar),
-                ...implsValidos.map((impl) => impl.arquivo).filter((item) => Boolean(item)),
-                ...implsQuebrados.flatMap((impl) => impl.candidatos?.map((candidato) => candidato.arquivo) ?? []),
-                ...vinculosValidos.map((vinculo) => vinculo.arquivo).filter((item) => Boolean(item)),
-                ...recursosValidos.map((recurso) => recurso.arquivo).filter(Boolean),
-                ...recursosDivergentes.map((recurso) => recurso.arquivo).filter(Boolean),
-            ])].sort((a, b) => a.localeCompare(b, "pt-BR")),
+        arquivosRelacionados,
+        arquivosProvaveisEditar: arquivosRelacionados,
+        consumerFramework,
+        appRoutes,
+        consumerSurfaces,
+        consumerBridges,
         checksSugeridos: [...new Set(tasks.flatMap((task) => task.checksSugeridos))],
         lacunas: [...new Set(tasks.flatMap((task) => task.lacunas))],
         tasks,
@@ -737,6 +1257,7 @@ function criarBriefingAgente(arquivo, modulo, ir, resumoDrift, resultadoDrift) {
                 ...(ir?.resumoAgente.riscos ?? []),
             ])],
         oQueTocar: resumoDrift.arquivosRelacionados,
+        arquivosProvaveisEditar: resumoDrift.arquivosProvaveisEditar,
         oQueValidar: [...new Set([
                 ...resumoDrift.checksSugeridos,
                 ...resultadoDrift.resumo_operacional.oQueValidar,
@@ -764,20 +1285,20 @@ function criarBriefingAgente(arquivo, modulo, ir, resumoDrift, resultadoDrift) {
             ...(ir?.routes.map((route) => `${route.metodo ?? "?"} ${route.caminho ?? route.nome}`) ?? []),
             ...(ir?.superficies.map((superficie) => `${superficie.tipo}:${superficie.nome}`) ?? []),
         ],
+        consumerFramework: resumoDrift.consumerFramework,
+        appRoutes: resumoDrift.appRoutes,
+        consumerSurfaces: resumoDrift.consumerSurfaces,
+        consumerBridges: resumoDrift.consumerBridges,
         testesMinimos: [
             "sema validar <arquivo> --json",
             "sema drift <arquivo> --json",
-            "sema verificar exemplos --json",
+            "sema verificar <arquivo-ou-pasta> --json",
         ],
     };
 }
-async function gerarContextoIa(arquivoEntrada, pastaSaidaOpcional) {
+async function carregarContextoModuloIa(arquivoEntrada) {
     const arquivo = path.resolve(arquivoEntrada);
     garantirArquivoSema(arquivo);
-    const pastaBase = pastaSaidaOpcional
-        ? path.resolve(pastaSaidaOpcional)
-        : path.resolve(process.cwd(), ".tmp", "contexto-ia", path.basename(arquivo, ".sema"));
-    await mkdir(pastaBase, { recursive: true });
     const contextoProjeto = await carregarProjeto(arquivo, process.cwd());
     const resultadoModulo = contextoProjeto.modulosSelecionados.find((item) => path.resolve(item.caminho) === arquivo)?.resultado;
     if (!resultadoModulo) {
@@ -785,6 +1306,7 @@ async function gerarContextoIa(arquivoEntrada, pastaSaidaOpcional) {
     }
     const sucesso = !temErros(resultadoModulo.diagnosticos);
     const modulo = resultadoModulo.modulo?.nome ?? path.basename(arquivo, ".sema");
+    const geradoEm = new Date().toISOString();
     const resultadoDrift = await analisarDriftLegado(contextoProjeto);
     const drift = {
         comando: "drift",
@@ -829,21 +1351,146 @@ async function gerarContextoIa(arquivoEntrada, pastaSaidaOpcional) {
         ir: resultadoModulo.ir ?? null,
     };
     const briefing = criarBriefingAgente(arquivo, modulo, resultadoModulo.ir ?? null, drift.resumo, resultadoDrift);
-    await writeFile(path.join(pastaBase, "validar.json"), `${JSON.stringify(validar, null, 2)}\n`, "utf8");
-    await writeFile(path.join(pastaBase, "diagnosticos.json"), `${JSON.stringify(diagnosticos, null, 2)}\n`, "utf8");
-    await writeFile(path.join(pastaBase, "ast.json"), `${JSON.stringify(ast, null, 2)}\n`, "utf8");
-    await writeFile(path.join(pastaBase, "ir.json"), `${JSON.stringify(ir, null, 2)}\n`, "utf8");
-    await writeFile(path.join(pastaBase, "drift.json"), `${JSON.stringify(drift, null, 2)}\n`, "utf8");
-    await writeFile(path.join(pastaBase, "briefing.json"), `${JSON.stringify(briefing, null, 2)}\n`, "utf8");
-    const resumo = `# Contexto de IA para ${modulo}
-
-- Arquivo alvo: \`${arquivo}\`
-- Modulo: \`${modulo}\`
-- Sucesso em validar: \`${sucesso}\`
-- Quantidade de diagnosticos: \`${resultadoModulo.diagnosticos.length}\`
+    return {
+        arquivo,
+        modulo,
+        sucesso,
+        geradoEm,
+        diagnosticos: resultadoModulo.diagnosticos,
+        ir: resultadoModulo.ir ?? null,
+        validar,
+        diagnosticosJson: diagnosticos,
+        ast,
+        irJson: ir,
+        drift,
+        briefing,
+    };
+}
+async function gerarArquivosResumoModuloIa(contexto, pastaBase) {
+    const guiaPorCapacidade = criarGuiaCapacidadeIa();
+    const resumoSemantico = coletarResumoSemanticoModulo(contexto);
+    const resumoMicro = renderizarResumoModuloTexto(resumoSemantico, "micro", "resumo");
+    const resumoCurto = renderizarResumoModuloTexto(resumoSemantico, "curto", "resumo");
+    const resumoMarkdown = renderizarResumoModuloMarkdown(resumoSemantico, "resumo", guiaPorCapacidade);
+    const briefingMinimo = criarBriefingMinimo(resumoSemantico, "resumo", "curto");
+    const promptCurto = criarPromptCurtoModulo(resumoSemantico, "mudanca", "curto", "pequena");
+    await writeFile(path.join(pastaBase, "resumo.micro.txt"), resumoMicro, "utf8");
+    await writeFile(path.join(pastaBase, "resumo.curto.txt"), resumoCurto, "utf8");
+    await writeFile(path.join(pastaBase, "resumo.md"), resumoMarkdown, "utf8");
+    await writeFile(path.join(pastaBase, "briefing.min.json"), `${JSON.stringify(briefingMinimo, null, 2)}\n`, "utf8");
+    await writeFile(path.join(pastaBase, "prompt-curto.txt"), promptCurto, "utf8");
+    return {
+        artefatosCompactos: ["resumo.micro.txt", "resumo.curto.txt", "resumo.md", "briefing.min.json", "prompt-curto.txt"],
+        guiaPorCapacidade,
+    };
+}
+async function gerarResumoProjetoIa(entrada, pastaSaidaOpcional, escreverNaRaiz = false) {
+    const contextoProjeto = await carregarProjeto(entrada, process.cwd());
+    const geradoEm = new Date().toISOString();
+    const guiaPorCapacidade = criarGuiaCapacidadeIa();
+    const entradaCanonica = criarEntradaCanonicaProjeto(guiaPorCapacidade);
+    const resultadoDrift = await analisarDriftLegado(contextoProjeto);
+    const modulos = contextoProjeto.modulosSelecionados.map((item) => {
+        const modulo = item.resultado.modulo?.nome ?? path.basename(item.caminho, ".sema");
+        const driftResumo = resumirDriftPorModulo(modulo, item.caminho, resultadoDrift);
+        const briefing = criarBriefingAgente(item.caminho, modulo, item.resultado.ir ?? null, driftResumo, resultadoDrift);
+        return coletarResumoSemanticoModulo({
+            arquivo: item.caminho,
+            modulo,
+            geradoEm,
+            ir: item.resultado.ir ?? null,
+            briefing,
+            drift: {
+                comando: "drift",
+                caminho: item.caminho,
+                modulo,
+                sucesso: resultadoDrift.sucesso,
+                resumo: driftResumo,
+                drift: resultadoDrift,
+            },
+        });
+    });
+    const baseProjeto = contextoProjeto.baseProjeto;
+    const pastaSaida = escreverNaRaiz
+        ? baseProjeto
+        : pastaSaidaOpcional
+            ? path.resolve(pastaSaidaOpcional)
+            : path.resolve(baseProjeto, ".tmp", "sema-resumo");
+    await mkdir(pastaSaida, { recursive: true });
+    const semaBrief = renderizarResumoProjetoMarkdown(geradoEm, modulos, guiaPorCapacidade);
+    const indexJson = {
+        comando: "resumo-projeto",
+        geradoEm,
+        cliVersao: VERSAO_CLI,
+        baseProjeto,
+        totalModulos: modulos.length,
+        entradaCanonica,
+        guiaPorCapacidade,
+        modulos,
+    };
+    const micro = [
+        `PROJETO: ${path.basename(baseProjeto)}`,
+        `MODULOS: ${modulos.length}`,
+        `ENTRADA_IA: ${entradaCanonica.porCapacidade.pequena.join(" -> ")}`,
+        `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)}`,
+        `GERADO_EM: ${geradoEm}`,
+        "",
+    ].join("\n");
+    const curto = [
+        `PROJETO: ${path.basename(baseProjeto)}`,
+        `BASE: ${baseProjeto}`,
+        `MODULOS: ${modulos.length}`,
+        `ENTRADA_IA: ${entradaCanonica.porCapacidade.media.join(" -> ")}`,
+        `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)}`,
+        `TOP_ARQUIVOS: ${resumirListaTexto(unicosOrdenados(modulos.flatMap((modulo) => modulo.arquivosProvaveis)), 6)}`,
+        `GERADO_EM: ${geradoEm}`,
+        "",
+    ].join("\n");
+    await writeFile(path.join(pastaSaida, "SEMA_BRIEF.md"), semaBrief, "utf8");
+    await writeFile(path.join(pastaSaida, "SEMA_BRIEF.micro.txt"), micro, "utf8");
+    await writeFile(path.join(pastaSaida, "SEMA_BRIEF.curto.txt"), curto, "utf8");
+    await writeFile(path.join(pastaSaida, "SEMA_INDEX.json"), `${JSON.stringify(indexJson, null, 2)}\n`, "utf8");
+    return {
+        geradoEm,
+        baseProjeto,
+        pastaSaida,
+        artefatos: ["SEMA_BRIEF.md", "SEMA_BRIEF.micro.txt", "SEMA_BRIEF.curto.txt", "SEMA_INDEX.json"],
+        modulos,
+        guiaPorCapacidade,
+    };
+}
+async function gerarContextoIa(arquivoEntrada, pastaSaidaOpcional) {
+    const contexto = await carregarContextoModuloIa(arquivoEntrada);
+    const pastaBase = pastaSaidaOpcional
+        ? path.resolve(pastaSaidaOpcional)
+        : path.resolve(process.cwd(), ".tmp", "contexto-ia", path.basename(contexto.arquivo, ".sema"));
+    await mkdir(pastaBase, { recursive: true });
+    await writeFile(path.join(pastaBase, "validar.json"), `${JSON.stringify(contexto.validar, null, 2)}\n`, "utf8");
+    await writeFile(path.join(pastaBase, "diagnosticos.json"), `${JSON.stringify(contexto.diagnosticosJson, null, 2)}\n`, "utf8");
+    await writeFile(path.join(pastaBase, "ast.json"), `${JSON.stringify(contexto.ast, null, 2)}\n`, "utf8");
+    await writeFile(path.join(pastaBase, "ir.json"), `${JSON.stringify(contexto.irJson, null, 2)}\n`, "utf8");
+    await writeFile(path.join(pastaBase, "drift.json"), `${JSON.stringify(contexto.drift, null, 2)}\n`, "utf8");
+    await writeFile(path.join(pastaBase, "briefing.json"), `${JSON.stringify(contexto.briefing, null, 2)}\n`, "utf8");
+    const resumoGerado = await gerarArquivosResumoModuloIa(contexto, pastaBase);
+    const resumo = `# Contexto de IA para ${contexto.modulo}
+
+- Arquivo alvo: \`${contexto.arquivo}\`
+- Modulo: \`${contexto.modulo}\`
+- Sucesso em validar: \`${contexto.sucesso}\`
+- Quantidade de diagnosticos: \`${contexto.diagnosticos.length}\`
+- Gerado em: \`${contexto.geradoEm}\`
 
 ## Arquivos gerados neste pacote
 
+- \`resumo.micro.txt\`
+- \`resumo.curto.txt\`
+- \`resumo.md\`
+- \`briefing.min.json\`
+- \`prompt-curto.txt\`
 - \`validar.json\`
 - \`diagnosticos.json\`
 - \`ast.json\`
@@ -853,28 +1500,61 @@ async function gerarContextoIa(arquivoEntrada, pastaSaidaOpcional) {
 
 ## Fluxo recomendado para o agente
 
-1. Ler \`ast.json\` para entender a forma escrita.
-2. Ler \`ir.json\` para entender a forma semantica resolvida.
-3. Ler \`drift.json\` para ver quais arquivos e simbolos vivos sustentam a implementacao.
-4. Ler \`briefing.json\` para saber o que tocar, o que validar e o que esta frouxo.
-5. Ler \`diagnosticos.json\` se houver falha ou aviso relevante.
-6. Editar o arquivo \`.sema\`.
-7. Rodar \`sema formatar "${arquivo}"\`.
-8. Rodar \`sema validar "${arquivo}" --json\`.
-9. Fechar com \`sema verificar exemplos --json --saida ./.tmp/verificacao-ia\` ou \`npm run project:check\`.
+### IA pequena ou gratuita
+
+1. Ler \`resumo.micro.txt\`.
+2. Ler \`briefing.min.json\`.
+3. Se ainda couber contexto, ler \`resumo.curto.txt\`.
+
+### IA media
+
+1. Ler \`resumo.curto.txt\`.
+2. Ler \`briefing.min.json\`.
+3. Ler \`drift.json\`.
+4. Se precisar, subir para \`resumo.md\`.
+
+### IA grande ou com tool use
+
+1. Ler \`README.md\`.
+2. Ler \`resumo.md\`.
+3. Ler \`briefing.json\`.
+4. Ler \`drift.json\`.
+5. So depois abrir \`ir.json\` e \`ast.json\`.
+
+## 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\`.
+5. Fechar com \`sema verificar <arquivo-ou-pasta> --json --saida ./.tmp/verificacao-ia\`.
 
 ## Textos base para onboarding do agente
 
 - \`sema starter-ia\`
+- \`sema resumo "${contexto.arquivo}" --micro --para onboarding\`
+- \`sema prompt-curto "${contexto.arquivo}" --para mudanca\`
 - \`sema prompt-ia\`
 `;
     await writeFile(path.join(pastaBase, "README.md"), resumo, "utf8");
     return {
-        sucesso: true,
-        arquivo,
-        modulo,
+        sucesso: contexto.sucesso,
+        arquivo: contexto.arquivo,
+        modulo: contexto.modulo,
         pastaSaida: pastaBase,
-        artefatos: ["validar.json", "diagnosticos.json", "ast.json", "ir.json", "drift.json", "briefing.json", "README.md"],
+        artefatos: [
+            "validar.json",
+            "diagnosticos.json",
+            "ast.json",
+            "ir.json",
+            "drift.json",
+            "briefing.json",
+            "README.md",
+            ...resumoGerado.artefatosCompactos,
+        ],
+        artefatosCompactos: resumoGerado.artefatosCompactos,
+        geradoEm: contexto.geradoEm,
+        guiaPorCapacidade: resumoGerado.guiaPorCapacidade,
     };
 }
 async function comandoIniciar(cwd, template) {
@@ -1044,6 +1724,596 @@ async function comandoIniciar(cwd, template) {
 - Contratos em \`contratos/\`
 - Handlers App Router em \`src/app/api/\`
 - Rota de exemplo validada por \`drift\`
+`,
+            },
+        ];
+    }
+    else if (template === "nextjs-consumer") {
+        arquivos = [
+            {
+                caminhoRelativo: "sema.config.json",
+                conteudo: `{
+  "origens": ["./contratos"],
+  "saida": "./generated",
+  "alvos": ["typescript"],
+  "alvoPadrao": "typescript",
+  "estruturaSaida": "modulos",
+  "framework": "base",
+  "modoEstrito": true,
+  "diretoriosCodigo": ["./src"],
+  "fontesLegado": ["nextjs-consumer", "typescript"],
+  "diretoriosSaidaPorAlvo": {
+    "typescript": "./generated/typescript"
+  },
+  "convencoesGeracaoPorProjeto": "base"
+}
+`,
+            },
+            {
+                caminhoRelativo: "contratos/showroom_consumer.sema",
+                conteudo: `module showroom.consumer {
+  task fetch_showroom_ranking {
+    input {
+    }
+    output {
+      ranking: Json
+    }
+    impl {
+      ts: src.lib.sema_consumer_bridge.semaFetchShowroomRanking
+    }
+    vinculos {
+      arquivo: "src/lib/sema_consumer_bridge.ts"
+      simbolo: src.lib.sema_consumer_bridge.semaFetchShowroomRanking
+      superficie: "/ranking"
+      arquivo: "src/app/ranking/page.tsx"
+      arquivo: "src/app/ranking/loading.tsx"
+      arquivo: "src/app/ranking/error.tsx"
+    }
+    guarantees {
+      ranking existe
+    }
+  }
+}
+`,
+            },
+            {
+                caminhoRelativo: "src/lib/sema_consumer_bridge.ts",
+                conteudo: `export async function semaFetchShowroomRanking() {
+  return {
+    ranking: [
+      { clube: "Tigres do Norte", pontos: 33 },
+      { clube: "Porto Azul", pontos: 31 },
+      { clube: "Galo de Ouro", pontos: 28 },
+    ],
+  };
+}
+`,
+            },
+            {
+                caminhoRelativo: "src/app/ranking/page.tsx",
+                conteudo: `import { semaFetchShowroomRanking } from "../../lib/sema_consumer_bridge";
+
+export default async function RankingPage() {
+  const { ranking } = await semaFetchShowroomRanking();
+
+  return (
+    <main>
+      <h1>Ranking showroom</h1>
+      <ul>
+        {ranking.map((item) => (
+          <li key={item.clube}>
+            {item.clube} - {item.pontos} pts
+          </li>
+        ))}
+      </ul>
+    </main>
+  );
+}
+`,
+            },
+            {
+                caminhoRelativo: "src/app/ranking/loading.tsx",
+                conteudo: `export default function Loading() {
+  return <p>Carregando ranking...</p>;
+}
+`,
+            },
+            {
+                caminhoRelativo: "src/app/ranking/error.tsx",
+                conteudo: `"use client";
+
+export default function Error({
+  error,
+  reset,
+}: {
+  error: Error;
+  reset: () => void;
+}) {
+  return (
+    <main>
+      <h1>Falha ao carregar ranking</h1>
+      <p>{error.message}</p>
+      <button type="button" onClick={reset}>Tentar novamente</button>
+    </main>
+  );
+}
+`,
+            },
+            {
+                caminhoRelativo: "README.md",
+                conteudo: `# Starter Next.js Consumer + Sema
+
+- Contratos em \`contratos/\`
+- Bridge consumer canonico em \`src/lib/sema_consumer_bridge.ts\`
+- Superficies App Router em \`src/app/\`
+- O slice oficial desta fase e \`consumer bridge + App Router surfaces\`
+- \`drift\` valida \`impl\`, \`vinculos\`, bridge e superficies, sem prometer visual drift
+`,
+            },
+        ];
+    }
+    else if (template === "react-vite-consumer") {
+        arquivos = [
+            {
+                caminhoRelativo: "sema.config.json",
+                conteudo: `{
+  "origens": ["./contratos"],
+  "saida": "./generated",
+  "alvos": ["typescript"],
+  "alvoPadrao": "typescript",
+  "estruturaSaida": "modulos",
+  "framework": "base",
+  "modoEstrito": true,
+  "diretoriosCodigo": ["./src"],
+  "fontesLegado": ["react-vite-consumer", "typescript"],
+  "diretoriosSaidaPorAlvo": {
+    "typescript": "./generated/typescript"
+  },
+  "convencoesGeracaoPorProjeto": "base"
+}
+`,
+            },
+            {
+                caminhoRelativo: "contratos/showroom_consumer.sema",
+                conteudo: `module showroom.consumer {
+  task fetch_showroom_ranking {
+    input {
+    }
+    output {
+      ranking: Json
+    }
+    impl {
+      ts: src.lib.sema_consumer_bridge.semaFetchShowroomRanking
+    }
+    vinculos {
+      arquivo: "src/lib/sema_consumer_bridge.ts"
+      simbolo: src.lib.sema_consumer_bridge.semaFetchShowroomRanking
+      superficie: "/ranking"
+      arquivo: "src/router.tsx"
+      arquivo: "src/pages/ranking.tsx"
+    }
+    guarantees {
+      ranking existe
+    }
+  }
+}
+`,
+            },
+            {
+                caminhoRelativo: "src/lib/sema_consumer_bridge.ts",
+                conteudo: `export async function semaFetchShowroomRanking() {
+  return {
+    ranking: [
+      { clube: "Tigres do Norte", pontos: 33 },
+      { clube: "Porto Azul", pontos: 31 },
+      { clube: "Galo de Ouro", pontos: 28 },
+    ],
+  };
+}
+`,
+            },
+            {
+                caminhoRelativo: "src/pages/ranking.tsx",
+                conteudo: `import { useEffect, useState } from "react";
+import { semaFetchShowroomRanking } from "../lib/sema_consumer_bridge";
+
+export function RankingPage() {
+  const [ranking, setRanking] = useState<Array<{ clube: string; pontos: number }>>([]);
+
+  useEffect(() => {
+    void semaFetchShowroomRanking().then((payload) => setRanking(payload.ranking ?? []));
+  }, []);
+
+  return (
+    <main>
+      <h1>Ranking showroom</h1>
+      <ul>
+        {ranking.map((item) => (
+          <li key={item.clube}>
+            {item.clube} - {item.pontos} pts
+          </li>
+        ))}
+      </ul>
+    </main>
+  );
+}
+`,
+            },
+            {
+                caminhoRelativo: "src/router.tsx",
+                conteudo: `import { createBrowserRouter } from "react-router-dom";
+import { RankingPage } from "./pages/ranking";
+
+export const appRouter = createBrowserRouter([
+  {
+    path: "/ranking",
+    Component: RankingPage,
+  },
+]);
+`,
+            },
+            {
+                caminhoRelativo: "src/App.tsx",
+                conteudo: `import { RouterProvider } from "react-router-dom";
+import { appRouter } from "./router";
+
+export default function App() {
+  return <RouterProvider router={appRouter} />;
+}
+`,
+            },
+            {
+                caminhoRelativo: "src/main.tsx",
+                conteudo: `import React from "react";
+import ReactDOM from "react-dom/client";
+import App from "./App";
+
+ReactDOM.createRoot(document.getElementById("root") as HTMLElement).render(
+  <React.StrictMode>
+    <App />
+  </React.StrictMode>,
+);
+`,
+            },
+            {
+                caminhoRelativo: "README.md",
+                conteudo: `# Starter React Vite Consumer + Sema
+
+- Contratos em \`contratos/\`
+- Bridge consumer canonico em \`src/lib/sema_consumer_bridge.ts\`
+- Rotas explicitas em \`src/router.tsx\`
+- Superficies consumer em \`src/pages/\`
+- O slice oficial desta fase e \`consumer bridge + react-router surfaces\`
+- \`drift\` valida \`impl\`, \`vinculos\`, bridge e superficies, sem prometer visual drift
+`,
+            },
+        ];
+    }
+    else if (template === "angular-consumer") {
+        arquivos = [
+            {
+                caminhoRelativo: "sema.config.json",
+                conteudo: `{
+  "origens": ["./contratos"],
+  "saida": "./generated",
+  "alvos": ["typescript"],
+  "alvoPadrao": "typescript",
+  "estruturaSaida": "modulos",
+  "framework": "base",
+  "modoEstrito": true,
+  "diretoriosCodigo": ["./src"],
+  "fontesLegado": ["angular-consumer", "typescript"],
+  "diretoriosSaidaPorAlvo": {
+    "typescript": "./generated/typescript"
+  },
+  "convencoesGeracaoPorProjeto": "base"
+}
+`,
+            },
+            {
+                caminhoRelativo: "contratos/showroom_consumer.sema",
+                conteudo: `module showroom.consumer {
+  task fetch_showroom_ranking {
+    input {
+    }
+    output {
+      ranking: Json
+    }
+    impl {
+      ts: src.app.sema_consumer_bridge.semaFetchShowroomRanking
+    }
+    vinculos {
+      arquivo: "src/app/sema_consumer_bridge.ts"
+      simbolo: src.app.sema_consumer_bridge.semaFetchShowroomRanking
+      superficie: "/ranking"
+      arquivo: "src/app/app.routes.ts"
+      arquivo: "src/app/features/ranking/ranking.routes.ts"
+      arquivo: "src/app/features/ranking/ranking-page.component.ts"
+    }
+    guarantees {
+      ranking existe
+    }
+  }
+}
+`,
+            },
+            {
+                caminhoRelativo: "src/app/sema_consumer_bridge.ts",
+                conteudo: `export async function semaFetchShowroomRanking() {
+  return {
+    ranking: [
+      { clube: "Tigres do Norte", pontos: 33 },
+      { clube: "Porto Azul", pontos: 31 },
+      { clube: "Galo de Ouro", pontos: 28 },
+    ],
+  };
+}
+`,
+            },
+            {
+                caminhoRelativo: "src/app/app.routes.ts",
+                conteudo: `import { Routes } from "@angular/router";
+
+export const routes: Routes = [
+  {
+    path: "ranking",
+    loadChildren: () => import("./features/ranking/ranking.routes").then((m) => m.RANKING_ROUTES),
+  },
+];
+`,
+            },
+            {
+                caminhoRelativo: "src/app/features/ranking/ranking.routes.ts",
+                conteudo: `import { Routes } from "@angular/router";
+
+export const RANKING_ROUTES: Routes = [
+  {
+    path: "",
+    loadComponent: () => import("./ranking-page.component").then((m) => m.RankingPageComponent),
+  },
+];
+`,
+            },
+            {
+                caminhoRelativo: "src/app/features/ranking/ranking-page.component.ts",
+                conteudo: `import { Component, OnInit } from "@angular/core";
+import { CommonModule } from "@angular/common";
+import { semaFetchShowroomRanking } from "../../sema_consumer_bridge";
+
+@Component({
+  selector: "app-ranking-page",
+  standalone: true,
+  imports: [CommonModule],
+  template: \`
+    <main>
+      <h1>Ranking showroom</h1>
+      <ul>
+        <li *ngFor="let item of ranking">
+          {{ item.clube }} - {{ item.pontos }} pts
+        </li>
+      </ul>
+    </main>
+  \`,
+})
+export class RankingPageComponent implements OnInit {
+  ranking: Array<{ clube: string; pontos: number }> = [];
+
+  async ngOnInit() {
+    const payload = await semaFetchShowroomRanking();
+    this.ranking = payload.ranking ?? [];
+  }
+}
+`,
+            },
+            {
+                caminhoRelativo: "src/app/app.component.ts",
+                conteudo: `import { Component } from "@angular/core";
+import { RouterOutlet } from "@angular/router";
+
+@Component({
+  selector: "app-root",
+  standalone: true,
+  imports: [RouterOutlet],
+  template: "<router-outlet />",
+})
+export class AppComponent {}
+`,
+            },
+            {
+                caminhoRelativo: "src/main.ts",
+                conteudo: `import { bootstrapApplication } from "@angular/platform-browser";
+import { provideRouter } from "@angular/router";
+import { AppComponent } from "./app/app.component";
+import { routes } from "./app/app.routes";
+
+void bootstrapApplication(AppComponent, {
+  providers: [provideRouter(routes)],
+});
+`,
+            },
+            {
+                caminhoRelativo: "README.md",
+                conteudo: `# Starter Angular Consumer + Sema
+
+- Contratos em \`contratos/\`
+- Bridge consumer canonico em \`src/app/sema_consumer_bridge.ts\`
+- Rotas lazy em \`src/app/app.routes.ts\`
+- Feature folders em \`src/app/features/\`
+- O slice oficial desta fase e \`consumer bridge + route config surfaces\`
+- \`drift\` valida \`impl\`, \`vinculos\`, bridge e superficies, sem prometer visual drift
+`,
+            },
+        ];
+    }
+    else if (template === "flutter-consumer") {
+        arquivos = [
+            {
+                caminhoRelativo: "sema.config.json",
+                conteudo: `{
+  "origens": ["./contratos"],
+  "saida": "./generated",
+  "alvos": ["dart"],
+  "alvoPadrao": "dart",
+  "estruturaSaida": "modulos",
+  "framework": "base",
+  "modoEstrito": true,
+  "diretoriosCodigo": ["./lib"],
+  "fontesLegado": ["flutter-consumer", "dart"],
+  "diretoriosSaidaPorAlvo": {
+    "dart": "./generated/dart"
+  },
+  "convencoesGeracaoPorProjeto": "base"
+}
+`,
+            },
+            {
+                caminhoRelativo: "pubspec.yaml",
+                conteudo: `name: sema_flutter_consumer
+description: Starter Flutter consumer IA-first com Sema
+publish_to: "none"
+
+environment:
+  sdk: ">=3.3.0 <4.0.0"
+
+dependencies:
+  flutter:
+    sdk: flutter
+  go_router: ^14.0.0
+`,
+            },
+            {
+                caminhoRelativo: "contratos/showroom_consumer.sema",
+                conteudo: `module showroom.consumer {
+  task fetch_showroom_ranking {
+    input {
+    }
+    output {
+      resultado: Json
+    }
+    impl {
+      dart: lib.sema_consumer_bridge.semaFetchShowroomRanking
+    }
+    vinculos {
+      arquivo: "lib/sema_consumer_bridge.dart"
+      simbolo: lib.sema_consumer_bridge.semaFetchShowroomRanking
+      superficie: "/ranking"
+      arquivo: "lib/router.dart"
+      arquivo: "lib/screens/ranking_screen.dart"
+    }
+    guarantees {
+      resultado existe
+    }
+  }
+}
+`,
+            },
+            {
+                caminhoRelativo: "lib/sema_consumer_bridge.dart",
+                conteudo: `Future<Map<String, dynamic>> semaFetchShowroomRanking() async {
+  return {
+    "ranking": [
+      {"clube": "Tigres do Norte", "pontos": 33},
+      {"clube": "Porto Azul", "pontos": 31},
+      {"clube": "Galo de Ouro", "pontos": 28},
+    ],
+  };
+}
+`,
+            },
+            {
+                caminhoRelativo: "lib/router.dart",
+                conteudo: `import "package:go_router/go_router.dart";
+import "package:flutter/widgets.dart";
+import "screens/ranking_screen.dart";
+
+final appRouter = GoRouter(
+  routes: [
+    GoRoute(
+      path: "/ranking",
+      builder: (BuildContext context, GoRouterState state) => const RankingScreen(),
+    ),
+  ],
+);
+`,
+            },
+            {
+                caminhoRelativo: "lib/screens/ranking_screen.dart",
+                conteudo: `import "package:flutter/widgets.dart";
+import "../sema_consumer_bridge.dart";
+
+class RankingScreen extends StatefulWidget {
+  const RankingScreen({super.key});
+
+  @override
+  State<RankingScreen> createState() => _RankingScreenState();
+}
+
+class _RankingScreenState extends State<RankingScreen> {
+  List<Map<String, dynamic>> ranking = const [];
+
+  @override
+  void initState() {
+    super.initState();
+    semaFetchShowroomRanking().then((payload) {
+      final itens = (payload["ranking"] as List<dynamic>? ?? const [])
+          .whereType<Map<String, dynamic>>()
+          .toList();
+      if (!mounted) return;
+      setState(() {
+        ranking = itens;
+      });
+    });
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return ListView(
+      children: [
+        const Padding(
+          padding: EdgeInsets.all(16),
+          child: Text("Ranking showroom"),
+        ),
+        ...ranking.map((item) => Padding(
+          padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 8),
+          child: Text("\${item["clube"]} - \${item["pontos"]} pts"),
+        )),
+      ],
+    );
+  }
+}
+`,
+            },
+            {
+                caminhoRelativo: "lib/main.dart",
+                conteudo: `import "package:flutter/material.dart";
+import "router.dart";
+
+void main() {
+  runApp(const ShowroomApp());
+}
+
+class ShowroomApp extends StatelessWidget {
+  const ShowroomApp({super.key});
+
+  @override
+  Widget build(BuildContext context) {
+    return MaterialApp.router(
+      routerConfig: appRouter,
+    );
+  }
+}
+`,
+            },
+            {
+                caminhoRelativo: "README.md",
+                conteudo: `# Starter Flutter Consumer + Sema
+
+- Contratos em \`contratos/\`
+- Bridge consumer canonico em \`lib/sema_consumer_bridge.dart\`
+- Rotas consumer em \`lib/router.dart\`
+- Superficies consumer em \`lib/screens/\`
+- O slice oficial desta fase e \`consumer bridge + router/screen surfaces\`
+- \`drift\` valida \`impl\`, \`vinculos\`, bridge e superficies, sem prometer visual diff
 `,
             },
         ];
@@ -1602,6 +2872,10 @@ async function comandoInspecionar(entrada, emJson, cwd = process.cwd()) {
             modoAdocao: contextoProjeto.modoAdocao,
             scoreDrift: resultadoDrift.resumo_operacional.scoreMedio,
             confiancaGeral: resultadoDrift.resumo_operacional.confiancaGeral,
+            consumerFramework: resultadoDrift.consumerFramework,
+            appRoutes: resultadoDrift.appRoutes,
+            consumerSurfaces: resultadoDrift.consumerSurfaces,
+            consumerBridges: resultadoDrift.consumerBridges,
         },
         projeto: {
             arquivos: contextoProjeto.arquivosProjeto,
@@ -1936,44 +3210,80 @@ async function comandoStarterIa() {
     console.log(STARTER_IA);
     return 0;
 }
+async function comandoSyncAiEntrypoints(emJson) {
+    const resumoProjeto = await gerarResumoProjetoIa(process.cwd(), undefined, true);
+    const indexJson = JSON.parse(await readFile(path.join(resumoProjeto.pastaSaida, "SEMA_INDEX.json"), "utf8"));
+    const artefatos = [...new Set([
+            ...ARQUIVOS_CANONICOS_IA_RAIZ,
+            ...resumoProjeto.artefatos,
+        ])];
+    if (emJson) {
+        console.log(JSON.stringify({
+            comando: "sync-ai-entrypoints",
+            sucesso: true,
+            baseProjeto: resumoProjeto.baseProjeto,
+            pastaSaida: resumoProjeto.pastaSaida,
+            artefatos,
+            entradaCanonica: indexJson.entradaCanonica,
+        }, null, 2));
+        return 0;
+    }
+    console.log("Entrypoints IA-first sincronizados");
+    console.log("");
+    console.log(`Base do projeto: ${resumoProjeto.baseProjeto}`);
+    console.log(`Ordem canonica: ${indexJson.entradaCanonica.ordemLeitura.join(" -> ")}`);
+    console.log(`IA pequena: ${indexJson.entradaCanonica.porCapacidade.pequena.join(" -> ")}`);
+    console.log(`IA media: ${indexJson.entradaCanonica.porCapacidade.media.join(" -> ")}`);
+    console.log(`IA grande: ${indexJson.entradaCanonica.porCapacidade.grande.join(" -> ")}`);
+    return 0;
+}
 async function comandoAjudaIa() {
     const descoberta = await descobrirDocsIa();
     console.log("Ajuda de IA da Sema");
     console.log("");
+    console.log(renderizarCaixaAscii([
+        "IA-first para greenfield, edicao guiada e legado sem contrato inicial",
+        "use o menor artefato semantico que resolva a tarefa",
+    ]));
+    console.log("");
     console.log(renderizarCabecalhoDocsIa(descoberta));
     console.log("");
-    console.log("O que a Sema faz de verdade");
-    console.log("- Governa contrato, intencao, erro, efeito, garantia, fluxo, vinculos e execucao.");
-    console.log("- Usa `importar` para bootstrap revisavel de legado.");
-    console.log("- Usa `impl` para ligar contrato a simbolos reais.");
-    console.log("- Usa `vinculos` para ligar contrato a arquivo, simbolo, recurso e superficie real.");
-    console.log("- Usa `execucao` para explicitar timeout, retry, compensacao e criticidade.");
-    console.log("- Usa `drift` para medir divergencia entre contrato e codigo vivo com score, confianca e lacunas.");
-    console.log("- Usa `contexto-ia` para preparar AST, IR, diagnosticos, drift e `briefing.json` antes da edicao.");
+    console.log(renderizarSecaoAscii("Tres jeitos de usar a Sema", [
+        "[1] Producao inicial: modele, valide, compile e verifique antes de subir codigo derivado.",
+        "[2] Edicao em projeto com Sema: inspecione, leia resumo, rode drift e gere contexto antes de editar codigo vivo.",
+        "[3] Projeto sem Sema ainda: importe, revise o rascunho, formate, valide e use drift como juiz da adocao incremental.",
+    ]));
     console.log("");
-    console.log("O que a Sema nao promete");
-    console.log("- Nao escreve contrato final sozinho.");
-    console.log("- Nao substitui decisao arquitetural.");
-    console.log("- Nao adivinha regra de negocio que o codigo nao explicita.");
+    console.log(renderizarSecaoAscii("Capacidade de IA", [
+        "pequena: `sema resumo --micro`, `briefing.min.json`, `prompt-curto.txt`",
+        "media: `sema resumo --curto`, `drift.json`, `briefing.min.json`",
+        "grande: `sema contexto-ia`, `briefing.json`, `ir.json`, `ast.json`",
+    ]));
     console.log("");
-    console.log("Fluxo recomendado");
-    console.log("- Use `sema starter-ia` para um texto curto de onboarding.");
-    console.log("- Use `sema prompt-ia` para o prompt-base geral.");
-    console.log("- Use `sema prompt-ia-ui` para tarefas visuais com Sema + UI.");
-    console.log("- Use `sema prompt-ia-react` para projeto com Sema + React + TypeScript.");
-    console.log("- Use `sema prompt-ia-sema-primeiro` para forcar modelagem semantica antes da implementacao.");
-    console.log("- Use `sema exemplos-prompt-ia` para pegar modelos prontos de prompt.");
-    console.log("- Use `sema inspecionar` para descobrir base, codigo vivo e fontes legado.");
-    console.log("- Use `sema drift` para medir impls, vinculos, rotas, score e lacunas.");
-    console.log("- Use `sema contexto-ia <arquivo.sema>` para gerar AST, IR, drift e `briefing.json` do modulo alvo.");
-    console.log("- Use `sema compilar <arquivo-ou-pasta> --alvo <typescript|python|dart> --saida <diretorio>` quando a tarefa pedir codigo derivado.");
+    console.log(renderizarSecaoAscii("Fluxo recomendado", [
+        "Use `sema starter-ia` para um texto curto de onboarding.",
+        "Use `sema sync-ai-entrypoints` para regenerar `SEMA_BRIEF.*` e `SEMA_INDEX.json` na raiz.",
+        "Use `sema resumo <arquivo> --micro --para onboarding` para IA pequena.",
+        "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.",
+        "Use `sema inspecionar` para descobrir base, codigo vivo e fontes legado.",
+        "Use `sema drift` para medir impls, vinculos, rotas, score e lacunas.",
+        "Use `sema contexto-ia <arquivo.sema>` para gerar AST, IR, drift, `briefing.json` e `briefing.min.json`.",
+        "Use `sema compilar <arquivo-ou-pasta> --alvo <typescript|python|dart> --saida <diretorio>` quando a tarefa pedir codigo derivado.",
+    ]));
     console.log("");
-    console.log("Regra pratica");
-    console.log("- Se voce quer testar a Sema de verdade, nao peca so HTML solto.");
-    console.log("- Peca `.sema` + arquitetura + React + TypeScript, ou use o modo `Sema primeiro`.");
-    console.log("- Se o projeto ja existe, trate `importar` como rascunho e `drift` como juiz.");
-    console.log("- Antes de editar backend vivo, leia `briefing.json` em vez de sair cavando arquivo na fe.");
-    console.log("- Trate `route`, `worker`, `evento`, `fila`, `cron`, `webhook`, `cache`, `storage` e `policy` como superficies de primeira classe.");
+    console.log(renderizarSecaoAscii("Regras praticas", [
+        "Foi feita para IA operar melhor; leitura humana e consequencia, nao centro de produto.",
+        "Governa contrato, intencao, erro, efeito, garantia, fluxo, vinculos e execucao.",
+        "Nao escreve contrato final sozinho nem substitui decisao arquitetural.",
+        "Se voce quer testar a Sema de verdade, nao peca so HTML solto.",
+        "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 pequena comeca no menor artefato que resolve a tarefa; nao enfie `ast.json` inteiro nela de bobeira.",
+        "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.",
+    ]));
     return 0;
 }
 async function comandoPromptIa() {
@@ -2021,6 +3331,142 @@ async function comandoExemplosPromptIa() {
     console.log(EXEMPLOS_PROMPT_IA);
     return 0;
 }
+async function comandoResumo(entrada, args, emJson) {
+    const tamanho = normalizarTamanhoResumo(args);
+    const modo = normalizarModoResumo(obterOpcao(args, "--para"));
+    const pastaSaida = obterOpcao(args, "--saida");
+    const escreverNaRaiz = possuiFlag(args, "--raiz");
+    const alvo = entrada ? path.resolve(process.cwd(), entrada) : process.cwd();
+    if (entrada && entrada.toLowerCase().endsWith(".sema")) {
+        const contexto = await carregarContextoModuloIa(alvo);
+        const resumoSemantico = coletarResumoSemanticoModulo(contexto);
+        const guiaPorCapacidade = criarGuiaCapacidadeIa();
+        const texto = tamanho === "medio"
+            ? renderizarResumoModuloMarkdown(resumoSemantico, modo, guiaPorCapacidade)
+            : renderizarResumoModuloTexto(resumoSemantico, tamanho, modo);
+        let pastaResumo;
+        let artefatosCompactos = [];
+        if (pastaSaida) {
+            pastaResumo = path.resolve(pastaSaida);
+            await mkdir(pastaResumo, { recursive: true });
+            const gerado = await gerarArquivosResumoModuloIa(contexto, pastaResumo);
+            artefatosCompactos = gerado.artefatosCompactos;
+        }
+        if (emJson) {
+            console.log(JSON.stringify({
+                comando: "resumo",
+                modo,
+                tamanho,
+                geradoEm: contexto.geradoEm,
+                arquivo: contexto.arquivo,
+                modulo: contexto.modulo,
+                pastaSaida: pastaResumo ?? null,
+                artefatosCompactos,
+                guiaPorCapacidade,
+                resumo: resumoSemantico,
+                texto,
+            }, null, 2));
+            return 0;
+        }
+        if (pastaResumo) {
+            console.log(`Resumo IA-first gerado em ${pastaResumo}`);
+            console.log("");
+        }
+        console.log(texto);
+        return 0;
+    }
+    const resumoProjeto = await gerarResumoProjetoIa(alvo, pastaSaida, escreverNaRaiz);
+    const arquivoResumo = tamanho === "micro"
+        ? "SEMA_BRIEF.micro.txt"
+        : tamanho === "curto"
+            ? "SEMA_BRIEF.curto.txt"
+            : "SEMA_BRIEF.md";
+    const texto = await readFile(path.join(resumoProjeto.pastaSaida, arquivoResumo), "utf8");
+    if (emJson) {
+        console.log(JSON.stringify({
+            comando: "resumo",
+            modo,
+            tamanho,
+            geradoEm: resumoProjeto.geradoEm,
+            baseProjeto: resumoProjeto.baseProjeto,
+            pastaSaida: resumoProjeto.pastaSaida,
+            artefatos: resumoProjeto.artefatos,
+            guiaPorCapacidade: resumoProjeto.guiaPorCapacidade,
+            modulos: resumoProjeto.modulos,
+            texto,
+        }, null, 2));
+        return 0;
+    }
+    console.log(`Resumo IA-first do projeto gerado em ${resumoProjeto.pastaSaida}`);
+    console.log("");
+    console.log(texto);
+    return 0;
+}
+async function comandoPromptCurto(entrada, args, emJson) {
+    const tamanho = normalizarTamanhoResumo(args);
+    const modo = normalizarModoResumo(obterOpcao(args, "--para"));
+    const alvo = entrada ? path.resolve(process.cwd(), entrada) : process.cwd();
+    if (entrada && entrada.toLowerCase().endsWith(".sema")) {
+        const contexto = await carregarContextoModuloIa(alvo);
+        const resumoSemantico = coletarResumoSemanticoModulo(contexto);
+        const capacidade = tamanho === "micro" ? "pequena" : tamanho === "curto" ? "media" : "grande";
+        const prompt = criarPromptCurtoModulo(resumoSemantico, modo, tamanho, capacidade);
+        if (emJson) {
+            console.log(JSON.stringify({
+                comando: "prompt-curto",
+                modo,
+                tamanho,
+                capacidade,
+                geradoEm: contexto.geradoEm,
+                arquivo: contexto.arquivo,
+                modulo: contexto.modulo,
+                prompt,
+            }, null, 2));
+            return 0;
+        }
+        console.log(prompt);
+        return 0;
+    }
+    const resumoProjeto = await gerarResumoProjetoIa(alvo);
+    const arquivoResumo = tamanho === "micro"
+        ? "SEMA_BRIEF.micro.txt"
+        : tamanho === "curto"
+            ? "SEMA_BRIEF.curto.txt"
+            : "SEMA_BRIEF.md";
+    const contextoProjeto = await readFile(path.join(resumoProjeto.pastaSaida, arquivoResumo), "utf8");
+    const capacidade = tamanho === "micro" ? "pequena" : tamanho === "curto" ? "media" : "grande";
+    const prompt = `Voce esta operando Sema em modo IA-first.
+
+Isto nao e material feito para humano; e contexto comprimido para IA.
+
+Capacidade alvo: ${capacidade}
+Modo da tarefa: ${modo}
+
+Regras:
+- comece pelo resumo compacto abaixo
+- se a tarefa pedir mais contexto, abra \`SEMA_INDEX.json\`
+- nao tente ler o repo inteiro se o resumo ja disser onde tocar
+- preserve contrato, risco, lacuna e checks sugeridos
+
+Contexto do projeto:
+${contextoProjeto.trim()}
+`;
+    if (emJson) {
+        console.log(JSON.stringify({
+            comando: "prompt-curto",
+            modo,
+            tamanho,
+            capacidade,
+            geradoEm: resumoProjeto.geradoEm,
+            baseProjeto: resumoProjeto.baseProjeto,
+            pastaSaida: resumoProjeto.pastaSaida,
+            prompt,
+        }, null, 2));
+        return 0;
+    }
+    console.log(prompt);
+    return 0;
+}
 async function comandoContextoIa(arquivo, pastaSaida, emJson) {
     const resultado = await gerarContextoIa(arquivo, pastaSaida);
     if (emJson) {
@@ -2252,7 +3698,7 @@ async function principal() {
             {
                 const fonte = normalizarFonteImportacao(posicionais[0]);
                 if (!fonte || !posicionais[1]) {
-                    console.error("Uso: sema importar <nestjs|fastapi|flask|nextjs|firebase|dotnet|java|go|rust|cpp|typescript|python|dart> <diretorio> [--saida <diretorio>] [--namespace <base>] [--json]");
+                    console.error("Uso: sema importar <nestjs|fastapi|flask|nextjs|nextjs-consumer|react-vite-consumer|angular-consumer|flutter-consumer|firebase|dotnet|java|go|rust|cpp|typescript|python|dart> <diretorio> [--saida <diretorio>] [--namespace <base>] [--json]");
                     codigoSaida = 1;
                     break;
                 }
@@ -2271,6 +3717,15 @@ async function principal() {
         case "starter-ia":
             codigoSaida = await comandoStarterIa();
             break;
+        case "sync-ai-entrypoints":
+            codigoSaida = await comandoSyncAiEntrypoints(possuiFlag(resto, "--json"));
+            break;
+        case "resumo":
+            codigoSaida = await comandoResumo(posicionais[0], resto, possuiFlag(resto, "--json"));
+            break;
+        case "prompt-curto":
+            codigoSaida = await comandoPromptCurto(posicionais[0], resto, possuiFlag(resto, "--json"));
+            break;
         case "prompt-ia":
             codigoSaida = await comandoPromptIa();
             break;