@semacode/cli 0.8.8 → 1.0.0

package/dist/index.js

@@ -16,12 +16,18 @@ const STARTER_IA = `Voce esta trabalhando com Sema, um Protocolo de Governanca d
 
 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 modela contratos, estados, fluxos, erros, efeitos e garantias
+- 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
-- a Sema usa \`drift\` para medir diferenca entre contrato e codigo vivo
 - a Sema usa \`impl\` para ligar task a simbolo real do runtime
+- 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 \`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
@@ -30,13 +36,20 @@ 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
 - use \`sema formatar\` como fonte unica de estilo
 - preserve a intencao do contrato
 - 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>\`
 - estrutura sintatica: \`sema ast <arquivo.sema> --json\`
 - estrutura semantica: \`sema ir <arquivo.sema> --json\`
@@ -44,39 +57,56 @@ Comandos essenciais:
 - 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>\`
-- auditoria de coerencia contra codigo vivo: \`sema drift <arquivo-ou-pasta> [--json]\`
 - 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. 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\`
 2. rode \`sema validar --json\`
 3. se houver falha, use \`diagnosticos --json\`
-4. se a tarefa partir de legado, rode \`sema drift\`
+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
 
+Superficies que a IA deve enxergar como first-class:
+- \`route\`
+- \`worker\`
+- \`evento\`
+- \`fila\`
+- \`cron\`
+- \`webhook\`
+- \`cache\`
+- \`storage\`
+- \`policy\`
+
 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
@@ -84,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
@@ -271,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\`
@@ -306,6 +339,8 @@ Comandos:
   sema formatar <arquivo-ou-pasta> [--check] [--json]
   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
@@ -335,18 +370,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;
@@ -620,23 +688,329 @@ 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.",
+        "- 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),
+    };
+}
+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}`,
+        `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)}`,
+        "",
+        "## 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,
+        simbolosRelacionados: resumo.simbolosRelacionados,
+        riscosPrincipais: resumo.riscosPrincipais,
+        lacunas: resumo.lacunas,
+        inferido: resumo.inferido,
+        checksSugeridos: resumo.checksSugeridos,
+        testesMinimos: resumo.testesMinimos,
+    };
+}
+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 backend vivo sem olhar risco, lacuna e checks sugeridos
+
+Contexto compacto:
+${resumoTexto}
+`;
+}
+function renderizarResumoProjetoMarkdown(geradoEm, modulos, 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}\``,
+        "",
+        "## 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 falharContextoIa(mensagem) {
     throw new Error(mensagem);
 }
@@ -655,6 +1029,12 @@ function resumirDriftPorModulo(modulo, caminho, resultadoDrift) {
     const implsQuebrados = modulo
         ? resultadoDrift.impls_quebrados.filter((impl) => impl.modulo === modulo)
         : [];
+    const vinculosValidos = modulo
+        ? resultadoDrift.vinculos_validos.filter((vinculo) => vinculo.modulo === modulo)
+        : [];
+    const vinculosQuebrados = modulo
+        ? resultadoDrift.vinculos_quebrados.filter((vinculo) => vinculo.modulo === modulo)
+        : [];
     const rotasDivergentes = modulo
         ? resultadoDrift.rotas_divergentes.filter((rota) => rota.modulo === modulo)
         : [];
@@ -669,28 +1049,84 @@ function resumirDriftPorModulo(modulo, caminho, resultadoDrift) {
         modulo,
         implsValidos: implsValidos.length,
         implsQuebrados: implsQuebrados.length,
+        vinculosValidos: vinculosValidos.length,
+        vinculosQuebrados: vinculosQuebrados.length,
         recursosValidos: recursosValidos.length,
         recursosDivergentesCount: recursosDivergentes.length,
         tasksSemImplementacao: tasks.filter((task) => task.semImplementacao).length,
+        scoreMedio: tasks.length > 0 ? Math.round(tasks.reduce((total, task) => total + task.scoreSemantico, 0) / tasks.length) : 0,
+        confiancaGeral: tasks.some((task) => task.confiancaVinculo === "alta")
+            ? "alta"
+            : 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")),
+        checksSugeridos: [...new Set(tasks.flatMap((task) => task.checksSugeridos))],
+        lacunas: [...new Set(tasks.flatMap((task) => task.lacunas))],
         tasks,
         rotasDivergentes,
         recursosDivergentes,
+        vinculosQuebradosDetalhes: vinculosQuebrados,
     };
 }
