@semacode/cli 2.3.0 → 3.0.0

package/dist/drift.part08.d.ts

@@ -1,5 +1,6 @@
 import type { IrBancoDados, IrModulo, IrTask } from "@sema/nucleo";
 import { OrigemRecursoDrift, RecursoEsperadoDrift, RecursoResolvido, RegistroColunaPersistenciaDrift, RegistroPersistenciaRealDrift, RegistroRepositorioPersistenciaDrift, SimboloResolvido, TipoRecursoDrift } from "./drift.part01.js";
+import { type AdaptadorLeituraCompartilhadaDrift } from "./drift.part04.js";
 export declare function registrarRepositorioPersistenciaDrift(repositorios: Map<string, RegistroRepositorioPersistenciaDrift>, origem: OrigemRecursoDrift, recurso: string, arquivo: string): void;
 export declare function extrairColunasSqlDetalhadas(arquivo: string, codigo: string): RegistroColunaPersistenciaDrift[];
 export declare function extrairColunasPrismaDetalhadas(arquivo: string, codigo: string): RegistroColunaPersistenciaDrift[];
@@ -7,7 +8,7 @@ export declare function extrairCamposMongoDetalhados(arquivo: string, codigo: st
 export declare function extrairCamposRedisDetalhados(arquivo: string, codigo: string): RegistroColunaPersistenciaDrift[];
 export declare function extrairCamposArquivoLocalDetalhados(arquivo: string, codigo: string): RegistroColunaPersistenciaDrift[];
 export declare function registrarRepositoriosPorRecursos(repositorios: Map<string, RegistroRepositorioPersistenciaDrift>, arquivo: string, codigo: string, recursos: RecursoResolvido[]): void;
-export declare function indexarPersistenciaDetalhada(diretorios: string[]): Promise<{
+export declare function indexarPersistenciaDetalhada(diretorios: string[], adaptadorLeitura?: AdaptadorLeituraCompartilhadaDrift): Promise<{
     colunas: RegistroColunaPersistenciaDrift[];
     repositorios: RegistroRepositorioPersistenciaDrift[];
 }>;

package/dist/drift.part08.js

@@ -1,11 +1,11 @@
-// SEMA-GOVERNED: sema.governanca_ia_contexto
-// Descricao: CLI particionada; consulte contratos/sema/governanca_ia_contexto.sema antes de editar.
+// SEMA-GOVERNED: sema.produto.governanca_ia.drift
+// Descricao: indexa persistencia detalhada reutilizando o catalogo fisico do drift.
 import { readFile } from "node:fs/promises";
 import { categorizarPersistenciaPorOrigem, normalizarFragmentoArquivo, quebrarTermosEscopo } from "./drift.part01.js";
 import { fecharPrefixoRecurso, limparLiteralRecurso, normalizarNomeRecursoDrift } from "./drift.part02.js";
 import { extrairRecursosArquivoLocal, extrairRecursosMongoDb, extrairRecursosPersistenciaCodigoVivo, extrairRecursosPrisma, inferirMotoresRelacionais, variantesNomeRecursoDrift } from "./drift.part03.js";
 import { normalizarOrigemParaEngine, registrarColunaPersistenciaDrift } from "./drift.part07.js";
-import { listarArquivosRecursivos } from "./drift.part04.js";
+import { chaveCaminhoCanonicoDrift, deduplicarRaizesSobrepostasDrift, listarArquivosRecursivos, } from "./drift.part04.js";
 import { recursoResolvidoCombinaEsperado } from "./drift.part10.js";
 import { recursoPersistenciaCombinaAlvo } from "./drift.part09.js";
 export function registrarRepositorioPersistenciaDrift(repositorios, origem, recurso, arquivo) {
@@ -172,38 +172,48 @@ export function registrarRepositoriosPorRecursos(repositorios, arquivo, codigo,
         registrarRepositorioPersistenciaDrift(repositorios, recurso.origem, recurso.nome, arquivo);
     }
 }
-export async function indexarPersistenciaDetalhada(diretorios) {
+export async function indexarPersistenciaDetalhada(diretorios, adaptadorLeitura) {
+    adaptadorLeitura?.emitir?.("extractor.run");
     const colunas = new Map();
     const repositorios = new Map();
-    for (const diretorio of diretorios) {
+    const arquivosUnicos = new Map();
+    for (const diretorio of deduplicarRaizesSobrepostasDrift(diretorios)) {
         const arquivos = await listarArquivosRecursivos(diretorio, [
             ".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs",
             ".py", ".dart", ".lua", ".cs", ".java", ".go", ".rs", ".cpp", ".cc", ".cxx", ".hpp", ".h", ".php",
             ".sql", ".psql", ".ddl", ".prisma",
-        ]);
+        ], adaptadorLeitura);
         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.origem, coluna.recurso, coluna.coluna, coluna.arquivo);
+            const chave = chaveCaminhoCanonicoDrift(arquivo);
+            if (!arquivosUnicos.has(chave)) {
+                arquivosUnicos.set(chave, arquivo);
             }
-            for (const coluna of extrairColunasPrismaDetalhadas(arquivo, codigo)) {
-                registrarColunaPersistenciaDrift(colunas, coluna.origem, coluna.recurso, coluna.coluna, coluna.arquivo);
-            }
-            for (const coluna of extrairCamposMongoDetalhados(arquivo, codigo)) {
-                registrarColunaPersistenciaDrift(colunas, coluna.origem, coluna.recurso, coluna.coluna, coluna.arquivo);
-            }
-            for (const coluna of extrairCamposRedisDetalhados(arquivo, codigo)) {
-                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);
         }
     }
+    for (const arquivo of arquivosUnicos.values()) {
+        const codigo = adaptadorLeitura
+            ? await adaptadorLeitura.lerTexto(arquivo)
+            : 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.origem, coluna.recurso, coluna.coluna, coluna.arquivo);
+        }
+        for (const coluna of extrairColunasPrismaDetalhadas(arquivo, codigo)) {
+            registrarColunaPersistenciaDrift(colunas, coluna.origem, coluna.recurso, coluna.coluna, coluna.arquivo);
+        }
+        for (const coluna of extrairCamposMongoDetalhados(arquivo, codigo)) {
+            registrarColunaPersistenciaDrift(colunas, coluna.origem, coluna.recurso, coluna.coluna, coluna.arquivo);
+        }
+        for (const coluna of extrairCamposRedisDetalhados(arquivo, codigo)) {
+            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);
+    }
     return {
         colunas: [...colunas.values()],
         repositorios: [...repositorios.values()],

package/dist/drift.part11.js

@@ -1,16 +1,123 @@
-// SEMA-GOVERNED: sema.governanca_ia_contexto
-// Descricao: CLI particionada; consulte contratos/sema/governanca_ia_contexto.sema antes de editar.
+// SEMA-GOVERNED: sema.governanca_ia_contexto, sema.produto.governanca_ia.drift.cache.store
+// Descrição: integra índices calculados ou reutilizados e sempre recalcula o resultado final do drift.
 import path from "node:path";
-import { emitirDiagnosticosArquivosOrcamento } from "./driftOrcamento.js";
+import { emitirDiagnosticosArquivosOrcamento, workspaceExigeCabecalhoCodigoGovernado, } from "./driftOrcamento.js";
 import { definirDiretoriosIgnoradosAtivos, obterDiretoriosIgnoradosAtivos, extrairTermosEscopoDrift, resolverDiretoriosIgnoradosAtivos, resolverOpcoesDrift } from "./drift.part01.js";
 import { construirContextoRelevanciaConsumer, filtrarConsumerSurfacesPorEscopo } from "./drift.part02.js";
 import { inferirConsumerFrameworkPrincipal } from "./drift.part06.js";
-import { calcularConfiancaTask, calcularRiscoOperacional, calcularScoreTask, resumirLacunasTask, resumirOperacional } from "./drift.part04.js";
-import { analisarPersistenciaReal } from "./drift.part09.js";
+import { calcularConfiancaTask, calcularRiscoOperacional, calcularScoreTask, chaveCaminhoCanonicoDrift, encontrarCandidatosFisicosImplementacaoDrift, resumirLacunasTask, resumirOperacional } from "./drift.part04.js";
+import { analisarPersistenciaReal, ordenarCandidatos } from "./drift.part09.js";
 import { simboloEhBridgeConsumer } from "./drift.part05.js";
 import { prepararIndicesDrift } from "./drift.part13.js";
 import { analisarModulosSelecionadosDrift } from "./drift.part14.js";
 import { resolverPoliticaPontuacaoSemantica } from "./driftScore.js";
+function arquivosVinculadosFisicamenteDrift(contexto, modulo, task) {
+    const arquivos = new Set();
+    for (const vinculo of [...modulo.vinculos, ...task.vinculos]) {
+        const arquivo = vinculo.arquivo
+            ?? (vinculo.tipo === "arquivo" ? vinculo.valor : undefined);
+        if (arquivo) {
+            arquivos.add(chaveCaminhoCanonicoDrift(path.resolve(contexto.baseProjeto, arquivo)));
+        }
+    }
+    return arquivos;
+}
+function prepararMapaImplementacoesHonestoDrift(contexto, mapaImpl, todosSimbolos) {
+    const mapaImplHonesto = new Map(mapaImpl);
+    const usosPorOrigemECaminho = new Map();
+    for (const item of contexto.modulosSelecionados) {
+        const ir = item.resultado.ir;
+        if (!ir) {
+            continue;
+        }
+        for (const task of ir.tasks) {
+            const arquivosVinculados = arquivosVinculadosFisicamenteDrift(contexto, ir, task);
+            for (const impl of task.implementacoesExternas) {
+                const candidatos = encontrarCandidatosFisicosImplementacaoDrift(todosSimbolos, impl.origem, impl.caminho);
+                const candidatosVinculados = candidatos.filter((candidato) => arquivosVinculados.has(chaveCaminhoCanonicoDrift(candidato.arquivo)));
+                const resolvido = candidatos.length === 1
+                    ? candidatos[0]
+                    : candidatosVinculados.length === 1
+                        ? candidatosVinculados[0]
+                        : undefined;
+                const uso = {
+                    modulo: ir.nome,
+                    task: task.nome,
+                    origem: impl.origem,
+                    caminho: impl.caminho,
+                    implementacao: impl,
+                    candidatos,
+                    resolvido,
+                    ambiguo: candidatos.length > 1 && candidatosVinculados.length !== 1,
+                };
+                const chaveGrupo = `${impl.origem}\u0000${impl.caminho}`;
+                const usos = usosPorOrigemECaminho.get(chaveGrupo) ?? [];
+                usos.push(uso);
+                usosPorOrigemECaminho.set(chaveGrupo, usos);
+            }
+        }
+    }
+    const ambiguidades = [];
+    const gruposPorCaminho = new Map();
+    for (const usos of usosPorOrigemECaminho.values()) {
+        const caminho = usos[0].caminho;
+        const resolvidos = new Map();
+        for (const uso of usos) {
+            if (uso.resolvido) {
+                resolvidos.set(chaveCaminhoCanonicoDrift(uso.resolvido.arquivo), uso.resolvido);
+            }
+        }
+        const conflitoEntreUsos = resolvidos.size > 1;
+        const deveFalharFechado = usos.some((uso) => uso.ambiguo || !uso.resolvido)
+            || conflitoEntreUsos;
+        if (deveFalharFechado && (usos.some((uso) => uso.ambiguo) || conflitoEntreUsos)) {
+            const candidatosDoGrupo = [...new Map(usos.flatMap((uso) => uso.candidatos).map((candidato) => [
+                    chaveCaminhoCanonicoDrift(candidato.arquivo),
+                    candidato,
+                ])).values()];
+            for (const uso of usos) {
+                ambiguidades.push({
+                    ...uso,
+                    candidatos: uso.candidatos.length > 1 ? uso.candidatos : candidatosDoGrupo,
+                    ambiguo: true,
+                });
+            }
+        }
+        const grupos = gruposPorCaminho.get(caminho) ?? [];
+        grupos.push({
+            usos,
+            resolvido: deveFalharFechado ? undefined : resolvidos.values().next().value,
+        });
+        gruposPorCaminho.set(caminho, grupos);
+    }
+    const substituicoesCaminho = [];
+    let sequenciaCaminhoTemporario = 0;
+    for (const [caminho, grupos] of gruposPorCaminho) {
+        mapaImplHonesto.delete(caminho);
+        const gruposResolvidos = grupos.filter((grupo) => grupo.resolvido);
+        const resolucoesDistintas = new Map();
+        for (const grupo of gruposResolvidos) {
+            const resolvido = grupo.resolvido;
+            resolucoesDistintas.set(`${resolvido.origem}:${chaveCaminhoCanonicoDrift(resolvido.arquivo)}:${resolvido.caminho}`, resolvido);
+        }
+        if (gruposResolvidos.length === grupos.length && resolucoesDistintas.size === 1) {
+            mapaImplHonesto.set(caminho, resolucoesDistintas.values().next().value);
+            continue;
+        }
+        for (const grupo of gruposResolvidos) {
+            for (const uso of grupo.usos) {
+                const temporario = `__sema_impl_${sequenciaCaminhoTemporario++}`;
+                mapaImplHonesto.set(temporario, uso.resolvido);
+                substituicoesCaminho.push({
+                    implementacao: uso.implementacao,
+                    original: uso.caminho,
+                    temporario,
+                });
+            }
+        }
+    }
+    return { mapaImplHonesto, ambiguidades, substituicoesCaminho };
+}
 export async function analisarDriftLegado(contexto, opcoes) {
     const opcoesResolvidas = resolverOpcoesDrift(opcoes);
     const configuracaoEscopo = {
@@ -22,7 +129,29 @@ export async function analisarDriftLegado(contexto, opcoes) {
     const diretoriosIgnoradosAnteriores = obterDiretoriosIgnoradosAtivos();
     definirDiretoriosIgnoradosAtivos(resolverDiretoriosIgnoradosAtivos(opcoesResolvidas));
     try {
-        const { detalhesPersistencia, indexDart, indexTs, mapaImpl, mapaRecursos, todasRotasIndexadas, todosArquivosConhecidos, todosRecursos, todosSimbolos, } = await prepararIndicesDrift(contexto, configuracaoEscopo);
+        const indicesPreparados = await prepararIndicesDrift(contexto, configuracaoEscopo, {
+            observador: opcoesResolvidas.observador,
+            modoCache: opcoesResolvidas.modoCache,
+            avisosModoCache: opcoesResolvidas.avisosModoCache,
+        });
+        const { detalhesPersistencia, indexDart, indexTs, mapaImpl, mapaRecursos, todasRotasIndexadas, todosArquivosConhecidos, todosRecursos, todosSimbolos, planoEscopo, cache: estadoCache, catalogo: metricasCatalogo, leitorArquivosPlanejados, } = indicesPreparados;
+        const relativoEscopo = (arquivo) => {
+            const relativo = path.relative(contexto.baseProjeto, arquivo).replace(/\\/g, "/");
+            return relativo && !relativo.startsWith("../")
+                ? relativo
+                : arquivo.replace(/\\/g, "/");
+        };
+        configuracaoEscopo.estrategia = planoEscopo.estrategia;
+        configuracaoEscopo.cobertura = planoEscopo.cobertura;
+        configuracaoEscopo.arquivosPlanejados = planoEscopo.arquivos.map(relativoEscopo);
+        configuracaoEscopo.arquivosDeclarados = planoEscopo.arquivosDeclarados.map(relativoEscopo);
+        configuracaoEscopo.arquivosInferidos = planoEscopo.arquivosInferidos.map(relativoEscopo);
+        configuracaoEscopo.arquivosAusentes = planoEscopo.arquivosAusentes.map(relativoEscopo);
+        const bloqueiosAnalise = new Set(planoEscopo.bloqueios);
+        configuracaoEscopo.bloqueios = [...bloqueiosAnalise];
+        configuracaoEscopo.catalogo = metricasCatalogo;
+        configuracaoEscopo.cache = estadoCache;
+        const { mapaImplHonesto, ambiguidades, substituicoesCaminho } = prepararMapaImplementacoesHonestoDrift(contexto, mapaImpl, todosSimbolos);
         const implsValidos = [];
         const implsQuebrados = [];
         const vinculosValidos = [];
@@ -31,33 +160,121 @@ export async function analisarDriftLegado(contexto, opcoes) {
         const recursosValidos = [];
         const recursosDivergentes = [];
         const diagnosticos = [];
+        const moduloDiagnostico = contexto.modulosSelecionados[0]?.resultado.ir?.nome
+            ?? contexto.modulosSelecionados[0]?.resultado.modulo?.nome
+            ?? "projeto";
+        for (const arquivoAusente of planoEscopo.arquivosAusentes) {
+            const arquivo = relativoEscopo(arquivoAusente);
+            diagnosticos.push({
+                tipo: "vinculo_quebrado",
+                modulo: moduloDiagnostico,
+                arquivo,
+                severidade: "erro",
+                mensagem: `O arquivo planejado "${arquivo}" não existe no workspace; a cobertura do drift ficou parcial.`,
+            });
+        }
+        if (planoEscopo.cobertura === "parcial" && planoEscopo.arquivosAusentes.length === 0) {
+            diagnosticos.push({
+                tipo: "vinculo_quebrado",
+                modulo: moduloDiagnostico,
+                severidade: "erro",
+                mensagem: "A cobertura do drift ficou parcial e não permite declarar a análise como bem-sucedida.",
+            });
+        }
+        if (planoEscopo.bloqueios.includes("escopo_estreito_sem_vinculos")) {
+            diagnosticos.push({
+                tipo: "escopo_estreito_sem_vinculos",
+                modulo: moduloDiagnostico,
+                severidade: "erro",
+                mensagem: "Escopo de arquivo ou módulo sem arquivo vinculado nem implementação resolvível. Declare `vinculos { arquivo: ... }` ou execute explicitamente com `--escopo projeto`.",
+            });
+        }
+        if (planoEscopo.bloqueios.includes("escopo_estreito_ambiguo")) {
+            diagnosticos.push({
+                tipo: "escopo_estreito_ambiguo",
+                modulo: moduloDiagnostico,
+                severidade: "erro",
+                mensagem: "Mais de um arquivo pode implementar o mesmo símbolo. Declare um vínculo de arquivo inequívoco antes do drift.",
+            });
+        }
         const tasksResumo = [];
         const taskPorChave = new Map();
         const guardrailsPorTask = new Map();
         const resumoVinculosPorTask = new Map();
         const arquivosAncoraHerdadosPorTask = new Map();
-        analisarModulosSelecionadosDrift({
-            contexto,
-            mapaImpl,
-            todosSimbolos,
-            mapaRecursos,
-            todosRecursos,
-            todasRotasIndexadas,
-            todosArquivosConhecidos,
-            implsValidos,
-            implsQuebrados,
-            vinculosValidos,
-            vinculosQuebrados,
-            rotasDivergentes,
-            recursosValidos,
-            recursosDivergentes,
-            diagnosticos,
-            tasksResumo,
-            taskPorChave,
-            guardrailsPorTask,
-            resumoVinculosPorTask,
-            arquivosAncoraHerdadosPorTask,
-        });
+        // O analisador legado consulta implementações apenas pelo caminho. Chaves efêmeras
+        // mantêm resoluções de origens distintas isoladas durante essa chamada e são restauradas logo depois.
+        for (const substituicao of substituicoesCaminho) {
+            substituicao.implementacao.caminho = substituicao.temporario;
+        }
+        try {
+            analisarModulosSelecionadosDrift({
+                contexto,
+                mapaImpl: mapaImplHonesto,
+                todosSimbolos,
+                mapaRecursos,
+                todosRecursos,
+                todasRotasIndexadas,
+                todosArquivosConhecidos,
+                implsValidos,
+                implsQuebrados,
+                vinculosValidos,
+                vinculosQuebrados,
+                rotasDivergentes,
+                recursosValidos,
+                recursosDivergentes,
+                diagnosticos,
+                tasksResumo,
+                taskPorChave,
+                guardrailsPorTask,
+                resumoVinculosPorTask,
+                arquivosAncoraHerdadosPorTask,
+            });
+        }
+        finally {
+            for (const substituicao of substituicoesCaminho) {
+                substituicao.implementacao.caminho = substituicao.original;
+            }
+        }
+        const caminhoOriginalPorTemporario = new Map(substituicoesCaminho.map((substituicao) => [substituicao.temporario, substituicao.original]));
+        for (const registro of [...implsValidos, ...implsQuebrados]) {
+            registro.caminho = caminhoOriginalPorTemporario.get(registro.caminho) ?? registro.caminho;
+        }
+        for (const ambiguidade of ambiguidades) {
+            const candidatos = ambiguidade.candidatos.map((candidato) => ({
+                origem: candidato.origem,
+                caminho: candidato.caminho,
+                arquivo: candidato.arquivo,
+                simbolo: candidato.simbolo,
+                confianca: "alta",
+                motivo: `Arquivo físico candidato à implementação ambígua "${ambiguidade.origem}:${ambiguidade.caminho}".`,
+            }));
+            const registro = implsQuebrados.find((impl) => impl.modulo === ambiguidade.modulo
+                && impl.task === ambiguidade.task
+                && impl.origem === ambiguidade.origem
+                && impl.caminho === ambiguidade.caminho);
+            if (registro) {
+                registro.candidatos = candidatos;
+            }
+            const resumo = tasksResumo.find((task) => task.modulo === ambiguidade.modulo && task.task === ambiguidade.task);
+            if (resumo) {
+                const arquivosCandidatos = new Set(candidatos.map((candidato) => chaveCaminhoCanonicoDrift(candidato.arquivo)));
+                const candidatosRestantes = resumo.candidatosImpl.filter((candidato) => !arquivosCandidatos.has(chaveCaminhoCanonicoDrift(candidato.arquivo)));
+                resumo.candidatosImpl = [
+                    ...candidatos,
+                    ...ordenarCandidatos(candidatosRestantes),
+                ].slice(0, 5);
+            }
+            diagnosticos.push({
+                tipo: "escopo_estreito_ambiguo",
+                modulo: ambiguidade.modulo,
+                task: ambiguidade.task,
+                severidade: "erro",
+                mensagem: `A implementação "${ambiguidade.origem}:${ambiguidade.caminho}" é ambígua: ${candidatos.length} arquivos físicos correspondem ao mesmo caminho semântico. Declare um vínculo de arquivo inequívoco.`,
+            });
+            bloqueiosAnalise.add("escopo_estreito_ambiguo");
+        }
+        configuracaoEscopo.bloqueios = [...bloqueiosAnalise];
         for (const resumo of tasksResumo) {
             const chaveTask = `${resumo.modulo}:${resumo.task}`;
             const task = taskPorChave.get(chaveTask);
@@ -204,7 +421,7 @@ export async function analisarDriftLegado(contexto, opcoes) {
         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, mapaImpl);
+        const persistenciaReal = await analisarPersistenciaReal(contexto, mapaRecursos, detalhesPersistencia, opcoesResolvidas, mapaImplHonesto);
         for (const item of persistenciaReal) {
             if (item.status === "divergente") {
                 diagnosticos.push({
@@ -249,12 +466,39 @@ export async function analisarDriftLegado(contexto, opcoes) {
         const moduloOrcamento = contexto.modulosSelecionados[0]?.resultado.ir?.nome
             ?? contexto.modulosSelecionados[0]?.resultado.modulo?.nome
             ?? "projeto";
-        const exigeCabecalhoCodigoGovernado = contexto.configCarregada?.config.modoEstrito === true
-            && contexto.arquivosProjeto.some((arquivo) => path.basename(arquivo).toLowerCase() === "agents.md");
+        const exigeCabecalhoCodigoGovernado = await workspaceExigeCabecalhoCodigoGovernado(contexto.baseProjeto, contexto.configCarregada?.config.modoEstrito === true);
+        const chaveArquivoOrcamento = (arquivo) => {
+            const absoluto = path.resolve(contexto.baseProjeto, arquivo);
+            return process.platform === "win32" ? absoluto.toLowerCase() : absoluto;
+        };
+        const contratosJaCarregados = new Map(contexto.modulosCarregados.map((modulo) => [
+            chaveArquivoOrcamento(modulo.caminho),
+            modulo.codigo,
+        ]));
+        const leitorArquivosOrcamento = {
+            contem: (arquivo) => {
+                const chave = chaveArquivoOrcamento(arquivo);
+                return contratosJaCarregados.has(chave)
+                    || leitorArquivosPlanejados.contem(arquivo);
+            },
+            lerTexto: async (arquivo) => {
+                const contrato = contratosJaCarregados.get(chaveArquivoOrcamento(arquivo));
+                if (contrato !== undefined) {
+                    return contrato;
+                }
+                if (!leitorArquivosPlanejados.contem(arquivo)) {
+                    throw new Error(`Arquivo fora do catálogo planejado do drift: ${arquivo}`);
+                }
+                return leitorArquivosPlanejados.lerTexto(arquivo);
+            },
+        };
+        const arquivosOrcamentoPlanejados = [...arquivosOrcamento]
+            .filter((arquivo) => leitorArquivosOrcamento.contem(arquivo));
         const diagnosticosOrcamento = await emitirDiagnosticosArquivosOrcamento({
             baseProjeto: contexto.baseProjeto,
-            arquivos: [...arquivosOrcamento],
+            arquivos: arquivosOrcamentoPlanejados,
             exigirCabecalhoCodigoGovernado: exigeCabecalhoCodigoGovernado,
+            leitorArquivos: leitorArquivosOrcamento,
         });
         for (const diagnostico of diagnosticosOrcamento) {
             diagnosticos.push({
@@ -274,6 +518,9 @@ export async function analisarDriftLegado(contexto, opcoes) {
             && recursosDivergentes.length === 0
             && vinculosQuebrados.length === 0
             && persistenciaReal.every((item) => item.status !== "divergente" && item.compatibilidade !== "invalido")
+            && planoEscopo.cobertura === "completa"
+            && planoEscopo.arquivosAusentes.length === 0
+            && bloqueiosAnalise.size === 0
             && !possuiBloqueioOrcamento;
         const payloadBase = {
             comando: "drift",

package/dist/drift.part12.d.ts

@@ -7,7 +7,7 @@ export declare function classificarArquivoImpacto(arquivo: string): RegistroImpa
 export declare function prioridadeArquivoImpacto(tipo: RegistroImpactoSemanticoArquivo["tipo"]): RegistroImpactoSemanticoArquivo["prioridade"];
 export declare function textoIrCombinaTermos(texto: string, termos: string[]): boolean;
 export declare function registrarArquivoImpactado(mapa: Map<string, RegistroImpactoSemanticoArquivo>, arquivo: string, linhas: number[], motivos: string[]): void;
-export declare function listarArquivosImpacto(contexto: ContextoProjetoCarregado, opcoes?: OpcoesDriftLegado): Promise<string[]>;
+export declare function listarArquivosImpacto(contexto: ContextoProjetoCarregado, opcoes?: OpcoesDriftLegado, arquivosPlanejados?: readonly string[]): Promise<string[]>;
 export declare function extrairLinhasComVariantes(codigo: string, variantes: string[]): number[];
 export declare function serializarTaskParaImpacto(task: IrTask): string;
 export declare function serializarRouteParaImpacto(route: IrRoute): string;