@semacode/cli 1.5.0 → 1.5.1

package/README.md

@@ -58,7 +58,7 @@ sema drift ./contratos-importados --json
 
 ## Persistencia vendor-first
 
-A CLI 1.5.0 entende blocos `database` e recursos de persistencia no IR, no formatador, no semantico, na importacao, no drift, no impact map e na renomeacao semantica assistida. O objetivo nao e esconder diferencas entre bancos, e sim capturar essas diferencas no contrato.
+A CLI 1.5.1 entende blocos `database` e recursos de persistencia no IR, no formatador, no semantico, na importacao, no drift, no impact map e na renomeacao semantica assistida. O objetivo nao e esconder diferencas entre bancos, e sim capturar essas diferencas no contrato.
 
 Cobertura publica:
 

package/dist/drift.d.ts

@@ -42,8 +42,9 @@ interface RegistroRotaDivergente {
     caminho?: string;
     motivo: string;
 }
-type OrigemRecursoDrift = "firebase" | EngineBanco;
-type TipoRecursoDrift = "colecao" | TipoRecursoPersistencia;
+type OrigemRecursoDrift = "firebase" | EngineBanco | "arquivo";
+type TipoRecursoDrift = "colecao" | TipoRecursoPersistencia | "arquivo_local";
+type CategoriaPersistenciaDrift = "relacional" | "documental" | "chave_valor" | "local_arquivo" | "desconhecida";
 interface RecursoResolvido {
     origem: OrigemRecursoDrift;
     nome: string;
@@ -62,13 +63,15 @@ interface RegistroRecursoDrift {
     status: "resolvido" | "divergente";
 }
 interface RegistroColunaPersistenciaDrift {
-    engine: EngineBanco;
+    origem: OrigemRecursoDrift;
+    categoriaPersistencia: CategoriaPersistenciaDrift;
     recurso: string;
     coluna: string;
     arquivo: string;
 }
 interface RegistroRepositorioPersistenciaDrift {
-    engine: EngineBanco;
+    origem: OrigemRecursoDrift;
+    categoriaPersistencia: CategoriaPersistenciaDrift;
     recurso: string;
     arquivo: string;
 }
@@ -113,6 +116,7 @@ export interface RegistroPersistenciaRealDrift {
     task: string;
     alvo: string;
     engine: OrigemRecursoDrift | "desconhecido";
+    categoriaPersistencia: CategoriaPersistenciaDrift;
     tipo: TipoRecursoDrift;
     status: "materializado" | "parcial" | "divergente";
     arquivos: string[];

package/dist/drift.js

@@ -56,6 +56,7 @@ const TERMOS_ESCopo_IGNORADOS = new Set([
     "data",
     "drift",
     "flow",
+    "int",
     "module",
     "modulo",
     "publico",
@@ -110,18 +111,29 @@ function quebrarTermosEscopo(valor) {
         .map((item) => item.trim())
         .filter((item) => item.length >= 3 && !TERMOS_ESCopo_IGNORADOS.has(item));
 }
+function quebrarTermosModuloEscopo(nomeModulo) {
+    const segmentos = nomeModulo
+        .split(".")
+        .map((item) => item.trim())
+        .filter(Boolean);
+    const relevantes = segmentos.length > 1 ? segmentos.slice(1) : segmentos;
+    return relevantes.flatMap((segmento) => quebrarTermosEscopo(segmento));
+}
 function extrairTermosEscopoDrift(contexto, escopo) {
     if (escopo === "projeto") {
         return [];
     }
     const termos = new Set();
-    termos.add(paraIdentificadorModulo(path.basename(contexto.entradaResolvida, path.extname(contexto.entradaResolvida))));
+    const termosRaizProjeto = new Set(quebrarTermosEscopo(path.basename(contexto.baseProjeto)));
+    if (escopo === "arquivo" || path.extname(contexto.entradaResolvida)) {
+        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)) {
+        for (const termo of quebrarTermosModuloEscopo(ir.nome)) {
             termos.add(termo);
         }
         for (const task of ir.tasks) {
@@ -140,7 +152,26 @@ function extrairTermosEscopoDrift(contexto, escopo) {
             }
         }
     }
-    return [...termos].filter(Boolean).sort((a, b) => a.localeCompare(b, "pt-BR"));
+    return [...termos]
+        .filter((termo) => Boolean(termo) && !termosRaizProjeto.has(termo))
+        .sort((a, b) => a.localeCompare(b, "pt-BR"));
+}
+function categorizarPersistenciaPorOrigem(origem) {
+    switch (origem) {
+        case "postgres":
+        case "mysql":
+        case "sqlite":
+            return "relacional";
+        case "mongodb":
+        case "firebase":
+            return "documental";
+        case "redis":
+            return "chave_valor";
+        case "arquivo":
+            return "local_arquivo";
+        default:
+            return "desconhecida";
+    }
 }
 function caminhoTemSegmentoIgnorado(arquivo, segmentos) {
     const partes = normalizarFragmentoArquivo(arquivo).split("/").filter(Boolean);
@@ -210,9 +241,104 @@ function textoCombinaEscopo(texto, termos) {
     const normalizado = paraIdentificadorModulo(texto);
     return termos.some((termo) => normalizado.includes(termo));
 }
-function filtrarConsumerSurfacesPorEscopo(consumerSurfaces, consumerBridges, contexto, configuracao) {
+function construirContextoRelevanciaConsumer(contexto, tasksResumo, vinculosValidos) {
+    const arquivosAncora = new Set();
+    const rotasAncora = new Set();
+    for (const modulo of contexto.modulosSelecionados) {
+        const ir = modulo.resultado.ir;
+        if (!ir) {
+            continue;
+        }
+        for (const route of ir.routes) {
+            if (route.caminho) {
+                rotasAncora.add(normalizarCaminhoRota(route.caminho));
+            }
+        }
+    }
+    for (const task of tasksResumo) {
+        for (const arquivo of [...task.arquivosReferenciados, ...task.arquivosProvaveisEditar]) {
+            arquivosAncora.add(arquivo);
+        }
+    }
+    for (const vinculo of vinculosValidos) {
+        if (vinculo.arquivo) {
+            arquivosAncora.add(vinculo.arquivo);
+        }
+        if (vinculo.tipo === "superficie" || vinculo.tipo === "rota") {
+            rotasAncora.add(normalizarCaminhoRota(vinculo.valor));
+        }
+    }
+    return {
+        arquivosAncora: [...arquivosAncora].sort((a, b) => a.localeCompare(b, "pt-BR")),
+        rotasAncora: [...rotasAncora].sort((a, b) => a.localeCompare(b, "pt-BR")),
+    };
+}
+function pontuarTextoEscopo(texto, termos) {
+    if (termos.length === 0) {
+        return 0;
+    }
+    const normalizado = paraIdentificadorModulo(texto);
+    const segmentos = new Set(normalizado.split("_").filter(Boolean));
+    let score = 0;
+    for (const termo of termos) {
+        if (segmentos.has(termo)) {
+            score += 4;
+            continue;
+        }
+        if (normalizado.includes(termo)) {
+            score += 2;
+        }
+    }
+    return Math.min(score, 8);
+}
+function pontuarProximidadeArquivoConsumer(arquivo, arquivosAncora) {
+    if (arquivosAncora.length === 0) {
+        return 0;
+    }
+    const alvo = normalizarFragmentoArquivo(arquivo);
+    const diretorioAlvo = path.posix.dirname(alvo);
+    let scoreMaximo = 0;
+    for (const ancora of arquivosAncora) {
+        const ancoraNormalizada = normalizarFragmentoArquivo(ancora);
+        const diretorioAncora = path.posix.dirname(ancoraNormalizada);
+        if (alvo === ancoraNormalizada) {
+            return 8;
+        }
+        if (diretorioAlvo === diretorioAncora) {
+            scoreMaximo = Math.max(scoreMaximo, 6);
+            continue;
+        }
+        const ultimoDiretorioAlvo = diretorioAlvo.split("/").filter(Boolean).at(-1);
+        const ultimoDiretorioAncora = diretorioAncora.split("/").filter(Boolean).at(-1);
+        if (ultimoDiretorioAlvo && ultimoDiretorioAlvo === ultimoDiretorioAncora) {
+            scoreMaximo = Math.max(scoreMaximo, 4);
+        }
+    }
+    return scoreMaximo;
+}
+function pontuarProximidadeRotaConsumer(rota, rotasAncora) {
+    if (rotasAncora.length === 0) {
+        return 0;
+    }
+    const rotaNormalizada = normalizarCaminhoRota(rota);
+    const segmentosRota = rotaNormalizada.split("/").filter(Boolean);
+    let scoreMaximo = 0;
+    for (const ancora of rotasAncora) {
+        const rotaAncora = normalizarCaminhoRota(ancora);
+        if (rotaNormalizada === rotaAncora) {
+            return 8;
+        }
+        const segmentosAncora = rotaAncora.split("/").filter(Boolean);
+        if (segmentosRota[0] && segmentosRota[0] === segmentosAncora[0]) {
+            scoreMaximo = Math.max(scoreMaximo, 4);
+        }
+    }
+    return scoreMaximo;
+}
+function filtrarConsumerSurfacesPorEscopo(consumerSurfaces, consumerBridges, contexto, configuracao, relevancia) {
     const raizesWorktreePermitidas = resolverRaizesIgnoradasPermitidas(contexto, DIRETORIOS_WORKTREE);
     const raizesConsumidorPermitidas = resolverRaizesIgnoradasPermitidas(contexto, DIRETORIOS_CONSUMIDOR_LATERAL);
+    const limiar = configuracao.escopo === "arquivo" ? 5 : 4;
     const manterSurface = (surface) => {
         if (configuracao.ignorarWorktrees
             && caminhoIgnoradoForaDoEscopoReal(surface.arquivo, DIRETORIOS_WORKTREE, raizesWorktreePermitidas)) {
@@ -222,11 +348,13 @@ function filtrarConsumerSurfacesPorEscopo(consumerSurfaces, consumerBridges, con
             && 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";
+        if (configuracao.escopo === "projeto") {
+            return true;
         }
-        return configuracao.escopo === "projeto" ? true : combinaEscopo;
+        const score = pontuarTextoEscopo(`${surface.rota} ${surface.arquivo} ${surface.tipoArquivo}`, configuracao.termosEscopo)
+            + pontuarProximidadeArquivoConsumer(surface.arquivo, relevancia?.arquivosAncora ?? [])
+            + pontuarProximidadeRotaConsumer(surface.rota, relevancia?.rotasAncora ?? []);
+        return score >= limiar;
     };
     const manterBridge = (bridge) => {
         if (configuracao.ignorarWorktrees
@@ -237,11 +365,12 @@ function filtrarConsumerSurfacesPorEscopo(consumerSurfaces, consumerBridges, con
             && 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";
+        if (configuracao.escopo === "projeto") {
+            return true;
         }
-        return configuracao.escopo === "projeto" ? true : combinaEscopo;
+        const score = pontuarTextoEscopo(`${bridge.caminho} ${bridge.arquivo} ${bridge.simbolo}`, configuracao.termosEscopo)
+            + pontuarProximidadeArquivoConsumer(bridge.arquivo, relevancia?.arquivosAncora ?? []);
+        return score >= limiar;
     };
     return {
         consumerSurfaces: consumerSurfaces.filter(manterSurface),
@@ -542,6 +671,29 @@ function extrairRecursosRedis(arquivo, codigo) {
     }
     return [...recursos.values()];
 }
+function extrairRecursosArquivoLocal(arquivo, codigo) {
+    const recursos = new Map();
+    const contextoArquivoLocal = /\b(?:json|jsonl|ndjson)\b/i.test(codigo)
+        || /\b(?:read_text|write_text|readFile(?:Sync)?|writeFile(?:Sync)?|open)\b/i.test(codigo)
+        || /\.(?:json|jsonl|ndjson|db|sqlite|sqlite3)\b/i.test(codigo)
+        || /(?:repository|repositories|repositorio|repo|store|storage|persist|cache)/i.test(normalizarFragmentoArquivo(arquivo));
+    if (!contextoArquivoLocal) {
+        return [];
+    }
+    for (const match of codigo.matchAll(/["'`]([^"'`]+\.(?:json|jsonl|ndjson|db|sqlite|sqlite3))["'`]/gi)) {
+        const literal = match[1] ?? "";
+        const nomeBase = path.basename(literal, path.extname(literal));
+        registrarRecursoDrift(recursos, "arquivo", "arquivo_local", nomeBase, arquivo);
+    }
+    const nomeArquivo = path.basename(arquivo).replace(/\.(?:ts|tsx|js|jsx|mjs|cjs|py|dart|cs|java|go|rs|cpp|cc|cxx|hpp|h)$/i, "");
+    const nomeStore = nomeArquivo
+        .replace(/(?:[_.-]?(?:repository|repositories|repo|store|storage|persistencia|persistence))$/i, "")
+        .trim();
+    if (nomeStore && /(?:repository|repositories|repositorio|repo|store|storage|persist|cache)/i.test(nomeArquivo)) {
+        registrarRecursoDrift(recursos, "arquivo", "arquivo_local", nomeStore, arquivo);
+    }
+    return [...recursos.values()];
+}
 function extrairRecursosPersistenciaCodigoVivo(arquivo, codigo) {
     const recursos = new Map();
     for (const recurso of extrairColecoesFirebase(arquivo, codigo)) {
@@ -556,6 +708,9 @@ function extrairRecursosPersistenciaCodigoVivo(arquivo, codigo) {
     for (const recurso of extrairRecursosRedis(arquivo, codigo)) {
         registrarRecursoDrift(recursos, recurso.origem, recurso.tipo, recurso.nome, recurso.arquivo, recurso.simbolo);
     }
+    for (const recurso of extrairRecursosArquivoLocal(arquivo, codigo)) {
+        registrarRecursoDrift(recursos, recurso.origem, recurso.tipo, recurso.nome, recurso.arquivo, recurso.simbolo);
+    }
     return [...recursos.values()];
 }
 function extrairRecursosPrisma(arquivo, codigo) {
@@ -1757,7 +1912,11 @@ async function indexarCpp(diretorios) {
 async function indexarPersistenciaDeclarativa(diretorios) {
     const recursos = new Map();
     for (const diretorio of diretorios) {
-        const arquivos = await listarArquivosRecursivos(diretorio, [".sql", ".psql", ".ddl", ".prisma"]);
+        const arquivos = await listarArquivosRecursivos(diretorio, [
+            ".sql", ".psql", ".ddl", ".prisma",
+            ".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs",
+            ".py", ".dart", ".cs", ".java", ".go", ".rs", ".cpp", ".cc", ".cxx", ".hpp", ".h",
+        ]);
         for (const arquivo of arquivos) {
             const codigo = await readFile(arquivo, "utf8");
             const extracoes = arquivo.endsWith(".prisma")
@@ -1771,33 +1930,35 @@ async function indexarPersistenciaDeclarativa(diretorios) {
     return { recursos: [...recursos.values()] };
 }
 function normalizarOrigemParaEngine(origem) {
-    return origem && origem !== "firebase" ? origem : undefined;
+    return origem && origem !== "firebase" && origem !== "arquivo" ? origem : undefined;
 }
-function registrarColunaPersistenciaDrift(colunas, engine, recurso, coluna, arquivo) {
+function registrarColunaPersistenciaDrift(colunas, origem, 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}`;
+    const chave = `${origem}:${normalizarNomeRecursoDrift(recursoNormalizado)}:${normalizarNomeRecursoDrift(colunaNormalizada)}:${arquivo}`;
     if (!colunas.has(chave)) {
         colunas.set(chave, {
-            engine,
+            origem,
+            categoriaPersistencia: categorizarPersistenciaPorOrigem(origem),
             recurso: recursoNormalizado,
             coluna: colunaNormalizada,
             arquivo,
         });
     }
 }
-function registrarRepositorioPersistenciaDrift(repositorios, engine, recurso, arquivo) {
+function registrarRepositorioPersistenciaDrift(repositorios, origem, recurso, arquivo) {
     const recursoNormalizado = fecharPrefixoRecurso(limparLiteralRecurso(recurso));
     if (!recursoNormalizado) {
         return;
     }
-    const chave = `${engine}:${normalizarNomeRecursoDrift(recursoNormalizado)}:${arquivo}`;
+    const chave = `${origem}:${normalizarNomeRecursoDrift(recursoNormalizado)}:${arquivo}`;
     if (!repositorios.has(chave)) {
         repositorios.set(chave, {
-            engine,
+            origem,
+            categoriaPersistencia: categorizarPersistenciaPorOrigem(origem),
             recurso: recursoNormalizado,
             arquivo,
         });
@@ -1912,19 +2073,38 @@ function extrairCamposRedisDetalhados(arquivo, codigo) {
     }
     return [...colunas.values()];
 }
+function extrairCamposArquivoLocalDetalhados(arquivo, codigo) {
+    const colunas = new Map();
+    const recursos = extrairRecursosArquivoLocal(arquivo, codigo);
+    if (recursos.length === 0) {
+        return [];
+    }
+    const registrarCampo = (recurso, trecho) => {
+        for (const match of trecho.matchAll(/["'`]?([A-Za-z_][\w$-]*)["'`]?\s*:/g)) {
+            registrarColunaPersistenciaDrift(colunas, "arquivo", recurso, match[1], arquivo);
+        }
+    };
+    const blocos = [
+        ...codigo.matchAll(/\b(?:_empty_store|empty_store|default_store)\b[\s\S]{0,1000}?return\s*\{([\s\S]*?)\n\s*\}/g),
+        ...codigo.matchAll(/\bstore\s*=\s*\{([\s\S]*?)\n\s*\}/g),
+    ];
+    for (const recurso of recursos) {
+        for (const bloco of blocos) {
+            registrarCampo(recurso.nome, bloco[1] ?? "");
+        }
+    }
+    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);
+    const contextoAcesso = /\b(?:select|insert|update|delete|aggregate|findOne|findMany|findUnique|findFirst|prisma\.|db\.collection|createClient|hset|hget|xadd|xread|json\.(?:load|loads|dump|dumps)|JSON\.(?:parse|stringify)|read_text|write_text|readFile(?:Sync)?|writeFile(?:Sync)?|open)\b/i.test(codigo)
+        || /\.(?:json|jsonl|ndjson|db|sqlite|sqlite3)\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);
+        registrarRepositorioPersistenciaDrift(repositorios, recurso.origem, recurso.nome, arquivo);
     }
 }
 async function indexarPersistenciaDetalhada(diretorios) {
@@ -1942,16 +2122,19 @@ async function indexarPersistenciaDetalhada(diretorios) {
                 ? extrairRecursosPrisma(arquivo, codigo)
                 : extrairRecursosPersistenciaCodigoVivo(arquivo, codigo);
             for (const coluna of extrairColunasSqlDetalhadas(arquivo, codigo)) {
-                registrarColunaPersistenciaDrift(colunas, coluna.engine, coluna.recurso, coluna.coluna, coluna.arquivo);
+                registrarColunaPersistenciaDrift(colunas, coluna.origem, coluna.recurso, coluna.coluna, coluna.arquivo);
             }
             for (const coluna of extrairColunasPrismaDetalhadas(arquivo, codigo)) {
-                registrarColunaPersistenciaDrift(colunas, coluna.engine, coluna.recurso, coluna.coluna, coluna.arquivo);
+                registrarColunaPersistenciaDrift(colunas, coluna.origem, coluna.recurso, coluna.coluna, coluna.arquivo);
             }
             for (const coluna of extrairCamposMongoDetalhados(arquivo, codigo)) {
-                registrarColunaPersistenciaDrift(colunas, coluna.engine, coluna.recurso, coluna.coluna, coluna.arquivo);
+                registrarColunaPersistenciaDrift(colunas, coluna.origem, coluna.recurso, coluna.coluna, coluna.arquivo);
             }
             for (const coluna of extrairCamposRedisDetalhados(arquivo, codigo)) {
-                registrarColunaPersistenciaDrift(colunas, coluna.engine, coluna.recurso, coluna.coluna, coluna.arquivo);
+                registrarColunaPersistenciaDrift(colunas, coluna.origem, coluna.recurso, coluna.coluna, coluna.arquivo);
+            }
+            for (const coluna of extrairCamposArquivoLocalDetalhados(arquivo, codigo)) {
+                registrarColunaPersistenciaDrift(colunas, coluna.origem, coluna.recurso, coluna.coluna, coluna.arquivo);
             }
             registrarRepositoriosPorRecursos(repositorios, arquivo, codigo, recursos);
         }
@@ -1964,12 +2147,70 @@ async function indexarPersistenciaDetalhada(diretorios) {
 function recursoDetalhadoCombina(recurso, esperado) {
     return variantesNomeRecursoDrift(recurso).some((variante) => esperado.nomes.some((nome) => variantesNomeRecursoDrift(nome).includes(variante)));
 }
+function deduplicarRecursosResolvidos(recursos) {
+    return [...new Map(recursos.map((recurso) => [`${recurso.origem}:${recurso.tipo}:${recurso.nome}:${recurso.arquivo}:${recurso.simbolo ?? ""}`, recurso])).values()];
+}
+function normalizarArquivoDeclaradoDrift(valor) {
+    return normalizarFragmentoArquivo(valor);
+}
+function arquivoCombinaDeclaradoDrift(arquivoReal, arquivoDeclarado) {
+    const real = normalizarArquivoDeclaradoDrift(arquivoReal);
+    const declarado = normalizarArquivoDeclaradoDrift(arquivoDeclarado);
+    return real === declarado || real.endsWith(declarado) || declarado.endsWith(real);
+}
+function coletarArquivosPreferidosPersistenciaTask(task) {
+    const arquivos = new Set();
+    for (const vinculo of task.vinculos) {
+        if (vinculo.arquivo) {
+            arquivos.add(vinculo.arquivo);
+        }
+        if (vinculo.tipo === "arquivo" && vinculo.valor) {
+            arquivos.add(vinculo.valor);
+        }
+    }
+    return arquivos;
+}
+function resolverPersistenciaLocalPorTask(mapaRecursos, task, ir, esperado) {
+    const todosRecursos = deduplicarRecursosResolvidos([...mapaRecursos.values()].flat());
+    const arquivosPreferidos = [...coletarArquivosPreferidosPersistenciaTask(task)];
+    const candidatosPorArquivo = arquivosPreferidos.length > 0
+        ? todosRecursos.filter((recurso) => recurso.origem === "arquivo"
+            && arquivosPreferidos.some((arquivo) => arquivoCombinaDeclaradoDrift(recurso.arquivo, arquivo)))
+        : [];
+    if (candidatosPorArquivo.length > 0) {
+        return candidatosPorArquivo;
+    }
+    const termos = new Set([
+        ...quebrarTermosEscopo(ir.nome),
+        ...quebrarTermosEscopo(task.nome),
+        ...quebrarTermosEscopo(esperado.alvo),
+    ]);
+    if (termos.size === 0) {
+        return [];
+    }
+    return todosRecursos.filter((recurso) => recurso.origem === "arquivo"
+        && [...termos].some((termo) => variantesNomeRecursoDrift(recurso.nome).some((variacao) => variacao.includes(termo))));
+}
+function detalhePersistenciaCombinaOrigem(origemDetalhe, recursoReal) {
+    if (!recursoReal) {
+        return true;
+    }
+    return origemDetalhe === recursoReal.origem;
+}
 function localizarCompatibilidadePersistencia(bancos, esperado, recursoReal) {
     for (const banco of bancos) {
         for (const recurso of banco.resources) {
             if (!recursoPersistenciaCombinaAlvo(recurso, esperado.alvo)) {
                 continue;
             }
+            if (recursoReal?.origem === "arquivo") {
+                return {
+                    engine: "arquivo",
+                    compatibilidade: "adaptado",
+                    motivoCompatibilidade: `Persistencia local/arquivo detectada no codigo vivo em vez do engine ${banco.engine}.`,
+                    tipo: recursoReal.tipo,
+                };
+            }
             const engine = banco.engine ?? normalizarOrigemParaEngine(recursoReal?.origem);
             const compatibilidade = engine
                 ? recurso.compatibilidade.find((item) => item.engine === engine) ?? recurso.compatibilidade[0]
@@ -1982,6 +2223,14 @@ function localizarCompatibilidadePersistencia(bancos, esperado, recursoReal) {
             };
         }
     }
+    if (recursoReal?.origem === "arquivo") {
+        return {
+            engine: "arquivo",
+            compatibilidade: "desconhecida",
+            motivoCompatibilidade: "Persistencia local/arquivo detectada sem database vendor-first declarado.",
+            tipo: recursoReal.tipo,
+        };
+    }
     return {
         engine: recursoReal?.origem ?? esperado.origem ?? "desconhecido",
         compatibilidade: "desconhecida",
@@ -2002,22 +2251,41 @@ export async function analisarPersistenciaReal(contexto, mapaRecursos, detalhesP
         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()];
+                let recursosReais = deduplicarRecursosResolvidos(correspondencias);
+                const arquivosPreferidos = [...coletarArquivosPreferidosPersistenciaTask(task)];
+                if (recursosReais.length === 0) {
+                    recursosReais = resolverPersistenciaLocalPorTask(mapa, task, ir, esperado);
+                }
                 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))
+                let colunas = [...new Set(detalhes.colunas
+                        .filter((coluna) => detalhePersistenciaCombinaOrigem(coluna.origem, recursosReais[0])
                         && 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))
+                let repositorios = [...new Set(detalhes.repositorios
+                        .filter((repositorio) => detalhePersistenciaCombinaOrigem(repositorio.origem, recursosReais[0])
                         && recursoDetalhadoCombina(repositorio.recurso, esperado))
                         .map((repositorio) => repositorio.arquivo))].sort((a, b) => a.localeCompare(b, "pt-BR"));
+                if (recursosReais.some((recurso) => recurso.origem === "arquivo") && arquivosPreferidos.length > 0) {
+                    if (colunas.length === 0) {
+                        colunas = [...new Set(detalhes.colunas
+                                .filter((coluna) => coluna.origem === "arquivo"
+                                && arquivosPreferidos.some((arquivo) => arquivoCombinaDeclaradoDrift(coluna.arquivo, arquivo)))
+                                .map((coluna) => coluna.coluna))].sort((a, b) => a.localeCompare(b, "pt-BR"));
+                    }
+                    if (repositorios.length === 0) {
+                        repositorios = [...new Set(detalhes.repositorios
+                                .filter((repositorio) => repositorio.origem === "arquivo"
+                                && arquivosPreferidos.some((arquivo) => arquivoCombinaDeclaradoDrift(repositorio.arquivo, arquivo)))
+                                .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,
+                    categoriaPersistencia: categorizarPersistenciaPorOrigem((compatibilidade.engine === "desconhecido" ? undefined : compatibilidade.engine)),
                     tipo: compatibilidade.tipo,
                     status: recursosReais.length === 0
                         ? "divergente"
@@ -2259,6 +2527,10 @@ function recursoPersistenciaCombinaAlvo(recurso, alvo) {
     }
     return nomesRecursoPersistencia(recurso).some((nome) => variantesNomeRecursoDrift(nome).some((variacao) => alvoVariantes.has(variacao)));
 }
+function taskSugerePersistenciaSemBanco(task) {
+    return task.vinculos.some((vinculo) => /(?:repository|repositories|repositorio|repo|store|storage|persist|cache)/i.test(`${vinculo.valor} ${vinculo.arquivo ?? ""} ${vinculo.simbolo ?? ""}`))
+        || task.implementacoesExternas.some((impl) => /(?:repository|repositories|repositorio|repo|store|storage|persist|cache)/i.test(impl.caminho));
+}
 function extrairRecursosEsperados(task, ir) {
     const esperados = new Map();
     const registrar = (esperado) => {
@@ -2279,7 +2551,25 @@ function extrairRecursosEsperados(task, ir) {
         }
     }
     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) {
+    if (efeitosPersistencia.length === 0) {
+        return [...esperados.values()];
+    }
+    if (ir.databases.length === 0) {
+        const sugerePersistenciaLocal = taskSugerePersistenciaSemBanco(task);
+        for (const efeito of efeitosPersistencia) {
+            if (efeito.categoria !== "persistencia" || !sugerePersistenciaLocal) {
+                continue;
+            }
+            if ([...esperados.values()].some((item) => item.alvo === efeito.alvo)) {
+                continue;
+            }
+            registrar({
+                categoria: "persistencia",
+                alvo: efeito.alvo,
+                tiposAceitos: ["table", "collection", "document", "keyspace", "stream", "view", "query", "index", "arquivo_local"],
+                nomes: [efeito.alvo],
+            });
+        }
         return [...esperados.values()];
     }
     for (const efeito of efeitosPersistencia) {
@@ -2570,7 +2860,10 @@ export async function analisarDriftLegado(contexto, opcoes) {
                     checksSugeridos: [],
                 });
                 for (const recursoEsperado of extrairRecursosEsperados(task, ir)) {
-                    const resolvido = resolverRecursoEsperado(mapaRecursos, recursoEsperado, arquivosReferenciados);
+                    let resolvido = resolverRecursoEsperado(mapaRecursos, recursoEsperado, arquivosReferenciados);
+                    if (!resolvido) {
+                        resolvido = resolverPersistenciaLocalPorTask(mapaRecursos, task, ir, recursoEsperado)[0];
+                    }
                     const registro = {
                         modulo: ir.nome,
                         task: task.nome,
@@ -2903,6 +3196,7 @@ export async function analisarDriftLegado(contexto, opcoes) {
                 });
             }
         }
+        const relevanciaConsumer = construirContextoRelevanciaConsumer(contexto, tasksResumo, vinculosValidos);
         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]
@@ -2915,7 +3209,7 @@ export async function analisarDriftLegado(contexto, opcoes) {
                     simbolo: simbolo.simbolo,
                 },
             ])).values()].sort((a, b) => a.caminho.localeCompare(b.caminho, "pt-BR")
-            || a.arquivo.localeCompare(b.arquivo, "pt-BR")), contexto, configuracaoEscopo);
+            || a.arquivo.localeCompare(b.arquivo, "pt-BR")), contexto, configuracaoEscopo, relevanciaConsumer);
         const consumerSurfaces = consumersFiltrados.consumerSurfaces;
         const consumerBridges = consumersFiltrados.consumerBridges;
         const appRoutes = [...new Set(consumerSurfaces.map((surface) => surface.rota))]