-async function gerarContextoIa(arquivoEntrada, pastaSaidaOpcional) {
+function criarBriefingAgente(arquivo, modulo, ir, resumoDrift, resultadoDrift) {
+    const tarefasModulo = resultadoDrift.tasks.filter((task) => task.modulo === modulo);
+    return {
+        arquivo,
+        modulo,
+        perfilCompatibilidade: ir?.perfilCompatibilidade ?? "interno",
+        scoreSemantico: resumoDrift.scoreMedio,
+        confiancaGeral: resumoDrift.confiancaGeral,
+        riscosPrincipais: [...new Set([
+                ...resultadoDrift.resumo_operacional.riscosPrincipais.filter((item) => item.startsWith(`${modulo}:`) || tarefasModulo.some((task) => item.startsWith(`${task.task}:`))),
+                ...(ir?.resumoAgente.riscos ?? []),
+            ])],
+        oQueTocar: resumoDrift.arquivosRelacionados,
+        oQueValidar: [...new Set([
+                ...resumoDrift.checksSugeridos,
+                ...resultadoDrift.resumo_operacional.oQueValidar,
+            ])],
+        oQueEstaFrouxo: [...new Set([
+                ...resumoDrift.lacunas,
+                ...resultadoDrift.resumo_operacional.oQueEstaFrouxo,
+            ])],
+        oQueFoiInferido: [...new Set([
+                ...resultadoDrift.impls_quebrados
+                    .filter((impl) => impl.modulo === modulo)
+                    .flatMap((impl) => impl.candidatos?.map((candidato) => candidato.caminho) ?? []),
+                ...resultadoDrift.vinculos_validos
+                    .filter((vinculo) => vinculo.modulo === modulo && vinculo.status === "parcial")
+                    .map((vinculo) => `${vinculo.dono}:${vinculo.valor}`),
+            ])],
+        simbolosRelacionados: [...new Set([
+                ...tarefasModulo.flatMap((task) => task.simbolosReferenciados),
+                ...resultadoDrift.vinculos_validos
+                    .filter((vinculo) => vinculo.modulo === modulo)
+                    .map((vinculo) => vinculo.simbolo)
+                    .filter((item) => Boolean(item)),
+            ])],
+        superficiesImpactadas: [
+            ...(ir?.routes.map((route) => `${route.metodo ?? "?"} ${route.caminho ?? route.nome}`) ?? []),
+            ...(ir?.superficies.map((superficie) => `${superficie.tipo}:${superficie.nome}`) ?? []),
+        ],
+        testesMinimos: [
+            "sema validar <arquivo> --json",
+            "sema drift <arquivo> --json",
+            "sema verificar <arquivo-ou-pasta> --json",
+        ],
+    };
+}
+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) {
@@ -698,6 +1134,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",
@@ -741,49 +1178,207 @@ async function gerarContextoIa(arquivoEntrada, pastaSaidaOpcional) {
         diagnosticos: resultadoModulo.diagnosticos,
         ir: resultadoModulo.ir ?? null,
     };
-    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");
-    const resumo = `# Contexto de IA para ${modulo}
-
-- Arquivo alvo: \`${arquivo}\`
-- Modulo: \`${modulo}\`
-- Sucesso em validar: \`${sucesso}\`
-- Quantidade de diagnosticos: \`${resultadoModulo.diagnosticos.length}\`
+    const briefing = criarBriefingAgente(arquivo, modulo, resultadoModulo.ir ?? null, drift.resumo, resultadoDrift);
+    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 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,
+        guiaPorCapacidade,
+        modulos,
+    };
+    const micro = [
+        `PROJETO: ${path.basename(baseProjeto)}`,
+        `MODULOS: ${modulos.length}`,
+        `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}`,
+        `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\`
 - \`ir.json\`
 - \`drift.json\`
+- \`briefing.json\`
 
 ## 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 \`diagnosticos.json\` se houver falha ou aviso relevante.
-5. Editar o arquivo \`.sema\`.
-6. Rodar \`sema formatar "${arquivo}"\`.
-7. Rodar \`sema validar "${arquivo}" --json\`.
-8. 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", "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) {
@@ -1509,6 +2104,8 @@ async function comandoInspecionar(entrada, emJson, cwd = process.cwd()) {
             diretoriosCodigo: contextoProjeto.diretoriosCodigo,
             fontesLegado: contextoProjeto.fontesLegado,
             modoAdocao: contextoProjeto.modoAdocao,
+            scoreDrift: resultadoDrift.resumo_operacional.scoreMedio,
+            confiancaGeral: resultadoDrift.resumo_operacional.confiancaGeral,
         },
         projeto: {
             arquivos: contextoProjeto.arquivosProjeto,
@@ -1517,6 +2114,7 @@ async function comandoInspecionar(entrada, emJson, cwd = process.cwd()) {
                 modulo: item.resultado.modulo?.nome ?? null,
                 sucesso: !temErros(item.resultado.diagnosticos),
                 diagnosticos: item.resultado.diagnosticos.length,
+                superficies: item.resultado.ir?.superficies.map((superficie) => `${superficie.tipo}:${superficie.nome}`) ?? [],
                 implementacao: resumirDriftPorModulo(item.resultado.modulo?.nome ?? null, item.caminho, resultadoDrift),
             })),
         },
@@ -1533,6 +2131,8 @@ async function comandoInspecionar(entrada, emJson, cwd = process.cwd()) {
     console.log(`- Estrutura de saida: ${payload.configuracao.estruturaSaida}`);
     console.log(`- Alvos: ${payload.configuracao.alvos.join(", ")}`);
     console.log(`- Modo de adocao: ${payload.configuracao.modoAdocao}`);
+    console.log(`- Score medio de drift: ${payload.configuracao.scoreDrift}`);
+    console.log(`- Confianca geral: ${payload.configuracao.confiancaGeral}`);
     console.log("- Saidas por alvo:");
     for (const [alvo, saida] of Object.entries(payload.configuracao.saidas)) {
         console.log(`  - ${alvo}: ${saida}`);
@@ -1568,9 +2168,13 @@ async function comandoDrift(entrada, emJson, cwd = process.cwd()) {
     console.log(`- Tasks analisadas: ${resultado.tasks.length}`);
     console.log(`- Impl validos: ${resultado.impls_validos.length}`);
     console.log(`- Impl quebrados: ${resultado.impls_quebrados.length}`);
+    console.log(`- Vinculos validos: ${resultado.vinculos_validos.length}`);
+    console.log(`- Vinculos quebrados: ${resultado.vinculos_quebrados.length}`);
     console.log(`- Rotas divergentes: ${resultado.rotas_divergentes.length}`);
     console.log(`- Recursos vivos validos: ${resultado.recursos_validos.length}`);
     console.log(`- Recursos vivos divergentes: ${resultado.recursos_divergentes.length}`);
+    console.log(`- Score medio: ${resultado.resumo_operacional.scoreMedio}`);
+    console.log(`- Confianca geral: ${resultado.resumo_operacional.confiancaGeral}`);
     if (resultado.impls_quebrados.length > 0) {
         console.log("- Impl quebrados:");
         for (const impl of resultado.impls_quebrados) {
@@ -1608,6 +2212,24 @@ async function comandoDrift(entrada, emJson, cwd = process.cwd()) {
             }
         }
     }
+    if (resultado.vinculos_quebrados.length > 0) {
+        console.log("- Vinculos quebrados:");
+        for (const vinculo of resultado.vinculos_quebrados) {
+            console.log(`  - ${vinculo.modulo}.${vinculo.dono} :: ${vinculo.tipo}=${vinculo.valor}`);
+        }
+    }
+    if (resultado.resumo_operacional.oQueTocar.length > 0) {
+        console.log("- O que tocar primeiro:");
+        for (const alvo of resultado.resumo_operacional.oQueTocar.slice(0, 8)) {
+            console.log(`  - ${alvo}`);
+        }
+    }
+    if (resultado.resumo_operacional.oQueValidar.length > 0) {
+        console.log("- O que validar:");
+        for (const check of resultado.resumo_operacional.oQueValidar.slice(0, 8)) {
+            console.log(`  - ${check}`);
+        }
+    }
     if (resultado.diagnosticos.length === 0) {
         console.log("Nenhum drift relevante encontrado.");
     }
@@ -1825,11 +2447,15 @@ async function comandoAjudaIa() {
     console.log(renderizarCabecalhoDocsIa(descoberta));
     console.log("");
     console.log("O que a Sema faz de verdade");
-    console.log("- Governa contrato, intencao, erro, efeito, garantia, fluxo e vinculo com implementacao viva.");
+    console.log("- Foi feita para IA operar melhor; leitura humana e consequencia, nao centro de produto.");
+    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 `drift` para medir divergencia entre contrato e codigo vivo.");
-    console.log("- Usa `contexto-ia` para preparar AST, IR, diagnosticos e drift antes da edicao.");
+    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 `resumo` e `prompt-curto` para IA pequena ou gratuita.");
+    console.log("- Usa `contexto-ia` para preparar AST, IR, diagnosticos, drift, `briefing.json` e artefatos compactos antes da edicao.");
     console.log("");
     console.log("O que a Sema nao promete");
     console.log("- Nao escreve contrato final sozinho.");
@@ -1838,18 +2464,25 @@ async function comandoAjudaIa() {
     console.log("");
     console.log("Fluxo recomendado");
     console.log("- Use `sema starter-ia` para um texto curto de onboarding.");
+    console.log("- Use `sema resumo <arquivo> --micro --para onboarding` para IA pequena.");
+    console.log("- Use `sema prompt-curto <arquivo> --curto --para mudanca` para colar contexto em modelo gratuito.");
     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 contexto-ia <arquivo.sema>` para gerar AST, IR e diagnosticos do modulo alvo.");
+    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, `briefing.json` e `briefing.min.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("");
     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("- IA pequena comeca no menor artefato que resolve a tarefa; nao enfie `ast.json` inteiro nela de bobeira.");
+    console.log("- Antes de editar backend vivo, leia `briefing.min.json` ou `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.");
     return 0;
 }
 async function comandoPromptIa() {
@@ -1897,6 +2530,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) {
@@ -2147,6 +2916,12 @@ async function principal() {
         case "starter-ia":
             codigoSaida = await comandoStarterIa();
             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;