@semacode/cli 1.5.18 → 1.5.19

package/dist/index.js

@@ -18,13 +18,13 @@ import { carregarConfiguracaoProjeto, carregarProjeto, resolverAlvoPadrao, resol
 import { importarProjetoLegado, resumoImportacao } from "./importador.js";
 import { analisarDriftLegado, assistirRenomeacaoSemantica, gerarMapaImpactoSemantico, } from "./drift.js";
 import { resolverDocumentacaoObrigatoria, verificarDocumentacaoMudanca, } from "./docs.js";
-const STARTER_IA = `Voce esta trabalhando com Sema, um contrato semantico IA-first para agentes operarem software vivo em backend e front consumer.
+const STARTER_IA = `Voce esta trabalhando com Sema, um contrato semantico IA-first para agentes operarem 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 desenhado para IA, nao para ergonomia humana
-- humanos sao autores/aprovadores; agentes sao os consumidores primarios do contrato
-- leitura humana e bonus toleravel, nao objetivo de produto
+- a Sema se apresenta publicamente como protocolo e funciona tecnicamente como linguagem de intencao
+- a Sema e protocolo de governanca semantica desenhado para IA, nao para ergonomia humana
+- humanos sao autores/aprovadores; agentes sao os consumidores primarios do contrato
+- 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
@@ -41,10 +41,11 @@ Importante:
 - se a tarefa envolver UI, prefira pedir Sema + React + TypeScript ou Sema + arquitetura de front-end
 - evite pedir HTML unico solto quando a intencao for testar a Sema de verdade
 
-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
+Regras:
+- nao invente sintaxe fora da gramatica e dos exemplos oficiais
+- antes de qualquer acao, crie, edite ou remova o contrato .sema aplicavel; isso vale para Software, Author, Workflow, Ops, Game, Legal e Research
+- se a IA for 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
@@ -106,9 +107,9 @@ Superficies que a IA deve enxergar como first-class:
 
 Nao improvise quando faltar contexto.
 `;
-const PROMPT_BASE_IA = `Voce esta trabalhando com Sema, um contrato semantico IA-first para agentes operarem software vivo.
-
-Trate a Sema como protocolo de governanca semantica e linguagem de intencao feita para IA, nao para leitura humana confortavel. Humanos escrevem e aprovam; agentes consomem. Nao invente sintaxe, palavras-chave ou blocos fora da gramatica e dos exemplos oficiais.
+const PROMPT_BASE_IA = `Voce esta trabalhando com Sema, um contrato semantico IA-first para agentes operarem software vivo.
+
+Trate a Sema como protocolo de governanca semantica e linguagem de intencao feita para IA, nao para leitura humana confortavel. Humanos escrevem e aprovam; agentes consomem. Nao invente sintaxe, palavras-chave ou blocos fora da gramatica e dos exemplos oficiais.
 
 Fontes de verdade, em ordem:
 1. se o projeto expuser \`SEMA_CONTEXT.md\`, comece por ele
@@ -121,13 +122,14 @@ Fontes de verdade, em ordem:
 8. \`sema resumo\` e \`briefing.min.json\` quando a IA for pequena
 9. AST, IR e diagnosticos exportados pela CLI em JSON quando a capacidade aguentar
 
-Regras de operacao:
-- preserve o significado semantico
-- use o formatador oficial da Sema como fonte unica de estilo
-- use diagnosticos estruturados como contrato de correcao
-- use a IR como fonte de verdade semantica quando houver duvida
-- use predicados canonicos como normalizacao opcional, preservando a forma original
-- nao conclua uma alteracao sem validar e verificar o modulo
+Regras de operacao:
+- contrato vem antes da acao: crie, edite ou remova o .sema aplicavel antes de codigo, docs operacionais, texto Author, workflow, jogo, pesquisa, legal ou ops
+- preserve o significado semantico
+- use o formatador oficial da Sema como fonte unica de estilo
+- use diagnosticos estruturados como contrato de correcao
+- use a IR como fonte de verdade semantica quando houver duvida
+- use predicados canonicos como normalizacao opcional, preservando a forma original
+- nao conclua uma alteracao sem validar e verificar o modulo
 - comece pelo menor artefato semantico que resolva a tarefa
 
 Antes de editar \`.sema\`, entenda:
@@ -241,9 +243,10 @@ Se houver duvida, siga os exemplos oficiais e mantenha a separacao:
 `;
 const PROMPT_IA_SEMA_PRIMEIRO = `Quero que voce trabalhe no modo "Sema primeiro".
 
-Regra principal:
-- modele primeiro o dominio em arquivos \`.sema\`
-- so depois proponha ou gere codigo de aplicacao derivado disso
+Regra principal:
+- modele primeiro o dominio em arquivos \`.sema\`
+- se a intencao mudar, crie, edite ou remova o contrato antes de qualquer acao operacional
+- so depois proponha ou gere codigo de aplicacao derivado disso
 
 Fluxo obrigatorio:
 1. entender o dominio pedido
@@ -344,6 +347,9 @@ const DOCUMENTOS_SUPORTE_IA = [
     "docs/sintaxe.md",
     "docs/cli.md",
     "docs/mcp.md",
+    "docs/profiles.md",
+    "docs/profiles-author-agents-flow.md",
+    "docs/testes.md",
     "docs/documentacao.md",
     "docs/deploy.md",
     "docs/env.md",
@@ -461,7 +467,20 @@ function ajuda() {
             "sema docs-impacto --intencao \"fazer deploy\" --criar-ausentes --json",
             "sema contexto-ia <arquivo.sema> --saida ./.tmp/contexto --json",
             "",
-            "[3] Adotar Sema em projeto que ainda nao usa",
+            "[3] Governar escrita autoral com Sema Author",
+            "sema author iniciar [--tema-sensivel] [--saida contratos/author.sema]",
+            "sema author validar contratos/author.sema --json",
+            "sema author briefing contratos/author.sema --json",
+            "sema author revisar-cliches contratos/author.sema --texto <texto> --json  # reprova se houver bloqueio",
+            "sema author validar-narrativa contratos/author.sema --texto <texto> --texto-anterior <texto> --json",
+            "sema author validar-proibicoes contratos/author.sema --texto <texto> --json",
+            "",
+            "[4] Validar profiles semanticos",
+            "sema profile validar workflow contratos/sema/workflow_ops.sema --maturidade production --preset webhook --artefato-arquivo workflow.md --json",
+            "sema profile validar ops contratos/sema/workflow_ops.sema --maturidade critical --preset deploy --artefato-arquivo runbook.md --json",
+            "sema profile validar game contratos/sema/game.sema --maturidade prototype --preset playtest --artefato-arquivo playtest.md --json",
+            "",
+            "[5] 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",
@@ -486,6 +505,8 @@ function ajuda() {
             "teste local: sema testar <arquivo.sema> --alvo <python|typescript|dart|lua> --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]",
+            "author: sema author <iniciar|validar|briefing|revisar-cliches|validar-narrativa|validar-proibicoes> [arquivo] [--tema-sensivel] [--preset conto|romance|roteiro|lore|campanha] [--saida <arquivo>] [--texto <texto>] [--json]",
+            "profile: sema profile validar <software|workflow|ops|game|legal|research> <arquivo-ou-pasta> [--maturidade draft|prototype|production|critical] [--preset <preset>] [--artefato <texto>|--artefato-arquivo <arquivo>] [--json]",
         ]),
         "",
         renderizarSecaoAscii("Ajuda IA-first", [
@@ -501,8 +522,14 @@ function ajuda() {
             "sema contexto-ia <arquivo.sema> [--saida <diretorio>] [--json]",
             "sema sync-ai-entrypoints [--json]",
             "sema instalar-exemplos [--json]",
+            "sema mcp-instalar-chave --stdin [--endpoint <url>] [--dry-run] [--json]",
             "sema docs-impacto --intencao <acao> [--arquivo <caminho>] [--criar-ausentes] [--json]",
             "sema finalizar-mudanca --intencao <acao> [--arquivo <caminho>] [--doc-lida <caminho>] [--json]",
+            "sema author briefing <arquivo.sema> [--json]",
+            "sema author revisar-cliches <arquivo.sema> [--texto <texto>|--texto-arquivo <arquivo>] [--texto-anterior <texto>|--texto-anterior-arquivo <arquivo>] [--json]",
+            "sema author validar-narrativa <arquivo.sema> [--texto <texto>|--texto-arquivo <arquivo>] [--json]",
+            "sema author validar-proibicoes <arquivo.sema> [--texto <texto>|--texto-arquivo <arquivo>] [--json]",
+            "sema profile validar <profile> <arquivo.sema> [--maturidade draft|prototype|production|critical] [--preset <preset>] [--artefato <texto>|--artefato-arquivo <arquivo>] [--json]",
         ]),
         "",
         renderizarSecaoAscii("Operacional", [
@@ -558,6 +585,15 @@ const OPCOES_COM_VALOR = new Set([
     "--intencao",
     "--arquivo",
     "--doc-lida",
+    "--texto",
+    "--texto-arquivo",
+    "--endpoint",
+    "--maturidade",
+    "--preset",
+    "--artefato",
+    "--artifact",
+    "--artefato-arquivo",
+    "--artifact-file",
 ]);
 const ALIAS_OPCOES = {
     "-a": "--alvo",
@@ -611,6 +647,138 @@ function comandoDisponivel(comando, argumentos = ["--version"]) {
     const execucao = spawnSync(comando, argumentos, { stdio: "ignore", shell: process.platform === "win32" });
     return (execucao.status ?? 1) === 0;
 }
+const MCP_CLIENT_TOKEN_ENV_VAR = "SEMA_MCP_AUTH_TOKEN";
+const MCP_CLIENT_ENDPOINT_ENV_VAR = "SEMA_MCP_ENDPOINT";
+const MCP_ENDPOINT_PADRAO = "https://sema.otimitare.online/mcp";
+function tokenPareceChaveMcpComercial(token) {
+    return /^sema_mcp_[A-Za-z0-9_-]{16,}$/.test(token);
+}
+function prefixoSeguroTokenMcp(token) {
+    return token.slice(0, Math.min(14, token.length));
+}
+function ajudaMcpInstalarChave() {
+    return [
+        "Uso: sema mcp-instalar-chave --stdin [--endpoint <url>] [--dry-run] [--json]",
+        "",
+        "Instala a chave MCP comercial no ambiente do usuario local.",
+        "",
+        "Seguranca:",
+        "- a chave deve vir por stdin, nunca por argumento",
+        `- grava ${MCP_CLIENT_TOKEN_ENV_VAR} e ${MCP_CLIENT_ENDPOINT_ENV_VAR} no usuario`,
+        "- nao imprime o token completo",
+        "",
+        "Exemplo:",
+        "  Get-Clipboard | sema mcp-instalar-chave --stdin --json",
+    ].join("\n");
+}
+async function lerStdinTexto() {
+    return await new Promise((resolve, reject) => {
+        let conteudo = "";
+        process.stdin.setEncoding("utf8");
+        process.stdin.on("data", (chunk) => {
+            conteudo += chunk;
+        });
+        process.stdin.on("error", reject);
+        process.stdin.on("end", () => resolve(conteudo));
+    });
+}
+function instalarChaveMcpNoUsuarioWindows(token, endpoint, dryRun) {
+    if (dryRun) {
+        return;
+    }
+    if (process.platform !== "win32") {
+        throw new Error("Instalacao persistente automatica da chave MCP esta disponivel apenas no Windows por enquanto.");
+    }
+    const script = [
+        "$ErrorActionPreference = 'Stop'",
+        "$token = $env:SEMA_MCP_INSTALL_TOKEN_VALUE",
+        "$endpoint = $env:SEMA_MCP_INSTALL_ENDPOINT_VALUE",
+        "if ([string]::IsNullOrWhiteSpace($token)) { throw 'Chave MCP vazia.' }",
+        `[Environment]::SetEnvironmentVariable('${MCP_CLIENT_TOKEN_ENV_VAR}', $token, 'User')`,
+        `[Environment]::SetEnvironmentVariable('${MCP_CLIENT_ENDPOINT_ENV_VAR}', $endpoint, 'User')`,
+    ].join("; ");
+    const execucao = spawnSync("powershell.exe", ["-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-Command", script], {
+        encoding: "utf8",
+        windowsHide: true,
+        env: {
+            ...process.env,
+            SEMA_MCP_INSTALL_TOKEN_VALUE: token,
+            SEMA_MCP_INSTALL_ENDPOINT_VALUE: endpoint,
+        },
+    });
+    if ((execucao.status ?? 1) !== 0) {
+        throw new Error((execucao.stderr || execucao.stdout || "PowerShell falhou ao gravar a chave MCP do usuario.").trim());
+    }
+}
+async function comandoMcpInstalarChave(args, json) {
+    if (possuiFlag(args, "--help") || possuiFlag(args, "-h")) {
+        console.log(ajudaMcpInstalarChave());
+        return 0;
+    }
+    const dryRun = possuiFlag(args, "--dry-run");
+    const endpoint = obterOpcao(args, "--endpoint", MCP_ENDPOINT_PADRAO) ?? MCP_ENDPOINT_PADRAO;
+    const recebePorStdin = possuiFlag(args, "--stdin");
+    const tokenOrigem = recebePorStdin ? await lerStdinTexto() : "";
+    const token = tokenOrigem.trim();
+    const resultadoBase = {
+        comando: "mcp-instalar-chave",
+        dryRun,
+        sistema: process.platform,
+        envVar: MCP_CLIENT_TOKEN_ENV_VAR,
+        endpointEnvVar: MCP_CLIENT_ENDPOINT_ENV_VAR,
+        endpoint,
+        tokenPrefix: prefixoSeguroTokenMcp(token),
+        tokenLength: token.length,
+        reinicioNecessario: true,
+        tokenExposto: false,
+    };
+    try {
+        if (!recebePorStdin) {
+            throw new Error("Use --stdin para instalar a chave MCP. A chave nao deve ir por argumento nem fallback de ambiente.");
+        }
+        if (!token) {
+            throw new Error("Informe a chave MCP por stdin: sema mcp-instalar-chave --stdin.");
+        }
+        if (!tokenPareceChaveMcpComercial(token)) {
+            throw new Error("A chave MCP precisa comecar com sema_mcp_ e ter formato comercial valido.");
+        }
+        if (!/^https:\/\/.+\/mcp(?:[?#].*)?$/.test(endpoint)) {
+            throw new Error("O endpoint MCP precisa ser HTTPS e terminar em /mcp.");
+        }
+        instalarChaveMcpNoUsuarioWindows(token, endpoint, dryRun);
+        const resultado = {
+            ...resultadoBase,
+            sucesso: true,
+            persistente: !dryRun && process.platform === "win32",
+        };
+        if (json) {
+            console.log(JSON.stringify(resultado, null, 2));
+        }
+        else {
+            console.log("Chave MCP instalada para o usuario atual.");
+            console.log(`Env var: ${MCP_CLIENT_TOKEN_ENV_VAR}`);
+            console.log(`Endpoint: ${endpoint}`);
+            console.log("Reabra Codex, VS Code ou o fork MCP para carregar a variavel.");
+        }
+        return 0;
+    }
+    catch (erro) {
+        const mensagem = erro instanceof Error ? erro.message : String(erro);
+        const resultado = {
+            ...resultadoBase,
+            sucesso: false,
+            persistente: false,
+            erro: mensagem,
+        };
+        if (json) {
+            console.log(JSON.stringify(resultado, null, 2));
+        }
+        else {
+            console.error(mensagem);
+        }
+        return 1;
+    }
+}
 function resolverExecucaoPython() {
     if (comandoDisponivel("python")) {
         return { comando: "python", argumentosBase: [], rotulo: "python" };
@@ -1305,6 +1473,8 @@ function criarGuiaCapacidadeIa() {
 }
 function coletarResumoSemanticoModulo(contexto) {
     const { arquivo, modulo, geradoEm, ir, briefing, drift } = contexto;
+    const modoVerificacaoCodigo = contexto.modoVerificacaoCodigo ?? "codigo_completo";
+    const fontesConclusao = contexto.fontesConclusao ?? ["contrato", "codigo"];
     const tarefas = ir?.tasks ?? [];
     const rotas = ir?.routes ?? [];
     const superficies = ir?.superficies ?? [];
@@ -1328,10 +1498,17 @@ function coletarResumoSemanticoModulo(contexto) {
         ...rotas.flatMap((route) => route.resumoAgente.entidadesAfetadas),
         ...superficies.flatMap((superficie) => superficie.resumoAgente.entidadesAfetadas),
     ]);
-    return {
+    const resumo = {
         geradoEm,
         arquivo,
         modulo,
+        modoVerificacaoCodigo,
+        avisoVerificacaoCodigo: modoVerificacaoCodigo === "contratos_apenas"
+            ? "Somente contratos foram enviados; implementacao nao foi verificada neste modo."
+            : modoVerificacaoCodigo === "codigo_selecionado"
+                ? "Codigo selecionado foi enviado; conclusoes de implementacao valem apenas para os arquivos do snapshot."
+                : null,
+        fontesConclusao,
         perfilCompatibilidade: ir?.perfilCompatibilidade ?? briefing.perfilCompatibilidade,
         scoreSemantico: briefing.scoreSemantico,
         confiancaGeral: briefing.confiancaGeral,
@@ -1362,6 +1539,87 @@ function coletarResumoSemanticoModulo(contexto) {
         ancoragensVinculo: limitarLista(unicosOrdenados(briefing.ancoragensVinculo ?? []), 8),
         arquivosProvaveisEditar: limitarLista(unicosOrdenados(briefing.arquivosProvaveisEditar ?? briefing.oQueTocar), 8),
     };
+    return modoVerificacaoCodigo === "codigo_completo"
+        ? resumo
+        : normalizarResumoModoContratosApenas(resumo);
+}
+const LACUNAS_DEPENDENTES_DE_CODIGO = new Set([
+    "sem_impl",
+    "impl_quebrado",
+    "sem_vinculos",
+    "vinculo_quebrado",
+    "rastreabilidade_fraca",
+]);
+function normalizarResumoModoContratosApenas(resumo) {
+    const lacunasCodigo = resumo.lacunas.some((lacuna) => LACUNAS_DEPENDENTES_DE_CODIGO.has(lacuna));
+    const riscosCodigo = resumo.riscosPrincipais.some((risco) => /vinculo_fraco|sem_impl|impl_quebrado|vinculo_quebrado|rastreabilidade_fraca/i.test(risco));
+    const modoContratosApenas = resumo.modoVerificacaoCodigo === "contratos_apenas";
+    const lacunas = resumo.lacunas
+        .filter((lacuna) => !LACUNAS_DEPENDENTES_DE_CODIGO.has(lacuna));
+    const riscosPrincipais = resumo.riscosPrincipais
+        .filter((risco) => !/vinculo_fraco|sem_impl|impl_quebrado|vinculo_quebrado|rastreabilidade_fraca/i.test(risco));
+    const checksSugeridos = resumo.checksSugeridos
+        .filter((check) => !/drift|vinculo/i.test(check));
+    return {
+        ...resumo,
+        riscosPrincipais: limitarLista(unicosOrdenados([
+            ...riscosPrincipais,
+            ...(riscosCodigo || lacunasCodigo ? ["codigo_nao_verificado_neste_modo"] : []),
+        ]), 6),
+        lacunas: limitarLista(unicosOrdenados([
+            ...lacunas,
+            ...(lacunasCodigo ? [modoContratosApenas ? "implementacao_nao_enviada" : "implementacao_nao_presente_no_snapshot"] : []),
+            ...(lacunasCodigo ? ["codigo_nao_verificado_neste_modo"] : []),
+        ]), 6),
+        inferido: limitarLista(unicosOrdenados([
+            ...resumo.inferido,
+            modoContratosApenas ? "modo_contratos_apenas" : "modo_codigo_selecionado",
+            modoContratosApenas ? "codigo_nao_verificado_neste_modo" : "codigo_parcial_verificado_neste_modo",
+        ]), 6),
+        checksSugeridos: limitarLista(unicosOrdenados([
+            ...checksSugeridos,
+            modoContratosApenas
+                ? "sincronizar codigo selecionado para verificar implementacao"
+                : "ampliar snapshot se precisar verificar outro codigo",
+        ]), 6),
+    };
+}
+async function detectarModoVerificacaoCodigo(baseProjeto, diretoriosCodigo) {
+    try {
+        const snapshot = JSON.parse(await readFile(path.join(baseProjeto, "SEMA_SNAPSHOT.json"), "utf8"));
+        if (snapshot?.modo === "contratos_apenas")
+            return "contratos_apenas";
+        if (snapshot?.modo === "codigo_selecionado")
+            return "codigo_selecionado";
+    }
+    catch { }
+    return diretoriosCodigo.length === 0 ? "contratos_apenas" : "codigo_completo";
+}
+async function detectarFontesConclusaoSnapshot(baseProjeto) {
+    try {
+        const snapshot = JSON.parse(await readFile(path.join(baseProjeto, "SEMA_SNAPSHOT.json"), "utf8"));
+        if (Array.isArray(snapshot?.fontesConclusao) && snapshot.fontesConclusao.length > 0) {
+            return snapshot.fontesConclusao.map(String);
+        }
+    }
+    catch { }
+    return ["contrato", "codigo"];
+}
+function descreverFontesConclusao(fontes, modo) {
+    return fontes.map((fonte) => {
+        if (fonte === "contrato")
+            return "contrato: intencao oficial e regra normativa";
+        if (fonte === "codigo") {
+            return modo === "codigo_selecionado"
+                ? "codigo: evidencia restrita ao snapshot selecionado"
+                : "codigo: evidencia da implementacao disponivel";
+        }
+        if (fonte === "documentacao")
+            return "documentacao: regra de negocio, operacao ou runbook contextual";
+        if (fonte === "indice")
+            return "indice: mapa de arquivos, hashes, timestamps e escopo recebido";
+        return `${fonte}: fonte complementar`;
+    });
 }
 function renderizarResumoModuloTexto(resumo, tamanho, modo) {
     const limite = tamanho === "micro" ? 2 : tamanho === "curto" ? 4 : 6;
@@ -1370,6 +1628,9 @@ function renderizarResumoModuloTexto(resumo, tamanho, modo) {
         `MODULO: ${resumo.modulo}`,
         `FAZ: ${resumo.faz}`,
         `PERFIL: ${resumo.perfilCompatibilidade}`,
+        `MODO_CODIGO: ${resumo.modoVerificacaoCodigo}`,
+        ...(resumo.avisoVerificacaoCodigo ? [`AVISO_CODIGO: ${resumo.avisoVerificacaoCodigo}`] : []),
+        `FONTES_CONCLUSAO: ${resumirListaTexto(resumo.fontesConclusao, limite)}`,
         `CONSUMER_FRAMEWORK: ${resumo.consumerFramework ?? "nenhum"}`,
         `APP_ROUTES: ${resumirListaTexto(resumo.appRoutes, limite)}`,
         `CONSUMER_SURFACES: ${resumirListaTexto(resumo.consumerSurfaces, limite)}`,
@@ -1406,6 +1667,9 @@ function renderizarResumoModuloMarkdown(resumo, modo, guiaPorCapacidade) {
         `- Gerado em: \`${resumo.geradoEm}\``,
         `- Arquivo: \`${resumo.arquivo}\``,
         `- Perfil: \`${resumo.perfilCompatibilidade}\``,
+        `- Modo de codigo: \`${resumo.modoVerificacaoCodigo}\``,
+        ...(resumo.avisoVerificacaoCodigo ? [`- Aviso de codigo: ${resumo.avisoVerificacaoCodigo}`] : []),
+        `- Fontes de conclusao: ${resumirListaTexto(resumo.fontesConclusao, 6)}`,
         `- Score: \`${resumo.scoreSemantico}\``,
         `- Confianca: \`${resumo.confiancaGeral}\``,
         `- Risco operacional: \`${resumo.riscoOperacional}\``,
@@ -1470,6 +1734,9 @@ function criarBriefingMinimo(resumo, modo, tamanho) {
         tamanho,
         arquivo: resumo.arquivo,
         modulo: resumo.modulo,
+        modoVerificacaoCodigo: resumo.modoVerificacaoCodigo,
+        avisoVerificacaoCodigo: resumo.avisoVerificacaoCodigo,
+        fontesConclusao: resumo.fontesConclusao,
         perfilCompatibilidade: resumo.perfilCompatibilidade,
         scoreSemantico: resumo.scoreSemantico,
         confiancaGeral: resumo.confiancaGeral,
@@ -1501,7 +1768,7 @@ function criarPromptCurtoModulo(resumo, modo, tamanho, capacidade) {
     const resumoTexto = renderizarResumoModuloTexto(resumo, tamanho, modo).trim();
     return `Voce esta operando Sema em modo IA-first.
 
-Esta linguagem existe para traduzir intencao operacional em contrato consumivel por IA. Humanos aprovam; agentes operam.
+Esta linguagem existe para traduzir intencao operacional em contrato consumivel por IA. Humanos aprovam; agentes operam.
 
 Capacidade alvo: ${capacidade}
 Modo da tarefa: ${modo}
@@ -1827,6 +2094,8 @@ async function gerarResumoProjetoIa(entrada, pastaSaidaOpcional, escreverNaRaiz
     const geradoEm = new Date().toISOString();
     const guiaPorCapacidade = criarGuiaCapacidadeIa();
     const entradaCanonica = criarEntradaCanonicaProjeto(guiaPorCapacidade);
+    const modoVerificacaoCodigo = await detectarModoVerificacaoCodigo(contextoProjeto.baseProjeto, contextoProjeto.diretoriosCodigo);
+    const fontesConclusao = await detectarFontesConclusaoSnapshot(contextoProjeto.baseProjeto);
     const resultadoDrift = await analisarDriftLegado(contextoProjeto);
     const modulos = contextoProjeto.modulosSelecionados.map((item) => {
         const modulo = item.resultado.modulo?.nome ?? path.basename(item.caminho, ".sema");
@@ -1846,6 +2115,8 @@ async function gerarResumoProjetoIa(entrada, pastaSaidaOpcional, escreverNaRaiz
                 resumo: driftResumo,
                 drift: resultadoDrift,
             },
+            modoVerificacaoCodigo,
+            fontesConclusao,
         });
     });
     const baseProjeto = contextoProjeto.baseProjeto;
@@ -1861,6 +2132,9 @@ async function gerarResumoProjetoIa(entrada, pastaSaidaOpcional, escreverNaRaiz
         geradoEm,
         cliVersao: VERSAO_CLI,
         baseProjeto,
+        modoVerificacaoCodigo,
+        fontesConclusao,
+        conclusoesPorFonte: descreverFontesConclusao(fontesConclusao, modoVerificacaoCodigo),
         totalModulos: modulos.length,
         entradaCanonica,
         guiaPorCapacidade,
@@ -1869,6 +2143,8 @@ async function gerarResumoProjetoIa(entrada, pastaSaidaOpcional, escreverNaRaiz
     const micro = [
         `PROJETO: ${path.basename(baseProjeto)}`,
         `MODULOS: ${modulos.length}`,
+        `MODO_CODIGO: ${modoVerificacaoCodigo}`,
+        `FONTES_CONCLUSAO: ${resumirListaTexto(fontesConclusao, 4)}`,
         `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)}`,
@@ -1880,6 +2156,13 @@ async function gerarResumoProjetoIa(entrada, pastaSaidaOpcional, escreverNaRaiz
         `PROJETO: ${path.basename(baseProjeto)}`,
         `BASE: ${baseProjeto}`,
         `MODULOS: ${modulos.length}`,
+        `MODO_CODIGO: ${modoVerificacaoCodigo}`,
+        ...(modoVerificacaoCodigo === "contratos_apenas"
+            ? ["AVISO_CODIGO: somente contratos enviados; implementacao nao verificada neste modo"]
+            : modoVerificacaoCodigo === "codigo_selecionado"
+                ? ["AVISO_CODIGO: codigo selecionado enviado; conclusoes valem apenas para o snapshot"]
+                : []),
+        `FONTES_CONCLUSAO: ${resumirListaTexto(fontesConclusao, 6)}`,
         `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)}`,
@@ -1896,6 +2179,7 @@ async function gerarResumoProjetoIa(entrada, pastaSaidaOpcional, escreverNaRaiz
         geradoEm,
         baseProjeto,
         pastaSaida,
+        modoVerificacaoCodigo,
         artefatos: ["SEMA_BRIEF.md", "SEMA_BRIEF.micro.txt", "SEMA_BRIEF.curto.txt", "SEMA_INDEX.json"],
         modulos,
         guiaPorCapacidade,
@@ -3293,6 +3577,1544 @@ async function comandoInstalarExemplos(emJson) {
     console.log(`- Preservados: ${resultado.preservados.length}`);
     return 0;
 }
+const POLITICAS_AUTHOR_GATE = [
+    {
+        id: "escolhido_predestinado",
+        categoria: "cliche",
+        contratoTokens: [
+            "sem_cliche_escolhido_predestinado",
+            "cliche_escolhido_predestinado",
+            "aceitar_cliche_sem_justificativa",
+        ],
+        regex: /\b(escolhid[oa]|predestinad[oa]|profecia)\b/gi,
+        severidade: "alta",
+        motivo: "Destino abstrato substitui desejo, decisao e custo concreto.",
+        sugestao: "Troque destino abstrato por desejo, custo e conflito concreto.",
+        sugestaoReescrita: "Comece por uma escolha sob pressao, uma perda concreta ou um prazo que force o personagem a agir.",
+    },
+    {
+        id: "dialogo_resumo",
+        categoria: "dialogo",
+        contratoTokens: [
+            "sem_dialogo_resumo",
+            "dialogo_resumo",
+            "dialogo_expositivo",
+            "aceitar_dialogo_expositivo",
+        ],
+        regex: /\b(como voce sabe|deixe-me explicar|resumindo|em outras palavras)\b/gi,
+        severidade: "media",
+        motivo: "Dialogo explica informacao para o leitor em vez de criar atrito entre personagens.",
+        sugestao: "Transforme explicacao em atrito, subtexto ou acao observavel.",
+        sugestaoReescrita: "Troque a explicacao direta por uma acusacao, hesitacao, pergunta hostil ou gesto que revele a informacao.",
+    },
+    {
+        id: "frase_de_efeito_vazia",
+        categoria: "promessa_narrativa",
+        contratoTokens: [
+            "sem_frase_de_efeito_vazia",
+            "frase_de_efeito_vazia",
+            "validar_promessa_narrativa",
+        ],
+        regex: /\b(o destino nos chama|a esperanca e tudo|o tempo dira|no fim tudo ficara bem)\b/gi,
+        severidade: "media",
+        motivo: "Frase pronta promete emocao sem consequencia especifica de cena.",
+        sugestao: "Substitua frase pronta por consequencia especifica da cena.",
+        sugestaoReescrita: "Ancore a frase em objeto, dano, promessa quebrada ou consequencia verificavel.",
+    },
+    {
+        id: "voz_generica_de_ia",
+        categoria: "voz",
+        contratoTokens: [
+            "sem_voz_generica_de_ia",
+            "voz_generica_de_ia",
+            "aceitar_voz_generica_de_ia",
+            "politica_estilo_por_autor",
+        ],
+        regex: /\b(uma jornada de autodescoberta|emocionante e envolvente|profundamente humano|historia cativante)\b/gi,
+        severidade: "alta",
+        motivo: "Rotulo editorial descreve qualidade pretendida em vez de produzir experiencia narrativa.",
+        sugestao: "Corte rotulo editorial e mostre textura, decisao e perda.",
+        sugestaoReescrita: "Mostre uma imagem concreta, uma decisao desconfortavel ou uma perda que carregue o tom.",
+    },
+    {
+        id: "moralizacao_barata",
+        categoria: "tom",
+        contratoTokens: [
+            "sem_moralizacao_barata",
+            "moralizacao_barata",
+            "score_coerencia_tonal",
+        ],
+        regex: /\b(licao importante|todos aprenderam|moral da historia|o bem sempre vence)\b/gi,
+        severidade: "media",
+        motivo: "Conclusao moralizante entrega a interpretacao pronta e reduz ambiguidade.",
+        sugestao: "Deixe a consequencia moral emergir da acao, nao de sermoes.",
+        sugestaoReescrita: "Troque a licao declarada por uma consequencia que obrigue o leitor a inferir o custo moral.",
+    },
+    {
+        id: "exposicao_sem_conflito",
+        categoria: "conflito",
+        contratoTokens: [
+            "sem_exposicao_sem_conflito",
+            "exposicao_sem_conflito",
+            "validar_promessa_narrativa",
+        ],
+        regex: /\b(ele explicou tudo|ela contou toda a verdade|a historia era simples)\b/gi,
+        severidade: "media",
+        motivo: "Exposicao resolve informacao sem resistencia, suspeita ou conflito.",
+        sugestao: "Divida informacao em conflito, suspeita, erro ou descoberta.",
+        sugestaoReescrita: "Quebre a informacao em revelacao parcial, mal-entendido, mentira util ou descoberta com preco.",
+    },
+];
+function contarOcorrencias(regex, texto) {
+    const flags = regex.flags.includes("g") ? regex.flags : `${regex.flags}g`;
+    return Array.from(texto.matchAll(new RegExp(regex.source, flags))).length;
+}
+function posicaoLinhaColunaAuthor(texto, indice) {
+    const antes = texto.slice(0, Math.max(0, indice));
+    const linhas = antes.split(/\r?\n/);
+    return {
+        linha: linhas.length,
+        coluna: (linhas.at(-1)?.length ?? 0) + 1,
+    };
+}
+function recortarContextoAuthor(texto, inicio, fim, margem = 70) {
+    const alvoInicio = Math.max(0, inicio - margem);
+    const alvoFim = Math.min(texto.length, fim + margem);
+    const recorte = texto.slice(alvoInicio, alvoFim).replace(/\s+/g, " ").trim();
+    const prefixo = alvoInicio > 0 ? "... " : "";
+    const sufixo = alvoFim < texto.length ? " ..." : "";
+    return `${prefixo}${recorte}${sufixo}`.trim();
+}
+function localizarTrechosRegexAuthor(regex, texto, motivo, sugestao, limite = 5) {
+    const flags = regex.flags.includes("g") ? regex.flags : `${regex.flags}g`;
+    const local = new RegExp(regex.source, flags);
+    const trechos = [];
+    const vistos = new Set();
+    for (const match of texto.matchAll(local)) {
+        const raw = match[0] ?? "";
+        const inicio = match.index ?? -1;
+        if (!raw || inicio < 0)
+            continue;
+        const fim = inicio + raw.length;
+        const { linha, coluna } = posicaoLinhaColunaAuthor(texto, inicio);
+        const chave = `${linha}:${coluna}:${raw.toLowerCase()}`;
+        if (vistos.has(chave))
+            continue;
+        vistos.add(chave);
+        trechos.push({
+            texto: recortarContextoAuthor(texto, inicio, fim),
+            linha,
+            coluna,
+            inicio,
+            fim,
+            motivo,
+            sugestao,
+        });
+        if (trechos.length >= limite)
+            break;
+    }
+    return trechos;
+}
+function localizarTrechosPorEvidenciasAuthor(texto, evidencias, motivo, sugestao) {
+    const trechos = [];
+    const vistos = new Set();
+    for (const evidencia of evidencias.filter(Boolean)) {
+        const regex = regexFraseAuthor(evidencia);
+        for (const trecho of localizarTrechosRegexAuthor(regex, texto, motivo, sugestao, 3)) {
+            const chave = `${trecho.linha}:${trecho.coluna}:${trecho.texto}`;
+            if (vistos.has(chave))
+                continue;
+            vistos.add(chave);
+            trechos.push(trecho);
+            if (trechos.length >= 5)
+                return trechos;
+        }
+    }
+    return trechos;
+}
+function criarTrechoContextualAuthor(texto, motivo, sugestao) {
+    const match = texto.match(/\S[\s\S]{0,180}/);
+    if (!match || match.index === undefined)
+        return [];
+    const inicio = match.index;
+    const fim = inicio + match[0].length;
+    const { linha, coluna } = posicaoLinhaColunaAuthor(texto, inicio);
+    return [{
+            texto: recortarContextoAuthor(texto, inicio, fim, 0),
+            linha,
+            coluna,
+            inicio,
+            fim,
+            motivo,
+            sugestao,
+        }];
+}
+function normalizarTextoAuthor(texto) {
+    return texto
+        .normalize("NFD")
+        .replace(/[\u0300-\u036f]/g, "")
+        .toLowerCase();
+}
+function extrairTokensContratoAuthor(conteudo) {
+    const tokens = new Set();
+    for (const match of conteudo.matchAll(/\b[A-Za-z_][A-Za-z0-9_.-]*\b/g)) {
+        tokens.add(match[0]);
+    }
+    return tokens;
+}
+function politicaAuthorAtiva(politica, tokensContrato) {
+    return [
+        politica.id,
+        `sem_${politica.id}`,
+        `validar_${politica.id}`,
+        `aceitar_${politica.id}`,
+        ...politica.contratoTokens,
+    ].some((token) => tokensContrato.has(token));
+}
+function regexFraseAuthor(frase) {
+    const escapada = frase
+        .trim()
+        .replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
+        .replace(/\s+/g, "\\s+");
+    return new RegExp(`\\b${escapada}\\b`, "gi");
+}
+function slugParaTextoAuthor(slug) {
+    return slug.replace(/_/g, " ").trim();
+}
+function riscoAuthorPorSeveridade(severidade) {
+    return severidade === "alta" ? "alto" : severidade === "media" ? "medio" : "baixo";
+}
+function severidadeAuthorPadrao(severidade, categoria) {
+    if (categoria === "tema_sensivel")
+        return "critical";
+    if (severidade === "alta")
+        return categoria === "proibicao_literal" ? "blocking" : "blocking";
+    if (severidade === "media")
+        return "warning";
+    return "info";
+}
+function normalizarIdAuthor(valor) {
+    return normalizarTextoAuthor(valor)
+        .replace(/[^a-z0-9]+/g, "_")
+        .replace(/^_+|_+$/g, "");
+}
+function removerComentarioSema(linha) {
+    return linha
+        .replace(/\/\/.*$/g, "")
+        .replace(/#.*$/g, "")
+        .trim();
+}
+function extrairLinhasForbiddenAuthor(conteudo) {
+    const linhas = [];
+    for (const bloco of conteudo.matchAll(/forbidden\s*\{([\s\S]*?)\}/gi)) {
+        for (const linha of bloco[1].split(/\r?\n/)) {
+            const limpa = removerComentarioSema(linha);
+            if (!limpa || limpa === "}")
+                continue;
+            linhas.push(limpa);
+        }
+    }
+    return linhas;
+}
+function extrairFrasesProibidasAuthor(conteudo) {
+    const frases = [];
+    const regex = /\b(?:avoid|evitar|proibir|proibido|proibida|banir|banido|banida|nao_usar|nao usar)\s*["'`](.+?)["'`]/gi;
+    for (const match of conteudo.matchAll(regex)) {
+        const frase = match[1]?.trim();
+        if (frase)
+            frases.push(frase);
+    }
+    return frases;
+}
+function politicaCatalogoConhecidaAuthor(token) {
+    const chave = normalizarIdAuthor(token.replace(/^(sem|validar|aceitar)_/, ""));
+    return POLITICAS_AUTHOR_GATE.some((politica) => (politica.id === token
+        || politica.id === chave
+        || politica.contratoTokens.includes(token)
+        || politica.contratoTokens.includes(chave)));
+}
+function textoProibicaoLiteralAuthor(valor) {
+    const bruto = valor.trim().replace(/^["'`]|["'`]$/g, "").trim();
+    if (!bruto)
+        return null;
+    if (/\s/.test(bruto))
+        return bruto.replace(/\s+/g, " ");
+    const dinamica = bruto.match(/^(?:frase|palavra|termo)_(?:banida|banido|proibida|proibido)_(.+)$/);
+    if (dinamica)
+        return slugParaTextoAuthor(dinamica[1]);
+    const explicita = bruto.match(/^(?:proibido|proibida|banido|banida|nao_usar|evitar|sem)_(.+)$/);
+    if (explicita && !politicaCatalogoConhecidaAuthor(explicita[1])) {
+        return slugParaTextoAuthor(explicita[1]);
+    }
+    if (politicaCatalogoConhecidaAuthor(bruto))
+        return null;
+    if (/^(aceitar|gerar|publicar|obra|fontes|estilo|voz|dialogo|cliche|exposicao|moralizacao|score|tratar|ignorar|aprovar|validar|contrato|texto|diagnostico|author|revisor|sensitivity|proibicao)_/.test(bruto)) {
+        return null;
+    }
+    if (!bruto.includes("_"))
+        return null;
+    return slugParaTextoAuthor(bruto);
+}
+function politicasProibicoesLiteraisAuthor(conteudo, ir) {
+    const tarefas = ir?.tasks ?? [];
+    const superficies = ir?.superficies ?? [];
+    const declaradas = [
+        ...tarefas.flatMap((task) => task.forbidden.regras),
+        ...superficies.flatMap((superficie) => superficie.forbidden.regras),
+        ...extrairLinhasForbiddenAuthor(conteudo),
+        ...extrairFrasesProibidasAuthor(conteudo),
+    ];
+    const politicas = [];
+    const vistos = new Set();
+    for (const declarada of declaradas) {
+        const texto = textoProibicaoLiteralAuthor(declarada);
+        if (!texto)
+            continue;
+        const idBase = normalizarIdAuthor(texto);
+        if (!idBase || vistos.has(idBase))
+            continue;
+        vistos.add(idBase);
+        politicas.push({
+            id: `proibicao_literal_author_${idBase}`,
+            categoria: "proibicao_literal",
+            contratoTokens: [declarada],
+            regex: regexFraseAuthor(texto),
+            severidade: "alta",
+            motivo: `O texto usa uma proibicao literal declarada no contrato Author: "${texto}".`,
+            sugestao: `Remova "${texto}" ou edite o contrato antes de manter esse elemento narrativo.`,
+            sugestaoReescrita: `Troque "${texto}" por um evento, objeto ou relacao permitida pelo contrato atual.`,
+        });
+    }
+    return politicas;
+}
+function politicasDinamicasContratoAuthor(tokensContrato) {
+    const politicas = [];
+    for (const token of tokensContrato) {
+        const match = token.match(/^(frase|palavra|termo)_(?:banida|banido|proibida|proibido)_(.+)$/);
+        if (!match) {
+            continue;
+        }
+        const [, tipo, slug] = match;
+        const texto = slugParaTextoAuthor(slug);
+        const regex = tipo === "palavra"
+            ? new RegExp(`\\b${texto.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`, "gi")
+            : regexFraseAuthor(texto);
+        politicas.push({
+            id: token,
+            categoria: tipo === "palavra" ? "palavra_generica" : "frase_generica",
+            contratoTokens: [token],
+            regex,
+            severidade: "alta",
+            motivo: `Termo proibido pelo contrato Author: "${texto}".`,
+            sugestao: `Remova "${texto}" ou justifique com detalhe concreto de cena.`,
+            sugestaoReescrita: `Substitua "${texto}" por uma imagem, decisao ou consequencia especifica da obra.`,
+        });
+    }
+    return politicas;
+}
+function criarAchadoAuthor(politica, textoFonte, origem) {
+    const trechos = localizarTrechosRegexAuthor(politica.regex, textoFonte, politica.motivo, politica.sugestaoReescrita);
+    const ocorrencias = contarOcorrencias(politica.regex, textoFonte);
+    if (ocorrencias <= 0) {
+        return null;
+    }
+    return {
+        id: politica.id,
+        categoria: politica.categoria,
+        severidade: politica.severidade,
+        severidadePadrao: severidadeAuthorPadrao(politica.severidade, politica.categoria),
+        ocorrencias,
+        risco: riscoAuthorPorSeveridade(politica.severidade),
+        motivo: politica.motivo,
+        sugestao: politica.sugestao,
+        sugestaoReescrita: politica.sugestaoReescrita,
+        origem,
+        bloqueante: politica.severidade === "alta" || politica.categoria !== "observacao",
+        trechos,
+        evidencias: trechos.map((trecho) => trecho.texto),
+    };
+}
+function contarPalavrasAuthor(textoNormalizado, palavras) {
+    return palavras.reduce((total, palavra) => {
+        const regex = new RegExp(`\\b${palavra}\\b`, "g");
+        return total + Array.from(textoNormalizado.matchAll(regex)).length;
+    }, 0);
+}
+function criarAchadoHeuristicoAuthor(id, categoria, severidade, ocorrencias, sugestao, evidencias = [], textoFonte = "", motivo = sugestao, sugestaoReescrita = sugestao) {
+    if (ocorrencias <= 0) {
+        return null;
+    }
+    const trechos = textoFonte
+        ? localizarTrechosPorEvidenciasAuthor(textoFonte, evidencias, motivo, sugestaoReescrita)
+        : [];
+    return {
+        id,
+        categoria,
+        severidade,
+        severidadePadrao: severidadeAuthorPadrao(severidade, categoria),
+        ocorrencias,
+        risco: riscoAuthorPorSeveridade(severidade),
+        motivo,
+        sugestao,
+        sugestaoReescrita,
+        origem: "heuristica",
+        bloqueante: true,
+        trechos: trechos.length > 0 ? trechos : (textoFonte ? criarTrechoContextualAuthor(textoFonte, motivo, sugestaoReescrita) : []),
+        evidencias,
+    };
+}
+function contratoAutorizaTemaSensivel(conteudoContrato) {
+    return /sensitivity_reviewer|validar_tema_sensivel|PublicoAuthor[\s\S]*SENSIVEL|PublicoSensivel/i.test(conteudoContrato);
+}
+function avaliarHeuristicasNarrativasAuthor(textoFonte, conteudoContrato, tokensContrato) {
+    const normalizado = normalizarTextoAuthor(textoFonte);
+    const achados = [];
+    const gateAtivo = (token) => tokensContrato.has(token) || tokensContrato.has(`validar_${token}`) || tokensContrato.has(`sem_${token}`);
+    if (gateAtivo("palavra_generica_sem_concreto") || tokensContrato.has("score_coerencia_tonal")) {
+        const genericas = ["algo", "coisa", "muito", "incrivel", "especial", "importante", "profundo", "intenso", "cativante", "emocionante"];
+        const ocorrencias = contarPalavrasAuthor(normalizado, genericas);
+        achados.push(criarAchadoHeuristicoAuthor("palavra_generica_sem_concreto", "palavra_generica", ocorrencias >= 4 ? "alta" : "media", ocorrencias >= 3 ? ocorrencias : 0, "Troque adjetivo abstrato por imagem, acao, escolha ou custo observavel.", genericas.filter((palavra) => new RegExp(`\\b${palavra}\\b`).test(normalizado)), textoFonte, "Palavra generica aparece sem ancoragem concreta suficiente.", "Substitua por imagem fisica, acao especifica, escolha ou custo observavel."));
+    }
+    if (gateAtivo("arco_emocional_sem_mudanca")) {
+        const temMarcadorMudanca = /\b(passou de|deixou de|percebeu|decidiu|renunciou|custou|perdeu|escolheu|mudou|foi obrigado|teve que)\b/i.test(normalizado);
+        achados.push(criarAchadoHeuristicoAuthor("arco_emocional_sem_mudanca", "arco_emocional", "alta", textoFonte.trim().length > 120 && !temMarcadorMudanca ? 1 : 0, "Declare a mudanca emocional da cena: estado inicial, pressao, decisao e custo.", [], textoFonte, "Texto longo nao mostra mudanca emocional rastreavel.", "Mostre estado inicial, pressao, decisao e custo emocional em uma sequencia concreta."));
+    }
+    if (gateAtivo("personagem_sem_memoria")) {
+        const temNome = /\b[A-Z][a-z]{2,}\b/.test(textoFonte);
+        const temEstado = /\b(quer|teme|esconde|prometeu|lembra|culpa|ferida|objetivo|segredo)\b/i.test(normalizado);
+        achados.push(criarAchadoHeuristicoAuthor("personagem_sem_memoria", "memoria_personagem", "alta", !temNome || !temEstado ? 1 : 0, "Amarre personagem a memoria persistente: desejo, medo, segredo, ferida ou promessa ja declarada.", [], textoFonte, "Personagem aparece sem memoria operacional suficiente para guiar continuidade.", "Declare desejo, medo, segredo, ferida ou promessa que possa ser reutilizada depois."));
+    }
+    if (gateAtivo("promessa_narrativa_quebrada")) {
+        const temPromessa = /\b(promessa|prometeu|proteger|objetivo|misterio|conflito|pergunta|ameaca|custo)\b/i.test(normalizado);
+        const resolveSemCusto = /\b(no fim tudo ficara bem|de repente tudo se resolveu|por sorte)\b/i.test(normalizado);
+        achados.push(criarAchadoHeuristicoAuthor("promessa_narrativa_quebrada", "promessa_narrativa", resolveSemCusto ? "alta" : "media", resolveSemCusto || !temPromessa ? 1 : 0, "Toda promessa narrativa precisa de pergunta, tensao, consequencia e validacao antes de ser resolvida.", resolveSemCusto ? ["no fim tudo ficara bem", "de repente tudo se resolveu", "por sorte"].filter((termo) => normalizado.includes(termo)) : [], textoFonte, resolveSemCusto ? "Resolucao sem custo enfraquece a promessa narrativa." : "Texto nao explicita promessa, pergunta, ameaca ou custo narrativo.", "Amarre a promessa a pergunta, tensao, consequencia e validacao antes de resolver."));
+    }
+    if (gateAtivo("impacto_capitulo_nao_mapeado")) {
+        const mudancaCanonica = /\b(morreu|matou|traiu|revelou|destruiu|rompeu|desapareceu|casou|venceu|perdeu)\b/i.test(normalizado);
+        const temConsequencia = /\b(por isso|como consequencia|afetou|obriga|altera|muda|impacta|no capitulo seguinte)\b/i.test(normalizado);
+        achados.push(criarAchadoHeuristicoAuthor("impacto_capitulo_nao_mapeado", "impact_map", "alta", mudancaCanonica && !temConsequencia ? 1 : 0, "Mudanca canonica precisa de impact map entre capitulos, relacoes, promessas e cenas futuras.", [], textoFonte, "Mudanca canonica aparece sem consequencia mapeada para continuidade.", "Declare quem muda, que promessa quebra e qual cena futura fica obrigada a responder."));
+    }
+    if (gateAtivo("tema_sensivel_sem_autorizacao")) {
+        const termosSensiveis = ["suicidio", "abuso", "luto", "trauma", "violencia sexual", "automutilacao", "racismo"];
+        const ocorrencias = termosSensiveis.filter((termo) => normalizado.includes(termo)).length;
+        achados.push(criarAchadoHeuristicoAuthor("tema_sensivel_sem_autorizacao", "tema_sensivel", "alta", ocorrencias > 0 && !contratoAutorizaTemaSensivel(conteudoContrato) ? ocorrencias : 0, "Tema sensivel so pode entrar quando publico, fontes, limites e sensitivity reviewer estiverem contratados.", termosSensiveis.filter((termo) => normalizado.includes(termo)), textoFonte, "Tema sensivel detectado sem autorizacao explicita no contrato Author.", "Declare publico, limites, fontes e sensitivity reviewer antes de manter esse tema."));
+    }
+    if (gateAtivo("rpg_campanha_sem_estado")) {
+        const mencionaCampanha = /\b(campanha|sessao|npc|jogador|party|mestre|dado|quest)\b/i.test(normalizado);
+        const temEstadoCampanha = /\b(estado|inventario|local|missao|relacao|faccao|reputacao|checkpoint)\b/i.test(normalizado);
+        achados.push(criarAchadoHeuristicoAuthor("rpg_campanha_sem_estado", "campanha_persistente", "media", mencionaCampanha && !temEstadoCampanha ? 1 : 0, "Modo RPG/campanha precisa preservar estado: local, inventario, relacoes, faccoes, missao e consequencias.", ["campanha", "sessao", "npc", "jogador", "party", "mestre", "dado", "quest"].filter((termo) => normalizado.includes(termo)), textoFonte, "Campanha/RPG foi mencionado sem estado persistente suficiente.", "Inclua local, inventario, relacoes, faccao, missao, checkpoint ou consequencia persistente."));
+    }
+    return achados.filter((achado) => achado !== null);
+}
+function extrairIrNarrativoAuthor(texto) {
+    const normalizado = normalizarTextoAuthor(texto);
+    const personagens = unicosOrdenados(Array.from(texto.matchAll(/\b[A-Z][a-z]{2,}\b/g))
+        .map((match) => match[0])
+        .filter((nome) => !["O", "A", "Os", "As", "Um", "Uma", "Por", "Para", "Isso", "Como"].includes(nome))).slice(0, 12);
+    const capitulos = unicosOrdenados(Array.from(normalizado.matchAll(/\b(?:capitulo|sessao)\s+([a-z0-9_-]+)/g)).map((match) => match[0])).slice(0, 12);
+    const eventos = unicosOrdenados(Array.from(normalizado.matchAll(/\b(morreu|matou|traiu|revelou|decidiu|perdeu|venceu|rompeu|descobriu|prometeu)\b/g)).map((match) => match[0])).slice(0, 12);
+    const temasSensiveis = ["suicidio", "abuso", "luto", "trauma", "violencia sexual", "automutilacao", "racismo"]
+        .filter((termo) => normalizado.includes(termo));
+    const modoCampanha = /\b(campanha|sessao|npc|jogador|party|mestre|quest)\b/i.test(normalizado);
+    return { personagens, capitulos, eventos, temasSensiveis, modoCampanha };
+}
+function compararDiffSemanticoAuthor(textoAnterior, textoAtual) {
+    if (!textoAnterior) {
+        return {
+            disponivel: false,
+            personagensAdicionados: [],
+            personagensRemovidos: [],
+            eventosAdicionados: [],
+            eventosRemovidos: [],
+            riscoDrift: "baixo",
+        };
+    }
+    const anterior = extrairIrNarrativoAuthor(textoAnterior);
+    const atual = extrairIrNarrativoAuthor(textoAtual);
+    const adicionados = (atuais, antigos) => atuais.filter((item) => !antigos.includes(item));
+    const removidos = (antigos, atuais) => antigos.filter((item) => !atuais.includes(item));
+    const personagensAdicionados = adicionados(atual.personagens, anterior.personagens);
+    const personagensRemovidos = removidos(anterior.personagens, atual.personagens);
+    const eventosAdicionados = adicionados(atual.eventos, anterior.eventos);
+    const eventosRemovidos = removidos(anterior.eventos, atual.eventos);
+    const mudancas = personagensAdicionados.length + personagensRemovidos.length + eventosAdicionados.length + eventosRemovidos.length;
+    return {
+        disponivel: true,
+        personagensAdicionados,
+        personagensRemovidos,
+        eventosAdicionados,
+        eventosRemovidos,
+        riscoDrift: mudancas >= 5 ? "alto" : mudancas >= 2 ? "medio" : "baixo",
+    };
+}
+function calcularScoreAuthor(achados, categorias) {
+    const relevantes = categorias ? achados.filter((achado) => categorias.includes(achado.categoria)) : achados;
+    const penalidade = relevantes.reduce((total, achado) => {
+        const peso = achado.severidade === "alta" ? 30 : achado.severidade === "media" ? 15 : 5;
+        return total + (peso * Math.max(1, achado.ocorrencias));
+    }, 0);
+    return Math.max(0, 100 - penalidade);
+}
+function calcularScoreRiscoAuthor(achados, contratoValido) {
+    const risco = achados.reduce((total, achado) => {
+        const peso = achado.severidade === "alta" ? 35 : achado.severidade === "media" ? 18 : 6;
+        return total + (peso * Math.max(1, achado.ocorrencias));
+    }, contratoValido ? 0 : 40);
+    return Math.min(100, risco);
+}
+function montarImpactMapAuthor(achados) {
+    const camadasPorCategoria = {
+        arco_emocional: ["personagem", "cena", "capitulo"],
+        campanha_persistente: ["campanha", "sessao", "estado"],
+        cliche: ["premissa", "personagem", "promessa"],
+        conflito: ["cena", "informacao", "ritmo"],
+        dialogo: ["dialogo", "subtexto", "exposicao"],
+        frase_generica: ["estilo", "voz", "promessa"],
+        impact_map: ["capitulo", "continuidade", "cenas futuras"],
+        memoria_personagem: ["personagem", "relacoes", "canon"],
+        palavra_generica: ["estilo", "imagem", "voz"],
+        proibicao_literal: ["contrato", "texto", "guardrail"],
+        promessa_narrativa: ["promessa", "resolucao", "expectativa"],
+        tema_sensivel: ["publico", "fontes", "limites"],
+        tom: ["tom", "publico", "estilo"],
+        voz: ["voz", "estilo", "autor"],
+    };
+    return achados.map((achado) => ({
+        alvo: achado.id,
+        camadas: camadasPorCategoria[achado.categoria] ?? ["texto"],
+        motivo: achado.sugestao,
+    }));
+}
+function extrairGuardrailsAuthor(conteudo, ir) {
+    const tarefas = ir?.tasks ?? [];
+    const superficies = ir?.superficies ?? [];
+    const linhasMarcadas = conteudo
+        .split(/\r?\n/)
+        .map((linha) => linha.trim())
+        .filter((linha) => /(cliche|proibid|forbidden|sensivel|publico|fonte|estilo|voz|dialogo|conflito|atrito|dano|limite)/i.test(linha));
+    return limitarLista(unicosOrdenados([
+        ...tarefas.flatMap((task) => task.rules),
+        ...tarefas.flatMap((task) => task.guarantees),
+        ...tarefas.flatMap((task) => task.forbidden.regras),
+        ...superficies.flatMap((superficie) => superficie.forbidden.regras),
+        ...linhasMarcadas,
+    ]), 18);
+}
+function extrairProibicoesAuthor(ir, conteudo) {
+    const tarefas = ir?.tasks ?? [];
+    const superficies = ir?.superficies ?? [];
+    const proibicoesDeclaradas = [
+        ...tarefas.flatMap((task) => task.forbidden.regras),
+        ...superficies.flatMap((superficie) => superficie.forbidden.regras),
+    ];
+    const proibicoesLiterais = politicasProibicoesLiteraisAuthor(conteudo, ir)
+        .map((politica) => slugParaTextoAuthor(politica.id.replace(/^proibicao_literal_author_/, "")));
+    const proibicoesTextuais = conteudo
+        .split(/\r?\n/)
+        .map((linha) => linha.trim())
+        .filter((linha) => /^(aceitar_|gerar_|publicar_|obra_|fontes_|estilo_|voz_|dialogo_|cliche_|exposicao_|moralizacao_)/.test(linha));
+    return limitarLista(unicosOrdenados([...proibicoesDeclaradas, ...proibicoesTextuais, ...proibicoesLiterais]), 16);
+}
+const REQUISITOS_PROFILE = {
+    software: [
+        { id: "contrato_antes_codigo", descricao: "declara contrato antes de codigo vivo", termos: [/contrato/i, /codigo|implementacao|vivo/i], obrigatorio: true },
+        { id: "drift_e_impacto", descricao: "exige drift e mapa de impacto antes de editar", termos: [/drift/i, /impacto|impact map|mapa/i], obrigatorio: true },
+        { id: "vinculos_rastreaveis", descricao: "mantem vinculos rastreaveis entre contrato e implementacao", termos: [/vinculos?|impl/i, /arquivo|simbolo/i], obrigatorio: true },
+        { id: "checks_de_fechamento", descricao: "declara validacao, testes e verificacao de fechamento", termos: [/validar|verificar/i, /testes?|checks?/i], obrigatorio: true },
+    ],
+    workflow: [
+        { id: "runtime_como_alvo", descricao: "trata workflow runtime como alvo de compatibilidade", termos: [/runtime|workflow|orquestracao/i, /compatibilidade|scorecard/i], obrigatorio: true },
+        { id: "adapter_honesto", descricao: "declara adapter sem fingir paridade total", termos: [/adapter|adaptado|n8n/i, /parcial|invalido|equivalencia/i], obrigatorio: true },
+        { id: "superficies_nativas", descricao: "mapeia webhook, cron, HTTP e branching", termos: [/webhook/i, /cron/i, /http|branching|transformacao/i], obrigatorio: true },
+        { id: "lacunas_operacionais", descricao: "marca lacunas de authz, dados, audit, compensacao e guarantees", termos: [/authz|autorizacao/i, /audit|auditoria/i, /compensacao|guarantees/i], obrigatorio: true },
+    ],
+    ops: [
+        { id: "runbook_e_rollback", descricao: "exige runbook, rollback e criterio de recuperacao", termos: [/runbook/i, /rollback|recuperacao/i], obrigatorio: true },
+        { id: "observabilidade", descricao: "declara healthcheck, metricas, logs ou traces", termos: [/healthcheck|metricas|logs?|traces?|observabilidade/i], obrigatorio: true },
+        { id: "incidente_e_oncall", descricao: "modela incidente, severidade e responsavel operacional", termos: [/incidente|severidade/i, /responsavel|oncall|operador/i], obrigatorio: true },
+        { id: "segredos_e_acesso", descricao: "trata segredos e acesso como superficie operacional", termos: [/segredos?|secret/i, /authz|acesso|permissao/i], obrigatorio: true },
+    ],
+    game: [
+        { id: "loop_jogavel", descricao: "declara loop jogavel e objetivo do jogador", termos: [/loop/i, /jogador|player/i], obrigatorio: true },
+        { id: "estado_e_regras", descricao: "declara estado, regras e transicoes de jogo", termos: [/estado|state/i, /regras?|transitions?|transicoes/i], obrigatorio: true },
+        { id: "falha_balanceamento", descricao: "modela falha, balanceamento e abuso", termos: [/falha|derrota|erro/i, /balanceamento|abuso|exploit/i], obrigatorio: true },
+        { id: "telemetria_jogo", descricao: "define telemetria ou replay de decisao", termos: [/telemetria|replay|metricas/i], obrigatorio: false },
+    ],
+    legal: [
+        { id: "jurisdicao_e_escopo", descricao: "declara jurisdicao, escopo e limite de uso", termos: [/jurisdicao/i, /escopo|limite/i], obrigatorio: true },
+        { id: "fontes_normativas", descricao: "exige fontes normativas ou base documental", termos: [/fonte|norma|lei|regulamento/i, /citacao|evidencia|documento/i], obrigatorio: true },
+        { id: "revisao_humana", descricao: "bloqueia parecer final sem revisao humana", termos: [/revisao_humana|humana|advogado|aprovador/i, /bloqueio|forbidden|proib/i], obrigatorio: true },
+        { id: "auditoria_legal", descricao: "registra auditoria e retencao de decisao", termos: [/audit|auditoria/i, /retencao|correlacao|motivo/i], obrigatorio: true },
+    ],
+    research: [
+        { id: "pergunta_metodo", descricao: "declara pergunta, metodo e criterio de evidencia", termos: [/pergunta|hipotese/i, /metodo|metodologia/i], obrigatorio: true },
+        { id: "fontes_e_citacoes", descricao: "exige fontes, citacoes e qualidade de evidencia", termos: [/fonte|citacao|referencia/i, /evidencia|confianca|qualidade/i], obrigatorio: true },
+        { id: "incerteza_e_limite", descricao: "declara incerteza, lacunas e limites da conclusao", termos: [/incerteza|lacuna|limite/i, /conclusao|afirmacao/i], obrigatorio: true },
+        { id: "reprodutibilidade", descricao: "preserva protocolo, dados e reproducibilidade", termos: [/protocolo|dataset|dados/i, /reprodut|replic/i], obrigatorio: false },
+    ],
+};
+const REQUISITOS_PROFILE_COMUNS = [
+    {
+        id: "contrato_antes_de_acao",
+        descricao: "exige criar, editar ou remover contrato antes de qualquer acao",
+        termos: [/contrato/i, /criar|editar|remover/i, /antes de qualquer acao|antes da acao|antes de agir|contrato primeiro/i],
+        obrigatorio: true,
+    },
+];
+const ALIASES_PROFILE = {
+    software: "software",
+    codigo: "software",
+    code: "software",
+    workflow: "workflow",
+    workflow_ops: "workflow",
+    workflows: "workflow",
+    n8n: "workflow",
+    automacao: "workflow",
+    orquestracao: "workflow",
+    ops: "ops",
+    operacao: "ops",
+    operacional: "ops",
+    devops: "ops",
+    game: "game",
+    jogo: "game",
+    games: "game",
+    legal: "legal",
+    juridico: "legal",
+    research: "research",
+    pesquisa: "research",
+};
+function normalizarProfileSemantico(valor) {
+    if (!valor) {
+        return null;
+    }
+    const chave = valor.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+    return ALIASES_PROFILE[chave] ?? null;
+}
+function normalizarMaturidadeProfile(valor) {
+    const chave = (valor ?? "production").toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+    if (chave === "draft" || chave === "rascunho")
+        return "draft";
+    if (chave === "prototype" || chave === "prototipo")
+        return "prototype";
+    if (chave === "critical" || chave === "critico" || chave === "critica")
+        return "critical";
+    return "production";
+}
+const PRESETS_PROFILE = {
+    software: ["api", "modulo", "refactor", "persistencia", "security"],
+    workflow: ["webhook", "fila", "n8n", "cron", "integracao"],
+    ops: ["deploy", "migration", "incidente", "rollback", "critical"],
+    legal: ["lgpd", "contrato", "dpa", "termos_uso", "privacidade", "due_diligence", "compliance"],
+    research: ["rapida", "tecnica", "decisoria", "critica"],
+    game: ["casual", "arcade", "rpg", "economia", "playtest"],
+};
+const REQUISITOS_PRESET_PROFILE = {
+    security: [
+        { id: "security_entrada_saida", descricao: "declara validacao de entrada e saida segura", termos: [/entrada|input/i, /saida|output|retorno/i, /segur|sanitiz|valid/i], obrigatorio: true, severidade: "blocking" },
+    ],
+    webhook: [
+        { id: "webhook_idempotencia", descricao: "webhook declara idempotencia e retry seguro", termos: [/webhook/i, /idempot/i, /retry|retent/i], obrigatorio: true, severidade: "blocking" },
+    ],
+    fila: [
+        { id: "fila_dlq", descricao: "fila declara erro, retentativa e fila morta", termos: [/fila|queue/i, /erro|falha/i, /dlq|dead.?letter|fila morta/i], obrigatorio: true, severidade: "blocking" },
+    ],
+    cron: [
+        { id: "cron_janela_execucao", descricao: "cron declara janela, concorrencia e reprocessamento", termos: [/cron|agenda/i, /janela|concorr/i, /reprocess|idempot/i], obrigatorio: true, severidade: "blocking" },
+    ],
+    deploy: [
+        { id: "deploy_healthcheck", descricao: "deploy declara healthcheck, rollback e validacao live", termos: [/deploy/i, /healthcheck|healthz/i, /rollback/i], obrigatorio: true, severidade: "blocking" },
+    ],
+    migration: [
+        { id: "migration_reversivel", descricao: "migration declara reversibilidade, backup e criterio de rollback", termos: [/migration|migracao/i, /revers|rollback/i, /backup|snapshot/i], obrigatorio: true, severidade: "critical" },
+    ],
+    incidente: [
+        { id: "incidente_severidade_comunicacao", descricao: "incidente declara severidade, comunicacao e dono", termos: [/incidente|sev/i, /comunic/i, /responsavel|dono/i], obrigatorio: true, severidade: "critical" },
+    ],
+    rollback: [
+        { id: "rollback_criterio_recuperacao", descricao: "rollback declara criterio objetivo de recuperacao", termos: [/rollback/i, /criterio|gatilho/i, /recuper/i], obrigatorio: true, severidade: "blocking" },
+    ],
+    lgpd: [
+        { id: "lgpd_matriz_dados", descricao: "LGPD declara dado, finalidade, base legal e retencao", termos: [/dado|titular/i, /finalidade/i, /base legal/i, /retencao|retenção/i], obrigatorio: true, severidade: "critical" },
+    ],
+    contrato: [
+        { id: "contrato_clausulas_nucleo", descricao: "contrato declara partes, objeto, obrigacoes e rescisao", termos: [/partes/i, /objeto/i, /obrigac|obrigaç/i, /rescis/i], obrigatorio: true, severidade: "blocking" },
+    ],
+    dpa: [
+        { id: "dpa_operador_controlador", descricao: "DPA declara controlador, operador, dados e subprocessadores", termos: [/controlador/i, /operador/i, /subprocess/i, /dados/i], obrigatorio: true, severidade: "critical" },
+    ],
+    termos_uso: [
+        { id: "termos_uso_limites", descricao: "termos de uso declaram uso permitido, proibicoes e limitacao", termos: [/uso permitido/i, /proibid|vedad/i, /limitacao|limitação/i], obrigatorio: true, severidade: "blocking" },
+    ],
+    privacidade: [
+        { id: "privacidade_dados_direitos", descricao: "privacidade declara dados, finalidade, direitos e contato", termos: [/dados/i, /finalidade/i, /direitos/i, /contato/i], obrigatorio: true, severidade: "blocking" },
+    ],
+    due_diligence: [
+        { id: "due_diligence_risco_evidencia", descricao: "due diligence declara risco, evidencia e pendencias", termos: [/risco/i, /evidencia|evidência/i, /pendenc|pendênc/i], obrigatorio: true, severidade: "blocking" },
+    ],
+    compliance: [
+        { id: "compliance_controle_auditoria", descricao: "compliance declara controles, auditoria e responsavel", termos: [/controle/i, /auditoria/i, /responsavel|responsável/i], obrigatorio: true, severidade: "blocking" },
+    ],
+    decisoria: [
+        { id: "research_matriz_decisao", descricao: "pesquisa decisoria declara criterio, peso e alternativa", termos: [/criterio|critério/i, /peso/i, /alternativa/i], obrigatorio: true, severidade: "blocking" },
+    ],
+    critica: [
+        { id: "research_contraditorio", descricao: "pesquisa critica tenta derrubar a propria conclusao", termos: [/contradit|contra.?evidencia|contra.?evidência/i, /hipotese|hipótese|conclusao|conclusão/i], obrigatorio: true, severidade: "blocking" },
+    ],
+    playtest: [
+        { id: "game_playtest_temporal", descricao: "playtest declara primeiros segundos, primeiro minuto e tensao", termos: [/primeiros? 10 segundos|10s/i, /1 minuto|um minuto/i, /tensao|tensão/i], obrigatorio: true, severidade: "blocking" },
+    ],
+    economia: [
+        { id: "game_economia_balanceada", descricao: "economia declara moeda, fonte, gasto e exploit", termos: [/moeda|economia/i, /fonte/i, /gasto|sink/i, /exploit/i], obrigatorio: true, severidade: "blocking" },
+    ],
+};
+function normalizarPresetProfile(profile, valor) {
+    if (!valor)
+        return null;
+    const chave = valor.toLowerCase().normalize("NFD").replace(/[\u0300-\u036f]/g, "").replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+    const alias = {
+        privacidade: "privacidade",
+        privacy: "privacidade",
+        termos: "termos_uso",
+        termos_de_uso: "termos_uso",
+        due: "due_diligence",
+        diligence: "due_diligence",
+        pesquisa_rapida: "rapida",
+        pesquisa_tecnica: "tecnica",
+        pesquisa_decisoria: "decisoria",
+        pesquisa_critica: "critica",
+        critico: "critical",
+        critica_ops: "critical",
+        modulo_codigo: "modulo",
+        seguranca: "security",
+        seguranca_codigo: "security",
+    };
+    const preset = alias[chave] ?? chave;
+    return PRESETS_PROFILE[profile].includes(preset) ? preset : null;
+}
+function moduloCombinaComProfile(modulo, caminho, profile) {
+    const alvo = `${modulo ?? ""} ${caminho}`.toLowerCase();
+    if (profile === "workflow") {
+        return /workflow|n8n|orquestracao/.test(alvo);
+    }
+    return alvo.includes(profile);
+}
+function severidadeRequisitoProfile(requisito, profile, maturidade) {
+    if (requisito.severidade)
+        return requisito.severidade;
+    if (!requisito.obrigatorio)
+        return "warning";
+    if (maturidade === "critical")
+        return "critical";
+    if ((profile === "legal" && /revisao|jurisdicao|fontes|auditoria/i.test(requisito.id)) ||
+        (profile === "ops" && /runbook|rollback|segredos|incidente/i.test(requisito.id))) {
+        return "critical";
+    }
+    return maturidade === "draft" ? "warning" : "blocking";
+}
+function avaliarRequisitosProfile(conteudo, requisitos, profile, maturidade, fonte = "contrato") {
+    return requisitos.map((requisito) => ({
+        id: requisito.id,
+        descricao: requisito.descricao,
+        obrigatorio: requisito.obrigatorio,
+        atendido: requisito.termos.every((termo) => termo.test(conteudo)),
+        severidade: severidadeRequisitoProfile(requisito, profile, maturidade),
+        termos: requisito.termos.map((termo) => termo.source),
+        fonte,
+    }));
+}
+function decidirAcaoAgenteProfile(contratoValido, achados) {
+    if (!contratoValido)
+        return "parar";
+    const pendentes = achados.filter((achado) => !achado.atendido);
+    if (pendentes.some((achado) => achado.severidade === "critical"))
+        return "chamar_humano";
+    if (pendentes.some((achado) => achado.severidade === "blocking"))
+        return "parar";
+    if (pendentes.some((achado) => achado.severidade === "warning"))
+        return "continuar_com_ressalva";
+    return "continuar";
+}
+function calcularScoreProfile(contratoValido, achados) {
+    const pendentesObrigatorios = achados.filter((achado) => achado.obrigatorio && !achado.atendido).length;
+    const pendentesRecomendados = achados.filter((achado) => !achado.obrigatorio && !achado.atendido).length;
+    return Math.max(0, 100 - (contratoValido ? 0 : 40) - pendentesObrigatorios * 20 - pendentesRecomendados * 8);
+}
+function penalidadeAchadoProfile(achado) {
+    if (achado.atendido)
+        return 0;
+    if (achado.severidade === "critical")
+        return 40;
+    if (achado.severidade === "blocking")
+        return 25;
+    if (achado.severidade === "warning")
+        return 10;
+    return 0;
+}
+function calcularScoreAchadosProfile(base, achados) {
+    return Math.max(0, base - achados.reduce((total, achado) => total + penalidadeAchadoProfile(achado), 0));
+}
+function contratoProibeTermoProfile(contrato, termo) {
+    const escaped = termo.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const padroes = [
+        new RegExp(`(forbidden|proibid|vedad|nao usar|não usar|sem)\\s+[^\\n]{0,80}${escaped}`, "i"),
+        new RegExp(`${escaped}[^\\n]{0,80}(forbidden|proibid|vedad|nao permitido|não permitido|nao usar|não usar)`, "i"),
+    ];
+    return padroes.some((padrao) => padrao.test(contrato));
+}
+function criarAchadoArtefatoProfile(id, descricao, atendido, severidade, trecho, sugestao, motivo) {
+    return {
+        id,
+        descricao,
+        obrigatorio: severidade === "blocking" || severidade === "critical",
+        atendido,
+        severidade,
+        termos: [],
+        fonte: "artefato",
+        trecho,
+        motivo,
+        sugestao,
+    };
+}
+function trechoRegexProfile(texto, regex) {
+    const match = regex.exec(texto);
+    if (!match || match.index < 0)
+        return undefined;
+    const inicio = Math.max(0, match.index - 60);
+    const fim = Math.min(texto.length, match.index + match[0].length + 60);
+    return texto.slice(inicio, fim).replace(/\s+/g, " ").trim();
+}
+function contemArtefatoProfile(texto, regex) {
+    regex.lastIndex = 0;
+    return regex.test(texto);
+}
+function regexGlobalProfile(regex) {
+    const flags = regex.flags.includes("g") ? regex.flags : `${regex.flags}g`;
+    return new RegExp(regex.source, flags);
+}
+function trechoDoMatchProfile(texto, indice, tamanho) {
+    const inicio = Math.max(0, indice - 60);
+    const fim = Math.min(texto.length, indice + tamanho + 60);
+    return texto.slice(inicio, fim).replace(/\s+/g, " ").trim();
+}
+function termoNegadoNoArtefato(texto, indice, tamanho) {
+    const antes = texto.slice(Math.max(0, indice - 90), indice);
+    const depois = texto.slice(indice + tamanho, Math.min(texto.length, indice + tamanho + 90));
+    const negacaoAntes = /\b(?:sem|ausente|ausencia|ausência|faltando|falta|faltam|inexistente|indefinid[ao]s?|pendente|nao\s+(?:ha|há|define|declara|especifica|possui|tem|existe|inclui|contem|contém|configura|implementa|mapeia|separa|informa|descreve|testa|valida)|não\s+(?:ha|há|define|declara|especifica|possui|tem|existe|inclui|contem|contém|configura|implementa|mapeia|separa|informa|descreve|testa|valida))\b[\s\S]{0,80}$/i;
+    const negacaoDepois = /^[\s\S]{0,80}\b(?:ausente|ausentes|ausencia|ausência|inexistente|indefinid[ao]s?|faltando|pendente|nao\s+(?:definid[ao]|declarad[ao]|especificad[ao]|testad[ao]|valid[ao]|implementad[ao]|configurad[ao]|mapead[ao])|não\s+(?:definid[ao]|declarad[ao]|especificad[ao]|testad[ao]|valid[ao]|implementad[ao]|configurad[ao]|mapead[ao]))\b/i;
+    return negacaoAntes.test(antes) || negacaoDepois.test(depois);
+}
+function avaliarPresencaPositivaArtefato(texto, regex) {
+    const busca = regexGlobalProfile(regex);
+    let primeiroNegado = null;
+    let match;
+    let iteracoes = 0;
+    while ((match = busca.exec(texto)) && iteracoes < 80) {
+        iteracoes += 1;
+        if (match[0].length === 0)
+            busca.lastIndex += 1;
+        if (!termoNegadoNoArtefato(texto, match.index, match[0].length)) {
+            return { atendido: true };
+        }
+        primeiroNegado ??= { indice: match.index, tamanho: match[0].length };
+    }
+    if (primeiroNegado) {
+        return {
+            atendido: false,
+            trecho: trechoDoMatchProfile(texto, primeiroNegado.indice, primeiroNegado.tamanho),
+            motivo: "termo encontrado em contexto de negacao/ausencia; mencao negativa nao satisfaz requisito.",
+        };
+    }
+    return { atendido: false };
+}
+function validarTermosObrigatoriosArtefato(texto, checks) {
+    return checks.map((check) => {
+        const presenca = avaliarPresencaPositivaArtefato(texto, check.regex);
+        return criarAchadoArtefatoProfile(check.id, check.descricao, presenca.atendido, check.severidade ?? "blocking", presenca.trecho, check.sugestao, presenca.motivo);
+    });
+}
+function avaliarArtefatoSoftwareProfile(contrato, artefato, maturidade, preset) {
+    const regras = [
+        { id: "software_eval_proibido", termo: "eval", regex: /\beval\s*\(/i, descricao: "codigo usa eval, risco basico de execucao dinamica", sugestao: "troque por parser explicito, tabela de operacoes ou validacao estruturada." },
+        { id: "software_function_proibido", termo: "Function", regex: /\bnew\s+Function\b|\bFunction\s*\(/i, descricao: "codigo usa Function dinamico, risco basico de execucao dinamica", sugestao: "remova geracao dinamica de codigo e modele comandos permitidos." },
+        { id: "software_innerhtml_inseguro", termo: "innerHTML", regex: /\.innerHTML\s*=|\bdangerouslySetInnerHTML\b/i, descricao: "codigo escreve HTML diretamente em superficie insegura", sugestao: "use textContent, template seguro ou sanitizacao comprovada." },
+        { id: "software_sql_concatenado", termo: "SQL", regex: /\b(SELECT|INSERT|UPDATE|DELETE)\b[\s\S]{0,220}(\+|\$\{)/i, descricao: "codigo aparenta concatenar SQL dinamico", sugestao: "use query parametrizada ou builder seguro." },
+        { id: "software_segredo_hardcoded", termo: "secret", regex: /\b(api[_-]?key|secret|token|password|senha|credential)\b\s*[:=]\s*["'`][^"'`\s]{8,}["'`]/i, descricao: "codigo aparenta carregar segredo fixo no artefato", sugestao: "mova segredo para variavel de ambiente/cofre e use redacao em exemplos." },
+        { id: "software_tls_desativado", termo: "TLS", regex: /rejectUnauthorized\s*:\s*false|NODE_TLS_REJECT_UNAUTHORIZED\s*=\s*["']?0/i, descricao: "codigo aparenta desativar validacao TLS/certificado", sugestao: "corrija cadeia de certificado ou use ambiente de teste isolado sem desligar TLS em producao." },
+        { id: "software_shell_input_dinamico", termo: "shell", regex: /\b(exec|execSync|spawn|spawnSync)\s*\([\s\S]{0,160}(req\.|request\.|params|query|body|input|usuario|userInput)/i, descricao: "codigo aparenta executar shell com entrada dinamica", sugestao: "modele allowlist de comandos/argumentos e evite interpolar entrada do usuario." },
+    ];
+    return regras.flatMap((regra) => {
+        const achou = contemArtefatoProfile(artefato, regra.regex);
+        if (!achou)
+            return [];
+        const politicaEstrita = contratoProibeTermoProfile(contrato, regra.termo) || maturidade === "critical" || preset === "security";
+        const severidade = maturidade === "critical"
+            ? "critical"
+            : politicaEstrita
+                ? "blocking"
+                : "warning";
+        return [criarAchadoArtefatoProfile(regra.id, regra.descricao, false, severidade, trechoRegexProfile(artefato, regra.regex), regra.sugestao)];
+    });
+}
+function avaliarArtefatoWorkflowProfile(contrato, artefato, preset) {
+    const achados = validarTermosObrigatoriosArtefato(artefato, [
+        { id: "workflow_idempotencia_artefato", descricao: "workflow real declara idempotencia", regex: /idempot/i, sugestao: "adicione chave idempotente por evento/webhook ou etapa." },
+        { id: "workflow_retry_artefato", descricao: "workflow real declara retry/retentativa", regex: /retry|retent/i, sugestao: "declare politica de retentativa, limites e erro final." },
+        { id: "workflow_compensacao_artefato", descricao: "workflow real declara compensacao/fallback", regex: /compens|fallback|revers/i, sugestao: "declare compensacao para efeitos ja aplicados." },
+    ]);
+    const contratoExigePagamentoAntes = /validar pagamento[\s\S]{0,120}antes[\s\S]{0,120}criar pedido/i.test(contrato);
+    const criaPedido = artefato.search(/criar pedido/i);
+    const validaPagamento = artefato.search(/validar pagamento/i);
+    if (contratoExigePagamentoAntes && criaPedido >= 0 && validaPagamento >= 0 && criaPedido < validaPagamento) {
+        achados.push(criarAchadoArtefatoProfile("workflow_ordem_pagamento_invertida", "workflow cria pedido antes de validar pagamento, contrariando ordem contratada", false, "critical", trechoRegexProfile(artefato, /criar pedido[\s\S]{0,160}validar pagamento/i), "reordene a etapa de validacao antes da criacao persistente ou declare reserva reversivel."));
+    }
+    if (preset === "webhook" && !avaliarPresencaPositivaArtefato(artefato, /webhook/i).atendido) {
+        achados.push(criarAchadoArtefatoProfile("workflow_preset_webhook_sem_superficie", "preset webhook exige superficie webhook no artefato", false, "blocking", undefined, "nomeie endpoint/evento, payload e idempotencia."));
+    }
+    return achados;
+}
+function avaliarArtefatoOpsProfile(artefato, preset) {
+    const checks = [
+        { id: "ops_runbook_artefato", descricao: "plano operacional contem runbook", regex: /runbook|passo a passo|procedimento/i, sugestao: "adicione runbook executavel com passos, dono e criterio de parada." },
+        { id: "ops_rollback_artefato", descricao: "plano operacional contem rollback", regex: /rollback|reverter|revers/i, sugestao: "adicione comando/criterio de rollback." },
+        { id: "ops_healthcheck_artefato", descricao: "plano operacional contem healthcheck", regex: /healthcheck|healthz|smoke|verificacao live|verificação live/i, sugestao: "declare endpoint, comando ou metrica que prova recuperacao." },
+        { id: "ops_responsavel_artefato", descricao: "plano operacional declara responsavel/oncall", regex: /responsavel|responsável|owner|oncall|dono/i, sugestao: "declare responsavel operacional, oncall ou dono da mudanca." },
+        { id: "ops_comunicacao_artefato", descricao: "plano operacional contem comunicacao", regex: /comunic|avisar|status page|cliente/i, severidade: "warning", sugestao: "adicione quando e quem comunicar." },
+    ];
+    const achados = validarTermosObrigatoriosArtefato(artefato, checks);
+    if ((preset === "migration" || preset === "critical") && !avaliarPresencaPositivaArtefato(artefato, /backup|snapshot|revers/i).atendido) {
+        achados.push(criarAchadoArtefatoProfile("ops_migration_sem_reversibilidade", "migration/critical exige reversibilidade comprovada", false, "critical", undefined, "declare backup, snapshot, down migration ou estrategia manual testada."));
+    }
+    if (preset === "rollback" && !avaliarPresencaPositivaArtefato(artefato, /criterio|critério|gatilho|recuper/i).atendido) {
+        achados.push(criarAchadoArtefatoProfile("ops_rollback_sem_criterio_recuperacao", "rollback exige criterio objetivo de recuperacao", false, "blocking", undefined, "declare gatilho de rollback e criterio verificavel de recuperacao."));
+    }
+    return achados;
+}
+function avaliarArtefatoLegalProfile(artefato, preset) {
+    const achados = [];
+    const pareceFinal = /parecer final|opiniao definitiva|opinião definitiva|conclusao juridica definitiva|conclusão jurídica definitiva/i.test(artefato);
+    const temRevisaoHumana = avaliarPresencaPositivaArtefato(artefato, /revisao humana|revisão humana|advogado|minuta|rascunho|preliminar/i).atendido;
+    const temAvisoNaoParecer = /nao e parecer|não é parecer/i.test(artefato);
+    const temFreioHumano = temRevisaoHumana || temAvisoNaoParecer;
+    if (pareceFinal && !temFreioHumano) {
+        achados.push(criarAchadoArtefatoProfile("legal_parecer_final_sem_revisao", "documento legal parece parecer final sem revisao humana obrigatoria", false, "critical", trechoRegexProfile(artefato, /parecer final|opiniao definitiva|opinião definitiva/i), "marque como minuta/preliminar e exija revisao humana por profissional habilitado."));
+    }
+    if (preset === "lgpd") {
+        achados.push(...validarTermosObrigatoriosArtefato(artefato, [
+            { id: "legal_lgpd_base_finalidade", descricao: "artefato LGPD declara base legal e finalidade", regex: /base legal[\s\S]{0,160}finalidade|finalidade[\s\S]{0,160}base legal/i, severidade: "critical", sugestao: "inclua matriz dado -> finalidade -> base legal." },
+            { id: "legal_lgpd_retencao_direitos", descricao: "artefato LGPD declara retencao e direitos do titular", regex: /retencao|retenção/i, severidade: "blocking", sugestao: "inclua retencao, descarte e direitos do titular." },
+        ]));
+    }
+    if (preset === "privacidade") {
+        achados.push(...validarTermosObrigatoriosArtefato(artefato, [
+            { id: "legal_privacidade_dados_finalidade", descricao: "politica de privacidade declara dados tratados e finalidade", regex: /dados?[\s\S]{0,120}finalidade|finalidade[\s\S]{0,120}dados?/i, severidade: "critical", sugestao: "inclua dados coletados/tratados e finalidade de cada uso." },
+            { id: "legal_privacidade_base_legal", descricao: "politica de privacidade declara base legal", regex: /base legal|consentimento|legitimo interesse|legítimo interesse|execucao de contrato|execução de contrato/i, severidade: "critical", sugestao: "declare base legal por finalidade." },
+            { id: "legal_privacidade_retencao", descricao: "politica de privacidade declara retencao/descarte", regex: /retencao|retenção|descarte|prazo de guarda/i, severidade: "blocking", sugestao: "declare prazo de retencao e descarte." },
+            { id: "legal_privacidade_direitos_contato", descricao: "politica de privacidade declara direitos do titular e contato/DPO", regex: /direitos? do titular[\s\S]{0,160}(contato|dpo|encarregado)|(?:contato|dpo|encarregado)[\s\S]{0,160}direitos? do titular/i, severidade: "blocking", sugestao: "declare direitos do titular e canal de contato/encarregado." },
+        ]));
+    }
+    return achados;
+}
+function avaliarArtefatoResearchProfile(artefato, preset) {
+    const achados = validarTermosObrigatoriosArtefato(artefato, [
+        { id: "research_fontes_artefato", descricao: "resposta final cita fontes ou referencias", regex: /https?:\/\/|\[[0-9]+\]|fonte|referencia|referência/i, sugestao: "inclua fontes citaveis e separe evidencia de opiniao." },
+        { id: "research_incerteza_artefato", descricao: "resposta final declara incerteza ou limite", regex: /incerteza|limite|baixa confianca|baixa confiança|lacuna/i, sugestao: "declare limites, incertezas e o que nao foi verificado." },
+        { id: "research_fato_inferencia_artefato", descricao: "resposta separa fato de inferencia", regex: /fato|inferencia|inferência/i, sugestao: "rotule conclusoes como fato, inferencia ou recomendacao." },
+    ]);
+    if (preset === "critica" && !avaliarPresencaPositivaArtefato(artefato, /contra.?evidencia|contra.?evidência|evidencia contra|evidência contra|refut/i).atendido) {
+        achados.push(criarAchadoArtefatoProfile("research_sem_contraditorio", "pesquisa critica nao tentou derrubar a conclusao", false, "blocking", undefined, "adicione secao de evidencias contra a recomendacao principal."));
+    }
+    return achados;
+}
+function avaliarArtefatoGameProfile(artefato, preset) {
+    const achados = validarTermosObrigatoriosArtefato(artefato, [
+        { id: "game_loop_artefato", descricao: "artefato de jogo declara core loop", regex: /core loop|loop|ciclo/i, sugestao: "declare acao principal, feedback, recompensa e reinicio." },
+        { id: "game_estado_artefato", descricao: "artefato de jogo declara estado e transicoes", regex: /estado|state|playing|game_over|transic|transiç/i, sugestao: "declare estados e transicoes permitidas." },
+        { id: "game_pacing_artefato", descricao: "artefato de jogo declara pacing/curva", regex: /pacing|curva|dificuldade|sessao|sessão/i, severidade: "warning", sugestao: "adicione ritmo esperado e variacao de dificuldade." },
+    ]);
+    if (preset === "playtest" && !avaliarPresencaPositivaArtefato(artefato, /10 segundos|1 minuto|um minuto|primeiro minuto/i).atendido) {
+        achados.push(criarAchadoArtefatoProfile("game_playtest_sem_tempo", "playtest nao descreve primeiros segundos e primeiro minuto", false, "blocking", undefined, "adicione simulacao dos primeiros 10s e do primeiro minuto."));
+    }
+    return achados;
+}
+function avaliarArtefatoProfile(profile, contrato, artefato, maturidade, preset) {
+    if (!artefato || !artefato.trim())
+        return [];
+    switch (profile) {
+        case "software":
+            return avaliarArtefatoSoftwareProfile(contrato, artefato, maturidade, preset);
+        case "workflow":
+            return avaliarArtefatoWorkflowProfile(contrato, artefato, preset);
+        case "ops":
+            return avaliarArtefatoOpsProfile(artefato, preset);
+        case "legal":
+            return avaliarArtefatoLegalProfile(artefato, preset);
+        case "research":
+            return avaliarArtefatoResearchProfile(artefato, preset);
+        case "game":
+            return avaliarArtefatoGameProfile(artefato, preset);
+    }
+}
+async function carregarArtefatoProfile(args) {
+    const texto = obterOpcao(args, "--artefato") ?? obterOpcao(args, "--artifact");
+    const arquivo = obterOpcao(args, "--artefato-arquivo") ?? obterOpcao(args, "--artifact-file");
+    if (arquivo) {
+        const absoluto = path.resolve(process.cwd(), arquivo);
+        return { texto: await readFile(absoluto, "utf8"), arquivo: absoluto };
+    }
+    return { texto: texto ?? null, arquivo: null };
+}
+async function validarProfileSemantico(entrada, profile, opcoes) {
+    if (!entrada) {
+        throw new Error("Uso: sema profile validar <software|workflow|ops|game|legal|research> <arquivo-ou-pasta> [--maturidade draft|prototype|production|critical] [--preset <preset>] [--artefato <texto>|--artefato-arquivo <arquivo>] [--json]");
+    }
+    const modulos = await carregarModulos(entrada);
+    const escolhido = modulos.find((item) => moduloCombinaComProfile(item.resultado.modulo?.nome, item.caminho, profile)) ?? modulos[0];
+    if (!escolhido) {
+        throw new Error(`Nenhum modulo Sema encontrado para ${entrada}.`);
+    }
+    const conteudo = await readFile(escolhido.caminho, "utf8");
+    const maturidade = opcoes.maturidade;
+    const preset = opcoes.preset ?? null;
+    const contratoValido = !temErros(escolhido.resultado.diagnosticos);
+    const requisitosPreset = preset ? REQUISITOS_PRESET_PROFILE[preset] ?? [] : [];
+    const achadosContrato = avaliarRequisitosProfile(conteudo, [...REQUISITOS_PROFILE_COMUNS, ...REQUISITOS_PROFILE[profile]], profile, maturidade);
+    const achadosPreset = avaliarRequisitosProfile(conteudo, requisitosPreset, profile, maturidade, "preset");
+    const achadosArtefato = avaliarArtefatoProfile(profile, conteudo, opcoes.artefatoTexto, maturidade, preset);
+    const achados = [...achadosContrato, ...achadosPreset, ...achadosArtefato];
+    const requisitosPendentes = achados.filter((achado) => !achado.atendido).map((achado) => achado.id);
+    const obrigatoriosPendentes = achados.filter((achado) => achado.obrigatorio && !achado.atendido).map((achado) => achado.id);
+    const scoreContrato = calcularScoreProfile(contratoValido, [...achadosContrato, ...achadosPreset]);
+    const scoreArtefato = opcoes.artefatoTexto ? calcularScoreAchadosProfile(100, achadosArtefato) : null;
+    const scoreProntoParaAcao = Math.min(scoreContrato, scoreArtefato ?? scoreContrato);
+    const decisaoAgente = decidirAcaoAgenteProfile(contratoValido, achados);
+    const aprovado = contratoValido && obrigatoriosPendentes.length === 0 && scoreProntoParaAcao >= 80;
+    const podeContinuar = decisaoAgente === "continuar" || decisaoAgente === "continuar_com_ressalva";
+    return {
+        comando: "profile validar",
+        sucesso: aprovado,
+        profile,
+        arquivo: escolhido.caminho,
+        modulo: escolhido.resultado.modulo?.nome ?? null,
+        maturidade,
+        preset,
+        presetsDisponiveis: PRESETS_PROFILE[profile],
+        contratoValido,
+        artefatoRecebido: Boolean(opcoes.artefatoTexto),
+        artefatoArquivo: opcoes.artefatoArquivo ?? null,
+        aprovado,
+        bloqueado: !aprovado,
+        podeContinuar,
+        decisaoAgente,
+        scoreContrato,
+        scoreArtefato,
+        scoreProntoParaAcao,
+        achados,
+        achadosArtefato,
+        requisitosAtendidos: achados.filter((achado) => achado.atendido).map((achado) => achado.id),
+        requisitosPendentes,
+        checks: [
+            `sema profile validar ${profile} <arquivo> --preset ${preset ?? "<opcional>"} --artefato-arquivo <artefato> --json`,
+            "sema validar <arquivo> --json",
+            "sema drift <arquivo> --escopo modulo --json",
+            "sema contexto-ia <arquivo>",
+        ],
+        diagnosticos: escolhido.resultado.diagnosticos,
+    };
+}
+function renderizarProfileValidarTexto(resultado) {
+    const linhas = [
+        "PROFILE_VALIDAR",
+        `PROFILE: ${resultado.profile}`,
+        `ARQUIVO: ${resultado.arquivo}`,
+        `MODULO: ${resultado.modulo ?? "desconhecido"}`,
+        `MATURIDADE: ${resultado.maturidade}`,
+        `PRESET: ${resultado.preset ?? "nenhum"}`,
+        `ARTEFATO_RECEBIDO: ${resultado.artefatoRecebido ? "sim" : "nao"}`,
+        `APROVADO: ${resultado.aprovado ? "sim" : "nao"}`,
+        `BLOQUEADO: ${resultado.bloqueado ? "sim" : "nao"}`,
+        `DECISAO_AGENTE: ${resultado.decisaoAgente}`,
+        `SCORE_CONTRATO: ${resultado.scoreContrato}`,
+        `SCORE_ARTEFATO: ${resultado.scoreArtefato ?? "nao_avaliado"}`,
+        `SCORE_PRONTO_PARA_ACAO: ${resultado.scoreProntoParaAcao}`,
+    ];
+    for (const achado of resultado.achados) {
+        linhas.push(`- ${achado.id}: ${achado.atendido ? "ok" : "pendente"} ${achado.severidade}${achado.obrigatorio ? " obrigatorio" : " recomendado"} ${achado.fonte} - ${achado.descricao}`);
+        if (achado.trecho)
+            linhas.push(`  trecho: ${achado.trecho}`);
+        if (achado.motivo)
+            linhas.push(`  motivo: ${achado.motivo}`);
+        if (achado.sugestao)
+            linhas.push(`  sugestao: ${achado.sugestao}`);
+    }
+    return linhas.join("\n");
+}
+async function comandoProfile(posicionais, args, emJson) {
+    const subcomando = posicionais[0];
+    if (!subcomando || subcomando === "help" || subcomando === "ajuda") {
+        console.log([
+            "Uso: sema profile <validar>",
+            "",
+            "Comandos:",
+            "  sema profile validar <software|workflow|ops|game|legal|research> <arquivo-ou-pasta> [--maturidade draft|prototype|production|critical] [--preset <preset>] [--artefato <texto>|--artefato-arquivo <arquivo>] [--json]",
+            "",
+            "O profile e um gate semantico: se requisito obrigatorio faltar, a saida bloqueia.",
+        ].join("\n"));
+        return subcomando ? 0 : 1;
+    }
+    if (subcomando !== "validar") {
+        console.error(`Subcomando profile desconhecido: ${subcomando}`);
+        return 1;
+    }
+    const profile = normalizarProfileSemantico(posicionais[1] ?? obterOpcao(args, "--profile"));
+    const entrada = posicionais[2] ?? obterOpcao(args, "--arquivo");
+    if (!profile) {
+        console.error("Profile invalido. Use software, workflow, ops, game, legal ou research.");
+        return 1;
+    }
+    const preset = normalizarPresetProfile(profile, obterOpcao(args, "--preset"));
+    if (obterOpcao(args, "--preset") && !preset) {
+        console.error(`Preset invalido para ${profile}. Use: ${PRESETS_PROFILE[profile].join(", ")}.`);
+        return 1;
+    }
+    const artefato = await carregarArtefatoProfile(args);
+    const resultado = await validarProfileSemantico(entrada, profile, {
+        maturidade: normalizarMaturidadeProfile(obterOpcao(args, "--maturidade")),
+        preset,
+        artefatoTexto: artefato.texto,
+        artefatoArquivo: artefato.arquivo,
+    });
+    if (emJson) {
+        console.log(JSON.stringify(resultado, null, 2));
+    }
+    else {
+        console.log(renderizarProfileValidarTexto(resultado));
+    }
+    return resultado.sucesso ? 0 : 1;
+}
+async function iniciarProfileAuthor(destinoOpcional, temaSensivel, cwd = process.cwd()) {
+    const exemplos = await localizarDiretorioExemplosOficiais();
+    const nomeTemplate = temaSensivel ? "author_tema_sensivel.sema" : "author_obra_comum.sema";
+    const destino = path.resolve(cwd, destinoOpcional ?? path.join("contratos", "author.sema"));
+    if (!exemplos) {
+        return {
+            comando: "author iniciar",
+            sucesso: false,
+            destino,
+            template: null,
+            temaSensivel,
+            erro: "Diretorio de exemplos oficiais nao foi encontrado no pacote da CLI.",
+        };
+    }
+    const template = path.join(exemplos, nomeTemplate);
+    if (!(await caminhoExiste(template))) {
+        return {
+            comando: "author iniciar",
+            sucesso: false,
+            destino,
+            template,
+            temaSensivel,
+            erro: `Template oficial ${nomeTemplate} nao foi encontrado.`,
+        };
+    }
+    if (await caminhoExiste(destino)) {
+        return {
+            comando: "author iniciar",
+            sucesso: false,
+            destino,
+            template,
+            temaSensivel,
+            erro: `Arquivo ja existe: ${destino}`,
+        };
+    }
+    const moduloDestino = temaSensivel ? "author.tema_sensivel" : "author.obra_comum";
+    const conteudo = (await readFile(template, "utf8"))
+        .replace(/^module exemplos\.author\.(obra_comum|tema_sensivel) \{/m, `module ${moduloDestino} {`);
+    await mkdir(path.dirname(destino), { recursive: true });
+    await writeFile(destino, conteudo, "utf8");
+    return {
+        comando: "author iniciar",
+        sucesso: true,
+        destino,
+        template,
+        temaSensivel,
+    };
+}
+async function validarProfileAuthor(entrada, emJson) {
+    const modulos = await carregarModulos(entrada);
+    const resultados = modulos.map((item) => ({
+        caminho: item.caminho,
+        modulo: item.resultado.modulo?.nome ?? null,
+        sucesso: !temErros(item.resultado.diagnosticos),
+        diagnosticos: item.resultado.diagnosticos,
+    }));
+    const payload = {
+        comando: "author validar",
+        sucesso: resultados.every((resultado) => resultado.sucesso),
+        resultados,
+    };
+    if (emJson) {
+        console.log(JSON.stringify(payload, null, 2));
+        return payload.sucesso ? 0 : 1;
+    }
+    console.log(formatarDiagnosticos(modulos.flatMap((item) => item.resultado.diagnosticos)));
+    return payload.sucesso ? 0 : 1;
+}
+async function criarAuthorBriefing(entrada, preset = null) {
+    if (!entrada) {
+        throw new Error("Uso: sema author briefing <arquivo-ou-pasta> [--preset conto|romance|roteiro|lore|campanha] [--json]");
+    }
+    const modulos = await carregarModulos(entrada);
+    const escolhido = modulos.find((item) => /author/i.test(item.resultado.modulo?.nome ?? item.caminho)) ?? modulos[0];
+    if (!escolhido) {
+        throw new Error(`Nenhum modulo Sema encontrado para ${entrada}.`);
+    }
+    const conteudo = await readFile(escolhido.caminho, "utf8");
+    const ir = escolhido.resultado.ir ?? null;
+    const tasks = ir?.tasks.map((task) => task.nome) ?? [];
+    const flows = ir?.flows.map((flow) => flow.nome) ?? [];
+    const guardrails = extrairGuardrailsAuthor(conteudo, ir);
+    const proibicoes = extrairProibicoesAuthor(ir, conteudo);
+    const coreDetectado = /AuthorCore|author core|declarar_author_core|core:/i.test(conteudo);
+    const agentsDetectados = /AgentAuthor|AuthorAgent|agents_author|sensitivity_reviewer|revisor_cliche|guardiao/i.test(conteudo);
+    const flowDetectado = flows.length > 0 || /flow\s+author/i.test(conteudo);
+    return {
+        comando: "author briefing",
+        sucesso: !temErros(escolhido.resultado.diagnosticos),
+        arquivo: escolhido.caminho,
+        modulo: escolhido.resultado.modulo?.nome ?? null,
+        profile: "author",
+        preset,
+        presetsDisponiveis: PRESETS_AUTHOR,
+        coreDetectado,
+        agentsDetectados,
+        flowDetectado,
+        tasks,
+        flows,
+        guardrails,
+        proibicoes,
+        checks: [
+            ...checksPresetAuthor(preset).map((check) => `preset ${preset}: ${check}`),
+            "sema author validar <arquivo> --json",
+            "sema author revisar-cliches <arquivo> --texto <texto> --json",
+            "sema author validar-narrativa <arquivo> --texto <texto> --json",
+            "sema author validar-proibicoes <arquivo> --texto <texto> --json",
+            "sema validar <arquivo> --json",
+            "sema drift <arquivo> --json",
+        ],
+        diagnosticos: escolhido.resultado.diagnosticos,
+    };
+}
+async function revisarClichesAuthor(entrada, textoOpcional, textoArquivoOpcional, textoAnteriorOpcional, textoAnteriorArquivoOpcional, acao = "revisar-cliches", preset = null) {
+    if (!entrada) {
+        throw new Error(`Uso: sema author ${acao} <arquivo.sema> [--texto <texto>|--texto-arquivo <arquivo>] [--texto-anterior <texto>|--texto-anterior-arquivo <arquivo>] [--json]`);
+    }
+    const modulos = await carregarModulos(entrada);
+    const escolhido = modulos.find((item) => /author/i.test(item.resultado.modulo?.nome ?? item.caminho)) ?? modulos[0];
+    if (!escolhido) {
+        throw new Error(`Nenhum modulo Sema encontrado para ${entrada}.`);
+    }
+    const conteudoContrato = await readFile(escolhido.caminho, "utf8");
+    const textoFonte = textoArquivoOpcional
+        ? await readFile(path.resolve(textoArquivoOpcional), "utf8")
+        : textoOpcional ?? conteudoContrato;
+    const textoAnterior = textoAnteriorArquivoOpcional
+        ? await readFile(path.resolve(textoAnteriorArquivoOpcional), "utf8")
+        : textoAnteriorOpcional ?? null;
+    const tokensContrato = extrairTokensContratoAuthor(conteudoContrato);
+    const politicasAplicadasCatalogo = POLITICAS_AUTHOR_GATE
+        .filter((politica) => politicaAuthorAtiva(politica, tokensContrato));
+    const politicasDinamicas = politicasDinamicasContratoAuthor(tokensContrato);
+    const politicasProibicoes = politicasProibicoesLiteraisAuthor(conteudoContrato, escolhido.resultado.ir ?? null);
+    const achadosCatalogo = politicasAplicadasCatalogo
+        .map((politica) => criarAchadoAuthor(politica, textoFonte, "catalogo"))
+        .filter((achado) => achado !== null);
+    const achadosDinamicos = politicasDinamicas
+        .map((politica) => criarAchadoAuthor(politica, textoFonte, "contrato"))
+        .filter((achado) => achado !== null);
+    const achadosProibicoes = politicasProibicoes
+        .map((politica) => criarAchadoAuthor(politica, textoFonte, "contrato"))
+        .filter((achado) => achado !== null);
+    const achadosHeuristicos = avaliarHeuristicasNarrativasAuthor(textoFonte, conteudoContrato, tokensContrato);
+    const achadosPreset = avaliarPresetAuthor(preset, textoFonte);
+    const achados = acao === "validar-proibicoes"
+        ? achadosProibicoes
+        : [
+            ...achadosCatalogo,
+            ...achadosDinamicos,
+            ...achadosProibicoes,
+            ...achadosHeuristicos,
+            ...achadosPreset,
+        ];
+    const bloqueios = achados
+        .filter((achado) => achado.bloqueante)
+        .map((achado) => achado.id);
+    const contratoValido = !temErros(escolhido.resultado.diagnosticos);
+    const scoreCoerenciaTonal = calcularScoreAuthor(achados, ["tom", "voz", "palavra_generica", "frase_generica"]);
+    const scoreDriftNarrativo = calcularScoreAuthor(achados, [
+        "arco_emocional",
+        "campanha_persistente",
+        "impact_map",
+        "memoria_personagem",
+        "promessa_narrativa",
+        "proibicao_literal",
+        "tema_sensivel",
+    ]);
+    const scoreContratoFormal = contratoValido ? 100 : 0;
+    const scoreContratoBase = contratoValido ? calcularScoreAuthor(achados) : 0;
+    const scoreRisco = calcularScoreRiscoAuthor(achados, contratoValido);
+    const confiancaValidacao = textoFonte.trim().length === 0
+        ? "baixa"
+        : acao === "validar-narrativa" || acao === "validar-proibicoes" || politicasProibicoes.length > 0
+            ? "alta"
+            : "parcial";
+    const scoreAderenciaSemantica = confiancaValidacao === "parcial"
+        ? Math.min(scoreContratoBase, 85)
+        : scoreContratoBase;
+    const scoreContrato = Math.min(scoreContratoFormal, scoreAderenciaSemantica);
+    const aprovado = contratoValido
+        && bloqueios.length === 0
+        && scoreCoerenciaTonal >= 80
+        && scoreDriftNarrativo >= 80
+        && scoreAderenciaSemantica >= 80
+        && scoreRisco < 40;
+    const prontoParaAcao = aprovado && confiancaValidacao !== "baixa";
+    const guardrailsDeclarados = extrairGuardrailsAuthor(conteudoContrato, escolhido.resultado.ir ?? null);
+    const irNarrativo = extrairIrNarrativoAuthor(textoFonte);
+    const diffSemantico = compararDiffSemanticoAuthor(textoAnterior, textoFonte);
+    const impactMap = montarImpactMapAuthor(achados);
+    const diagnosticoLocalizado = achados.filter((achado) => achado.bloqueante);
+    const trechosBloqueantes = diagnosticoLocalizado.flatMap((achado) => achado.trechos);
+    const violacoesProibicoes = achados.filter((achado) => achado.categoria === "proibicao_literal");
+    const decisaoAgente = !contratoValido
+        ? "parar"
+        : diagnosticoLocalizado.some((achado) => achado.severidadePadrao === "critical")
+            ? "chamar_humano"
+            : bloqueios.length > 0
+                ? "parar"
+                : confiancaValidacao === "parcial"
+                    ? "continuar_com_ressalva"
+                    : "continuar";
+    const podeContinuar = decisaoAgente === "continuar" || decisaoAgente === "continuar_com_ressalva";
+    return {
+        comando: acao === "revisar-cliches"
+            ? "author revisar-cliches"
+            : acao === "validar-narrativa"
+                ? "author validar-narrativa"
+                : "author validar-proibicoes",
+        sucesso: aprovado,
+        contratoValido,
+        arquivo: escolhido.caminho,
+        textoFonte: textoArquivoOpcional ? path.resolve(textoArquivoOpcional) : "inline",
+        maturidade: "production",
+        preset,
+        presetsDisponiveis: PRESETS_AUTHOR,
+        aprovado,
+        bloqueado: !aprovado,
+        podeContinuar,
+        decisaoAgente,
+        scoreCoerenciaTonal,
+        scoreDriftNarrativo,
+        scoreContrato,
+        scoreContratoFormal,
+        scoreAderenciaSemantica,
+        scoreRisco,
+        prontoParaAcao,
+        confiancaValidacao,
+        achados,
+        bloqueios,
+        diagnosticoLocalizado,
+        trechosBloqueantes,
+        violacoesProibicoes,
+        modoSaidaAgente: "cirurgico",
+        politicasAplicadas: unicosOrdenados([
+            ...politicasAplicadasCatalogo.map((politica) => politica.id),
+            ...politicasDinamicas.map((politica) => politica.id),
+            ...politicasProibicoes.map((politica) => politica.id),
+            ...achadosHeuristicos.map((achado) => achado.id),
+            ...achadosPreset.map((achado) => achado.id),
+        ]),
+        guardrailsDeclarados,
+        irNarrativo,
+        impactMap,
+        diffSemantico,
+        recomendacoes: achados.length === 0
+            ? ["Contrato respeitado: nenhum bloqueio narrativo detectado. Ainda revise tensao, voz e consequencia da cena."]
+            : unicosOrdenados(achados.map((achado) => achado.sugestao)),
+        diagnosticos: escolhido.resultado.diagnosticos,
+    };
+}
+function renderizarAuthorBriefingTexto(resultado) {
+    return [
+        "AUTHOR_BRIEFING",
+        `ARQUIVO: ${resultado.arquivo}`,
+        `MODULO: ${resultado.modulo ?? "desconhecido"}`,
+        `PRESET: ${resultado.preset ?? "nenhum"}`,
+        `CORE: ${resultado.coreDetectado ? "ok" : "ausente"}`,
+        `AGENTS: ${resultado.agentsDetectados ? "ok" : "ausente"}`,
+        `FLOW: ${resultado.flowDetectado ? "ok" : "ausente"}`,
+        `TASKS: ${resumirListaTexto(resultado.tasks, 8)}`,
+        `FLOWS: ${resumirListaTexto(resultado.flows, 8)}`,
+        `PROIBICOES: ${resumirListaTexto(resultado.proibicoes, 8)}`,
+        `CHECKS: ${resumirListaTexto(resultado.checks, 4)}`,
+    ].join("\n");
+}
+function renderizarAuthorClichesTexto(resultado) {
+    const linhas = [
+        resultado.comando === "author revisar-cliches" ? "AUTHOR_CLICHES" : resultado.comando.toUpperCase().replace(/[\s-]+/g, "_"),
+        `ARQUIVO: ${resultado.arquivo}`,
+        `TEXTO: ${resultado.textoFonte}`,
+        `PRESET: ${resultado.preset ?? "nenhum"}`,
+        `APROVADO: ${resultado.aprovado ? "sim" : "nao"}`,
+        `BLOQUEADO: ${resultado.bloqueado ? "sim" : "nao"}`,
+        `DECISAO_AGENTE: ${resultado.decisaoAgente}`,
+        `SCORE_TOM: ${resultado.scoreCoerenciaTonal}`,
+        `SCORE_DRIFT: ${resultado.scoreDriftNarrativo}`,
+        `SCORE_CONTRATO: ${resultado.scoreContrato}`,
+        `SCORE_CONTRATO_FORMAL: ${resultado.scoreContratoFormal}`,
+        `SCORE_ADERENCIA_SEMANTICA: ${resultado.scoreAderenciaSemantica}`,
+        `SCORE_RISCO: ${resultado.scoreRisco}`,
+        `PRONTO_PARA_ACAO: ${resultado.prontoParaAcao ? "sim" : "nao"}`,
+        `CONFIANCA_VALIDACAO: ${resultado.confiancaValidacao}`,
+        `ACHADOS: ${resultado.achados.length}`,
+        `VIOLACOES_PROIBICOES: ${resultado.violacoesProibicoes.length}`,
+    ];
+    for (const achado of resultado.achados) {
+        linhas.push(`- ${achado.id} (${achado.categoria}, ${achado.severidade}, ${achado.ocorrencias} ocorrencia(s)): ${achado.motivo}`);
+        const primeiroTrecho = achado.trechos[0];
+        if (primeiroTrecho) {
+            linhas.push(`  trecho ${primeiroTrecho.linha}:${primeiroTrecho.coluna}: ${primeiroTrecho.texto}`);
+        }
+        linhas.push(`  sugestao: ${achado.sugestaoReescrita}`);
+    }
+    if (resultado.achados.length === 0) {
+        linhas.push("- nenhum bloqueio narrativo detectado");
+    }
+    return linhas.join("\n");
+}
+function normalizarSubcomandoAuthor(subcomando) {
+    return subcomando?.replace(/_/g, "-");
+}
+const PRESETS_AUTHOR = ["conto", "romance", "roteiro", "lore", "campanha"];
+function normalizarPresetAuthor(valor) {
+    if (!valor)
+        return null;
+    const chave = valor.toLowerCase().normalize("NFD").replace(/[\u0300-\u036f]/g, "").replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+    const alias = {
+        short_story: "conto",
+        novela: "romance",
+        script: "roteiro",
+        screenplay: "roteiro",
+        worldbuilding: "lore",
+        mundo: "lore",
+        campanha_persistente: "campanha",
+    };
+    const preset = alias[chave] ?? chave;
+    return PRESETS_AUTHOR.includes(preset) ? preset : null;
+}
+function checksPresetAuthor(preset) {
+    if (!preset)
+        return [];
+    const mapa = {
+        conto: ["conflito concreto", "virada", "fechamento com consequencia"],
+        romance: ["arco de personagem", "continuidade entre capitulos", "promessa narrativa"],
+        roteiro: ["cenas", "dialogo", "acao visual", "estrutura de ato"],
+        lore: ["canon", "mundo", "linha do tempo", "restricao de continuidade"],
+        campanha: ["memoria persistente", "estado de personagens", "eventos irreversiveis", "drift entre sessoes"],
+    };
+    return mapa[preset];
+}
+function avaliarPresetAuthor(preset, textoFonte) {
+    if (!preset)
+        return [];
+    const checks = {
+        conto: [
+            { id: "author_conto_sem_conflito", regex: /conflito|quer|precisa|perde|arrisca|custo/i, sugestao: "conto precisa de desejo, custo e conflito visiveis." },
+            { id: "author_conto_sem_fechamento", regex: /fim|final|consequencia|consequência|mudou|perdeu|ganhou/i, sugestao: "feche o conto com mudanca ou consequencia, nao so atmosfera." },
+        ],
+        romance: [
+            { id: "author_romance_sem_arco", regex: /arco|capitulo|capítulo|continuidade|promessa|personagem/i, sugestao: "romance precisa preservar arco, promessa e continuidade entre capitulos." },
+        ],
+        roteiro: [
+            { id: "author_roteiro_sem_cena", regex: /cena|ato|dialogo|diálogo|acao visual|ação visual|int\.|ext\./i, sugestao: "roteiro precisa de cena, acao visual e/ou dialogo estruturado." },
+        ],
+        lore: [
+            { id: "author_lore_sem_canon", regex: /canon|linha do tempo|mundo|facção|faccao|regra do mundo|continuidade/i, sugestao: "lore precisa de canon, mundo e restricoes de continuidade." },
+        ],
+        campanha: [
+            { id: "author_campanha_sem_estado", regex: /estado|memoria|memória|sessao|sessão|evento irreversivel|evento irreversível|personagem/i, sugestao: "campanha precisa guardar estado, memoria e eventos irreversiveis." },
+        ],
+    };
+    return checks[preset].flatMap((check) => {
+        if (check.regex.test(textoFonte))
+            return [];
+        const achado = criarAchadoHeuristicoAuthor(check.id, "preset_author", "media", 1, check.sugestao, [], textoFonte, check.sugestao, check.sugestao);
+        return achado ? [achado] : [];
+    });
+}
+async function comandoAuthor(posicionais, args, emJson) {
+    const subcomandoOriginal = posicionais[0];
+    const subcomando = normalizarSubcomandoAuthor(subcomandoOriginal);
+    if (!subcomando || subcomando === "help" || subcomando === "ajuda") {
+        console.log([
+            "Uso: sema author <iniciar|validar|briefing|revisar-cliches|validar-narrativa|validar-proibicoes>",
+            "",
+            "Comandos:",
+            "  sema author iniciar [--tema-sensivel] [--saida contratos/author.sema] [--json]",
+            "  sema author validar <arquivo-ou-pasta> [--json]",
+            "  sema author briefing <arquivo-ou-pasta> [--preset conto|romance|roteiro|lore|campanha] [--json]",
+            "  sema author revisar-cliches <arquivo.sema> [--preset conto|romance|roteiro|lore|campanha] [--texto <texto>|--texto-arquivo <arquivo>] [--texto-anterior <texto>|--texto-anterior-arquivo <arquivo>] [--json]",
+            "  sema author validar-narrativa <arquivo.sema> [--preset conto|romance|roteiro|lore|campanha] [--texto <texto>|--texto-arquivo <arquivo>] [--json]",
+            "  sema author validar-proibicoes <arquivo.sema> [--texto <texto>|--texto-arquivo <arquivo>] [--json]",
+            "",
+            "Aliases aceitos: revisar_cliches, validar_narrativa e validar_proibicoes.",
+        ].join("\n"));
+        return subcomando ? 0 : 1;
+    }
+    if (subcomando === "iniciar") {
+        const resultado = await iniciarProfileAuthor(obterOpcao(args, "--saida"), possuiFlag(args, "--tema-sensivel"));
+        if (emJson) {
+            console.log(JSON.stringify(resultado, null, 2));
+        }
+        else if (resultado.sucesso) {
+            console.log(`Profile Author criado em ${resultado.destino}`);
+        }
+        else {
+            console.error(resultado.erro ?? "Falha ao iniciar profile Author.");
+        }
+        return resultado.sucesso ? 0 : 1;
+    }
+    const entrada = posicionais[1] ?? obterOpcao(args, "--arquivo");
+    const presetAuthor = normalizarPresetAuthor(obterOpcao(args, "--preset"));
+    if (obterOpcao(args, "--preset") && !presetAuthor) {
+        console.error(`Preset Author invalido. Use: ${PRESETS_AUTHOR.join(", ")}.`);
+        return 1;
+    }
+    if (subcomando === "validar") {
+        return validarProfileAuthor(entrada, emJson);
+    }
+    if (subcomando === "briefing") {
+        const resultado = await criarAuthorBriefing(entrada, presetAuthor);
+        if (emJson) {
+            console.log(JSON.stringify(resultado, null, 2));
+        }
+        else {
+            console.log(renderizarAuthorBriefingTexto(resultado));
+        }
+        return resultado.sucesso ? 0 : 1;
+    }
+    if (subcomando === "revisar-cliches" || subcomando === "validar-narrativa" || subcomando === "validar-proibicoes") {
+        const resultado = await revisarClichesAuthor(entrada, obterOpcao(args, "--texto"), obterOpcao(args, "--texto-arquivo"), obterOpcao(args, "--texto-anterior"), obterOpcao(args, "--texto-anterior-arquivo"), subcomando, presetAuthor);
+        if (emJson) {
+            console.log(JSON.stringify(resultado, null, 2));
+        }
+        else {
+            console.log(renderizarAuthorClichesTexto(resultado));
+        }
+        return resultado.sucesso ? 0 : 1;
+    }
+    console.error(`Subcomando author desconhecido: ${subcomandoOriginal}`);
+    return 1;
+}
 function resolverEntradaDocs(posicionais, args) {
     const intencao = obterOpcao(args, "--intencao") ?? posicionais[0] ?? "";
     const arquivosPorFlag = obterOpcoesRepetidas(args, "--arquivo");
@@ -3712,23 +5534,43 @@ async function comandoAstJson(arquivo) {
     return temErros(resultado.diagnosticos) ? 1 : 0;
 }
 async function comandoIr(arquivo) {
-    const codigo = await lerArquivoTexto(arquivo);
-    const resultado = compilarCodigo(codigo, arquivo);
-    console.log(JSON.stringify(resultado.ir ?? null, null, 2));
-    return temErros(resultado.diagnosticos) ? 1 : 0;
+    if (!arquivo) {
+        console.error("Informe o arquivo .sema para gerar a IR.");
+        return 1;
+    }
+    const modulos = await carregarModulos(arquivo);
+    const resultado = modulos[0]?.resultado;
+    console.log(JSON.stringify(resultado?.ir ?? null, null, 2));
+    return resultado && !temErros(resultado.diagnosticos) ? 0 : 1;
 }
 async function comandoIrJson(arquivo) {
-    const codigo = await lerArquivoTexto(arquivo);
-    const resultado = compilarCodigo(codigo, arquivo);
+    if (!arquivo) {
+        console.log(JSON.stringify({
+            comando: "ir",
+            caminho: null,
+            modulo: null,
+            sucesso: false,
+            diagnosticos: [{
+                    codigo: "SEM_CLI_IR_ENTRADA_AUSENTE",
+                    mensagem: "Informe o arquivo .sema para gerar a IR.",
+                    severidade: "erro",
+                }],
+            ir: null,
+        }, null, 2));
+        return 1;
+    }
+    const modulos = await carregarModulos(arquivo);
+    const item = modulos[0];
+    const resultado = item?.resultado;
     console.log(JSON.stringify({
         comando: "ir",
-        caminho: path.resolve(arquivo),
-        modulo: resultado.modulo?.nome ?? null,
-        sucesso: !temErros(resultado.diagnosticos),
-        diagnosticos: resultado.diagnosticos,
-        ir: resultado.ir ?? null,
+        caminho: item?.caminho ? path.resolve(item.caminho) : path.resolve(arquivo),
+        modulo: resultado?.modulo?.nome ?? null,
+        sucesso: Boolean(resultado && !temErros(resultado.diagnosticos)),
+        diagnosticos: resultado?.diagnosticos ?? [],
+        ir: resultado?.ir ?? null,
     }, null, 2));
-    return temErros(resultado.diagnosticos) ? 1 : 0;
+    return resultado && !temErros(resultado.diagnosticos) ? 0 : 1;
 }
 async function comandoCompilar(entrada, alvo, saida, estrutura, framework, cwd = process.cwd()) {
     const incompatibilidade = validarCompatibilidadeFramework(alvo, framework);
@@ -4075,7 +5917,7 @@ async function comandoPromptCurto(entrada, args, emJson) {
     const capacidade = tamanho === "micro" ? "pequena" : tamanho === "curto" ? "media" : "grande";
     const prompt = `Voce esta operando Sema em modo IA-first.
 
-Isto e contexto comprimido para IA operar contrato semantico antes de tocar codigo vivo.
+Isto e contexto comprimido para IA operar contrato semantico antes de tocar codigo vivo.
 
 Capacidade alvo: ${capacidade}
 Modo da tarefa: ${modo}
@@ -4321,6 +6163,12 @@ async function principal() {
         case "iniciar":
             codigoSaida = await comandoIniciar(cwd, normalizarTemplateIniciar(obterOpcao(resto, "--template")));
             break;
+        case "author":
+            codigoSaida = await comandoAuthor(posicionais, resto, possuiFlag(resto, "--json"));
+            break;
+        case "profile":
+            codigoSaida = await comandoProfile(posicionais, resto, possuiFlag(resto, "--json"));
+            break;
         case "validar":
             codigoSaida = possuiFlag(resto, "--json")
                 ? await comandoValidarJson(posicionais[0])
@@ -4415,6 +6263,9 @@ async function principal() {
         case "instalar-exemplos":
             codigoSaida = await comandoInstalarExemplos(possuiFlag(resto, "--json"));
             break;
+        case "mcp-instalar-chave":
+            codigoSaida = await comandoMcpInstalarChave(resto, possuiFlag(resto, "--json"));
+            break;
         case "docs-impacto":
             codigoSaida = await comandoDocsImpacto(posicionais, resto, possuiFlag(resto, "--json"));
             break;