@semacode/cli 1.3.7 → 1.5.0

package/dist/drift.js

@@ -8,7 +8,7 @@ import { extrairRotasJava, extrairSimbolosJava } from "./java-http.js";
 import { contarIndentacaoPython, extrairRotasFlaskDecoradas, normalizarCaminhoFlask } from "./python-http.js";
 import { extrairRotasRust, extrairSimbolosRust } from "./rust-http.js";
 import { extrairRotasTypeScriptHttp } from "./typescript-http.js";
-const DIRETORIOS_IGNORADOS = new Set([
+const DIRETORIOS_IGNORADOS_BASE = new Set([
     ".git",
     ".hg",
     ".svn",
@@ -25,9 +25,563 @@ const DIRETORIOS_IGNORADOS = new Set([
     ".tmp",
     "generated",
 ]);
+const DIRETORIOS_WORKTREE = [
+    ".claude",
+    "worktrees",
+];
+const DIRETORIOS_CONSUMIDOR_LATERAL = [
+    "showcase",
+    "showcases",
+    "storybook",
+    "stories",
+    "playground",
+    "sandbox",
+    "fixture",
+    "fixtures",
+    "demo",
+    "demos",
+    "sample",
+    "samples",
+    "mini-web",
+];
+const TERMOS_ESCopo_IGNORADOS = new Set([
+    "api",
+    "app",
+    "apps",
+    "base",
+    "codigo",
+    "config",
+    "controller",
+    "controllers",
+    "data",
+    "drift",
+    "flow",
+    "module",
+    "modulo",
+    "publico",
+    "route",
+    "routes",
+    "schema",
+    "sema",
+    "service",
+    "services",
+    "src",
+    "task",
+    "tasks",
+    "tests",
+    "ui",
+    "web",
+]);
+let diretoriosIgnoradosAtivos = new Set(DIRETORIOS_IGNORADOS_BASE);
 function normalizarFragmentoArquivo(valor) {
     return valor.replace(/\\/g, "/").replace(/^\.?\//, "").trim().toLowerCase();
 }
+function normalizarEscopoDrift(valor) {
+    if (valor === "arquivo" || valor === "modulo" || valor === "projeto") {
+        return valor;
+    }
+    return "modulo";
+}
+function resolverOpcoesDrift(opcoes) {
+    return {
+        escopo: normalizarEscopoDrift(opcoes?.escopo),
+        ignorarWorktrees: opcoes?.ignorarWorktrees !== false,
+        ignorarConsumidoresLaterais: opcoes?.ignorarConsumidoresLaterais !== false,
+    };
+}
+function resolverDiretoriosIgnoradosAtivos(opcoes) {
+    const resolvidas = resolverOpcoesDrift(opcoes);
+    const diretorios = new Set(DIRETORIOS_IGNORADOS_BASE);
+    if (resolvidas.ignorarWorktrees) {
+        for (const diretorio of DIRETORIOS_WORKTREE) {
+            diretorios.add(diretorio);
+        }
+    }
+    if (resolvidas.ignorarConsumidoresLaterais) {
+        for (const diretorio of DIRETORIOS_CONSUMIDOR_LATERAL) {
+            diretorios.add(diretorio);
+        }
+    }
+    return diretorios;
+}
+function quebrarTermosEscopo(valor) {
+    return paraIdentificadorModulo(valor)
+        .split("_")
+        .map((item) => item.trim())
+        .filter((item) => item.length >= 3 && !TERMOS_ESCopo_IGNORADOS.has(item));
+}
+function extrairTermosEscopoDrift(contexto, escopo) {
+    if (escopo === "projeto") {
+        return [];
+    }
+    const termos = new Set();
+    termos.add(paraIdentificadorModulo(path.basename(contexto.entradaResolvida, path.extname(contexto.entradaResolvida))));
+    for (const modulo of contexto.modulosSelecionados) {
+        const ir = modulo.resultado.ir;
+        if (!ir) {
+            continue;
+        }
+        for (const termo of quebrarTermosEscopo(ir.nome)) {
+            termos.add(termo);
+        }
+        for (const task of ir.tasks) {
+            for (const termo of quebrarTermosEscopo(task.nome)) {
+                termos.add(termo);
+            }
+        }
+        for (const route of ir.routes) {
+            for (const termo of quebrarTermosEscopo(route.nome)) {
+                termos.add(termo);
+            }
+            if (route.caminho) {
+                for (const termo of quebrarTermosEscopo(route.caminho)) {
+                    termos.add(termo);
+                }
+            }
+        }
+    }
+    return [...termos].filter(Boolean).sort((a, b) => a.localeCompare(b, "pt-BR"));
+}
+function caminhoTemSegmentoIgnorado(arquivo, segmentos) {
+    const partes = normalizarFragmentoArquivo(arquivo).split("/").filter(Boolean);
+    return partes.some((parte) => segmentos.includes(parte));
+}
+function normalizarCaminhoComparacao(caminhoArquivo) {
+    return path.resolve(caminhoArquivo).replace(/\\/g, "/").replace(/\/+$/, "").toLowerCase();
+}
+function caminhoEstaDentroDe(base, alvo) {
+    const baseNormalizada = normalizarCaminhoComparacao(base);
+    const alvoNormalizado = normalizarCaminhoComparacao(alvo);
+    return alvoNormalizado === baseNormalizada || alvoNormalizado.startsWith(`${baseNormalizada}/`);
+}
+function resolverRaizEscopoReal(contexto) {
+    const entrada = path.resolve(contexto.entradaResolvida);
+    return path.extname(entrada) ? path.dirname(entrada) : entrada;
+}
+function resolverRaizesExplicitasConfiguradas(contexto) {
+    const configCarregada = contexto.configCarregada;
+    if (!configCarregada) {
+        return [];
+    }
+    const origensDeclaradas = configCarregada.config.origens ?? (configCarregada.config.origem ? [configCarregada.config.origem] : []);
+    return [...new Set([
+            ...(configCarregada.config.diretoriosCodigo ?? []).map((diretorio) => path.resolve(configCarregada.baseDiretorio, diretorio)),
+            ...origensDeclaradas.map((origem) => path.resolve(configCarregada.baseDiretorio, origem)),
+        ])].sort((a, b) => a.localeCompare(b, "pt-BR"));
+}
+function resolverRaizesIgnoradasPermitidas(contexto, segmentosIgnorados) {
+    return [...new Set([
+            resolverRaizEscopoReal(contexto),
+            ...resolverRaizesExplicitasConfiguradas(contexto),
+        ])]
+        .filter((raiz) => caminhoTemSegmentoIgnorado(raiz, segmentosIgnorados))
+        .sort((a, b) => a.localeCompare(b, "pt-BR"));
+}
+function caminhoIgnoradoForaDoEscopoReal(caminhoArquivo, segmentosIgnorados, raizesPermitidas) {
+    if (!caminhoTemSegmentoIgnorado(caminhoArquivo, segmentosIgnorados)) {
+        return false;
+    }
+    if (raizesPermitidas.length === 0) {
+        return true;
+    }
+    return !raizesPermitidas.some((raiz) => caminhoEstaDentroDe(raiz, caminhoArquivo));
+}
+function filtrarCaminhosEscopoReal(caminhos, contexto, configuracao) {
+    const raizesWorktreePermitidas = resolverRaizesIgnoradasPermitidas(contexto, DIRETORIOS_WORKTREE);
+    const raizesConsumidorPermitidas = resolverRaizesIgnoradasPermitidas(contexto, DIRETORIOS_CONSUMIDOR_LATERAL);
+    return caminhos.filter((caminho) => {
+        if (configuracao.ignorarWorktrees && caminhoIgnoradoForaDoEscopoReal(caminho, DIRETORIOS_WORKTREE, raizesWorktreePermitidas)) {
+            return false;
+        }
+        if (configuracao.ignorarConsumidoresLaterais
+            && caminhoIgnoradoForaDoEscopoReal(caminho, DIRETORIOS_CONSUMIDOR_LATERAL, raizesConsumidorPermitidas)) {
+            return false;
+        }
+        return true;
+    });
+}
+function resolverDiretoriosCodigoEscopoReal(contexto, configuracao) {
+    return filtrarCaminhosEscopoReal(contexto.diretoriosCodigo, contexto, configuracao);
+}
+function textoCombinaEscopo(texto, termos) {
+    if (termos.length === 0) {
+        return true;
+    }
+    const normalizado = paraIdentificadorModulo(texto);
+    return termos.some((termo) => normalizado.includes(termo));
+}
+function filtrarConsumerSurfacesPorEscopo(consumerSurfaces, consumerBridges, contexto, configuracao) {
+    const raizesWorktreePermitidas = resolverRaizesIgnoradasPermitidas(contexto, DIRETORIOS_WORKTREE);
+    const raizesConsumidorPermitidas = resolverRaizesIgnoradasPermitidas(contexto, DIRETORIOS_CONSUMIDOR_LATERAL);
+    const manterSurface = (surface) => {
+        if (configuracao.ignorarWorktrees
+            && caminhoIgnoradoForaDoEscopoReal(surface.arquivo, DIRETORIOS_WORKTREE, raizesWorktreePermitidas)) {
+            return false;
+        }
+        if (configuracao.ignorarConsumidoresLaterais
+            && caminhoIgnoradoForaDoEscopoReal(surface.arquivo, DIRETORIOS_CONSUMIDOR_LATERAL, raizesConsumidorPermitidas)) {
+            return false;
+        }
+        const combinaEscopo = textoCombinaEscopo(`${surface.rota} ${surface.arquivo} ${surface.tipoArquivo}`, configuracao.termosEscopo);
+        if (!configuracao.ignorarConsumidoresLaterais) {
+            return combinaEscopo || configuracao.escopo === "projeto";
+        }
+        return configuracao.escopo === "projeto" ? true : combinaEscopo;
+    };
+    const manterBridge = (bridge) => {
+        if (configuracao.ignorarWorktrees
+            && caminhoIgnoradoForaDoEscopoReal(bridge.arquivo, DIRETORIOS_WORKTREE, raizesWorktreePermitidas)) {
+            return false;
+        }
+        if (configuracao.ignorarConsumidoresLaterais
+            && caminhoIgnoradoForaDoEscopoReal(bridge.arquivo, DIRETORIOS_CONSUMIDOR_LATERAL, raizesConsumidorPermitidas)) {
+            return false;
+        }
+        const combinaEscopo = textoCombinaEscopo(`${bridge.caminho} ${bridge.arquivo} ${bridge.simbolo}`, configuracao.termosEscopo);
+        if (!configuracao.ignorarConsumidoresLaterais) {
+            return combinaEscopo || configuracao.escopo === "projeto";
+        }
+        return configuracao.escopo === "projeto" ? true : combinaEscopo;
+    };
+    return {
+        consumerSurfaces: consumerSurfaces.filter(manterSurface),
+        consumerBridges: consumerBridges.filter(manterBridge),
+    };
+}
+const NOMES_RECURSO_IGNORADOS = new Set([
+    "all",
+    "and",
+    "as",
+    "by",
+    "create",
+    "delete",
+    "from",
+    "group",
+    "inner",
+    "into",
+    "join",
+    "left",
+    "limit",
+    "offset",
+    "on",
+    "or",
+    "order",
+    "outer",
+    "returning",
+    "right",
+    "select",
+    "set",
+    "table",
+    "update",
+    "values",
+    "view",
+    "where",
+]);
+const OPERACOES_REDIS_KEYSPACE = [
+    "append",
+    "decr",
+    "del",
+    "expire",
+    "expireat",
+    "get",
+    "getdel",
+    "getex",
+    "getrange",
+    "hdel",
+    "hexists",
+    "hget",
+    "hgetall",
+    "hincrby",
+    "hkeys",
+    "hlen",
+    "hmget",
+    "hmset",
+    "hrandfield",
+    "hscan",
+    "hset",
+    "hsetnx",
+    "hvals",
+    "incr",
+    "incrby",
+    "lindex",
+    "llen",
+    "lpop",
+    "lpush",
+    "lrange",
+    "lrem",
+    "lset",
+    "rpop",
+    "rpush",
+    "sadd",
+    "scard",
+    "set",
+    "setex",
+    "setnx",
+    "smembers",
+    "spop",
+    "srem",
+    "ttl",
+    "type",
+    "zadd",
+    "zcard",
+    "zrange",
+    "zrem",
+];
+const OPERACOES_REDIS_STREAM = [
+    "xadd",
+    "xdel",
+    "xgroupcreate",
+    "xgroupdestroy",
+    "xlen",
+    "xrange",
+    "xread",
+    "xreadgroup",
+    "xrevrange",
+    "xtrim",
+];
+function limparLiteralRecurso(valor) {
+    return valor
+        .trim()
+        .replace(/^["'`]+|["'`]+$/g, "")
+        .replace(/\$\{[^}]+\}/g, "")
+        .replace(/\{[^}]+\}/g, "")
+        .replace(/%[sdifjo]/gi, "")
+        .trim();
+}
+function fecharPrefixoRecurso(valor) {
+    return valor.replace(/[:/_\-.]+$/g, "").trim();
+}
+function normalizarNomeRecursoDrift(valor) {
+    return fecharPrefixoRecurso(limparLiteralRecurso(valor))
+        .normalize("NFD")
+        .replace(/[\u0300-\u036f]/g, "")
+        .toLowerCase()
+        .replace(/["'`]/g, "")
+        .replace(/\s+/g, "");
+}
+function variantesNomeRecursoDrift(valor) {
+    const base = fecharPrefixoRecurso(limparLiteralRecurso(valor));
+    if (!base) {
+        return [];
+    }
+    const variantes = new Set();
+    const registrar = (candidato) => {
+        if (!candidato) {
+            return;
+        }
+        const normalizado = normalizarNomeRecursoDrift(candidato);
+        if (normalizado) {
+            variantes.add(normalizado);
+        }
+    };
+    registrar(base);
+    registrar(base.replace(/[.:/_-]+/g, "_"));
+    registrar(base.replace(/[.:/_-]+/g, ""));
+    const partes = base.split(/[.:/_-]+/).filter(Boolean);
+    if (partes.length > 1) {
+        registrar(partes.join("_"));
+        registrar(partes.join(""));
+    }
+    const singular = base.replace(/s$/i, "");
+    if (singular && singular !== base) {
+        registrar(singular);
+    }
+    else if (!/s$/i.test(base)) {
+        registrar(`${base}s`);
+    }
+    return [...variantes];
+}
+function recursoEhIgnorado(nome) {
+    const normalizado = normalizarNomeRecursoDrift(nome);
+    if (!normalizado || normalizado.length < 2) {
+        return true;
+    }
+    return NOMES_RECURSO_IGNORADOS.has(normalizado);
+}
+function registrarRecursoDrift(recursos, origem, tipo, nome, arquivo, simbolo) {
+    const nomeLimpo = fecharPrefixoRecurso(limparLiteralRecurso(nome));
+    if (!nomeLimpo || recursoEhIgnorado(nomeLimpo)) {
+        return;
+    }
+    const chave = `${origem}:${tipo}:${normalizarNomeRecursoDrift(nomeLimpo)}:${arquivo}:${simbolo ?? ""}`;
+    if (!recursos.has(chave)) {
+        recursos.set(chave, {
+            origem,
+            nome: nomeLimpo,
+            arquivo,
+            simbolo,
+            tipo,
+        });
+    }
+}
+function inferirMotoresRelacionais(codigo, arquivo) {
+    const motores = new Set();
+    const caminho = normalizarFragmentoArquivo(arquivo);
+    if (/\b(?:from|require)\s*\(?["'`]pg["'`]/i.test(codigo)
+        || /\bpostgres(?:ql)?\b/i.test(codigo)
+        || /\bon\s+conflict\b/i.test(codigo)
+        || /\breturning\b/i.test(codigo)
+        || /\bjsonb\b/i.test(codigo)
+        || /\bilike\b/i.test(codigo)
+        || /(?:^|\/)(?:postgres|pgsql)(?:\/|[-_.])/i.test(caminho)) {
+        motores.add("postgres");
+    }
+    if (/\b(?:from|require)\s*\(?["'`](?:mysql2?(?:\/promise)?|mysql)["'`]/i.test(codigo)
+        || /\bon\s+duplicate\s+key\b/i.test(codigo)
+        || /\bauto_increment\b/i.test(codigo)
+        || /\binnodb\b/i.test(codigo)
+        || /\bunsigned\b/i.test(codigo)
+        || /(?:^|\/)mysql(?:\/|[-_.])/i.test(caminho)) {
+        motores.add("mysql");
+    }
+    if (/\b(?:from|require)\s*\(?["'`](?:sqlite3|better-sqlite3|bun:sqlite|sqlite)["'`]/i.test(codigo)
+        || /\bpragma\b/i.test(codigo)
+        || /\bwithout\s+rowid\b/i.test(codigo)
+        || /\bsqlite\b/i.test(codigo)
+        || /(?:^|\/)sqlite(?:\/|[-_.])/i.test(caminho)) {
+        motores.add("sqlite");
+    }
+    const temSqlGenerico = /\b(?:select\b[\s\S]*?\bfrom\b|insert\s+into|update\s+[A-Za-z_][\w$.-]*\s+set|delete\s+from|create\s+(?:table|view)|alter\s+table|drop\s+(?:table|view)|join\s+[A-Za-z_][\w$.-]*)/i.test(codigo)
+        || /\.(?:from|into|table)\s*\(\s*["'`]/i.test(codigo)
+        || /\b(?:knex|db|trx)\s*\(\s*["'`][A-Za-z_][^"'`]+["'`]\s*\)/i.test(codigo)
+        || /\bprisma\.[A-Za-z_]\w*\.(?:find\w+|create|update|delete|upsert|aggregate|count)\b/i.test(codigo);
+    if (temSqlGenerico && motores.size === 0) {
+        motores.add("postgres");
+        motores.add("mysql");
+        motores.add("sqlite");
+    }
+    return [...motores];
+}
+function extrairRecursosSql(arquivo, codigo) {
+    const recursos = new Map();
+    const motores = inferirMotoresRelacionais(codigo, arquivo);
+    if (motores.length === 0) {
+        return [];
+    }
+    const registrarParaMotores = (tipo, nome) => {
+        for (const motor of motores) {
+            registrarRecursoDrift(recursos, motor, tipo, nome, arquivo);
+        }
+    };
+    const registrarTextoSql = (texto) => {
+        if (!/\b(?:select\b[\s\S]*?\bfrom\b|insert\s+into|update\s+[A-Za-z_][\w$.-]*\s+set|delete\s+from|create\s+(?:table|view)|alter\s+table|drop\s+(?:table|view)|join\s+[A-Za-z_][\w$.-]*|create\s+(?:unique\s+)?index)\b/i.test(texto)) {
+            return;
+        }
+        for (const match of texto.matchAll(/\bcreate\s+(?:or\s+replace\s+)?(table|view)\s+(?:if\s+not\s+exists\s+)?["'`]?([A-Za-z_][\w$.-]*)["'`]?/gi)) {
+            registrarParaMotores(match[1].toLowerCase(), match[2]);
+        }
+        for (const match of texto.matchAll(/\bcreate\s+(?:unique\s+)?index\s+(?:if\s+not\s+exists\s+)?["'`]?([A-Za-z_][\w$.-]*)["'`]?/gi)) {
+            registrarParaMotores("index", match[1]);
+        }
+        for (const match of texto.matchAll(/\b(?:insert\s+into|update|from|join|delete\s+from|truncate\s+table)\s+["'`]?([A-Za-z_][\w$.-]*)["'`]?/gi)) {
+            registrarParaMotores("table", match[1]);
+        }
+    };
+    if (/\.(?:sql|psql|ddl)$/i.test(arquivo)) {
+        registrarTextoSql(codigo);
+    }
+    else {
+        for (const literal of codigo.matchAll(/(["'`])([\s\S]*?)\1/g)) {
+            registrarTextoSql(literal[2] ?? "");
+        }
+    }
+    for (const match of codigo.matchAll(/\.(?:from|into|table)\s*\(\s*["'`]([^"'`]+)["'`]\s*\)/gi)) {
+        registrarParaMotores("table", match[1]);
+    }
+    for (const match of codigo.matchAll(/\b(?:knex|db|trx)\s*\(\s*["'`]([^"'`]+)["'`]\s*\)/gi)) {
+        registrarParaMotores("table", match[1]);
+    }
+    for (const match of codigo.matchAll(/\bprisma\.([A-Za-z_]\w*)\.(?:find\w+|create|update|delete|upsert|aggregate|count)\b/gi)) {
+        registrarParaMotores("table", match[1]);
+    }
+    return [...recursos.values()];
+}
+function extrairRecursosMongoDb(arquivo, codigo) {
+    const recursos = new Map();
+    const contextoMongo = /\b(?:mongodb|mongoose|mongoclient|objectid)\b/i.test(codigo)
+        || /\bdb\.collection\s*\(/i.test(codigo)
+        || /(?:^|\/)mongo(?:db)?(?:\/|[-_.])/i.test(normalizarFragmentoArquivo(arquivo));
+    if (!contextoMongo) {
+        return [];
+    }
+    for (const match of codigo.matchAll(/\b(?:db\.)?collection\s*\(\s*["'`]([^"'`]+)["'`]\s*\)/gi)) {
+        registrarRecursoDrift(recursos, "mongodb", "collection", match[1], arquivo);
+    }
+    for (const match of codigo.matchAll(/\bgetCollection\s*\(\s*["'`]([^"'`]+)["'`]\s*\)/gi)) {
+        registrarRecursoDrift(recursos, "mongodb", "collection", match[1], arquivo);
+    }
+    for (const match of codigo.matchAll(/\bmongoose\.model\s*\(\s*["'`]([^"'`]+)["'`](?:\s*,[\s\S]*?,\s*["'`]([^"'`]+)["'`])?/gi)) {
+        registrarRecursoDrift(recursos, "mongodb", "document", match[1], arquivo);
+        if (match[2]) {
+            registrarRecursoDrift(recursos, "mongodb", "collection", match[2], arquivo);
+        }
+    }
+    for (const match of codigo.matchAll(/\bdb\.([A-Za-z_]\w*)\.(?:find|findOne|aggregate|insertOne|insertMany|updateOne|updateMany|deleteOne|deleteMany|countDocuments)\b/gi)) {
+        registrarRecursoDrift(recursos, "mongodb", "collection", match[1], arquivo);
+    }
+    return [...recursos.values()];
+}
+function extrairRecursosRedis(arquivo, codigo) {
+    const recursos = new Map();
+    const contextoRedis = /\b(?:from|require)\s*\(?["'`](?:redis|ioredis)["'`]/i.test(codigo)
+        || /\bcreateClient\s*\(/i.test(codigo)
+        || /\bx(?:add|read|readgroup|groupcreate|groupdestroy)\s*\(/i.test(codigo)
+        || /(?:^|\/)redis(?:\/|[-_.])/i.test(normalizarFragmentoArquivo(arquivo));
+    if (!contextoRedis) {
+        return [];
+    }
+    const operacoesKeyspace = OPERACOES_REDIS_KEYSPACE.join("|");
+    const operacoesStream = OPERACOES_REDIS_STREAM.join("|");
+    const padraoKeyspace = new RegExp(`\\b(?:${operacoesKeyspace})\\s*\\(\\s*['"\\\`]([^'"\\\`]+)['"\\\`]`, "gi");
+    const padraoStream = new RegExp(`\\b(?:${operacoesStream})\\s*\\(\\s*['"\\\`]([^'"\\\`]+)['"\\\`]`, "gi");
+    for (const match of codigo.matchAll(padraoKeyspace)) {
+        registrarRecursoDrift(recursos, "redis", "keyspace", match[1], arquivo);
+    }
+    for (const match of codigo.matchAll(padraoStream)) {
+        registrarRecursoDrift(recursos, "redis", "stream", match[1], arquivo);
+    }
+    return [...recursos.values()];
+}
+function extrairRecursosPersistenciaCodigoVivo(arquivo, codigo) {
+    const recursos = new Map();
+    for (const recurso of extrairColecoesFirebase(arquivo, codigo)) {
+        registrarRecursoDrift(recursos, recurso.origem, recurso.tipo, recurso.nome, recurso.arquivo, recurso.simbolo);
+    }
+    for (const recurso of extrairRecursosSql(arquivo, codigo)) {
+        registrarRecursoDrift(recursos, recurso.origem, recurso.tipo, recurso.nome, recurso.arquivo, recurso.simbolo);
+    }
+    for (const recurso of extrairRecursosMongoDb(arquivo, codigo)) {
+        registrarRecursoDrift(recursos, recurso.origem, recurso.tipo, recurso.nome, recurso.arquivo, recurso.simbolo);
+    }
+    for (const recurso of extrairRecursosRedis(arquivo, codigo)) {
+        registrarRecursoDrift(recursos, recurso.origem, recurso.tipo, recurso.nome, recurso.arquivo, recurso.simbolo);
+    }
+    return [...recursos.values()];
+}
+function extrairRecursosPrisma(arquivo, codigo) {
+    const recursos = new Map();
+    const provider = codigo.match(/\bprovider\s*=\s*["'`](postgresql|mysql|sqlite)["'`]/i)?.[1]?.toLowerCase();
+    const origem = provider === "postgresql"
+        ? "postgres"
+        : provider === "mysql"
+            ? "mysql"
+            : provider === "sqlite"
+                ? "sqlite"
+                : undefined;
+    if (!origem) {
+        return [];
+    }
+    for (const match of codigo.matchAll(/\bmodel\s+([A-Za-z_]\w*)\s*\{([\s\S]*?)\n\}/g)) {
+        const nomeModelo = match[1];
+        const corpo = match[2] ?? "";
+        const tabelaMapeada = corpo.match(/@@map\s*\(\s*["'`]([^"'`]+)["'`]\s*\)/)?.[1];
+        registrarRecursoDrift(recursos, origem, "table", tabelaMapeada ?? nomeModelo, arquivo);
+        if (tabelaMapeada) {
+            registrarRecursoDrift(recursos, origem, "table", nomeModelo, arquivo);
+        }
+    }
+    return [...recursos.values()];
+}
 function escolherArquivoPorVinculo(arquivos, valor) {
     const normalizado = normalizarFragmentoArquivo(valor);
     const exato = arquivos.find((arquivo) => normalizarFragmentoArquivo(arquivo) === normalizado);
@@ -210,14 +764,35 @@ function resumirOperacional(resultado) {
         ? Math.round(resultado.tasks.reduce((total, task) => total + task.scoreSemantico, 0) / resultado.tasks.length)
         : 0;
     const confiancaGeral = scoreMedio >= 80 ? "alta" : scoreMedio >= 55 ? "media" : "baixa";
-    const riscosPrincipais = [...new Set(resultado.tasks.filter((task) => task.riscoOperacional !== "baixo").map((task) => `${task.task}:${task.riscoOperacional}`))];
-    const oQueTocar = [...new Set(resultado.tasks.flatMap((task) => task.arquivosProvaveisEditar))].slice(0, 20);
-    const oQueValidar = [...new Set(resultado.tasks.flatMap((task) => task.checksSugeridos))];
-    const oQueEstaFrouxo = [...new Set(resultado.tasks.flatMap((task) => task.lacunas))];
+    const riscosPrincipais = [...new Set([
+            ...resultado.tasks.filter((task) => task.riscoOperacional !== "baixo").map((task) => `${task.task}:${task.riscoOperacional}`),
+            ...resultado.persistencia_real
+                .filter((item) => item.status !== "materializado")
+                .map((item) => `${item.task}:${item.alvo}:persistencia_${item.status}`),
+        ])];
+    const oQueTocar = [...new Set([
+            ...resultado.tasks.flatMap((task) => task.arquivosProvaveisEditar),
+            ...resultado.persistencia_real.flatMap((item) => [...item.arquivos, ...item.repositorios]),
+        ])].slice(0, 20);
+    const oQueValidar = [...new Set([
+            ...resultado.tasks.flatMap((task) => task.checksSugeridos),
+            ...resultado.persistencia_real
+                .filter((item) => item.status !== "materializado")
+                .map((item) => `validar persistencia real de ${item.task} em ${item.alvo}`),
+        ])];
+    const oQueEstaFrouxo = [...new Set([
+            ...resultado.tasks.flatMap((task) => task.lacunas),
+            ...resultado.persistencia_real
+                .filter((item) => item.status !== "materializado" || item.compatibilidade === "desconhecida" || item.compatibilidade === "invalido")
+                .map((item) => `persistencia:${item.alvo}:${item.status}:${item.compatibilidade}`),
+        ])];
     const oQueFoiInferido = [
         ...new Set([
             ...resultado.impls_quebrados.flatMap((impl) => impl.candidatos?.map((candidato) => candidato.caminho) ?? []),
             ...resultado.vinculos_quebrados.filter((vinculo) => vinculo.status === "parcial").map((vinculo) => `${vinculo.dono}:${vinculo.valor}`),
+            ...resultado.persistencia_real
+                .filter((item) => item.compatibilidade === "desconhecida")
+                .map((item) => `${item.task}:${item.alvo}:compatibilidade_nao_confirmada`),
         ]),
     ];
     return {
@@ -286,7 +861,7 @@ async function listarArquivosRecursivos(diretorio, extensoes) {
     }
     const encontrados = [];
     for (const entrada of entradas) {
-        if (DIRETORIOS_IGNORADOS.has(entrada.name)) {
+        if (diretoriosIgnoradosAtivos.has(entrada.name.toLowerCase())) {
             continue;
         }
         const caminhoAtual = path.join(diretorio, entrada.name);
@@ -701,8 +1276,8 @@ async function indexarTypeScript(diretorios) {
             const sourceFile = ts.createSourceFile(arquivo, codigo, ts.ScriptTarget.Latest, true, scriptKind);
             const basesSimbolicas = caminhosSimbolicos(diretorio, arquivo);
             const relacao = path.relative(diretorio, arquivo);
-            for (const recurso of extrairColecoesFirebase(arquivo, codigo)) {
-                recursos.set(`${recurso.nome}:${recurso.arquivo}:${recurso.tipo}`, recurso);
+            for (const recurso of extrairRecursosPersistenciaCodigoVivo(arquivo, codigo)) {
+                registrarRecursoDrift(recursos, recurso.origem, recurso.tipo, recurso.nome, recurso.arquivo, recurso.simbolo);
             }
             for (const rota of extrairRotasTypeScriptHttp(sourceFile, relacao)) {
                 rotas.push({
@@ -889,6 +1464,7 @@ function registrarRotasPython(rotas, decoratorsPendentes, prefixo, arquivo, nome
 async function indexarPython(diretorios) {
     const simbolos = new Map();
     const rotas = [];
+    const recursos = new Map();
     for (const diretorio of diretorios) {
         const arquivos = (await listarArquivosRecursivos(diretorio, [".py"]))
             .filter((arquivo) => !arquivo.endsWith("__init__.py") && !/tests?[\\/]/i.test(arquivo));
@@ -896,6 +1472,9 @@ async function indexarPython(diretorios) {
             const texto = await readFile(arquivo, "utf8");
             const basesSimbolicas = caminhosSimbolicos(diretorio, arquivo);
             const prefixo = texto.match(/APIRouter\s*\(\s*prefix\s*=\s*["']([^"']+)["']/)?.[1];
+            for (const recurso of extrairRecursosPersistenciaCodigoVivo(arquivo, texto)) {
+                registrarRecursoDrift(recursos, recurso.origem, recurso.tipo, recurso.nome, recurso.arquivo, recurso.simbolo);
+            }
             for (const rota of extrairRotasFlaskDecoradas(texto)) {
                 rotas.push({
                     origem: "flask",
@@ -947,11 +1526,12 @@ async function indexarPython(diretorios) {
             }
         }
     }
-    return { simbolos: [...simbolos.values()], rotas };
+    return { simbolos: [...simbolos.values()], rotas, recursos: [...recursos.values()] };
 }
 async function indexarDart(diretorios) {
     const simbolos = new Map();
     const rotas = [];
+    const recursos = new Map();
     const consumerSurfaces = new Map();
     for (const diretorio of diretorios) {
         const arquivos = (await listarArquivosRecursivos(diretorio, [".dart"]))
@@ -960,6 +1540,9 @@ async function indexarDart(diretorios) {
             const texto = await readFile(arquivo, "utf8");
             const basesSimbolicas = caminhosSimbolicos(diretorio, arquivo);
             const relacao = path.relative(diretorio, arquivo);
+            for (const recurso of extrairRecursosPersistenciaCodigoVivo(arquivo, texto)) {
+                registrarRecursoDrift(recursos, recurso.origem, recurso.tipo, recurso.nome, recurso.arquivo, recurso.simbolo);
+            }
             for (const match of texto.matchAll(/(?:Future<[^\n]+>|[\w?<>.,\s]+)\s+(\w+)\(([^)]*)\)\s*(?:async\s*)?\{/g)) {
                 const nome = match[1];
                 if (["build", "toString"].includes(nome)) {
@@ -1006,6 +1589,7 @@ async function indexarDart(diretorios) {
     return {
         simbolos: [...simbolos.values()],
         rotas,
+        recursos: [...recursos.values()],
         consumerSurfaces: [...consumerSurfaces.values()].sort((a, b) => a.rota.localeCompare(b.rota, "pt-BR")
             || a.tipoArquivo.localeCompare(b.tipoArquivo, "pt-BR")
             || a.arquivo.localeCompare(b.arquivo, "pt-BR")),
@@ -1037,12 +1621,16 @@ function registrarSimboloGenerico(simbolos, origem, basesSimbolicas, arquivo, si
 async function indexarDotnet(diretorios) {
     const simbolos = new Map();
     const rotas = [];
+    const recursos = new Map();
     for (const diretorio of diretorios) {
         const arquivos = (await listarArquivosRecursivos(diretorio, [".cs"]))
             .filter((arquivo) => !/(^|[\\/])(bin|obj|Test[s]?)([\\/]|$)/i.test(arquivo));
         for (const arquivo of arquivos) {
             const codigo = await readFile(arquivo, "utf8");
             const basesSimbolicas = caminhosSimbolicos(diretorio, arquivo);
+            for (const recurso of extrairRecursosPersistenciaCodigoVivo(arquivo, codigo)) {
+                registrarRecursoDrift(recursos, recurso.origem, recurso.tipo, recurso.nome, recurso.arquivo, recurso.simbolo);
+            }
             for (const simbolo of extrairSimbolosDotnet(codigo)) {
                 registrarSimboloGenerico(simbolos, "cs", basesSimbolicas, arquivo, simbolo.simbolo);
             }
@@ -1057,17 +1645,21 @@ async function indexarDotnet(diretorios) {
             }
         }
     }
-    return { simbolos: [...simbolos.values()], rotas };
+    return { simbolos: [...simbolos.values()], rotas, recursos: [...recursos.values()] };
 }
 async function indexarJava(diretorios) {
     const simbolos = new Map();
     const rotas = [];
+    const recursos = new Map();
     for (const diretorio of diretorios) {
         const arquivos = (await listarArquivosRecursivos(diretorio, [".java"]))
             .filter((arquivo) => !/(^|[\\/])(target|build|out|Test[s]?)([\\/]|$)/i.test(arquivo));
         for (const arquivo of arquivos) {
             const codigo = await readFile(arquivo, "utf8");
             const basesSimbolicas = caminhosSimbolicos(diretorio, arquivo);
+            for (const recurso of extrairRecursosPersistenciaCodigoVivo(arquivo, codigo)) {
+                registrarRecursoDrift(recursos, recurso.origem, recurso.tipo, recurso.nome, recurso.arquivo, recurso.simbolo);
+            }
             for (const simbolo of extrairSimbolosJava(codigo)) {
                 registrarSimboloGenerico(simbolos, "java", basesSimbolicas, arquivo, simbolo.simbolo);
             }
@@ -1082,16 +1674,20 @@ async function indexarJava(diretorios) {
             }
         }
     }
-    return { simbolos: [...simbolos.values()], rotas };
+    return { simbolos: [...simbolos.values()], rotas, recursos: [...recursos.values()] };
 }
 async function indexarGo(diretorios) {
     const simbolos = new Map();
     const rotas = [];
+    const recursos = new Map();
     for (const diretorio of diretorios) {
         const arquivos = await listarArquivosRecursivos(diretorio, [".go"]);
         for (const arquivo of arquivos) {
             const codigo = await readFile(arquivo, "utf8");
             const basesSimbolicas = caminhosSimbolicos(diretorio, arquivo);
+            for (const recurso of extrairRecursosPersistenciaCodigoVivo(arquivo, codigo)) {
+                registrarRecursoDrift(recursos, recurso.origem, recurso.tipo, recurso.nome, recurso.arquivo, recurso.simbolo);
+            }
             for (const simbolo of extrairSimbolosGo(codigo)) {
                 registrarSimboloGenerico(simbolos, "go", basesSimbolicas, arquivo, simbolo.simbolo);
             }
@@ -1106,16 +1702,20 @@ async function indexarGo(diretorios) {
             }
         }
     }
-    return { simbolos: [...simbolos.values()], rotas };
+    return { simbolos: [...simbolos.values()], rotas, recursos: [...recursos.values()] };
 }
 async function indexarRust(diretorios) {
     const simbolos = new Map();
     const rotas = [];
+    const recursos = new Map();
     for (const diretorio of diretorios) {
         const arquivos = await listarArquivosRecursivos(diretorio, [".rs"]);
         for (const arquivo of arquivos) {
             const codigo = await readFile(arquivo, "utf8");
             const basesSimbolicas = caminhosSimbolicos(diretorio, arquivo);
+            for (const recurso of extrairRecursosPersistenciaCodigoVivo(arquivo, codigo)) {
+                registrarRecursoDrift(recursos, recurso.origem, recurso.tipo, recurso.nome, recurso.arquivo, recurso.simbolo);
+            }
             for (const simbolo of extrairSimbolosRust(codigo)) {
                 registrarSimboloGenerico(simbolos, "rust", basesSimbolicas, arquivo, simbolo.simbolo);
             }
@@ -1130,22 +1730,312 @@ async function indexarRust(diretorios) {
             }
         }
     }
-    return { simbolos: [...simbolos.values()], rotas };
+    return { simbolos: [...simbolos.values()], rotas, recursos: [...recursos.values()] };
 }
 async function indexarCpp(diretorios) {
     const simbolos = new Map();
+    const recursos = new Map();
     for (const diretorio of diretorios) {
         const arquivos = (await listarArquivosRecursivos(diretorio, [".cpp", ".cc", ".cxx", ".hpp", ".h"]))
             .filter((arquivo) => !/(^|[\\/])(windows|linux|macos|runner|flutter|ephemeral|build|vendor)([\\/]|$)/i.test(arquivo));
         for (const arquivo of arquivos) {
             const codigo = await readFile(arquivo, "utf8");
             const basesSimbolicas = caminhosSimbolicos(diretorio, arquivo);
+            for (const recurso of extrairRecursosPersistenciaCodigoVivo(arquivo, codigo)) {
+                registrarRecursoDrift(recursos, recurso.origem, recurso.tipo, recurso.nome, recurso.arquivo, recurso.simbolo);
+            }
             for (const simbolo of extrairSimbolosCpp(codigo)) {
                 registrarSimboloGenerico(simbolos, "cpp", basesSimbolicas, arquivo, simbolo.simbolo);
             }
         }
     }
-    return [...simbolos.values()];
+    return {
+        simbolos: [...simbolos.values()],
+        recursos: [...recursos.values()],
+    };
+}
+async function indexarPersistenciaDeclarativa(diretorios) {
+    const recursos = new Map();
+    for (const diretorio of diretorios) {
+        const arquivos = await listarArquivosRecursivos(diretorio, [".sql", ".psql", ".ddl", ".prisma"]);
+        for (const arquivo of arquivos) {
+            const codigo = await readFile(arquivo, "utf8");
+            const extracoes = arquivo.endsWith(".prisma")
+                ? extrairRecursosPrisma(arquivo, codigo)
+                : extrairRecursosPersistenciaCodigoVivo(arquivo, codigo);
+            for (const recurso of extracoes) {
+                registrarRecursoDrift(recursos, recurso.origem, recurso.tipo, recurso.nome, recurso.arquivo, recurso.simbolo);
+            }
+        }
+    }
+    return { recursos: [...recursos.values()] };
+}
+function normalizarOrigemParaEngine(origem) {
+    return origem && origem !== "firebase" ? origem : undefined;
+}
+function registrarColunaPersistenciaDrift(colunas, engine, recurso, coluna, arquivo) {
+    const recursoNormalizado = fecharPrefixoRecurso(limparLiteralRecurso(recurso));
+    const colunaNormalizada = fecharPrefixoRecurso(limparLiteralRecurso(coluna));
+    if (!recursoNormalizado || !colunaNormalizada || recursoEhIgnorado(colunaNormalizada)) {
+        return;
+    }
+    const chave = `${engine}:${normalizarNomeRecursoDrift(recursoNormalizado)}:${normalizarNomeRecursoDrift(colunaNormalizada)}:${arquivo}`;
+    if (!colunas.has(chave)) {
+        colunas.set(chave, {
+            engine,
+            recurso: recursoNormalizado,
+            coluna: colunaNormalizada,
+            arquivo,
+        });
+    }
+}
+function registrarRepositorioPersistenciaDrift(repositorios, engine, recurso, arquivo) {
+    const recursoNormalizado = fecharPrefixoRecurso(limparLiteralRecurso(recurso));
+    if (!recursoNormalizado) {
+        return;
+    }
+    const chave = `${engine}:${normalizarNomeRecursoDrift(recursoNormalizado)}:${arquivo}`;
+    if (!repositorios.has(chave)) {
+        repositorios.set(chave, {
+            engine,
+            recurso: recursoNormalizado,
+            arquivo,
+        });
+    }
+}
+function extrairColunasSqlDetalhadas(arquivo, codigo) {
+    const colunas = new Map();
+    const motores = inferirMotoresRelacionais(codigo, arquivo);
+    if (motores.length === 0) {
+        return [];
+    }
+    const registrarParaMotores = (recurso, coluna) => {
+        for (const motor of motores) {
+            registrarColunaPersistenciaDrift(colunas, motor, recurso, coluna, arquivo);
+        }
+    };
+    for (const match of codigo.matchAll(/\bcreate\s+table\s+(?:if\s+not\s+exists\s+)?["'`]?([A-Za-z_][\w$.-]*)["'`]?\s*\(([\s\S]*?)\)\s*;?/gi)) {
+        const tabela = match[1];
+        const corpo = match[2] ?? "";
+        for (const linha of corpo.split(/\r?\n|,/)) {
+            const trecho = linha.trim();
+            if (!trecho || /^(?:constraint|primary|foreign|unique|check|key|index)\b/i.test(trecho)) {
+                continue;
+            }
+            const coluna = trecho.match(/^["'`]?([A-Za-z_][\w$.-]*)["'`]?/i)?.[1];
+            if (coluna) {
+                registrarParaMotores(tabela, coluna);
+            }
+        }
+    }
+    for (const match of codigo.matchAll(/\binsert\s+into\s+["'`]?([A-Za-z_][\w$.-]*)["'`]?\s*\(([^)]+)\)/gi)) {
+        for (const coluna of (match[2] ?? "").split(",").map((item) => item.trim())) {
+            registrarParaMotores(match[1], coluna);
+        }
+    }
+    for (const match of codigo.matchAll(/\bupdate\s+["'`]?([A-Za-z_][\w$.-]*)["'`]?\s+set\s+([\s\S]*?)(?:\bwhere\b|;|$)/gi)) {
+        for (const coluna of (match[2] ?? "").split(",").map((item) => item.split("=")[0]?.trim() ?? "")) {
+            registrarParaMotores(match[1], coluna);
+        }
+    }
+    for (const match of codigo.matchAll(/\bselect\s+([\s\S]*?)\s+from\s+["'`]?([A-Za-z_][\w$.-]*)["'`]?/gi)) {
+        const tabela = match[2];
+        const lista = (match[1] ?? "").trim();
+        if (!lista || lista === "*") {
+            continue;
+        }
+        for (const coluna of lista.split(",").map((item) => item.trim().split(/\s+as\s+/i)[0] ?? "")) {
+            const nome = coluna.split(".").at(-1) ?? coluna;
+            registrarParaMotores(tabela, nome);
+        }
+    }
+    return [...colunas.values()];
+}
+function extrairColunasPrismaDetalhadas(arquivo, codigo) {
+    const colunas = new Map();
+    const provider = codigo.match(/\bprovider\s*=\s*["'`](postgresql|mysql|sqlite)["'`]/i)?.[1]?.toLowerCase();
+    const engine = provider === "postgresql"
+        ? "postgres"
+        : provider === "mysql"
+            ? "mysql"
+            : provider === "sqlite"
+                ? "sqlite"
+                : undefined;
+    if (!engine) {
+        return [];
+    }
+    for (const match of codigo.matchAll(/\bmodel\s+([A-Za-z_]\w*)\s*\{([\s\S]*?)\n\}/g)) {
+        const nomeModelo = match[1];
+        const corpo = match[2] ?? "";
+        const tabela = corpo.match(/@@map\s*\(\s*["'`]([^"'`]+)["'`]\s*\)/)?.[1] ?? nomeModelo;
+        for (const linha of corpo.split(/\r?\n/)) {
+            const limpa = linha.trim();
+            if (!limpa || limpa.startsWith("@@") || limpa.startsWith("//")) {
+                continue;
+            }
+            const coluna = limpa.match(/^([A-Za-z_]\w*)\s+/)?.[1];
+            const colunaMapeada = limpa.match(/@map\s*\(\s*["'`]([^"'`]+)["'`]\s*\)/)?.[1];
+            if (coluna) {
+                registrarColunaPersistenciaDrift(colunas, engine, tabela, colunaMapeada ?? coluna, arquivo);
+            }
+        }
+    }
+    return [...colunas.values()];
+}
+function extrairCamposMongoDetalhados(arquivo, codigo) {
+    const colunas = new Map();
+    const colecoes = extrairRecursosMongoDb(arquivo, codigo).filter((item) => item.tipo === "collection");
+    if (colecoes.length === 0) {
+        return [];
+    }
+    const registrarCampoMongo = (colecao, trecho) => {
+        for (const match of trecho.matchAll(/([A-Za-z_][\w$]*)\s*:/g)) {
+            registrarColunaPersistenciaDrift(colunas, "mongodb", colecao, match[1], arquivo);
+        }
+    };
+    for (const schema of codigo.matchAll(/\bnew\s+Schema\s*\(\s*\{([\s\S]*?)\}\s*\)/g)) {
+        for (const colecao of colecoes) {
+            registrarCampoMongo(colecao.nome, schema[1] ?? "");
+        }
+    }
+    for (const trecho of codigo.matchAll(/\b(?:find(?:One)?|update(?:One|Many)?|insertOne|insertMany)\s*\(\s*\{([\s\S]*?)\}\s*(?:,|\))/g)) {
+        for (const colecao of colecoes) {
+            registrarCampoMongo(colecao.nome, trecho[1] ?? "");
+        }
+    }
+    return [...colunas.values()];
+}
+function extrairCamposRedisDetalhados(arquivo, codigo) {
+    const colunas = new Map();
+    for (const match of codigo.matchAll(/\bh(?:set|get|del|exists)\s*\(\s*["'`]([^"'`]+)["'`]\s*,\s*["'`]([^"'`]+)["'`]/gi)) {
+        registrarColunaPersistenciaDrift(colunas, "redis", match[1], match[2], arquivo);
+    }
+    return [...colunas.values()];
+}
+function registrarRepositoriosPorRecursos(repositorios, arquivo, codigo, recursos) {
+    const contextoRepositorio = /(?:repository|repositories|repositorio|repositorios|repo|dao|store|queries|persistence|persistencia)/i.test(arquivo)
+        || /\b(?:Repository|Repositories|Dao|Store)\b/.test(codigo);
+    const contextoAcesso = /\b(?:select|insert|update|delete|aggregate|findOne|findMany|findUnique|findFirst|prisma\.|db\.collection|createClient|hset|hget|xadd|xread)\b/i.test(codigo);
+    if (!contextoRepositorio && !contextoAcesso) {
+        return;
+    }
+    for (const recurso of recursos) {
+        const engine = normalizarOrigemParaEngine(recurso.origem);
+        if (!engine) {
+            continue;
+        }
+        registrarRepositorioPersistenciaDrift(repositorios, engine, recurso.nome, arquivo);
+    }
+}
+async function indexarPersistenciaDetalhada(diretorios) {
+    const colunas = new Map();
+    const repositorios = new Map();
+    for (const diretorio of diretorios) {
+        const arquivos = await listarArquivosRecursivos(diretorio, [
+            ".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs",
+            ".py", ".dart", ".cs", ".java", ".go", ".rs", ".cpp", ".cc", ".cxx", ".hpp", ".h",
+            ".sql", ".psql", ".ddl", ".prisma",
+        ]);
+        for (const arquivo of arquivos) {
+            const codigo = await readFile(arquivo, "utf8");
+            const recursos = arquivo.endsWith(".prisma")
+                ? extrairRecursosPrisma(arquivo, codigo)
+                : extrairRecursosPersistenciaCodigoVivo(arquivo, codigo);
+            for (const coluna of extrairColunasSqlDetalhadas(arquivo, codigo)) {
+                registrarColunaPersistenciaDrift(colunas, coluna.engine, coluna.recurso, coluna.coluna, coluna.arquivo);
+            }
+            for (const coluna of extrairColunasPrismaDetalhadas(arquivo, codigo)) {
+                registrarColunaPersistenciaDrift(colunas, coluna.engine, coluna.recurso, coluna.coluna, coluna.arquivo);
+            }
+            for (const coluna of extrairCamposMongoDetalhados(arquivo, codigo)) {
+                registrarColunaPersistenciaDrift(colunas, coluna.engine, coluna.recurso, coluna.coluna, coluna.arquivo);
+            }
+            for (const coluna of extrairCamposRedisDetalhados(arquivo, codigo)) {
+                registrarColunaPersistenciaDrift(colunas, coluna.engine, coluna.recurso, coluna.coluna, coluna.arquivo);
+            }
+            registrarRepositoriosPorRecursos(repositorios, arquivo, codigo, recursos);
+        }
+    }
+    return {
+        colunas: [...colunas.values()],
+        repositorios: [...repositorios.values()],
+    };
+}
+function recursoDetalhadoCombina(recurso, esperado) {
+    return variantesNomeRecursoDrift(recurso).some((variante) => esperado.nomes.some((nome) => variantesNomeRecursoDrift(nome).includes(variante)));
+}
+function localizarCompatibilidadePersistencia(bancos, esperado, recursoReal) {
+    for (const banco of bancos) {
+        for (const recurso of banco.resources) {
+            if (!recursoPersistenciaCombinaAlvo(recurso, esperado.alvo)) {
+                continue;
+            }
+            const engine = banco.engine ?? normalizarOrigemParaEngine(recursoReal?.origem);
+            const compatibilidade = engine
+                ? recurso.compatibilidade.find((item) => item.engine === engine) ?? recurso.compatibilidade[0]
+                : recurso.compatibilidade[0];
+            return {
+                engine: (engine ?? recursoReal?.origem ?? "desconhecido"),
+                compatibilidade: compatibilidade?.status ?? "desconhecida",
+                motivoCompatibilidade: compatibilidade?.motivo,
+                tipo: recurso.resourceKind ?? recursoReal?.tipo ?? esperado.tiposAceitos[0] ?? "query",
+            };
+        }
+    }
+    return {
+        engine: recursoReal?.origem ?? esperado.origem ?? "desconhecido",
+        compatibilidade: "desconhecida",
+        tipo: recursoReal?.tipo ?? esperado.tiposAceitos[0] ?? "query",
+    };
+}
+export async function analisarPersistenciaReal(contexto, mapaRecursos, detalhesPersistencia, opcoes) {
+    const opcoesResolvidas = resolverOpcoesDrift(opcoes);
+    const diretoriosCodigoAtivos = resolverDiretoriosCodigoEscopoReal(contexto, opcoesResolvidas);
+    const mapa = mapaRecursos ?? construirMapaRecursos((await indexarPersistenciaDeclarativa(diretoriosCodigoAtivos)).recursos);
+    const detalhes = detalhesPersistencia ?? await indexarPersistenciaDetalhada(diretoriosCodigoAtivos);
+    const registros = [];
+    for (const item of contexto.modulosSelecionados) {
+        const ir = item.resultado.ir;
+        if (!ir) {
+            continue;
+        }
+        for (const task of ir.tasks) {
+            for (const esperado of extrairRecursosEsperados(task, ir)) {
+                const correspondencias = esperado.nomes.flatMap((nome) => variantesNomeRecursoDrift(nome).flatMap((variante) => (mapa.get(variante) ?? []).filter((recurso) => recursoResolvidoCombinaEsperado(recurso, esperado))));
+                const recursosReais = [...new Map(correspondencias.map((recurso) => [`${recurso.origem}:${recurso.tipo}:${recurso.nome}:${recurso.arquivo}`, recurso])).values()];
+                const compatibilidade = localizarCompatibilidadePersistencia(ir.databases, esperado, recursosReais[0]);
+                const colunas = [...new Set(detalhes.colunas
+                        .filter((coluna) => (!normalizarOrigemParaEngine(recursosReais[0]?.origem) || coluna.engine === normalizarOrigemParaEngine(recursosReais[0]?.origem))
+                        && recursoDetalhadoCombina(coluna.recurso, esperado))
+                        .map((coluna) => coluna.coluna))].sort((a, b) => a.localeCompare(b, "pt-BR"));
+                const repositorios = [...new Set(detalhes.repositorios
+                        .filter((repositorio) => (!normalizarOrigemParaEngine(recursosReais[0]?.origem) || repositorio.engine === normalizarOrigemParaEngine(recursosReais[0]?.origem))
+                        && recursoDetalhadoCombina(repositorio.recurso, esperado))
+                        .map((repositorio) => repositorio.arquivo))].sort((a, b) => a.localeCompare(b, "pt-BR"));
+                const arquivos = [...new Set(recursosReais.map((recurso) => recurso.arquivo))].sort((a, b) => a.localeCompare(b, "pt-BR"));
+                registros.push({
+                    modulo: ir.nome,
+                    task: task.nome,
+                    alvo: esperado.alvo,
+                    engine: compatibilidade.engine,
+                    tipo: compatibilidade.tipo,
+                    status: recursosReais.length === 0
+                        ? "divergente"
+                        : colunas.length > 0 || repositorios.length > 0
+                            ? "materializado"
+                            : "parcial",
+                    arquivos,
+                    colunas,
+                    repositorios,
+                    compatibilidade: compatibilidade.compatibilidade,
+                    motivoCompatibilidade: compatibilidade.motivoCompatibilidade,
+                });
+            }
+        }
+    }
+    return registros.sort((a, b) => a.modulo.localeCompare(b.modulo, "pt-BR")
+        || a.task.localeCompare(b.task, "pt-BR")
+        || a.alvo.localeCompare(b.alvo, "pt-BR"));
 }
 function normalizarCaminhoRota(caminho) {
     if (!caminho) {
@@ -1337,16 +2227,121 @@ function escolherRotasEsperadas(task, fontesLegado) {
 function taskEhBridgeFirebase(task) {
     return task.implementacoesExternas.some((impl) => impl.origem === "ts" && /sema_contract_bridge|collections?|apps\.worker/i.test(impl.caminho));
 }
-function extrairRecursosEsperados(task) {
-    if (!taskEhBridgeFirebase(task)) {
-        return [];
+function tiposAceitosParaRecursoPersistencia(recurso) {
+    switch (recurso.resourceKind) {
+        case "table":
+        case "view":
+        case "query":
+        case "index":
+        case "collection":
+        case "document":
+        case "keyspace":
+        case "stream":
+            return [recurso.resourceKind];
+        default:
+            return [];
+    }
+}
+function nomesRecursoPersistencia(recurso) {
+    return [...new Set([
+            recurso.nome,
+            recurso.table,
+            recurso.collection,
+            recurso.entity,
+            recurso.path,
+            recurso.surface,
+        ].filter((item) => Boolean(item)))];
+}
+function recursoPersistenciaCombinaAlvo(recurso, alvo) {
+    const alvoVariantes = new Set(variantesNomeRecursoDrift(alvo));
+    if (alvoVariantes.size === 0) {
+        return false;
+    }
+    return nomesRecursoPersistencia(recurso).some((nome) => variantesNomeRecursoDrift(nome).some((variacao) => alvoVariantes.has(variacao)));
+}
+function extrairRecursosEsperados(task, ir) {
+    const esperados = new Map();
+    const registrar = (esperado) => {
+        const chave = `${esperado.origem ?? "qualquer"}:${esperado.tiposAceitos.join(",")}:${esperado.nomes.join("|")}:${esperado.alvo}`;
+        if (!esperados.has(chave)) {
+            esperados.set(chave, esperado);
+        }
+    };
+    if (taskEhBridgeFirebase(task)) {
+        for (const efeito of task.efeitosEstruturados.filter((item) => item.categoria === "persistencia" && Boolean(item.alvo))) {
+            registrar({
+                categoria: "persistencia",
+                alvo: efeito.alvo,
+                origem: "firebase",
+                tiposAceitos: ["colecao"],
+                nomes: [efeito.alvo],
+            });
+        }
+    }
+    const efeitosPersistencia = task.efeitosEstruturados.filter((efeito) => ["persistencia", "db.read", "db.write"].includes(efeito.categoria) && Boolean(efeito.alvo));
+    if (efeitosPersistencia.length === 0 || ir.databases.length === 0) {
+        return [...esperados.values()];
+    }
+    for (const efeito of efeitosPersistencia) {
+        for (const database of ir.databases) {
+            for (const recurso of database.resources) {
+                const tiposAceitos = tiposAceitosParaRecursoPersistencia(recurso);
+                if (tiposAceitos.length === 0 || !recursoPersistenciaCombinaAlvo(recurso, efeito.alvo)) {
+                    continue;
+                }
+                registrar({
+                    categoria: "persistencia",
+                    alvo: efeito.alvo,
+                    origem: database.engine,
+                    tiposAceitos,
+                    nomes: nomesRecursoPersistencia(recurso),
+                });
+            }
+        }
+    }
+    return [...esperados.values()];
+}
+function construirMapaRecursos(recursos) {
+    const mapa = new Map();
+    for (const recurso of recursos) {
+        for (const variante of variantesNomeRecursoDrift(recurso.nome)) {
+            const existentes = mapa.get(variante) ?? [];
+            if (!existentes.some((item) => item.origem === recurso.origem
+                && item.tipo === recurso.tipo
+                && item.arquivo === recurso.arquivo
+                && item.nome === recurso.nome
+                && item.simbolo === recurso.simbolo)) {
+                existentes.push(recurso);
+                mapa.set(variante, existentes);
+            }
+        }
+    }
+    return mapa;
+}
+function recursoResolvidoCombinaEsperado(recurso, esperado) {
+    if (esperado.origem && recurso.origem !== esperado.origem) {
+        return false;
+    }
+    if (esperado.tiposAceitos.length > 0 && !esperado.tiposAceitos.includes(recurso.tipo)) {
+        return false;
+    }
+    const recursoVariantes = new Set(variantesNomeRecursoDrift(recurso.nome));
+    return esperado.nomes.some((nome) => variantesNomeRecursoDrift(nome).some((variante) => recursoVariantes.has(variante)));
+}
+function resolverRecursoEsperado(mapaRecursos, esperado, arquivosPreferidos) {
+    const candidatos = new Map();
+    for (const nome of esperado.nomes) {
+        for (const variante of variantesNomeRecursoDrift(nome)) {
+            for (const recurso of mapaRecursos.get(variante) ?? []) {
+                if (recursoResolvidoCombinaEsperado(recurso, esperado)) {
+                    candidatos.set(`${recurso.origem}:${recurso.tipo}:${recurso.nome}:${recurso.arquivo}:${recurso.simbolo ?? ""}`, recurso);
+                }
+            }
+        }
     }
-    return task.efeitosEstruturados
-        .filter((efeito) => efeito.categoria === "persistencia" && Boolean(efeito.alvo))
-        .map((efeito) => ({
-        categoria: "persistencia",
-        alvo: efeito.alvo,
-    }));
+    return [...candidatos.values()].sort((a, b) => Number(Boolean(arquivosPreferidos?.has(b.arquivo))) - Number(Boolean(arquivosPreferidos?.has(a.arquivo)))
+        || a.arquivo.localeCompare(b.arquivo, "pt-BR")
+        || a.nome.localeCompare(b.nome, "pt-BR"))[0];
 }
 function coletarVinculosIr(ir) {
     return [
@@ -1357,580 +2352,920 @@ function coletarVinculosIr(ir) {
         ...ir.superficies.flatMap((superficie) => superficie.vinculos.map((vinculo) => ({ donoTipo: "superficie", dono: `${superficie.tipo}:${superficie.nome}`, vinculo }))),
     ];
 }
-export async function analisarDriftLegado(contexto) {
-    const indexTs = await indexarTypeScript(contexto.diretoriosCodigo);
-    const indexPy = await indexarPython(contexto.diretoriosCodigo);
-    const indexDart = await indexarDart(contexto.diretoriosCodigo);
-    const indexDotnet = await indexarDotnet(contexto.diretoriosCodigo);
-    const indexJava = await indexarJava(contexto.diretoriosCodigo);
-    const indexGo = await indexarGo(contexto.diretoriosCodigo);
-    const indexRust = await indexarRust(contexto.diretoriosCodigo);
-    const indexCpp = await indexarCpp(contexto.diretoriosCodigo);
-    const todosSimbolos = [
-        ...indexTs.simbolos,
-        ...indexPy.simbolos,
-        ...indexDart.simbolos,
-        ...indexDotnet.simbolos,
-        ...indexJava.simbolos,
-        ...indexGo.simbolos,
-        ...indexRust.simbolos,
-        ...indexCpp,
-    ];
-    const mapaImpl = new Map([
-        ...indexTs.simbolos.map((item) => [item.caminho, item]),
-        ...indexPy.simbolos.map((item) => [item.caminho, item]),
-        ...indexDart.simbolos.map((item) => [item.caminho, item]),
-        ...indexDotnet.simbolos.map((item) => [item.caminho, item]),
-        ...indexJava.simbolos.map((item) => [item.caminho, item]),
-        ...indexGo.simbolos.map((item) => [item.caminho, item]),
-        ...indexRust.simbolos.map((item) => [item.caminho, item]),
-        ...indexCpp.map((item) => [item.caminho, item]),
-    ]);
-    const mapaRecursos = new Map(indexTs.recursos.map((item) => [item.nome, item]));
-    const todasRotasIndexadas = [
-        ...indexTs.rotas,
-        ...indexPy.rotas,
-        ...indexDart.rotas,
-        ...indexDotnet.rotas,
-        ...indexJava.rotas,
-        ...indexGo.rotas,
-        ...indexRust.rotas,
-    ];
-    const todosArquivosConhecidos = [...new Set([
-            ...todosSimbolos.map((item) => item.arquivo),
-            ...todasRotasIndexadas.map((item) => item.arquivo),
-            ...indexTs.recursos.map((item) => item.arquivo),
-        ])].sort((a, b) => a.localeCompare(b, "pt-BR"));
-    const implsValidos = [];
-    const implsQuebrados = [];
-    const vinculosValidos = [];
-    const vinculosQuebrados = [];
-    const rotasDivergentes = [];
-    const recursosValidos = [];
-    const recursosDivergentes = [];
-    const diagnosticos = [];
-    const tasksResumo = [];
-    const taskPorChave = new Map();
-    const guardrailsPorTask = new Map();
-    const resumoVinculosPorTask = new Map();
-    for (const item of contexto.modulosSelecionados) {
-        const ir = item.resultado.ir;
-        if (!ir) {
-            continue;
-        }
-        const superficiesPorChave = new Map(ir.superficies.map((superficie) => [`${superficie.tipo}:${superficie.nome}`, superficie]));
-        for (const task of ir.tasks) {
-            guardrailsPorTask.set(`${ir.nome}:${task.nome}`, {
-                publica: false,
-                sensivel: calcularRiscoOperacional(task) === "alto",
-                auth: task.auth.explicita,
-                authz: task.authz.explicita,
-                dados: task.dados.explicita,
-                audit: task.audit.explicita,
-                segredos: task.segredos.explicita,
-                forbidden: task.forbidden.explicita,
-                dadosSensiveis: Boolean(task.dados.classificacaoPadrao && ["pii", "financeiro", "credencial", "segredo"].includes(task.dados.classificacaoPadrao)
-                    || task.dados.campos.some((campo) => ["pii", "financeiro", "credencial", "segredo"].includes(campo.classificacao))),
-                efeitoPrivilegiado: task.efeitosEstruturados.some((efeito) => ["db.read", "db.write", "queue.publish", "queue.consume", "fs.read", "fs.write", "network.egress", "secret.read", "shell.exec"].includes(efeito.categoria)
-                    || ["alta", "critica"].includes(efeito.criticidade ?? "")),
-                exigeSegredos: task.efeitosEstruturados.some((efeito) => efeito.categoria === "secret.read")
-                    || Boolean(task.dados.classificacaoPadrao && ["credencial", "segredo"].includes(task.dados.classificacaoPadrao)
-                        || task.dados.campos.some((campo) => ["credencial", "segredo"].includes(campo.classificacao))),
-            });
-        }
-        for (const route of ir.routes) {
-            if (!route.task || route.perfilCompatibilidade !== "publico") {
+export async function analisarDriftLegado(contexto, opcoes) {
+    const opcoesResolvidas = resolverOpcoesDrift(opcoes);
+    const configuracaoEscopo = {
+        escopo: opcoesResolvidas.escopo,
+        ignorarWorktrees: opcoesResolvidas.ignorarWorktrees,
+        ignorarConsumidoresLaterais: opcoesResolvidas.ignorarConsumidoresLaterais,
+        termosEscopo: extrairTermosEscopoDrift(contexto, opcoesResolvidas.escopo),
+    };
+    const diretoriosIgnoradosAnteriores = diretoriosIgnoradosAtivos;
+    diretoriosIgnoradosAtivos = resolverDiretoriosIgnoradosAtivos(opcoesResolvidas);
+    try {
+        const diretoriosCodigoAtivos = resolverDiretoriosCodigoEscopoReal(contexto, configuracaoEscopo);
+        const indexTs = await indexarTypeScript(diretoriosCodigoAtivos);
+        const indexPy = await indexarPython(diretoriosCodigoAtivos);
+        const indexDart = await indexarDart(diretoriosCodigoAtivos);
+        const indexDotnet = await indexarDotnet(diretoriosCodigoAtivos);
+        const indexJava = await indexarJava(diretoriosCodigoAtivos);
+        const indexGo = await indexarGo(diretoriosCodigoAtivos);
+        const indexRust = await indexarRust(diretoriosCodigoAtivos);
+        const indexPersistencia = await indexarPersistenciaDeclarativa(diretoriosCodigoAtivos);
+        const detalhesPersistencia = await indexarPersistenciaDetalhada(diretoriosCodigoAtivos);
+        const indexCpp = await indexarCpp(diretoriosCodigoAtivos);
+        const todosSimbolos = [
+            ...indexTs.simbolos,
+            ...indexPy.simbolos,
+            ...indexDart.simbolos,
+            ...indexDotnet.simbolos,
+            ...indexJava.simbolos,
+            ...indexGo.simbolos,
+            ...indexRust.simbolos,
+            ...indexCpp.simbolos,
+        ];
+        const mapaImpl = new Map([
+            ...indexTs.simbolos.map((item) => [item.caminho, item]),
+            ...indexPy.simbolos.map((item) => [item.caminho, item]),
+            ...indexDart.simbolos.map((item) => [item.caminho, item]),
+            ...indexDotnet.simbolos.map((item) => [item.caminho, item]),
+            ...indexJava.simbolos.map((item) => [item.caminho, item]),
+            ...indexGo.simbolos.map((item) => [item.caminho, item]),
+            ...indexRust.simbolos.map((item) => [item.caminho, item]),
+            ...indexCpp.simbolos.map((item) => [item.caminho, item]),
+        ]);
+        const todosRecursos = [
+            ...indexTs.recursos,
+            ...indexPy.recursos,
+            ...indexDart.recursos,
+            ...indexDotnet.recursos,
+            ...indexJava.recursos,
+            ...indexGo.recursos,
+            ...indexRust.recursos,
+            ...indexCpp.recursos,
+            ...indexPersistencia.recursos,
+        ];
+        const mapaRecursos = construirMapaRecursos(todosRecursos);
+        const todasRotasIndexadas = [
+            ...indexTs.rotas,
+            ...indexPy.rotas,
+            ...indexDart.rotas,
+            ...indexDotnet.rotas,
+            ...indexJava.rotas,
+            ...indexGo.rotas,
+            ...indexRust.rotas,
+        ];
+        const todosArquivosConhecidos = [...new Set([
+                ...todosSimbolos.map((item) => item.arquivo),
+                ...todasRotasIndexadas.map((item) => item.arquivo),
+                ...todosRecursos.map((item) => item.arquivo),
+            ])].sort((a, b) => a.localeCompare(b, "pt-BR"));
+        const implsValidos = [];
+        const implsQuebrados = [];
+        const vinculosValidos = [];
+        const vinculosQuebrados = [];
+        const rotasDivergentes = [];
+        const recursosValidos = [];
+        const recursosDivergentes = [];
+        const diagnosticos = [];
+        const tasksResumo = [];
+        const taskPorChave = new Map();
+        const guardrailsPorTask = new Map();
+        const resumoVinculosPorTask = new Map();
+        for (const item of contexto.modulosSelecionados) {
+            const ir = item.resultado.ir;
+            if (!ir) {
                 continue;
             }
-            const guardrails = guardrailsPorTask.get(`${ir.nome}:${route.task}`);
-            if (guardrails) {
-                guardrails.publica = true;
-                guardrails.auth = guardrails.auth || route.auth.explicita;
-                guardrails.authz = guardrails.authz || route.authz.explicita;
-                guardrails.dados = guardrails.dados || route.dados.explicita;
-                guardrails.audit = guardrails.audit || route.audit.explicita;
-                guardrails.segredos = guardrails.segredos || route.segredos.explicita;
-                guardrails.forbidden = guardrails.forbidden || route.forbidden.explicita;
-                guardrails.dadosSensiveis = guardrails.dadosSensiveis || Boolean(route.dados.classificacaoPadrao && ["pii", "financeiro", "credencial", "segredo"].includes(route.dados.classificacaoPadrao)
-                    || route.dados.campos.some((campo) => ["pii", "financeiro", "credencial", "segredo"].includes(campo.classificacao)));
-                guardrails.efeitoPrivilegiado = guardrails.efeitoPrivilegiado || route.efeitosPublicos.some((efeito) => ["db.read", "db.write", "queue.publish", "queue.consume", "fs.read", "fs.write", "network.egress", "secret.read", "shell.exec"].includes(efeito.categoria)
-                    || ["alta", "critica"].includes(efeito.criticidade ?? ""));
-                guardrails.exigeSegredos = guardrails.exigeSegredos || route.efeitosPublicos.some((efeito) => efeito.categoria === "secret.read")
-                    || Boolean(route.dados.classificacaoPadrao && ["credencial", "segredo"].includes(route.dados.classificacaoPadrao)
-                        || route.dados.campos.some((campo) => ["credencial", "segredo"].includes(campo.classificacao)));
-            }
-        }
-        for (const superficie of ir.superficies) {
-            if (!superficie.task || superficie.perfilCompatibilidade !== "publico") {
-                continue;
+            const superficiesPorChave = new Map(ir.superficies.map((superficie) => [`${superficie.tipo}:${superficie.nome}`, superficie]));
+            for (const task of ir.tasks) {
+                guardrailsPorTask.set(`${ir.nome}:${task.nome}`, {
+                    publica: false,
+                    sensivel: calcularRiscoOperacional(task) === "alto",
+                    auth: task.auth.explicita,
+                    authz: task.authz.explicita,
+                    dados: task.dados.explicita,
+                    audit: task.audit.explicita,
+                    segredos: task.segredos.explicita,
+                    forbidden: task.forbidden.explicita,
+                    dadosSensiveis: Boolean(task.dados.classificacaoPadrao && ["pii", "financeiro", "credencial", "segredo"].includes(task.dados.classificacaoPadrao)
+                        || task.dados.campos.some((campo) => ["pii", "financeiro", "credencial", "segredo"].includes(campo.classificacao))),
+                    efeitoPrivilegiado: task.efeitosEstruturados.some((efeito) => ["db.read", "db.write", "queue.publish", "queue.consume", "fs.read", "fs.write", "network.egress", "secret.read", "shell.exec"].includes(efeito.categoria)
+                        || ["alta", "critica"].includes(efeito.criticidade ?? "")),
+                    exigeSegredos: task.efeitosEstruturados.some((efeito) => efeito.categoria === "secret.read")
+                        || Boolean(task.dados.classificacaoPadrao && ["credencial", "segredo"].includes(task.dados.classificacaoPadrao)
+                            || task.dados.campos.some((campo) => ["credencial", "segredo"].includes(campo.classificacao))),
+                });
             }
-            const guardrails = guardrailsPorTask.get(`${ir.nome}:${superficie.task}`);
-            if (guardrails) {
-                guardrails.publica = true;
-                guardrails.auth = guardrails.auth || superficie.auth.explicita;
-                guardrails.authz = guardrails.authz || superficie.authz.explicita;
-                guardrails.dados = guardrails.dados || superficie.dados.explicita;
-                guardrails.audit = guardrails.audit || superficie.audit.explicita;
-                guardrails.segredos = guardrails.segredos || superficie.segredos.explicita;
-                guardrails.forbidden = guardrails.forbidden || superficie.forbidden.explicita;
-                guardrails.dadosSensiveis = guardrails.dadosSensiveis || Boolean(superficie.dados.classificacaoPadrao && ["pii", "financeiro", "credencial", "segredo"].includes(superficie.dados.classificacaoPadrao)
-                    || superficie.dados.campos.some((campo) => ["pii", "financeiro", "credencial", "segredo"].includes(campo.classificacao)));
-                guardrails.efeitoPrivilegiado = guardrails.efeitoPrivilegiado || superficie.effects.some((efeito) => ["db.read", "db.write", "queue.publish", "queue.consume", "fs.read", "fs.write", "network.egress", "secret.read", "shell.exec"].includes(efeito.categoria)
-                    || ["alta", "critica"].includes(efeito.criticidade ?? ""));
-                guardrails.exigeSegredos = guardrails.exigeSegredos || superficie.effects.some((efeito) => efeito.categoria === "secret.read")
-                    || Boolean(superficie.dados.classificacaoPadrao && ["credencial", "segredo"].includes(superficie.dados.classificacaoPadrao)
-                        || superficie.dados.campos.some((campo) => ["credencial", "segredo"].includes(campo.classificacao)));
+            for (const route of ir.routes) {
+                if (!route.task || route.perfilCompatibilidade !== "publico") {
+                    continue;
+                }
+                const guardrails = guardrailsPorTask.get(`${ir.nome}:${route.task}`);
+                if (guardrails) {
+                    guardrails.publica = true;
+                    guardrails.auth = guardrails.auth || route.auth.explicita;
+                    guardrails.authz = guardrails.authz || route.authz.explicita;
+                    guardrails.dados = guardrails.dados || route.dados.explicita;
+                    guardrails.audit = guardrails.audit || route.audit.explicita;
+                    guardrails.segredos = guardrails.segredos || route.segredos.explicita;
+                    guardrails.forbidden = guardrails.forbidden || route.forbidden.explicita;
+                    guardrails.dadosSensiveis = guardrails.dadosSensiveis || Boolean(route.dados.classificacaoPadrao && ["pii", "financeiro", "credencial", "segredo"].includes(route.dados.classificacaoPadrao)
+                        || route.dados.campos.some((campo) => ["pii", "financeiro", "credencial", "segredo"].includes(campo.classificacao)));
+                    guardrails.efeitoPrivilegiado = guardrails.efeitoPrivilegiado || route.efeitosPublicos.some((efeito) => ["db.read", "db.write", "queue.publish", "queue.consume", "fs.read", "fs.write", "network.egress", "secret.read", "shell.exec"].includes(efeito.categoria)
+                        || ["alta", "critica"].includes(efeito.criticidade ?? ""));
+                    guardrails.exigeSegredos = guardrails.exigeSegredos || route.efeitosPublicos.some((efeito) => efeito.categoria === "secret.read")
+                        || Boolean(route.dados.classificacaoPadrao && ["credencial", "segredo"].includes(route.dados.classificacaoPadrao)
+                            || route.dados.campos.some((campo) => ["credencial", "segredo"].includes(campo.classificacao)));
+                }
             }
-        }
-        for (const task of ir.tasks) {
-            taskPorChave.set(`${ir.nome}:${task.nome}`, task);
-            let validos = 0;
-            let quebrados = 0;
-            const arquivosReferenciados = new Set();
-            const simbolosReferenciados = new Set();
-            const candidatosTask = new Map();
-            if (task.implementacoesExternas.length === 0) {
-                for (const candidato of sugerirCandidatosParaTaskSemImpl(todosSimbolos, task.nome)) {
-                    candidatosTask.set(`${candidato.origem}:${candidato.caminho}:${candidato.arquivo}:${candidato.simbolo}`, candidato);
+            for (const superficie of ir.superficies) {
+                if (!superficie.task || superficie.perfilCompatibilidade !== "publico") {
+                    continue;
                 }
-                diagnosticos.push({
-                    tipo: "task_sem_impl",
+                const guardrails = guardrailsPorTask.get(`${ir.nome}:${superficie.task}`);
+                if (guardrails) {
+                    guardrails.publica = true;
+                    guardrails.auth = guardrails.auth || superficie.auth.explicita;
+                    guardrails.authz = guardrails.authz || superficie.authz.explicita;
+                    guardrails.dados = guardrails.dados || superficie.dados.explicita;
+                    guardrails.audit = guardrails.audit || superficie.audit.explicita;
+                    guardrails.segredos = guardrails.segredos || superficie.segredos.explicita;
+                    guardrails.forbidden = guardrails.forbidden || superficie.forbidden.explicita;
+                    guardrails.dadosSensiveis = guardrails.dadosSensiveis || Boolean(superficie.dados.classificacaoPadrao && ["pii", "financeiro", "credencial", "segredo"].includes(superficie.dados.classificacaoPadrao)
+                        || superficie.dados.campos.some((campo) => ["pii", "financeiro", "credencial", "segredo"].includes(campo.classificacao)));
+                    guardrails.efeitoPrivilegiado = guardrails.efeitoPrivilegiado || superficie.effects.some((efeito) => ["db.read", "db.write", "queue.publish", "queue.consume", "fs.read", "fs.write", "network.egress", "secret.read", "shell.exec"].includes(efeito.categoria)
+                        || ["alta", "critica"].includes(efeito.criticidade ?? ""));
+                    guardrails.exigeSegredos = guardrails.exigeSegredos || superficie.effects.some((efeito) => efeito.categoria === "secret.read")
+                        || Boolean(superficie.dados.classificacaoPadrao && ["credencial", "segredo"].includes(superficie.dados.classificacaoPadrao)
+                            || superficie.dados.campos.some((campo) => ["credencial", "segredo"].includes(campo.classificacao)));
+                }
+            }
+            for (const task of ir.tasks) {
+                taskPorChave.set(`${ir.nome}:${task.nome}`, task);
+                let validos = 0;
+                let quebrados = 0;
+                const arquivosReferenciados = new Set();
+                const simbolosReferenciados = new Set();
+                const candidatosTask = new Map();
+                if (task.implementacoesExternas.length === 0) {
+                    for (const candidato of sugerirCandidatosParaTaskSemImpl(todosSimbolos, task.nome)) {
+                        candidatosTask.set(`${candidato.origem}:${candidato.caminho}:${candidato.arquivo}:${candidato.simbolo}`, candidato);
+                    }
+                    diagnosticos.push({
+                        tipo: "task_sem_impl",
+                        modulo: ir.nome,
+                        task: task.nome,
+                        mensagem: `Task "${task.nome}" ainda nao foi ligada a nenhuma implementacao externa.`,
+                    });
+                }
+                for (const impl of task.implementacoesExternas) {
+                    const resolvido = mapaImpl.get(impl.caminho);
+                    const registro = {
+                        modulo: ir.nome,
+                        task: task.nome,
+                        origem: impl.origem,
+                        caminho: impl.caminho,
+                        arquivo: resolvido?.arquivo,
+                        simbolo: resolvido?.simbolo,
+                        caminhoResolvido: resolvido?.caminho,
+                        status: resolvido ? "resolvido" : "quebrado",
+                    };
+                    if (resolvido) {
+                        arquivosReferenciados.add(resolvido.arquivo);
+                        simbolosReferenciados.add(resolvido.simbolo);
+                        implsValidos.push(registro);
+                        validos += 1;
+                    }
+                    else {
+                        registro.candidatos = sugerirCandidatosParaImpl(todosSimbolos, impl.origem, impl.caminho);
+                        for (const candidato of registro.candidatos) {
+                            candidatosTask.set(`${candidato.origem}:${candidato.caminho}:${candidato.arquivo}:${candidato.simbolo}`, candidato);
+                        }
+                        implsQuebrados.push(registro);
+                        quebrados += 1;
+                        diagnosticos.push({
+                            tipo: "impl_quebrado",
+                            modulo: ir.nome,
+                            task: task.nome,
+                            mensagem: `Implementacao externa "${impl.origem}:${impl.caminho}" nao foi encontrada nos diretorios de codigo vivos.`,
+                        });
+                    }
+                }
+                tasksResumo.push({
                     modulo: ir.nome,
                     task: task.nome,
-                    mensagem: `Task "${task.nome}" ainda nao foi ligada a nenhuma implementacao externa.`,
+                    impls: task.implementacoesExternas.length,
+                    implsValidos: validos,
+                    implsQuebrados: quebrados,
+                    semImplementacao: task.implementacoesExternas.length === 0,
+                    scoreSemantico: 0,
+                    confiancaVinculo: "baixa",
+                    riscoOperacional: "baixo",
+                    lacunas: [],
+                    arquivosReferenciados: [...arquivosReferenciados].sort((a, b) => a.localeCompare(b, "pt-BR")),
+                    arquivosProvaveisEditar: [],
+                    simbolosReferenciados: [...simbolosReferenciados].sort((a, b) => a.localeCompare(b, "pt-BR")),
+                    candidatosImpl: ordenarCandidatos([...candidatosTask.values()]).slice(0, 5),
+                    checksSugeridos: [],
                 });
+                for (const recursoEsperado of extrairRecursosEsperados(task, ir)) {
+                    const resolvido = resolverRecursoEsperado(mapaRecursos, recursoEsperado, arquivosReferenciados);
+                    const registro = {
+                        modulo: ir.nome,
+                        task: task.nome,
+                        categoria: recursoEsperado.categoria,
+                        alvo: recursoEsperado.alvo,
+                        arquivo: resolvido?.arquivo ?? "",
+                        origem: resolvido?.origem ?? recursoEsperado.origem ?? "firebase",
+                        tipo: resolvido?.tipo ?? recursoEsperado.tiposAceitos[0] ?? "query",
+                        status: resolvido ? "resolvido" : "divergente",
+                    };
+                    if (resolvido) {
+                        registro.arquivo = resolvido.arquivo;
+                        recursosValidos.push(registro);
+                    }
+                    else {
+                        recursosDivergentes.push(registro);
+                        const escopo = recursoEsperado.origem ? `${recursoEsperado.origem}` : "persistencia declarada";
+                        diagnosticos.push({
+                            tipo: "recurso_divergente",
+                            modulo: ir.nome,
+                            task: task.nome,
+                            mensagem: `Recurso vivo "${recursoEsperado.alvo}" nao foi encontrado no codigo legado para ${escopo}.`,
+                        });
+                    }
+                }
             }
-            for (const impl of task.implementacoesExternas) {
-                const resolvido = mapaImpl.get(impl.caminho);
-                const registro = {
-                    modulo: ir.nome,
-                    task: task.nome,
-                    origem: impl.origem,
-                    caminho: impl.caminho,
-                    arquivo: resolvido?.arquivo,
-                    simbolo: resolvido?.simbolo,
-                    caminhoResolvido: resolvido?.caminho,
-                    status: resolvido ? "resolvido" : "quebrado",
-                };
-                if (resolvido) {
-                    arquivosReferenciados.add(resolvido.arquivo);
-                    simbolosReferenciados.add(resolvido.simbolo);
-                    implsValidos.push(registro);
-                    validos += 1;
+            for (const route of ir.routes) {
+                const taskAssociada = ir.tasks.find((task) => task.nome === route.task);
+                const esperadas = escolherRotasEsperadas(taskAssociada ?? {
+                    nome: "",
+                    input: [],
+                    output: [],
+                    rules: [],
+                    regrasEstruturadas: [],
+                    effects: [],
+                    efeitosEstruturados: [],
+                    implementacoesExternas: [],
+                    vinculos: [],
+                    execucao: {
+                        idempotencia: false,
+                        timeout: "padrao",
+                        retry: "nenhum",
+                        compensacao: "nenhuma",
+                        criticidadeOperacional: "media",
+                        explicita: false,
+                    },
+                    auth: {
+                        explicita: false,
+                    },
+                    authz: {
+                        explicita: false,
+                        papeis: [],
+                        escopos: [],
+                    },
+                    dados: {
+                        explicita: false,
+                        campos: [],
+                    },
+                    audit: {
+                        explicita: false,
+                    },
+                    segredos: {
+                        explicita: false,
+                        itens: [],
+                    },
+                    forbidden: {
+                        explicita: false,
+                        regras: [],
+                    },
+                    guarantees: [],
+                    garantiasEstruturadas: [],
+                    errors: {},
+                    errosDetalhados: [],
+                    perfilCompatibilidade: "interno",
+                    resumoAgente: {
+                        riscos: [],
+                        checks: [],
+                        entidadesAfetadas: [],
+                        superficiesPublicas: [],
+                        mutacoesPrevistas: [],
+                    },
+                    tests: [],
+                }, contexto.fontesLegado);
+                if (!esperadas.length || !route.metodo || !route.caminho) {
+                    continue;
                 }
-                else {
-                    registro.candidatos = sugerirCandidatosParaImpl(todosSimbolos, impl.origem, impl.caminho);
-                    for (const candidato of registro.candidatos) {
-                        candidatosTask.set(`${candidato.origem}:${candidato.caminho}:${candidato.arquivo}:${candidato.simbolo}`, candidato);
-                    }
-                    implsQuebrados.push(registro);
-                    quebrados += 1;
+                const encontradas = todasRotasIndexadas.filter((rotaResolvida) => rotaResolvida.origem !== "nextjs-consumer"
+                    && rotaResolvida.origem !== "react-vite-consumer"
+                    && rotaResolvida.origem !== "angular-consumer"
+                    && rotaResolvida.origem !== "flutter-consumer"
+                    && esperadas.includes(rotaResolvida.origem));
+                const combina = encontradas.some((rotaResolvida) => rotaResolvida.metodo === route.metodo
+                    && normalizarCaminhoRota(rotaResolvida.caminho) === normalizarCaminhoRota(route.caminho));
+                if (!combina) {
+                    const registro = {
+                        modulo: ir.nome,
+                        route: route.nome,
+                        metodo: route.metodo,
+                        caminho: route.caminho,
+                        motivo: `Nenhuma rota publica ${route.metodo} ${route.caminho} foi encontrada no codigo legado para o framework esperado.`,
+                    };
+                    rotasDivergentes.push(registro);
                     diagnosticos.push({
-                        tipo: "impl_quebrado",
+                        tipo: "rota_divergente",
                         modulo: ir.nome,
-                        task: task.nome,
-                        mensagem: `Implementacao externa "${impl.origem}:${impl.caminho}" nao foi encontrada nos diretorios de codigo vivos.`,
+                        route: route.nome,
+                        mensagem: registro.motivo,
                     });
                 }
             }
-            tasksResumo.push({
-                modulo: ir.nome,
-                task: task.nome,
-                impls: task.implementacoesExternas.length,
-                implsValidos: validos,
-                implsQuebrados: quebrados,
-                semImplementacao: task.implementacoesExternas.length === 0,
-                scoreSemantico: 0,
-                confiancaVinculo: "baixa",
-                riscoOperacional: "baixo",
-                lacunas: [],
-                arquivosReferenciados: [...arquivosReferenciados].sort((a, b) => a.localeCompare(b, "pt-BR")),
-                arquivosProvaveisEditar: [],
-                simbolosReferenciados: [...simbolosReferenciados].sort((a, b) => a.localeCompare(b, "pt-BR")),
-                candidatosImpl: ordenarCandidatos([...candidatosTask.values()]).slice(0, 5),
-                checksSugeridos: [],
-            });
-            for (const recursoEsperado of extrairRecursosEsperados(task)) {
-                const resolvido = mapaRecursos.get(recursoEsperado.alvo);
+            for (const itemVinculo of coletarVinculosIr(ir)) {
                 const registro = {
                     modulo: ir.nome,
-                    task: task.nome,
-                    categoria: recursoEsperado.categoria,
-                    alvo: recursoEsperado.alvo,
-                    arquivo: resolvido?.arquivo ?? "",
-                    origem: "firebase",
-                    tipo: "colecao",
-                    status: resolvido ? "resolvido" : "divergente",
+                    donoTipo: itemVinculo.donoTipo,
+                    dono: itemVinculo.dono,
+                    tipo: itemVinculo.vinculo.tipo,
+                    valor: itemVinculo.vinculo.valor,
+                    status: "nao_encontrado",
+                    confianca: "baixa",
                 };
-                if (resolvido) {
-                    registro.arquivo = resolvido.arquivo;
-                    recursosValidos.push(registro);
+                const arquivoDeclarado = itemVinculo.vinculo.arquivo ?? (itemVinculo.vinculo.tipo === "arquivo" ? itemVinculo.vinculo.valor : undefined);
+                const simboloDeclarado = itemVinculo.vinculo.simbolo ?? (itemVinculo.vinculo.tipo === "simbolo" ? itemVinculo.vinculo.valor : undefined);
+                const recursoDeclarado = itemVinculo.vinculo.recurso ?? (["recurso", "tabela", "fila", "cache", "storage"].includes(itemVinculo.vinculo.tipo) ? itemVinculo.vinculo.valor : undefined);
+                const superficieDeclarada = itemVinculo.vinculo.superficie ?? (["superficie", "rota", "worker", "cron", "webhook", "evento", "policy", "fila", "cache", "storage"].includes(itemVinculo.vinculo.tipo) ? itemVinculo.vinculo.valor : undefined);
+                if (simboloDeclarado) {
+                    const resolucaoSimbolo = escolherSimboloPorVinculo(todosSimbolos, mapaImpl, simboloDeclarado);
+                    registro.status = resolucaoSimbolo.status;
+                    registro.confianca = resolucaoSimbolo.confianca;
+                    registro.arquivo = resolucaoSimbolo.simbolo?.arquivo;
+                    registro.simbolo = resolucaoSimbolo.simbolo?.simbolo;
+                }
+                else if (arquivoDeclarado) {
+                    const resolucaoArquivo = escolherArquivoPorVinculo(todosArquivosConhecidos, arquivoDeclarado);
+                    registro.status = resolucaoArquivo.status;
+                    registro.confianca = resolucaoArquivo.confianca;
+                    registro.arquivo = resolucaoArquivo.arquivo;
+                }
+                else if (recursoDeclarado) {
+                    const recurso = resolverRecursoEsperado(mapaRecursos, {
+                        categoria: "persistencia",
+                        alvo: recursoDeclarado,
+                        tiposAceitos: [],
+                        nomes: [recursoDeclarado],
+                    });
+                    if (recurso) {
+                        registro.status = "resolvido";
+                        registro.confianca = "alta";
+                        registro.arquivo = recurso.arquivo;
+                    }
+                }
+                else if (superficieDeclarada) {
+                    const rota = todasRotasIndexadas.find((rotaResolvida) => normalizarCaminhoRota(rotaResolvida.caminho) === normalizarCaminhoRota(superficieDeclarada));
+                    if (rota) {
+                        registro.status = "resolvido";
+                        registro.confianca = "alta";
+                        registro.arquivo = rota.arquivo;
+                        registro.simbolo = rota.simbolo;
+                    }
+                    else {
+                        const resolucaoArquivo = escolherArquivoPorVinculo(todosArquivosConhecidos, superficieDeclarada);
+                        registro.status = resolucaoArquivo.status;
+                        registro.confianca = resolucaoArquivo.confianca;
+                        registro.arquivo = resolucaoArquivo.arquivo;
+                    }
                 }
                 else {
-                    recursosDivergentes.push(registro);
+                    const resolucaoArquivo = escolherArquivoPorVinculo(todosArquivosConhecidos, itemVinculo.vinculo.valor);
+                    registro.status = resolucaoArquivo.status;
+                    registro.confianca = resolucaoArquivo.confianca;
+                    registro.arquivo = resolucaoArquivo.arquivo;
+                }
+                if (registro.status === "nao_encontrado" && itemVinculo.donoTipo === "superficie") {
+                    const superficie = superficiesPorChave.get(itemVinculo.dono);
+                    const ancora = superficie
+                        ? encontrarAncoraSuperficie(ir, superficie, todosSimbolos, mapaImpl, todosArquivosConhecidos)
+                        : undefined;
+                    if (ancora) {
+                        registro.status = "parcial";
+                        registro.confianca = ancora.confianca === "alta" ? "media" : ancora.confianca;
+                        registro.arquivo = registro.arquivo ?? ancora.arquivo;
+                        registro.simbolo = registro.simbolo ?? ancora.simbolo;
+                    }
+                }
+                if (registro.status === "nao_encontrado") {
+                    vinculosQuebrados.push(registro);
                     diagnosticos.push({
-                        tipo: "recurso_divergente",
+                        tipo: "vinculo_quebrado",
                         modulo: ir.nome,
-                        task: task.nome,
-                        mensagem: `Recurso vivo "${recursoEsperado.alvo}" nao foi encontrado nos bridges/configuracoes Firebase do codigo legado.`,
+                        mensagem: `Vinculo ${registro.tipo}="${registro.valor}" de ${registro.donoTipo} "${registro.dono}" nao foi resolvido no codigo vivo.`,
+                        ...(itemVinculo.donoTipo === "task" ? { task: itemVinculo.dono } : itemVinculo.donoTipo === "route" ? { route: itemVinculo.dono } : {}),
                     });
                 }
+                else {
+                    vinculosValidos.push(registro);
+                }
+                if (itemVinculo.donoTipo === "task") {
+                    const chaveTask = `${ir.nome}:${itemVinculo.dono}`;
+                    const resumo = resumoVinculosPorTask.get(chaveTask) ?? {
+                        validos: 0,
+                        quebrados: 0,
+                        arquivos: new Set(),
+                    };
+                    if (registro.status === "nao_encontrado") {
+                        resumo.quebrados += 1;
+                    }
+                    else {
+                        resumo.validos += 1;
+                    }
+                    if (registro.arquivo) {
+                        resumo.arquivos.add(registro.arquivo);
+                    }
+                    resumoVinculosPorTask.set(chaveTask, resumo);
+                }
             }
         }
-        for (const route of ir.routes) {
-            const taskAssociada = ir.tasks.find((task) => task.nome === route.task);
-            const esperadas = escolherRotasEsperadas(taskAssociada ?? {
-                nome: "",
-                input: [],
-                output: [],
-                rules: [],
-                regrasEstruturadas: [],
-                effects: [],
-                efeitosEstruturados: [],
-                implementacoesExternas: [],
-                vinculos: [],
-                execucao: {
-                    idempotencia: false,
-                    timeout: "padrao",
-                    retry: "nenhum",
-                    compensacao: "nenhuma",
-                    criticidadeOperacional: "media",
-                    explicita: false,
-                },
-                auth: {
-                    explicita: false,
-                },
-                authz: {
-                    explicita: false,
-                    papeis: [],
-                    escopos: [],
-                },
-                dados: {
-                    explicita: false,
-                    campos: [],
-                },
-                audit: {
-                    explicita: false,
-                },
-                segredos: {
-                    explicita: false,
-                    itens: [],
-                },
-                forbidden: {
-                    explicita: false,
-                    regras: [],
-                },
-                guarantees: [],
-                garantiasEstruturadas: [],
-                errors: {},
-                errosDetalhados: [],
-                perfilCompatibilidade: "interno",
-                resumoAgente: {
-                    riscos: [],
-                    checks: [],
-                    entidadesAfetadas: [],
-                    superficiesPublicas: [],
-                    mutacoesPrevistas: [],
-                },
-                tests: [],
-            }, contexto.fontesLegado);
-            if (!esperadas.length || !route.metodo || !route.caminho) {
+        for (const resumo of tasksResumo) {
+            const chaveTask = `${resumo.modulo}:${resumo.task}`;
+            const task = taskPorChave.get(chaveTask);
+            const guardrails = guardrailsPorTask.get(chaveTask) ?? {
+                publica: false,
+                sensivel: false,
+                auth: false,
+                authz: false,
+                dados: false,
+                audit: false,
+                segredos: false,
+                forbidden: false,
+                dadosSensiveis: false,
+                efeitoPrivilegiado: false,
+                exigeSegredos: false,
+            };
+            const resumoVinculos = resumoVinculosPorTask.get(chaveTask) ?? {
+                validos: 0,
+                quebrados: 0,
+                arquivos: new Set(),
+            };
+            if (!task) {
                 continue;
             }
-            const encontradas = todasRotasIndexadas.filter((rotaResolvida) => rotaResolvida.origem !== "nextjs-consumer"
-                && rotaResolvida.origem !== "react-vite-consumer"
-                && rotaResolvida.origem !== "angular-consumer"
-                && rotaResolvida.origem !== "flutter-consumer"
-                && esperadas.includes(rotaResolvida.origem));
-            const combina = encontradas.some((rotaResolvida) => rotaResolvida.metodo === route.metodo
-                && normalizarCaminhoRota(rotaResolvida.caminho) === normalizarCaminhoRota(route.caminho));
-            if (!combina) {
-                const registro = {
-                    modulo: ir.nome,
-                    route: route.nome,
-                    metodo: route.metodo,
-                    caminho: route.caminho,
-                    motivo: `Nenhuma rota publica ${route.metodo} ${route.caminho} foi encontrada no codigo legado para o framework esperado.`,
-                };
-                rotasDivergentes.push(registro);
+            resumo.confiancaVinculo = calcularConfiancaTask(task, resumo.implsValidos, resumo.implsQuebrados, resumoVinculos.validos, resumoVinculos.quebrados);
+            resumo.riscoOperacional = calcularRiscoOperacional(task);
+            resumo.lacunas = resumirLacunasTask(task, resumo.semImplementacao, resumo.implsQuebrados, resumoVinculos.quebrados, guardrails);
+            resumo.scoreSemantico = calcularScoreTask(task, resumo.implsValidos, resumo.implsQuebrados, resumoVinculos.validos, resumoVinculos.quebrados, resumo.semImplementacao);
+            resumo.arquivosProvaveisEditar = [...new Set([
+                    ...resumo.arquivosReferenciados,
+                    ...resumo.candidatosImpl.map((candidato) => candidato.arquivo),
+                    ...resumoVinculos.arquivos,
+                ])].sort((a, b) => a.localeCompare(b, "pt-BR"));
+            resumo.checksSugeridos = [...new Set([
+                    ...task.resumoAgente.checks,
+                    resumo.riscoOperacional !== "baixo" ? "revisar efeitos operacionais" : "",
+                    resumo.lacunas.includes("vinculo_quebrado") ? "corrigir vinculos rastreaveis" : "",
+                    resumo.lacunas.some((lacuna) => ["superficie_publica_sem_execucao", "execucao_critica_sem_bloco", "rastreabilidade_fraca"].includes(lacuna))
+                        ? "endurecer execucao e rastreabilidade para producao"
+                        : "",
+                    resumo.lacunas.some((lacuna) => ["auth_ausente", "authz_frouxa", "dados_nao_classificados", "audit_ausente", "segredo_sem_governanca", "proibicoes_ausentes"].includes(lacuna))
+                        ? "explicitar contratos de seguranca semantica"
+                        : "",
+                ].filter(Boolean))];
+            if (resumo.lacunas.includes("superficie_publica_sem_execucao")) {
                 diagnosticos.push({
-                    tipo: "rota_divergente",
-                    modulo: ir.nome,
-                    route: route.nome,
-                    mensagem: registro.motivo,
+                    tipo: "seguranca_frouxa",
+                    modulo: resumo.modulo,
+                    task: resumo.task,
+                    mensagem: `Task "${resumo.task}" alimenta superficie publica, mas ainda depende de execucao implicita.`,
                 });
             }
-        }
-        for (const itemVinculo of coletarVinculosIr(ir)) {
-            const registro = {
-                modulo: ir.nome,
-                donoTipo: itemVinculo.donoTipo,
-                dono: itemVinculo.dono,
-                tipo: itemVinculo.vinculo.tipo,
-                valor: itemVinculo.vinculo.valor,
-                status: "nao_encontrado",
-                confianca: "baixa",
-            };
-            const arquivoDeclarado = itemVinculo.vinculo.arquivo ?? (itemVinculo.vinculo.tipo === "arquivo" ? itemVinculo.vinculo.valor : undefined);
-            const simboloDeclarado = itemVinculo.vinculo.simbolo ?? (itemVinculo.vinculo.tipo === "simbolo" ? itemVinculo.vinculo.valor : undefined);
-            const recursoDeclarado = itemVinculo.vinculo.recurso ?? (["recurso", "tabela", "fila", "cache", "storage"].includes(itemVinculo.vinculo.tipo) ? itemVinculo.vinculo.valor : undefined);
-            const superficieDeclarada = itemVinculo.vinculo.superficie ?? (["superficie", "rota", "worker", "cron", "webhook", "evento", "policy", "fila", "cache", "storage"].includes(itemVinculo.vinculo.tipo) ? itemVinculo.vinculo.valor : undefined);
-            if (simboloDeclarado) {
-                const resolucaoSimbolo = escolherSimboloPorVinculo(todosSimbolos, mapaImpl, simboloDeclarado);
-                registro.status = resolucaoSimbolo.status;
-                registro.confianca = resolucaoSimbolo.confianca;
-                registro.arquivo = resolucaoSimbolo.simbolo?.arquivo;
-                registro.simbolo = resolucaoSimbolo.simbolo?.simbolo;
-            }
-            else if (arquivoDeclarado) {
-                const resolucaoArquivo = escolherArquivoPorVinculo(todosArquivosConhecidos, arquivoDeclarado);
-                registro.status = resolucaoArquivo.status;
-                registro.confianca = resolucaoArquivo.confianca;
-                registro.arquivo = resolucaoArquivo.arquivo;
-            }
-            else if (recursoDeclarado) {
-                const recurso = mapaRecursos.get(recursoDeclarado);
-                if (recurso) {
-                    registro.status = "resolvido";
-                    registro.confianca = "alta";
-                    registro.arquivo = recurso.arquivo;
-                }
+            if (resumo.lacunas.includes("execucao_critica_sem_bloco")) {
+                diagnosticos.push({
+                    tipo: "seguranca_frouxa",
+                    modulo: resumo.modulo,
+                    task: resumo.task,
+                    mensagem: `Task "${resumo.task}" opera com risco alto, mas ainda nao declarou execucao explicita.`,
+                });
             }
-            else if (superficieDeclarada) {
-                const rota = todasRotasIndexadas.find((rotaResolvida) => normalizarCaminhoRota(rotaResolvida.caminho) === normalizarCaminhoRota(superficieDeclarada));
-                if (rota) {
-                    registro.status = "resolvido";
-                    registro.confianca = "alta";
-                    registro.arquivo = rota.arquivo;
-                    registro.simbolo = rota.simbolo;
-                }
-                else {
-                    const resolucaoArquivo = escolherArquivoPorVinculo(todosArquivosConhecidos, superficieDeclarada);
-                    registro.status = resolucaoArquivo.status;
-                    registro.confianca = resolucaoArquivo.confianca;
-                    registro.arquivo = resolucaoArquivo.arquivo;
-                }
+            if (resumo.lacunas.includes("rastreabilidade_fraca")) {
+                diagnosticos.push({
+                    tipo: "seguranca_frouxa",
+                    modulo: resumo.modulo,
+                    task: resumo.task,
+                    mensagem: `Task "${resumo.task}" exige producao mais rastreavel, mas ainda nao declara impl nem vinculos.`,
+                });
             }
-            else {
-                const resolucaoArquivo = escolherArquivoPorVinculo(todosArquivosConhecidos, itemVinculo.vinculo.valor);
-                registro.status = resolucaoArquivo.status;
-                registro.confianca = resolucaoArquivo.confianca;
-                registro.arquivo = resolucaoArquivo.arquivo;
-            }
-            if (registro.status === "nao_encontrado" && itemVinculo.donoTipo === "superficie") {
-                const superficie = superficiesPorChave.get(itemVinculo.dono);
-                const ancora = superficie
-                    ? encontrarAncoraSuperficie(ir, superficie, todosSimbolos, mapaImpl, todosArquivosConhecidos)
-                    : undefined;
-                if (ancora) {
-                    registro.status = "parcial";
-                    registro.confianca = ancora.confianca === "alta" ? "media" : ancora.confianca;
-                    registro.arquivo = registro.arquivo ?? ancora.arquivo;
-                    registro.simbolo = registro.simbolo ?? ancora.simbolo;
-                }
+            if (resumo.lacunas.includes("auth_ausente")) {
+                diagnosticos.push({
+                    tipo: "seguranca_frouxa",
+                    modulo: resumo.modulo,
+                    task: resumo.task,
+                    mensagem: `Task "${resumo.task}" chega em superficie publica sem auth explicita em task, route ou superficie associada.`,
+                });
             }
-            if (registro.status === "nao_encontrado") {
-                vinculosQuebrados.push(registro);
+            if (resumo.lacunas.includes("authz_frouxa")) {
                 diagnosticos.push({
-                    tipo: "vinculo_quebrado",
-                    modulo: ir.nome,
-                    mensagem: `Vinculo ${registro.tipo}="${registro.valor}" de ${registro.donoTipo} "${registro.dono}" nao foi resolvido no codigo vivo.`,
-                    ...(itemVinculo.donoTipo === "task" ? { task: itemVinculo.dono } : itemVinculo.donoTipo === "route" ? { route: itemVinculo.dono } : {}),
+                    tipo: "seguranca_frouxa",
+                    modulo: resumo.modulo,
+                    task: resumo.task,
+                    mensagem: `Task "${resumo.task}" opera com risco ou exposicao, mas ainda nao explicita authz suficiente.`,
                 });
             }
-            else {
-                vinculosValidos.push(registro);
+            if (resumo.lacunas.includes("dados_nao_classificados")) {
+                diagnosticos.push({
+                    tipo: "seguranca_frouxa",
+                    modulo: resumo.modulo,
+                    task: resumo.task,
+                    mensagem: `Task "${resumo.task}" ainda nao classifica dados de entrada/saida de forma semantica.`,
+                });
             }
-            if (itemVinculo.donoTipo === "task") {
-                const chaveTask = `${ir.nome}:${itemVinculo.dono}`;
-                const resumo = resumoVinculosPorTask.get(chaveTask) ?? {
-                    validos: 0,
-                    quebrados: 0,
-                    arquivos: new Set(),
-                };
-                if (registro.status === "nao_encontrado") {
-                    resumo.quebrados += 1;
-                }
-                else {
-                    resumo.validos += 1;
-                }
-                if (registro.arquivo) {
-                    resumo.arquivos.add(registro.arquivo);
-                }
-                resumoVinculosPorTask.set(chaveTask, resumo);
-            }
-        }
-    }
-    for (const resumo of tasksResumo) {
-        const chaveTask = `${resumo.modulo}:${resumo.task}`;
-        const task = taskPorChave.get(chaveTask);
-        const guardrails = guardrailsPorTask.get(chaveTask) ?? {
-            publica: false,
-            sensivel: false,
-            auth: false,
-            authz: false,
-            dados: false,
-            audit: false,
-            segredos: false,
-            forbidden: false,
-            dadosSensiveis: false,
-            efeitoPrivilegiado: false,
-            exigeSegredos: false,
+            if (resumo.lacunas.includes("audit_ausente")) {
+                diagnosticos.push({
+                    tipo: "seguranca_frouxa",
+                    modulo: resumo.modulo,
+                    task: resumo.task,
+                    mensagem: `Task "${resumo.task}" ainda nao declara audit explicita para operacao sensivel ou publica.`,
+                });
+            }
+            if (resumo.lacunas.includes("segredo_sem_governanca")) {
+                diagnosticos.push({
+                    tipo: "seguranca_frouxa",
+                    modulo: resumo.modulo,
+                    task: resumo.task,
+                    mensagem: `Task "${resumo.task}" toca segredo ou credencial sem bloco segredos governando origem, escopo e rotacao.`,
+                });
+            }
+            if (resumo.lacunas.includes("proibicoes_ausentes")) {
+                diagnosticos.push({
+                    tipo: "seguranca_frouxa",
+                    modulo: resumo.modulo,
+                    task: resumo.task,
+                    mensagem: `Task "${resumo.task}" opera com efeito privilegiado ou dado sensivel sem forbidden explicito para conter abuso e vazamento.`,
+                });
+            }
+        }
+        const consumersFiltrados = filtrarConsumerSurfacesPorEscopo([...indexTs.consumerSurfaces, ...indexDart.consumerSurfaces].sort((a, b) => a.rota.localeCompare(b.rota, "pt-BR")
+            || a.tipoArquivo.localeCompare(b.tipoArquivo, "pt-BR")
+            || a.arquivo.localeCompare(b.arquivo, "pt-BR")), [...new Map([...indexTs.simbolos, ...indexDart.simbolos]
+                .filter((simbolo) => simboloEhBridgeConsumer(simbolo.caminho, simbolo.arquivo))
+                .map((simbolo) => [
+                `${simbolo.caminho}:${simbolo.arquivo}:${simbolo.simbolo}`,
+                {
+                    caminho: simbolo.caminho,
+                    arquivo: simbolo.arquivo,
+                    simbolo: simbolo.simbolo,
+                },
+            ])).values()].sort((a, b) => a.caminho.localeCompare(b.caminho, "pt-BR")
+            || a.arquivo.localeCompare(b.arquivo, "pt-BR")), contexto, configuracaoEscopo);
+        const consumerSurfaces = consumersFiltrados.consumerSurfaces;
+        const consumerBridges = consumersFiltrados.consumerBridges;
+        const appRoutes = [...new Set(consumerSurfaces.map((surface) => surface.rota))]
+            .sort((a, b) => a.localeCompare(b, "pt-BR"));
+        const consumerFramework = inferirConsumerFrameworkPrincipal(contexto.fontesLegado, consumerSurfaces, consumerBridges);
+        const persistenciaReal = await analisarPersistenciaReal(contexto, mapaRecursos, detalhesPersistencia, opcoesResolvidas);
+        for (const item of persistenciaReal) {
+            if (item.status === "divergente") {
+                diagnosticos.push({
+                    tipo: "recurso_divergente",
+                    modulo: item.modulo,
+                    task: item.task,
+                    mensagem: `Persistencia real para "${item.alvo}" ainda nao foi materializada no codigo vivo.`,
+                });
+            }
+            else if (item.compatibilidade === "invalido") {
+                diagnosticos.push({
+                    tipo: "recurso_divergente",
+                    modulo: item.modulo,
+                    task: item.task,
+                    mensagem: `Persistencia real para "${item.alvo}" conflita com a compatibilidade declarada do engine ${item.engine}.`,
+                });
+            }
+        }
+        const payloadBase = {
+            comando: "drift",
+            sucesso: implsQuebrados.length === 0
+                && rotasDivergentes.length === 0
+                && recursosDivergentes.length === 0
+                && vinculosQuebrados.length === 0
+                && persistenciaReal.every((item) => item.status !== "divergente" && item.compatibilidade !== "invalido"),
+            escopo_aplicado: configuracaoEscopo,
+            consumerFramework,
+            appRoutes,
+            consumerSurfaces,
+            consumerBridges,
+            modulos: contexto.modulosSelecionados.map((item) => ({
+                caminho: item.caminho,
+                modulo: item.resultado.ir?.nome ?? item.resultado.modulo?.nome ?? null,
+                tasks: item.resultado.ir?.tasks.length ?? 0,
+                routes: item.resultado.ir?.routes.length ?? 0,
+            })),
+            tasks: tasksResumo,
+            impls_validos: implsValidos,
+            impls_quebrados: implsQuebrados,
+            vinculos_validos: vinculosValidos,
+            vinculos_quebrados: vinculosQuebrados,
+            rotas_divergentes: rotasDivergentes,
+            recursos_validos: recursosValidos,
+            recursos_divergentes: recursosDivergentes,
+            persistencia_real: persistenciaReal,
+            diagnosticos,
+            resumo_operacional: {
+                scoreMedio: 0,
+                confiancaGeral: "baixa",
+                riscosPrincipais: [],
+                oQueTocar: [],
+                oQueValidar: [],
+                oQueEstaFrouxo: [],
+                oQueFoiInferido: [],
+            },
         };
-        const resumoVinculos = resumoVinculosPorTask.get(chaveTask) ?? {
-            validos: 0,
-            quebrados: 0,
-            arquivos: new Set(),
+        const resumoOperacional = resumirOperacional(payloadBase);
+        return {
+            ...payloadBase,
+            resumo_operacional: resumoOperacional,
         };
-        if (!task) {
-            continue;
+    }
+    finally {
+        diretoriosIgnoradosAtivos = diretoriosIgnoradosAnteriores;
+    }
+}
+const EXTENSOES_BUSCA_IMPACTO = [
+    ".sema",
+    ".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs",
+    ".py", ".dart", ".cs", ".java", ".go", ".rs", ".cpp", ".cc", ".cxx", ".hpp", ".h",
+    ".sql", ".psql", ".ddl", ".prisma", ".json",
+];
+function construirVariantesSemanticas(valor) {
+    const bruto = valor.trim();
+    const partes = paraIdentificadorModulo(valor).split("_").filter(Boolean);
+    if (!bruto && partes.length === 0) {
+        return [];
+    }
+    const camel = partes.length > 0
+        ? `${partes[0]}${partes.slice(1).map((item) => item[0]?.toUpperCase() + item.slice(1)).join("")}`
+        : bruto;
+    const pascal = partes.length > 0
+        ? partes.map((item) => item[0]?.toUpperCase() + item.slice(1)).join("")
+        : bruto;
+    return [...new Set([
+            bruto,
+            partes.join("_"),
+            partes.join("-"),
+            partes.join("."),
+            camel,
+            pascal,
+        ].filter(Boolean))];
+}
+function classificarArquivoImpacto(arquivo) {
+    const normalizado = normalizarFragmentoArquivo(arquivo);
+    if (normalizado.endsWith(".sema")) {
+        return "contrato";
+    }
+    if (/\.(sql|psql|ddl|prisma)$/i.test(normalizado) || /(?:^|\/)(?:db|database|migrations?|schemas?)\//i.test(normalizado)) {
+        return "persistencia";
+    }
+    if (/(?:^|\/)(?:repositorio|repositorios|repository|repositories|repo|dao|store)\//i.test(normalizado) || /(repository|repositorio|dao|store)/i.test(path.basename(normalizado))) {
+        return "repositorio";
+    }
+    if (/(?:^|\/)(?:routes?|controllers?|api)\//i.test(normalizado) || /(controller|route)/i.test(path.basename(normalizado))) {
+        return "rota";
+    }
+    if (/(?:^|\/)(?:workers?|jobs?|queues?|cron)\//i.test(normalizado) || /(worker|job|queue|cron)/i.test(path.basename(normalizado))) {
+        return "worker";
+    }
+    if (/(?:^|\/)(?:pages|screens|components|views|app)\//i.test(normalizado)) {
+        return "ui";
+    }
+    if (/(?:^|\/)(?:tests?|specs?|__tests__)\//i.test(normalizado) || /\.(spec|test)\./i.test(normalizado)) {
+        return "teste";
+    }
+    return "codigo";
+}
+function prioridadeArquivoImpacto(tipo) {
+    switch (tipo) {
+        case "contrato":
+        case "persistencia":
+        case "repositorio":
+        case "rota":
+            return "alta";
+        case "worker":
+        case "codigo":
+            return "media";
+        default:
+            return "baixa";
+    }
+}
+function textoIrCombinaTermos(texto, termos) {
+    return textoCombinaEscopo(texto, termos);
+}
+function registrarArquivoImpactado(mapa, arquivo, linhas, motivos) {
+    const tipo = classificarArquivoImpacto(arquivo);
+    const atual = mapa.get(arquivo);
+    if (atual) {
+        atual.linhas = [...new Set([...atual.linhas, ...linhas])].sort((a, b) => a - b);
+        atual.motivos = [...new Set([...atual.motivos, ...motivos])];
+        if (prioridadeArquivoImpacto(tipo) === "alta") {
+            atual.prioridade = "alta";
         }
-        resumo.confiancaVinculo = calcularConfiancaTask(task, resumo.implsValidos, resumo.implsQuebrados, resumoVinculos.validos, resumoVinculos.quebrados);
-        resumo.riscoOperacional = calcularRiscoOperacional(task);
-        resumo.lacunas = resumirLacunasTask(task, resumo.semImplementacao, resumo.implsQuebrados, resumoVinculos.quebrados, guardrails);
-        resumo.scoreSemantico = calcularScoreTask(task, resumo.implsValidos, resumo.implsQuebrados, resumoVinculos.validos, resumoVinculos.quebrados, resumo.semImplementacao);
-        resumo.arquivosProvaveisEditar = [...new Set([
-                ...resumo.arquivosReferenciados,
-                ...resumo.candidatosImpl.map((candidato) => candidato.arquivo),
-                ...resumoVinculos.arquivos,
-            ])].sort((a, b) => a.localeCompare(b, "pt-BR"));
-        resumo.checksSugeridos = [...new Set([
-                ...task.resumoAgente.checks,
-                resumo.riscoOperacional !== "baixo" ? "revisar efeitos operacionais" : "",
-                resumo.lacunas.includes("vinculo_quebrado") ? "corrigir vinculos rastreaveis" : "",
-                resumo.lacunas.some((lacuna) => ["superficie_publica_sem_execucao", "execucao_critica_sem_bloco", "rastreabilidade_fraca"].includes(lacuna))
-                    ? "endurecer execucao e rastreabilidade para producao"
-                    : "",
-                resumo.lacunas.some((lacuna) => ["auth_ausente", "authz_frouxa", "dados_nao_classificados", "audit_ausente", "segredo_sem_governanca", "proibicoes_ausentes"].includes(lacuna))
-                    ? "explicitar contratos de seguranca semantica"
-                    : "",
-            ].filter(Boolean))];
-        if (resumo.lacunas.includes("superficie_publica_sem_execucao")) {
-            diagnosticos.push({
-                tipo: "seguranca_frouxa",
-                modulo: resumo.modulo,
-                task: resumo.task,
-                mensagem: `Task "${resumo.task}" alimenta superficie publica, mas ainda depende de execucao implicita.`,
-            });
+        else if (prioridadeArquivoImpacto(tipo) === "media" && atual.prioridade === "baixa") {
+            atual.prioridade = "media";
         }
-        if (resumo.lacunas.includes("execucao_critica_sem_bloco")) {
-            diagnosticos.push({
-                tipo: "seguranca_frouxa",
-                modulo: resumo.modulo,
-                task: resumo.task,
-                mensagem: `Task "${resumo.task}" opera com risco alto, mas ainda nao declarou execucao explicita.`,
-            });
-        }
-        if (resumo.lacunas.includes("rastreabilidade_fraca")) {
-            diagnosticos.push({
-                tipo: "seguranca_frouxa",
-                modulo: resumo.modulo,
-                task: resumo.task,
-                mensagem: `Task "${resumo.task}" exige producao mais rastreavel, mas ainda nao declara impl nem vinculos.`,
-            });
+        return;
+    }
+    mapa.set(arquivo, {
+        arquivo,
+        tipo,
+        prioridade: prioridadeArquivoImpacto(tipo),
+        linhas: [...new Set(linhas)].sort((a, b) => a - b),
+        motivos: [...new Set(motivos)],
+    });
+}
+async function listarArquivosImpacto(contexto, opcoes) {
+    const opcoesResolvidas = resolverOpcoesDrift(opcoes);
+    const arquivos = new Set(filtrarCaminhosEscopoReal(contexto.arquivosProjeto, contexto, opcoesResolvidas));
+    for (const diretorio of resolverDiretoriosCodigoEscopoReal(contexto, opcoesResolvidas)) {
+        for (const arquivo of await listarArquivosRecursivos(diretorio, EXTENSOES_BUSCA_IMPACTO)) {
+            arquivos.add(arquivo);
         }
-        if (resumo.lacunas.includes("auth_ausente")) {
-            diagnosticos.push({
-                tipo: "seguranca_frouxa",
-                modulo: resumo.modulo,
-                task: resumo.task,
-                mensagem: `Task "${resumo.task}" chega em superficie publica sem auth explicita em task, route ou superficie associada.`,
-            });
+    }
+    return [...arquivos].sort((a, b) => a.localeCompare(b, "pt-BR"));
+}
+function extrairLinhasComVariantes(codigo, variantes) {
+    const linhas = [];
+    const texto = codigo.split(/\r?\n/);
+    for (let indice = 0; indice < texto.length; indice += 1) {
+        if (variantes.some((variante) => variante && texto[indice].includes(variante))) {
+            linhas.push(indice + 1);
         }
-        if (resumo.lacunas.includes("authz_frouxa")) {
-            diagnosticos.push({
-                tipo: "seguranca_frouxa",
-                modulo: resumo.modulo,
-                task: resumo.task,
-                mensagem: `Task "${resumo.task}" opera com risco ou exposicao, mas ainda nao explicita authz suficiente.`,
-            });
+    }
+    return linhas;
+}
+function serializarTaskParaImpacto(task) {
+    return JSON.stringify({
+        nome: task.nome,
+        input: task.input.map((campo) => campo.nome),
+        output: task.output.map((campo) => campo.nome),
+        effects: task.effects,
+        guarantees: task.guarantees,
+        errors: task.errors,
+        resumo: task.resumoAgente,
+    });
+}
+function serializarRouteParaImpacto(route) {
+    return JSON.stringify({
+        nome: route.nome,
+        caminho: route.caminho,
+        metodo: route.metodo,
+        task: route.task,
+        input: route.inputPublico.map((campo) => campo.nome),
+        output: route.outputPublico.map((campo) => campo.nome),
+    });
+}
+function serializarSuperficieParaImpacto(superficie) {
+    return JSON.stringify({
+        tipo: superficie.tipo,
+        nome: superficie.nome,
+        task: superficie.task,
+        input: superficie.input.map((campo) => campo.nome),
+        output: superficie.output.map((campo) => campo.nome),
+    });
+}
+function ordenarArquivosImpacto(arquivos) {
+    const ordemPrioridade = { alta: 0, media: 1, baixa: 2 };
+    return [...arquivos].sort((a, b) => ordemPrioridade[a.prioridade] - ordemPrioridade[b.prioridade]
+        || a.tipo.localeCompare(b.tipo, "pt-BR")
+        || a.arquivo.localeCompare(b.arquivo, "pt-BR"));
+}
+export async function gerarMapaImpactoSemantico(contexto, alvoSemantico, mudancaProposta, opcoes) {
+    const opcoesResolvidas = resolverOpcoesDrift(opcoes);
+    const diretoriosIgnoradosAnteriores = diretoriosIgnoradosAtivos;
+    diretoriosIgnoradosAtivos = resolverDiretoriosIgnoradosAtivos(opcoesResolvidas);
+    try {
+        const drift = await analisarDriftLegado(contexto, opcoesResolvidas);
+        const variantes = construirVariantesSemanticas(alvoSemantico);
+        const termos = [...new Set([...quebrarTermosEscopo(alvoSemantico), ...drift.escopo_aplicado.termosEscopo])];
+        const arquivosImpactados = new Map();
+        const arquivosBusca = await listarArquivosImpacto(contexto, opcoesResolvidas);
+        for (const arquivo of arquivosBusca) {
+            const codigo = await readFile(arquivo, "utf8");
+            const linhas = extrairLinhasComVariantes(codigo, variantes);
+            if (linhas.length > 0) {
+                registrarArquivoImpactado(arquivosImpactados, arquivo, linhas, ["token_semantico_encontrado"]);
+            }
         }
-        if (resumo.lacunas.includes("dados_nao_classificados")) {
-            diagnosticos.push({
-                tipo: "seguranca_frouxa",
-                modulo: resumo.modulo,
-                task: resumo.task,
-                mensagem: `Task "${resumo.task}" ainda nao classifica dados de entrada/saida de forma semantica.`,
-            });
+        const tasksAfetadas = new Set();
+        const routesAfetadas = new Set();
+        const superficiesAfetadas = new Set();
+        const persistenciaAfetada = new Set();
+        for (const item of contexto.modulosSelecionados) {
+            const ir = item.resultado.ir;
+            if (!ir) {
+                continue;
+            }
+            for (const task of ir.tasks) {
+                if (textoIrCombinaTermos(serializarTaskParaImpacto(task), termos)) {
+                    tasksAfetadas.add(`${ir.nome}.${task.nome}`);
+                }
+            }
+            for (const route of ir.routes) {
+                if (textoIrCombinaTermos(serializarRouteParaImpacto(route), termos)) {
+                    routesAfetadas.add(`${ir.nome}.${route.nome}`);
+                }
+            }
+            for (const superficie of ir.superficies) {
+                if (textoIrCombinaTermos(serializarSuperficieParaImpacto(superficie), termos)) {
+                    superficiesAfetadas.add(`${ir.nome}.${superficie.tipo}.${superficie.nome}`);
+                }
+            }
         }
-        if (resumo.lacunas.includes("audit_ausente")) {
-            diagnosticos.push({
-                tipo: "seguranca_frouxa",
-                modulo: resumo.modulo,
-                task: resumo.task,
-                mensagem: `Task "${resumo.task}" ainda nao declara audit explicita para operacao sensivel ou publica.`,
-            });
+        for (const task of drift.tasks.filter((item) => tasksAfetadas.has(`${item.modulo}.${item.task}`))) {
+            for (const arquivo of task.arquivosProvaveisEditar) {
+                registrarArquivoImpactado(arquivosImpactados, arquivo, [], ["arquivo_relacionado_por_drift"]);
+            }
         }
-        if (resumo.lacunas.includes("segredo_sem_governanca")) {
-            diagnosticos.push({
-                tipo: "seguranca_frouxa",
-                modulo: resumo.modulo,
-                task: resumo.task,
-                mensagem: `Task "${resumo.task}" toca segredo ou credencial sem bloco segredos governando origem, escopo e rotacao.`,
-            });
+        for (const item of drift.persistencia_real) {
+            if (textoIrCombinaTermos(`${item.alvo} ${item.task} ${item.colunas.join(" ")}`, termos)) {
+                persistenciaAfetada.add(`${item.task}:${item.alvo}`);
+                for (const arquivo of [...item.arquivos, ...item.repositorios]) {
+                    registrarArquivoImpactado(arquivosImpactados, arquivo, [], ["persistencia_relacionada"]);
+                }
+            }
         }
-        if (resumo.lacunas.includes("proibicoes_ausentes")) {
-            diagnosticos.push({
-                tipo: "seguranca_frouxa",
-                modulo: resumo.modulo,
-                task: resumo.task,
-                mensagem: `Task "${resumo.task}" opera com efeito privilegiado ou dado sensivel sem forbidden explicito para conter abuso e vazamento.`,
-            });
+        const contratosAfetados = ordenarArquivosImpacto([...arquivosImpactados.values()].filter((arquivo) => arquivo.tipo === "contrato")).map((arquivo) => arquivo.arquivo);
+        return {
+            comando: "impacto",
+            sucesso: arquivosImpactados.size > 0 || tasksAfetadas.size > 0 || persistenciaAfetada.size > 0,
+            escopo: drift.escopo_aplicado.escopo,
+            alvoSemantico,
+            mudancaProposta,
+            contratosAfetados,
+            tasksAfetadas: [...tasksAfetadas].sort((a, b) => a.localeCompare(b, "pt-BR")),
+            routesAfetadas: [...routesAfetadas].sort((a, b) => a.localeCompare(b, "pt-BR")),
+            superficiesAfetadas: [...superficiesAfetadas].sort((a, b) => a.localeCompare(b, "pt-BR")),
+            persistenciaAfetada: [...persistenciaAfetada].sort((a, b) => a.localeCompare(b, "pt-BR")),
+            arquivos: ordenarArquivosImpacto([...arquivosImpactados.values()]),
+            ordemOperacional: [
+                "Atualizar contrato .sema e revisar garantias publicas primeiro.",
+                "Ajustar persistencia e repositorios concretos antes de materializacao externa.",
+                "Revisar rotas, workers e bridges depois que o contrato e o storage estiverem coerentes.",
+                "Fechar com UI/consumidores e testes alinhados ao payload final.",
+            ],
+            validacoes: [
+                "Rodar sema validar no contrato alterado.",
+                "Rodar sema drift com o mesmo escopo apos a mudanca.",
+                "Revalidar testes de payload, persistencia e superficies publicas.",
+            ],
+        };
+    }
+    finally {
+        diretoriosIgnoradosAtivos = diretoriosIgnoradosAnteriores;
+    }
+}
+export async function assistirRenomeacaoSemantica(contexto, nomeAtual, nomeNovo, opcoes) {
+    const impacto = await gerarMapaImpactoSemantico(contexto, nomeAtual, `renomear ${nomeAtual} para ${nomeNovo}`, opcoes);
+    const variantesAntigas = construirVariantesSemanticas(nomeAtual);
+    const variantesNovas = construirVariantesSemanticas(nomeNovo);
+    const mapaSubstituicao = new Map();
+    variantesAntigas.forEach((antiga, indice) => {
+        mapaSubstituicao.set(antiga, variantesNovas[indice] ?? nomeNovo);
+    });
+    const sugestoes = [];
+    for (const arquivo of impacto.arquivos) {
+        const codigo = await readFile(arquivo.arquivo, "utf8");
+        const linhas = codigo.split(/\r?\n/);
+        for (let indice = 0; indice < linhas.length; indice += 1) {
+            const linha = linhas[indice];
+            for (const antiga of variantesAntigas) {
+                if (!antiga || !linha.includes(antiga)) {
+                    continue;
+                }
+                sugestoes.push({
+                    arquivo: arquivo.arquivo,
+                    linha: indice + 1,
+                    atual: antiga,
+                    sugerido: mapaSubstituicao.get(antiga) ?? nomeNovo,
+                    contexto: linha.trim().slice(0, 180),
+                });
+            }
         }
     }
-    const consumerSurfaces = [...indexTs.consumerSurfaces, ...indexDart.consumerSurfaces].sort((a, b) => a.rota.localeCompare(b.rota, "pt-BR")
-        || a.tipoArquivo.localeCompare(b.tipoArquivo, "pt-BR")
-        || a.arquivo.localeCompare(b.arquivo, "pt-BR"));
-    const consumerBridges = [...new Map([...indexTs.simbolos, ...indexDart.simbolos]
-            .filter((simbolo) => simboloEhBridgeConsumer(simbolo.caminho, simbolo.arquivo))
-            .map((simbolo) => [
-            `${simbolo.caminho}:${simbolo.arquivo}:${simbolo.simbolo}`,
-            {
-                caminho: simbolo.caminho,
-                arquivo: simbolo.arquivo,
-                simbolo: simbolo.simbolo,
-            },
-        ])).values()].sort((a, b) => a.caminho.localeCompare(b.caminho, "pt-BR")
-        || a.arquivo.localeCompare(b.arquivo, "pt-BR"));
-    const appRoutes = [...new Set(consumerSurfaces.map((surface) => surface.rota))]
-        .sort((a, b) => a.localeCompare(b, "pt-BR"));
-    const consumerFramework = inferirConsumerFrameworkPrincipal(contexto.fontesLegado, consumerSurfaces, consumerBridges);
-    const payloadBase = {
-        comando: "drift",
-        sucesso: implsQuebrados.length === 0 && rotasDivergentes.length === 0 && recursosDivergentes.length === 0 && vinculosQuebrados.length === 0,
-        consumerFramework,
-        appRoutes,
-        consumerSurfaces,
-        consumerBridges,
-        modulos: contexto.modulosSelecionados.map((item) => ({
-            caminho: item.caminho,
-            modulo: item.resultado.ir?.nome ?? item.resultado.modulo?.nome ?? null,
-            tasks: item.resultado.ir?.tasks.length ?? 0,
-            routes: item.resultado.ir?.routes.length ?? 0,
-        })),
-        tasks: tasksResumo,
-        impls_validos: implsValidos,
-        impls_quebrados: implsQuebrados,
-        vinculos_validos: vinculosValidos,
-        vinculos_quebrados: vinculosQuebrados,
-        rotas_divergentes: rotasDivergentes,
-        recursos_validos: recursosValidos,
-        recursos_divergentes: recursosDivergentes,
-        diagnosticos,
-        resumo_operacional: {
-            scoreMedio: 0,
-            confiancaGeral: "baixa",
-            riscosPrincipais: [],
-            oQueTocar: [],
-            oQueValidar: [],
-            oQueEstaFrouxo: [],
-            oQueFoiInferido: [],
-        },
-    };
-    const resumoOperacional = resumirOperacional(payloadBase);
     return {
-        ...payloadBase,
-        resumo_operacional: resumoOperacional,
+        comando: "renomear-semantico",
+        sucesso: sugestoes.length > 0,
+        escopo: impacto.escopo,
+        de: nomeAtual,
+        para: nomeNovo,
+        arquivos: impacto.arquivos,
+        sugestoes,
+        ordemOperacional: [
+            "Renomear primeiro no contrato .sema e nos campos publicos derivados.",
+            "Ajustar repositorios, payloads e bridges que materializam o nome antigo.",
+            "Rodar sema drift e revisar sugestoes restantes antes de fechar a troca.",
+        ],
+        validacoes: [
+            "Rodar sema validar no contrato renomeado.",
+            "Rodar sema drift para confirmar que payload e superficie nao ficaram misturados.",
+            "Reexecutar testes e checar snapshots ou fixtures afetados.",
+        ],
     };
 }
 //# sourceMappingURL=drift.js.map