@semacode/cli 0.8.8 → 1.0.0

package/node_modules/@sema/nucleo/dist/ir/conversor.js

@@ -1,13 +1,131 @@
 import { parsearEfeitoSemantico, parsearEtapaFlow, parsearExpressaoSemantica, parsearTransicaoEstado } from "../semantico/estruturas.js";
+const TIPOS_PRIMITIVOS = new Set([
+    "Texto",
+    "Numero",
+    "Inteiro",
+    "Decimal",
+    "Booleano",
+    "Data",
+    "DataHora",
+    "Id",
+    "Email",
+    "Url",
+    "Json",
+    "Vazio",
+]);
+function encontrarSubBloco(bloco, palavraChave) {
+    return bloco.blocos.find((subbloco) => subbloco.tipo === "bloco_generico" && subbloco.palavraChave === palavraChave);
+}
+function localizarCampo(bloco, ...nomes) {
+    return bloco?.campos.find((campo) => nomes.includes(campo.nome));
+}
+function valorCampoCompleto(campo) {
+    if (!campo) {
+        return undefined;
+    }
+    return [campo.valor, ...campo.modificadores].join(" ").trim() || undefined;
+}
+function normalizarTipoDeclarado(tipo) {
+    return tipo
+        .replace(/\s*([<>\[\](),|?])\s*/g, "$1")
+        .replace(/\s+/g, "")
+        .trim();
+}
+function dividirNoNivelRaiz(texto, separador) {
+    const partes = [];
+    let profundidadeAngular = 0;
+    let profundidadeColchete = 0;
+    let inicio = 0;
+    for (let indice = 0; indice < texto.length; indice += 1) {
+        const caractere = texto[indice];
+        if (caractere === "<") {
+            profundidadeAngular += 1;
+            continue;
+        }
+        if (caractere === ">") {
+            profundidadeAngular = Math.max(0, profundidadeAngular - 1);
+            continue;
+        }
+        if (caractere === "[") {
+            profundidadeColchete += 1;
+            continue;
+        }
+        if (caractere === "]") {
+            profundidadeColchete = Math.max(0, profundidadeColchete - 1);
+            continue;
+        }
+        if (profundidadeAngular === 0 && profundidadeColchete === 0 && texto.startsWith(separador, indice)) {
+            partes.push(texto.slice(inicio, indice));
+            inicio = indice + separador.length;
+            indice += separador.length - 1;
+        }
+    }
+    partes.push(texto.slice(inicio));
+    return partes.map((parte) => parte.trim()).filter(Boolean);
+}
+function analisarCampoTipo(tipo, modificadores) {
+    const tipoOriginal = normalizarTipoDeclarado(tipo);
+    const modificadoresNormalizados = modificadores.map((item) => item.trim()).filter(Boolean);
+    const refinamentos = modificadoresNormalizados.filter((item) => !["required", "optional", "opcional"].includes(item));
+    const opcionalPorModificador = modificadoresNormalizados.includes("optional") || modificadoresNormalizados.includes("opcional");
+    let tipoBase = tipoOriginal;
+    let cardinalidade = "unitario";
+    let tiposAlternativos = [];
+    let tipoItem;
+    let chaveMapa;
+    let valorMapa;
+    let opcional = opcionalPorModificador;
+    if (tipoBase.endsWith("?")) {
+        opcional = true;
+        tipoBase = tipoBase.slice(0, -1);
+    }
+    if (/^Opcional<.+>$/.test(tipoBase)) {
+        opcional = true;
+        tipoBase = tipoBase.slice("Opcional<".length, -1);
+    }
+    const uniao = dividirNoNivelRaiz(tipoBase, "|");
+    if (uniao.length > 1) {
+        cardinalidade = "uniao";
+        tiposAlternativos = uniao.map(normalizarTipoDeclarado);
+        tipoBase = tiposAlternativos[0] ?? tipoBase;
+    }
+    else if (/^Lista<.+>$/.test(tipoBase)) {
+        cardinalidade = "lista";
+        tipoItem = tipoBase.slice("Lista<".length, -1).trim();
+        tipoBase = tipoItem;
+    }
+    else if (/^Mapa<.+>$/.test(tipoBase)) {
+        cardinalidade = "mapa";
+        const partesMapa = dividirNoNivelRaiz(tipoBase.slice("Mapa<".length, -1), ",");
+        chaveMapa = partesMapa[0];
+        valorMapa = partesMapa[1];
+        tipoBase = valorMapa ?? tipoBase;
+    }
+    return {
+        tipo: tipoOriginal,
+        modificadores: modificadoresNormalizados,
+        tipoOriginal,
+        tipoBase,
+        cardinalidade,
+        opcional,
+        tiposAlternativos,
+        tipoItem,
+        chaveMapa,
+        valorMapa,
+        refinamentos,
+    };
+}
+function converterCampo(campo) {
+    return {
+        nome: campo.nome,
+        ...analisarCampoTipo(campo.valor, campo.modificadores),
+    };
+}
 function converterCampos(bloco) {
     if (!bloco) {
         return [];
     }
-    return bloco.campos.map((campo) => ({
-        nome: campo.nome,
-        tipo: campo.valor,
-        modificadores: campo.modificadores,
-    }));
+    return bloco.campos.map(converterCampo);
 }
 function converterBloco(bloco) {
     return {
@@ -30,29 +148,276 @@ function converterCaso(caso) {
         error: caso.error ? converterBloco(caso.error) : undefined,
     };
 }
-function encontrarSubBloco(bloco, palavraChave) {
-    return bloco.blocos.find((subbloco) => subbloco.tipo === "bloco_generico" && subbloco.palavraChave === palavraChave);
+function converterImplementacoes(bloco) {
+    const implementacoes = [];
+    for (const campo of bloco?.campos ?? []) {
+        const origem = campo.nome.toLowerCase();
+        if (origem === "ts" || origem === "typescript") {
+            implementacoes.push({ origem: "ts", caminho: campo.valor, resolucaoImpl: campo.valor, statusImpl: "nao_verificado" });
+            continue;
+        }
+        if (origem === "py" || origem === "python") {
+            implementacoes.push({ origem: "py", caminho: campo.valor, resolucaoImpl: campo.valor, statusImpl: "nao_verificado" });
+            continue;
+        }
+        if (origem === "dart") {
+            implementacoes.push({ origem: "dart", caminho: campo.valor, resolucaoImpl: campo.valor, statusImpl: "nao_verificado" });
+            continue;
+        }
+        if (origem === "cs" || origem === "csharp" || origem === "dotnet") {
+            implementacoes.push({ origem: "cs", caminho: campo.valor, resolucaoImpl: campo.valor, statusImpl: "nao_verificado" });
+            continue;
+        }
+        if (origem === "java") {
+            implementacoes.push({ origem: "java", caminho: campo.valor, resolucaoImpl: campo.valor, statusImpl: "nao_verificado" });
+            continue;
+        }
+        if (origem === "go" || origem === "golang") {
+            implementacoes.push({ origem: "go", caminho: campo.valor, resolucaoImpl: campo.valor, statusImpl: "nao_verificado" });
+            continue;
+        }
+        if (origem === "rust" || origem === "rs") {
+            implementacoes.push({ origem: "rust", caminho: campo.valor, resolucaoImpl: campo.valor, statusImpl: "nao_verificado" });
+            continue;
+        }
+        if (origem === "cpp" || origem === "cxx" || origem === "cc" || origem === "c++") {
+            implementacoes.push({ origem: "cpp", caminho: campo.valor, resolucaoImpl: campo.valor, statusImpl: "nao_verificado" });
+        }
+    }
+    return implementacoes;
 }
-function converterErrosPublicos(bloco) {
-    return (bloco?.campos ?? []).map((campo) => ({
-        nome: campo.nome,
-        codigo: campo.nome,
-        mensagem: [campo.valor, ...campo.modificadores].join(" ").trim() || undefined,
+function converterVinculos(bloco) {
+    if (!bloco) {
+        return [];
+    }
+    const campos = bloco.campos.map((campo) => {
+        const valor = valorCampoCompleto(campo) ?? "";
+        return {
+            tipo: campo.nome,
+            valor,
+            arquivo: campo.nome === "arquivo" ? valor : undefined,
+            simbolo: campo.nome === "simbolo" ? valor : undefined,
+            recurso: ["recurso", "tabela", "fila", "cache", "storage"].includes(campo.nome) ? valor : undefined,
+            superficie: ["superficie", "rota", "worker", "cron", "webhook", "evento", "policy", "fila", "cache", "storage"].includes(campo.nome) ? valor : undefined,
+            statusResolucao: "nao_verificado",
+        };
+    });
+    const linhas = bloco.linhas.map((linha) => {
+        const [tipo, ...resto] = linha.conteudo.split(/\s+/);
+        const valor = resto.join(" ").trim();
+        return {
+            tipo: tipo ?? "desconhecido",
+            valor,
+            statusResolucao: "nao_verificado",
+        };
+    }).filter((item) => item.valor);
+    const subblocos = bloco.blocos
+        .filter((item) => item.tipo === "bloco_generico")
+        .map((item) => ({
+        tipo: item.palavraChave === "desconhecido" ? (item.nome ?? "desconhecido") : item.palavraChave,
+        valor: item.nome ?? item.palavraChave,
+        arquivo: valorCampoCompleto(localizarCampo(item, "arquivo")),
+        simbolo: valorCampoCompleto(localizarCampo(item, "simbolo")),
+        recurso: valorCampoCompleto(localizarCampo(item, "recurso", "tabela", "fila", "cache", "storage")),
+        superficie: valorCampoCompleto(localizarCampo(item, "superficie", "rota", "worker", "cron", "webhook", "evento")),
+        statusResolucao: "nao_verificado",
     }));
+    return [...campos, ...linhas, ...subblocos];
 }
-function recomporCaminho(campo) {
-    if (!campo) {
-        return undefined;
+function converterExecucao(bloco) {
+    const idempotencia = valorCampoCompleto(localizarCampo(bloco, "idempotencia"));
+    const criticidadeOperacional = valorCampoCompleto(localizarCampo(bloco, "criticidade_operacional"));
+    return {
+        idempotencia: idempotencia === "verdadeiro" || idempotencia === "true",
+        timeout: valorCampoCompleto(localizarCampo(bloco, "timeout")) ?? "padrao",
+        retry: valorCampoCompleto(localizarCampo(bloco, "retry")) ?? "nenhum",
+        compensacao: valorCampoCompleto(localizarCampo(bloco, "compensacao")) ?? "nenhuma",
+        criticidadeOperacional: (criticidadeOperacional === "baixa"
+            || criticidadeOperacional === "alta"
+            || criticidadeOperacional === "critica") ? criticidadeOperacional : "media",
+        explicita: Boolean(bloco),
+    };
+}
+function converterErrosTask(bloco, fallback) {
+    const erros = new Map();
+    for (const campo of bloco?.campos ?? []) {
+        erros.set(campo.nome, {
+            codigo: campo.nome,
+            mensagem: valorCampoCompleto(campo) ?? "",
+        });
     }
-    return [campo.valor, ...campo.modificadores]
-        .join(" ")
-        .replace(/\s*\/\s*/g, "/")
-        .trim();
+    for (const subbloco of bloco?.blocos ?? []) {
+        if (subbloco.tipo !== "bloco_generico") {
+            continue;
+        }
+        const codigo = subbloco.nome ?? subbloco.palavraChave;
+        if (!codigo || codigo === "desconhecido") {
+            continue;
+        }
+        erros.set(codigo, {
+            codigo,
+            mensagem: valorCampoCompleto(localizarCampo(subbloco, "mensagem")) ?? `Erro estruturado "${codigo}".`,
+            categoria: valorCampoCompleto(localizarCampo(subbloco, "categoria")),
+            recuperabilidade: valorCampoCompleto(localizarCampo(subbloco, "recuperabilidade")),
+            acaoChamador: valorCampoCompleto(localizarCampo(subbloco, "acao_chamador")),
+            impactaEstado: valorCampoCompleto(localizarCampo(subbloco, "impacta_estado")) === "verdadeiro",
+            requerCompensacao: valorCampoCompleto(localizarCampo(subbloco, "requer_compensacao")) === "verdadeiro",
+        });
+    }
+    for (const erro of fallback ?? []) {
+        if (!erros.has(erro.codigo)) {
+            erros.set(erro.codigo, {
+                codigo: erro.codigo,
+                mensagem: erro.mensagem,
+                categoria: erro.categoria,
+                recuperabilidade: erro.recuperabilidade,
+                acaoChamador: erro.acaoChamador,
+                impactaEstado: erro.impactaEstado,
+                requerCompensacao: erro.requerCompensacao,
+            });
+        }
+    }
+    return [...erros.values()];
+}
+function extrairPerfil(bloco, padrao = "interno") {
+    const perfil = valorCampoCompleto(localizarCampo(bloco, "perfil", "compatibilidade"))?.toLowerCase();
+    if (perfil === "publico"
+        || perfil === "interno"
+        || perfil === "experimental"
+        || perfil === "legado"
+        || perfil === "deprecado") {
+        return perfil;
+    }
+    return padrao;
+}
+function tipoNaoPrimitivo(campo) {
+    if (!TIPOS_PRIMITIVOS.has(campo.tipoBase)) {
+        return campo.tipoBase;
+    }
+    if (campo.tipoItem && !TIPOS_PRIMITIVOS.has(campo.tipoItem)) {
+        return campo.tipoItem;
+    }
+    if (campo.valorMapa && !TIPOS_PRIMITIVOS.has(campo.valorMapa)) {
+        return campo.valorMapa;
+    }
+    return undefined;
+}
+function deduplicarTexto(valores) {
+    return [...new Set(valores.filter(Boolean))].sort((a, b) => a.localeCompare(b, "pt-BR"));
+}
+function resumirAgente(params) {
+    const entidadesAfetadas = deduplicarTexto([
+        ...(params.input ?? []).map(tipoNaoPrimitivo).filter((item) => Boolean(item)),
+        ...(params.output ?? []).map(tipoNaoPrimitivo).filter((item) => Boolean(item)),
+        ...(params.efeitos ?? []).map((efeito) => efeito.alvo),
+    ]);
+    const mutacoesPrevistas = deduplicarTexto((params.efeitos ?? []).map((efeito) => `${efeito.categoria}:${efeito.alvo}`));
+    const riscos = new Set();
+    if ((params.efeitos ?? []).some((efeito) => efeito.categoria === "persistencia")) {
+        riscos.add("altera_persistencia");
+    }
+    if ((params.efeitos ?? []).some((efeito) => efeito.criticidade === "alta" || efeito.criticidade === "critica")) {
+        riscos.add("efeito_critico");
+    }
+    if (params.execucao?.criticidadeOperacional === "alta" || params.execucao?.criticidadeOperacional === "critica") {
+        riscos.add("execucao_critica");
+    }
+    if ((params.vinculos ?? []).length === 0) {
+        riscos.add("vinculo_fraco");
+    }
+    const checks = new Set();
+    checks.add("rodar sema validar --json");
+    if ((params.output ?? []).length > 0) {
+        checks.add("verificar guarantees");
+    }
+    if ((params.vinculos ?? []).length > 0) {
+        checks.add("rodar sema drift --json");
+    }
+    if (params.superficiePublica) {
+        checks.add("validar superficie publica impactada");
+    }
+    return {
+        riscos: [...riscos],
+        checks: [...checks],
+        entidadesAfetadas,
+        superficiesPublicas: params.superficiePublica ? [params.superficiePublica] : [],
+        mutacoesPrevistas,
+    };
+}
+function recomporCaminho(campo) {
+    const valor = valorCampoCompleto(campo);
+    return valor?.replace(/\s*\/\s*/g, "/").trim();
 }
 function ehUseInterop(use) {
     return use.origem !== "sema";
 }
+function converterErroPublico(erro, origemTask) {
+    return {
+        nome: erro.codigo,
+        codigo: erro.codigo,
+        mensagem: erro.mensagem,
+        categoria: erro.categoria,
+        recuperabilidade: erro.recuperabilidade,
+        acaoChamador: erro.acaoChamador,
+        impactaEstado: erro.impactaEstado,
+        requerCompensacao: erro.requerCompensacao,
+        origemTask,
+    };
+}
+function calcularConfiancaPublica(route) {
+    if (route.task && route.vinculos.length > 0) {
+        return "alta";
+    }
+    if (route.task || route.vinculos.length > 0) {
+        return "media";
+    }
+    return "baixa";
+}
+function calcularRiscoPublico(route) {
+    if (route.efeitosPublicos.some((efeito) => efeito.categoria === "persistencia" || efeito.criticidade === "critica")) {
+        return "alto";
+    }
+    if (route.efeitosPublicos.length > 0 || route.errosPublicos.length > 0) {
+        return "medio";
+    }
+    return "baixo";
+}
+function converterSuperficie(tipo, superficie) {
+    const input = converterCampos(encontrarSubBloco(superficie, "input"));
+    const output = converterCampos(encontrarSubBloco(superficie, "output"));
+    const effects = (encontrarSubBloco(superficie, "effects")?.linhas ?? [])
+        .map((linha) => parsearEfeitoSemantico(linha.conteudo))
+        .filter((linha) => Boolean(linha));
+    const vinculos = converterVinculos(encontrarSubBloco(superficie, "vinculos"));
+    const execucao = converterExecucao(encontrarSubBloco(superficie, "execucao"));
+    const task = valorCampoCompleto(localizarCampo(superficie, "task", "tarefa"));
+    const perfilCompatibilidade = extrairPerfil(superficie, tipo === "webhook" ? "publico" : "interno");
+    const resumoAgente = resumirAgente({
+        input,
+        output,
+        efeitos: effects,
+        vinculos,
+        execucao,
+        superficiePublica: perfilCompatibilidade === "publico" ? `${tipo}:${superficie.nome ?? tipo}` : undefined,
+    });
+    return {
+        tipo,
+        nome: superficie.nome ?? tipo,
+        campos: converterCampos(superficie),
+        linhas: superficie.linhas.map((linha) => linha.conteudo),
+        task: task || undefined,
+        input,
+        output,
+        effects,
+        implementacoesExternas: converterImplementacoes(encontrarSubBloco(superficie, "impl")),
+        vinculos,
+        execucao,
+        perfilCompatibilidade,
+        resumoAgente,
+    };
+}
 export function converterParaIr(modulo, diagnosticos, contexto) {
+    const perfilModulo = extrairPerfil(modulo.vinculos, modulo.routes.length > 0 || modulo.webhooks.length > 0 ? "publico" : "interno");
     const types = modulo.types.map((type) => ({
         nome: type.nome,
         definicao: converterBloco(encontrarSubBloco(type.corpo, "fields") ?? type.corpo),
@@ -67,85 +432,88 @@ export function converterParaIr(modulo, diagnosticos, contexto) {
             .map((linha) => parsearExpressaoSemantica(linha.conteudo))
             .filter((linha) => Boolean(linha)),
     }));
-    const tasks = modulo.tasks.map((task) => ({
-        nome: task.nome,
-        input: converterCampos(task.input),
-        output: converterCampos(task.output),
-        rules: task.rules?.linhas.map((linha) => linha.conteudo) ?? [],
-        regrasEstruturadas: (task.rules?.linhas ?? []).map((linha) => parsearExpressaoSemantica(linha.conteudo)).filter((linha) => Boolean(linha)),
-        effects: task.effects?.linhas.map((linha) => linha.conteudo) ?? [],
-        efeitosEstruturados: (task.effects?.linhas ?? []).map((linha) => parsearEfeitoSemantico(linha.conteudo)).filter((linha) => Boolean(linha)),
-        implementacoesExternas: (task.impl?.campos ?? [])
-            .map((campo) => {
-            const origem = campo.nome.toLowerCase();
-            if (origem === "ts" || origem === "typescript") {
-                return { origem: "ts", caminho: campo.valor, resolucaoImpl: campo.valor, statusImpl: "nao_verificado" };
-            }
-            if (origem === "py" || origem === "python") {
-                return { origem: "py", caminho: campo.valor, resolucaoImpl: campo.valor, statusImpl: "nao_verificado" };
-            }
-            if (origem === "dart") {
-                return { origem: "dart", caminho: campo.valor, resolucaoImpl: campo.valor, statusImpl: "nao_verificado" };
-            }
-            if (origem === "cs" || origem === "csharp" || origem === "dotnet") {
-                return { origem: "cs", caminho: campo.valor, resolucaoImpl: campo.valor, statusImpl: "nao_verificado" };
-            }
-            if (origem === "java") {
-                return { origem: "java", caminho: campo.valor, resolucaoImpl: campo.valor, statusImpl: "nao_verificado" };
-            }
-            if (origem === "go" || origem === "golang") {
-                return { origem: "go", caminho: campo.valor, resolucaoImpl: campo.valor, statusImpl: "nao_verificado" };
-            }
-            if (origem === "rust" || origem === "rs") {
-                return { origem: "rust", caminho: campo.valor, resolucaoImpl: campo.valor, statusImpl: "nao_verificado" };
-            }
-            if (origem === "cpp" || origem === "cxx" || origem === "cc" || origem === "c++") {
-                return { origem: "cpp", caminho: campo.valor, resolucaoImpl: campo.valor, statusImpl: "nao_verificado" };
-            }
-            return undefined;
-        })
-            .filter((item) => Boolean(item)),
-        guarantees: task.guarantees?.linhas.map((linha) => linha.conteudo) ?? [],
-        garantiasEstruturadas: (task.guarantees?.linhas ?? []).map((linha) => parsearExpressaoSemantica(linha.conteudo)).filter((linha) => Boolean(linha)),
-        errors: Object.fromEntries((task.error?.campos ?? []).map((campo) => [campo.nome, [campo.valor, ...campo.modificadores].join(" ").trim()])),
-        stateContract: task.state ? {
-            nomeEstado: task.state.nome ?? task.state.campos.find((campo) => campo.nome === "state" || campo.nome === "estado")?.valor,
-            campos: converterCampos(task.state),
-            linhas: task.state.linhas.map((linha) => linha.conteudo),
-            transicoes: (encontrarSubBloco(task.state, "transitions")?.linhas ?? task.state.linhas)
-                .map((linha) => parsearTransicaoEstado(linha.conteudo))
+    const tarefasSemanticas = contexto?.tarefasDetalhadas ?? new Map();
+    const tasks = modulo.tasks.map((task) => {
+        const input = converterCampos(task.input);
+        const output = converterCampos(task.output);
+        const effects = (task.effects?.linhas ?? [])
+            .map((linha) => parsearEfeitoSemantico(linha.conteudo))
+            .filter((linha) => Boolean(linha));
+        const vinculos = converterVinculos(task.vinculos);
+        const execucao = converterExecucao(task.execucao);
+        const errosDetalhados = converterErrosTask(task.error, tarefasSemanticas.get(task.nome)?.errors);
+        const perfilCompatibilidade = extrairPerfil(task.corpo, "interno");
+        const resumoAgente = resumirAgente({
+            input,
+            output,
+            efeitos: effects,
+            vinculos,
+            execucao,
+        });
+        return {
+            nome: task.nome,
+            input,
+            output,
+            rules: task.rules?.linhas.map((linha) => linha.conteudo) ?? [],
+            regrasEstruturadas: (task.rules?.linhas ?? [])
+                .map((linha) => parsearExpressaoSemantica(linha.conteudo))
                 .filter((linha) => Boolean(linha)),
-        } : undefined,
-        tests: (task.tests?.blocos.filter((bloco) => bloco.tipo === "caso_teste") ?? []).map(converterCaso),
-    }));
+            effects: task.effects?.linhas.map((linha) => linha.conteudo) ?? [],
+            efeitosEstruturados: effects,
+            implementacoesExternas: converterImplementacoes(task.impl),
+            vinculos,
+            execucao,
+            guarantees: task.guarantees?.linhas.map((linha) => linha.conteudo) ?? [],
+            garantiasEstruturadas: (task.guarantees?.linhas ?? [])
+                .map((linha) => parsearExpressaoSemantica(linha.conteudo))
+                .filter((linha) => Boolean(linha)),
+            errors: Object.fromEntries(errosDetalhados.map((erro) => [erro.codigo, erro.mensagem])),
+            errosDetalhados,
+            perfilCompatibilidade,
+            stateContract: task.state ? {
+                nomeEstado: task.state.nome ?? task.state.campos.find((campo) => campo.nome === "state" || campo.nome === "estado")?.valor,
+                campos: converterCampos(task.state),
+                linhas: task.state.linhas.map((linha) => linha.conteudo),
+                transicoes: (encontrarSubBloco(task.state, "transitions")?.linhas ?? task.state.linhas)
+                    .map((linha) => parsearTransicaoEstado(linha.conteudo))
+                    .filter((linha) => Boolean(linha)),
+            } : undefined,
+            resumoAgente,
+            tests: (task.tests?.blocos.filter((bloco) => bloco.tipo === "caso_teste") ?? []).map(converterCaso),
+        };
+    });
     const tarefasPorNome = new Map(tasks.map((task) => [task.nome, task]));
-    const tarefasSemanticas = contexto?.tarefasDetalhadas ?? new Map();
-    const flows = modulo.flows.map((flow) => ({
-        nome: flow.nome,
-        campos: flow.corpo.campos.map((campo) => ({
-            nome: campo.nome,
-            tipo: campo.valor,
-            modificadores: campo.modificadores,
-        })),
-        linhas: flow.corpo.linhas.map((linha) => linha.conteudo),
-        tasksReferenciadas: flow.corpo.campos
-            .filter((campo) => campo.nome === "task" || campo.nome === "tarefa")
-            .map((campo) => campo.valor),
-        etapasEstruturadas: flow.corpo.linhas
-            .map((linha) => parsearEtapaFlow(linha.conteudo))
-            .filter((linha) => Boolean(linha)),
-        effects: (encontrarSubBloco(flow.corpo, "effects")?.linhas ?? []).map((linha) => linha.conteudo),
-        efeitosEstruturados: (encontrarSubBloco(flow.corpo, "effects")?.linhas ?? [])
+    const flows = modulo.flows.map((flow) => {
+        const campos = converterCampos(flow.corpo);
+        const effects = (encontrarSubBloco(flow.corpo, "effects")?.linhas ?? [])
             .map((linha) => parsearEfeitoSemantico(linha.conteudo))
-            .filter((linha) => Boolean(linha)),
-    }));
+            .filter((linha) => Boolean(linha));
+        const vinculos = converterVinculos(flow.vinculos);
+        const perfilCompatibilidade = extrairPerfil(flow.corpo, "interno");
+        return {
+            nome: flow.nome,
+            campos,
+            linhas: flow.corpo.linhas.map((linha) => linha.conteudo),
+            tasksReferenciadas: flow.corpo.campos
+                .filter((campo) => campo.nome === "task" || campo.nome === "tarefa")
+                .map((campo) => campo.valor),
+            etapasEstruturadas: flow.corpo.linhas
+                .map((linha) => parsearEtapaFlow(linha.conteudo))
+                .filter((linha) => Boolean(linha)),
+            effects: (encontrarSubBloco(flow.corpo, "effects")?.linhas ?? []).map((linha) => linha.conteudo),
+            efeitosEstruturados: effects,
+            vinculos,
+            perfilCompatibilidade,
+            resumoAgente: resumirAgente({
+                input: campos,
+                efeitos: effects,
+                vinculos,
+            }),
+        };
+    });
     const routes = modulo.routes.map((route) => ({
         nome: route.nome,
-        campos: route.corpo.campos.map((campo) => ({
-            nome: campo.nome,
-            tipo: campo.valor,
-            modificadores: campo.modificadores,
-        })),
+        campos: converterCampos(route.corpo),
         linhas: route.corpo.linhas.map((linha) => linha.conteudo),
         metodo: route.corpo.campos.find((campo) => campo.nome === "metodo")?.valor,
         caminho: recomporCaminho(route.corpo.campos.find((campo) => campo.nome === "caminho")),
@@ -154,7 +522,16 @@ export function converterParaIr(modulo, diagnosticos, contexto) {
         outputPublico: [],
         errosPublicos: [],
         efeitosPublicos: [],
+        vinculos: converterVinculos(route.vinculos),
+        perfilCompatibilidade: extrairPerfil(route.corpo, "publico"),
         garantiasPublicasMinimas: [],
+        resumoAgente: {
+            riscos: [],
+            checks: [],
+            entidadesAfetadas: [],
+            superficiesPublicas: [],
+            mutacoesPrevistas: [],
+        },
         publico: {
             metodo: undefined,
             caminho: undefined,
@@ -171,32 +548,57 @@ export function converterParaIr(modulo, diagnosticos, contexto) {
         const tarefaSemantica = route.task ? tarefasSemanticas.get(route.task) : undefined;
         const inputPublicoDeclarado = converterCampos(encontrarSubBloco(routeAst.corpo, "input"));
         const outputPublicoDeclarado = converterCampos(encontrarSubBloco(routeAst.corpo, "output"));
-        const errosPublicosDeclarados = converterErrosPublicos(encontrarSubBloco(routeAst.corpo, "error"));
+        const errosDeclarados = converterErrosTask(encontrarSubBloco(routeAst.corpo, "error"), tarefaSemantica?.errors);
         const efeitosPublicosDeclarados = (encontrarSubBloco(routeAst.corpo, "effects")?.linhas ?? [])
             .map((linha) => parsearEfeitoSemantico(linha.conteudo))
             .filter((linha) => Boolean(linha));
         const inputPublicoResolvido = inputPublicoDeclarado.length > 0
             ? inputPublicoDeclarado
-            : (tarefaAssociada?.input ?? tarefaSemantica?.input ?? []);
+            : (tarefaAssociada?.input ?? tarefaSemantica?.input?.map((campo) => ({
+                nome: campo.nome,
+                tipo: campo.tipo,
+                modificadores: campo.modificadores,
+                tipoOriginal: campo.tipo,
+                tipoBase: campo.tipo,
+                cardinalidade: "unitario",
+                opcional: false,
+                tiposAlternativos: [],
+                refinamentos: [],
+            })) ?? []);
         const outputPublicoResolvido = outputPublicoDeclarado.length > 0
             ? outputPublicoDeclarado
-            : (tarefaAssociada?.output ?? tarefaSemantica?.output ?? []);
-        const errosPublicosResolvidos = errosPublicosDeclarados.length > 0
-            ? errosPublicosDeclarados
-            : (tarefaAssociada
-                ? Object.entries(tarefaAssociada.errors).map(([nome, mensagem]) => ({ nome, codigo: nome, mensagem, origemTask: route.task }))
-                : (tarefaSemantica?.errors ?? []).map((erro) => ({ nome: erro.codigo, codigo: erro.codigo, mensagem: erro.mensagem, origemTask: route.task })));
+            : (tarefaAssociada?.output ?? tarefaSemantica?.output?.map((campo) => ({
+                nome: campo.nome,
+                tipo: campo.tipo,
+                modificadores: campo.modificadores,
+                tipoOriginal: campo.tipo,
+                tipoBase: campo.tipo,
+                cardinalidade: "unitario",
+                opcional: false,
+                tiposAlternativos: [],
+                refinamentos: [],
+            })) ?? []);
+        const errosPublicosResolvidos = errosDeclarados.length > 0
+            ? errosDeclarados.map((erro) => converterErroPublico(erro, route.task))
+            : (tarefaAssociada?.errosDetalhados ?? (tarefaSemantica?.errors ?? []).map((erro) => ({ codigo: erro.codigo, mensagem: erro.mensagem }))).map((erro) => converterErroPublico(erro, route.task));
         const garantiasPublicasMinimas = (tarefaAssociada?.guarantees ?? tarefaSemantica?.guarantees ?? []).filter((garantia) => {
             const referencia = garantia.trim().split(/\s+/)[0] ?? "";
             return outputPublicoResolvido.some((campo) => campo.nome === referencia || garantia.includes(`${campo.nome}.`));
         });
-        return {
+        const routeResolvida = {
             ...route,
             inputPublico: inputPublicoResolvido,
             outputPublico: outputPublicoResolvido,
             errosPublicos: errosPublicosResolvidos,
             efeitosPublicos: efeitosPublicosDeclarados,
             garantiasPublicasMinimas,
+            resumoAgente: resumirAgente({
+                input: inputPublicoResolvido,
+                output: outputPublicoResolvido,
+                efeitos: efeitosPublicosDeclarados,
+                vinculos: route.vinculos,
+                superficiePublica: `${route.metodo ?? "?"} ${route.caminho ?? "?"}`,
+            }),
             publico: {
                 metodo: route.metodo,
                 caminho: route.caminho,
@@ -206,10 +608,25 @@ export function converterParaIr(modulo, diagnosticos, contexto) {
                 errors: errosPublicosResolvidos,
                 effects: efeitosPublicosDeclarados,
                 garantiasMinimas: garantiasPublicasMinimas,
+                confiancaContrato: "media",
+                riscoRegressao: "medio",
                 divergenciasPublicas: [],
             },
         };
+        routeResolvida.publico.confiancaContrato = calcularConfiancaPublica(routeResolvida);
+        routeResolvida.publico.riscoRegressao = calcularRiscoPublico(routeResolvida);
+        return routeResolvida;
     });
+    const superficies = [
+        ...modulo.workers.map((item) => converterSuperficie("worker", item)),
+        ...modulo.eventos.map((item) => converterSuperficie("evento", item)),
+        ...modulo.filas.map((item) => converterSuperficie("fila", item)),
+        ...modulo.crons.map((item) => converterSuperficie("cron", item)),
+        ...modulo.webhooks.map((item) => converterSuperficie("webhook", item)),
+        ...modulo.caches.map((item) => converterSuperficie("cache", item)),
+        ...modulo.storages.map((item) => converterSuperficie("storage", item)),
+        ...modulo.policies.map((item) => converterSuperficie("policy", item)),
+    ];
     const states = modulo.states.map((state) => ({
         nome: state.nome,
         campos: converterCampos(encontrarSubBloco(state.corpo, "fields") ?? state.corpo),
@@ -221,6 +638,21 @@ export function converterParaIr(modulo, diagnosticos, contexto) {
             .map((linha) => parsearTransicaoEstado(linha.conteudo))
             .filter((linha) => Boolean(linha)),
     }));
+    const resumoAgenteModulo = resumirAgente({
+        input: [],
+        output: [],
+        efeitos: [
+            ...tasks.flatMap((task) => task.efeitosEstruturados),
+            ...routes.flatMap((route) => route.efeitosPublicos),
+            ...superficies.flatMap((superficie) => superficie.effects),
+        ],
+        vinculos: [
+            ...converterVinculos(modulo.vinculos),
+            ...tasks.flatMap((task) => task.vinculos),
+            ...routes.flatMap((route) => route.vinculos),
+            ...superficies.flatMap((superficie) => superficie.vinculos),
+        ],
+    });
     return {
         nome: modulo.nome,
         uses: contexto?.modulosImportados.length
@@ -234,13 +666,25 @@ export function converterParaIr(modulo, diagnosticos, contexto) {
         interoperabilidades: contexto?.interoperabilidades.map((interop) => ({ ...interop })) ?? modulo.uses
             .filter(ehUseInterop)
             .map((use) => ({ origem: use.origem, caminho: use.caminho })),
+        vinculos: converterVinculos(modulo.vinculos),
+        perfilCompatibilidade: perfilModulo,
         types,
         entities,
         enums: modulo.enums.map((enumeracao) => ({ nome: enumeracao.nome, valores: enumeracao.valores })),
         tasks,
         flows,
         routes,
+        superficies,
         states,
+        resumoAgente: {
+            ...resumoAgenteModulo,
+            superficiesPublicas: deduplicarTexto([
+                ...routes.map((route) => `${route.metodo ?? "?"} ${route.caminho ?? route.nome}`),
+                ...superficies
+                    .filter((superficie) => superficie.perfilCompatibilidade === "publico")
+                    .map((superficie) => `${superficie.tipo}:${superficie.nome}`),
+            ]),
+        },
         diagnosticos,
     };
 }