@semacode/cli 3.12.2 → 4.0.0

package/dist/drift.part14.js

@@ -2,7 +2,7 @@
 // Descricao: analisa modulos selecionados no drift; consulte contratos/sema/governanca_ia_contexto.sema antes de editar.
 import path from "node:path";
 import { escolherArquivoPorVinculo, escolherSimboloPorVinculo } from "./drift.part03.js";
-import { calcularRiscoOperacional, encontrarAncoraSuperficie } from "./drift.part04.js";
+import { calcularRiscoOperacional, chaveCaminhoCanonicoDrift, encontrarAncoraSuperficie } from "./drift.part04.js";
 import { resolverPersistenciaLocalPorTask } from "./drift.part08.js";
 import { escolherRotasEsperadas, normalizarCaminhoRota, ordenarCandidatos, sugerirCandidatosParaImpl, sugerirCandidatosParaTaskSemImpl } from "./drift.part09.js";
 import { coletarVinculosIr, extrairRecursosEsperados, resolverRecursoEsperado } from "./drift.part10.js";
@@ -30,8 +30,61 @@ function redigirCaminhoDeclaradoExterno(baseProjeto, valor) {
     const nome = path.basename(path.normalize(valor)) || "arquivo";
     return `[fora_do_workspace]/${nome}`;
 }
+function caminhoDeclaradoTentadoVinculo(vinculo) {
+    const arquivoDeclarado = vinculo.arquivo ?? (vinculo.tipo === "arquivo" ? vinculo.valor : undefined);
+    if (arquivoDeclarado) {
+        return arquivoDeclarado;
+    }
+    const recursoDeclarado = vinculo.recurso ?? (["recurso", "tabela", "fila", "cache", "storage"].includes(vinculo.tipo) ? vinculo.valor : undefined);
+    if (recursoDeclarado) {
+        return undefined;
+    }
+    const superficieDeclarada = vinculo.superficie ?? (["superficie", "rota", "worker", "cron", "webhook", "evento", "policy", "fila", "cache", "storage"].includes(vinculo.tipo) ? vinculo.valor : undefined);
+    return superficieDeclarada ?? vinculo.valor;
+}
+function sugerirDiretorioCodigoDrift(baseProjeto, caminhoAbsoluto) {
+    const diretorioRelativo = path.relative(path.resolve(baseProjeto), path.dirname(path.resolve(caminhoAbsoluto))).replace(/\\/g, "/");
+    return `./${diretorioRelativo || "."}`;
+}
+function arquivoDentroDoEscopoCodigo(contexto, caminhoAbsoluto) {
+    return contexto.diretoriosCodigo.some((diretorio) => {
+        const relativo = path.relative(path.resolve(diretorio), path.resolve(caminhoAbsoluto));
+        return relativo === "" || (!relativo.startsWith("..") && !path.isAbsolute(relativo));
+    });
+}
+// Simbolo declarado cujo dono ancora codigo em arquivo existente fora dos
+// diretoriosCodigo: casa o caminho do simbolo com o diretorio do arquivo.
+function escolherAncoraForaDoEscopoPorSimbolo(caminhos, baseProjeto, simbolo) {
+    const simboloComoCaminho = simbolo.toLowerCase().replaceAll(".", "/");
+    const porPrefixo = caminhos.find((caminho) => {
+        const diretorioRelativo = path.relative(path.resolve(baseProjeto), path.dirname(path.resolve(caminho))).replace(/\\/g, "/").toLowerCase();
+        return diretorioRelativo !== "" && simboloComoCaminho.startsWith(`${diretorioRelativo}/`);
+    });
+    if (porPrefixo) {
+        return porPrefixo;
+    }
+    return caminhos.length === 1 ? caminhos[0] : undefined;
+}
+// O analisador de modulos e sincrono: a existencia em disco dos caminhos
+// declarados em vinculos e sondada antes, pelo chamador, e injetada no estado.
+export function coletarCaminhosDeclaradosVinculosDrift(contexto) {
+    const caminhos = [];
+    for (const item of contexto.modulosSelecionados) {
+        const ir = item.resultado.ir;
+        if (!ir) {
+            continue;
+        }
+        for (const itemVinculo of coletarVinculosIr(ir)) {
+            const declarado = caminhoDeclaradoTentadoVinculo(itemVinculo.vinculo);
+            if (declarado) {
+                caminhos.push(path.resolve(contexto.baseProjeto, declarado));
+            }
+        }
+    }
+    return caminhos;
+}
 export function analisarModulosSelecionadosDrift(estado) {
-    const { contexto, mapaImpl, todosSimbolos, mapaRecursos, todosRecursos, todasRotasIndexadas, todosArquivosConhecidos, implsValidos, implsQuebrados, vinculosValidos, vinculosQuebrados, rotasDivergentes, recursosValidos, recursosDivergentes, diagnosticos, tasksResumo, taskPorChave, guardrailsPorTask, resumoVinculosPorTask, arquivosAncoraHerdadosPorTask, } = estado;
+    const { contexto, mapaImpl, todosSimbolos, mapaRecursos, todosRecursos, todasRotasIndexadas, todosArquivosConhecidos, implsValidos, implsQuebrados, vinculosValidos, vinculosQuebrados, vinculosForaDoEscopo, arquivosDeclaradosExistentes, rotasDivergentes, recursosValidos, recursosDivergentes, diagnosticos, tasksResumo, taskPorChave, guardrailsPorTask, resumoVinculosPorTask, arquivosAncoraHerdadosPorTask, } = estado;
     for (const item of contexto.modulosSelecionados) {
         const ir = item.resultado.ir;
         if (!ir) {
@@ -309,6 +362,23 @@ export function analisarModulosSelecionadosDrift(estado) {
                 });
             }
         }
+        const arquivosForaDoEscopoPorDono = new Map();
+        for (const itemVinculoDono of coletarVinculosIr(ir)) {
+            const declarado = itemVinculoDono.vinculo.arquivo
+                ?? (itemVinculoDono.vinculo.tipo === "arquivo" ? itemVinculoDono.vinculo.valor : undefined);
+            if (!declarado) {
+                continue;
+            }
+            const absoluto = path.resolve(contexto.baseProjeto, declarado);
+            if (arquivosDeclaradosExistentes.get(chaveCaminhoCanonicoDrift(absoluto)) !== true
+                || arquivoDentroDoEscopoCodigo(contexto, absoluto)) {
+                continue;
+            }
+            const chaveDono = `${itemVinculoDono.donoTipo}:${itemVinculoDono.dono}`;
+            const lista = arquivosForaDoEscopoPorDono.get(chaveDono) ?? [];
+            lista.push(absoluto);
+            arquivosForaDoEscopoPorDono.set(chaveDono, lista);
+        }
         for (const itemVinculo of coletarVinculosIr(ir)) {
             const registro = {
                 modulo: ir.nome,
@@ -385,13 +455,41 @@ export function analisarModulosSelecionadosDrift(estado) {
                 }
             }
             if (registro.status === "nao_encontrado") {
-                vinculosQuebrados.push(registro);
-                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 } : {}),
-                });
+                const caminhoTentado = caminhoDeclaradoTentadoVinculo(itemVinculo.vinculo);
+                const caminhoAbsoluto = caminhoTentado ? path.resolve(contexto.baseProjeto, caminhoTentado) : undefined;
+                const existeNoDisco = caminhoAbsoluto !== undefined
+                    && arquivosDeclaradosExistentes.get(chaveCaminhoCanonicoDrift(caminhoAbsoluto)) === true;
+                // Arquivo proprio declarado fora do escopo, ou simbolo que herda a ancora
+                // de arquivo declarado do mesmo dono existente fora dos diretoriosCodigo.
+                const alvoForaDoEscopo = existeNoDisco && caminhoAbsoluto !== undefined && !arquivoDentroDoEscopoCodigo(contexto, caminhoAbsoluto)
+                    ? caminhoAbsoluto
+                    : simboloDeclarado
+                        ? escolherAncoraForaDoEscopoPorSimbolo(arquivosForaDoEscopoPorDono.get(`${itemVinculo.donoTipo}:${itemVinculo.dono}`) ?? [], contexto.baseProjeto, simboloDeclarado)
+                        : undefined;
+                if (alvoForaDoEscopo) {
+                    const diretorioSugerido = sugerirDiretorioCodigoDrift(contexto.baseProjeto, alvoForaDoEscopo);
+                    registro.status = "fora_do_escopo";
+                    registro.confianca = "baixa";
+                    registro.arquivo = alvoForaDoEscopo;
+                    registro.diretorioSugerido = diretorioSugerido;
+                    vinculosForaDoEscopo.push(registro);
+                    diagnosticos.push({
+                        tipo: "vinculo_fora_do_escopo",
+                        modulo: ir.nome,
+                        severidade: "aviso",
+                        mensagem: `Vinculo ${registro.tipo}="${registro.valor}" de ${itemVinculo.donoTipo} "${itemVinculo.dono}": o codigo existe no workspace mas esta fora dos diretoriosCodigo do sema.config.json; adicione "${diretorioSugerido}" a diretoriosCodigo para o drift verificar este vinculo.`,
+                        ...(itemVinculo.donoTipo === "task" ? { task: itemVinculo.dono } : itemVinculo.donoTipo === "route" ? { route: itemVinculo.dono } : {}),
+                    });
+                }
+                else {
+                    vinculosQuebrados.push(registro);
+                    diagnosticos.push({
+                        tipo: "vinculo_quebrado",
+                        modulo: ir.nome,
+                        mensagem: `Vinculo ${registro.tipo}="${registro.valor}" de ${itemVinculo.donoTipo} "${itemVinculo.dono}" nao foi resolvido no codigo vivo.`,
+                        ...(itemVinculo.donoTipo === "task" ? { task: itemVinculo.dono } : itemVinculo.donoTipo === "route" ? { route: itemVinculo.dono } : {}),
+                    });
+                }
             }
             else {
                 vinculosValidos.push(registro);
@@ -429,7 +527,7 @@ export function analisarModulosSelecionadosDrift(estado) {
                 if (registro.status === "nao_encontrado") {
                     resumo.quebrados += 1;
                 }
-                else {
+                else if (registro.status !== "fora_do_escopo") {
                     resumo.validos += 1;
                 }
                 if (registro.arquivo) {

package/dist/driftEscopo.d.ts

@@ -18,5 +18,6 @@ export interface PlanoEscopoDrift {
     bloqueios: string[];
     dependencias: Record<string, string[]>;
 }
+export declare function sondarCaminhosDeclaradosExistentes(caminhos: readonly string[], baseProjeto: string): Promise<Map<string, boolean>>;
 export declare function planejarEscopoDrift(contexto: ContextoProjetoCarregado, configuracao: ConfiguracaoEscopoDriftAplicada): Promise<PlanoEscopoDrift>;
 export declare function expandirDependenciasPlanoDrift(contexto: ContextoProjetoCarregado, plano: PlanoEscopoDrift, catalogo: CatalogoDrift): Promise<PlanoEscopoDrift>;

package/dist/driftEscopo.js

@@ -84,6 +84,12 @@ async function sondarArquivosRegularesContidos(caminhos, raizReal) {
     const resultados = await mapearComLimite(unicos, CONCORRENCIA_SONDAGENS_DRIFT, async ([chave, caminho]) => [chave, await arquivoRegularContido(caminho, raizReal)]);
     return new Map(resultados);
 }
+// Sonda arquivos declarados em vinculos contra o workspace real: alimenta a
+// distincao entre "arquivo nao existe" e "existe fora dos diretoriosCodigo".
+export async function sondarCaminhosDeclaradosExistentes(caminhos, baseProjeto) {
+    const raizReal = await realpath(baseProjeto);
+    return sondarArquivosRegularesContidos(caminhos, raizReal);
+}
 function vinculosModulo(ir) {
     return [
         ...ir.vinculos,

package/dist/driftPack.d.ts

@@ -0,0 +1,65 @@
+import type { ResultadoDrift } from "./drift.part01.js";
+export type DriftPack = {
+    schema: "sema.ai.drift-pack/v1";
+    selection: "deterministic_evidence_compaction";
+    source: {
+        command: "drift";
+        scope: string;
+        cache: string;
+        targetModule: string | null;
+    };
+    status: {
+        success: boolean;
+        score: number;
+        confidence: string;
+        belowFloor: boolean;
+        belowTarget: boolean;
+        blocks: string[];
+    };
+    counts: {
+        modules: number;
+        tasks: number;
+        validImplementations: number;
+        brokenImplementations: number;
+        validLinks: number;
+        brokenLinks: number;
+        outOfScopeLinks: number;
+        divergentRoutes: number;
+        validResources: number;
+        divergentResources: number;
+        realPersistence: number;
+    };
+    blockers: {
+        implementations: Array<Record<string, unknown>>;
+        links: Array<Record<string, unknown>>;
+        routes: Array<Record<string, unknown>>;
+        resources: Array<Record<string, unknown>>;
+        diagnostics: Array<Record<string, unknown>>;
+        tasksWithoutImplementation: Array<Record<string, unknown>>;
+    };
+    guidance: {
+        touchFirst: string[];
+        validate: string[];
+        loose: string[];
+        inferred: string[];
+        risks: string[];
+    };
+    authority: {
+        semaRemainsAuthority: true;
+        rawDriftForwarded: false;
+        freshValidationRequired: true;
+        omitted: string[];
+    };
+    telemetry: {
+        packChars: number;
+        packEstimatedTokens: number;
+        estimateMethod: "chars_div_4";
+        rawDriftEstimatedTokens: number;
+        reductionPercent: number;
+        selectedFields: string[];
+    };
+};
+export declare function criarDriftPack(resultado: ResultadoDrift, options?: {
+    targetModule?: string;
+    rawDriftChars?: number;
+}): DriftPack;

package/dist/driftPack.js

@@ -0,0 +1,96 @@
+function estimarTokens(chars) {
+    return Math.ceil(chars / 4);
+}
+function compactarRegistro(registro, campos) {
+    return Object.fromEntries(campos
+        .filter((campo) => registro[campo] !== undefined && registro[campo] !== null)
+        .map((campo) => [campo, registro[campo]]));
+}
+export function criarDriftPack(resultado, options = {}) {
+    const targetModule = options.targetModule ?? null;
+    const tarefas = resultado.tasks
+        .filter((task) => !targetModule || task.modulo === targetModule)
+        .filter((task) => task.semImplementacao || task.implsQuebrados > 0 || task.lacunas.length > 0)
+        .map((task) => compactarRegistro(task, [
+        "modulo", "task", "impls", "implsValidos", "implsQuebrados", "semImplementacao", "scoreSemantico",
+        "confiancaVinculo", "riscoOperacional", "lacunas", "arquivosProvaveisEditar", "checksSugeridos",
+    ]));
+    const base = {
+        schema: "sema.ai.drift-pack/v1",
+        selection: "deterministic_evidence_compaction",
+        source: {
+            command: "drift",
+            scope: resultado.escopo_aplicado.escopo,
+            cache: resultado.escopo_aplicado.cache?.modo ?? "unknown",
+            targetModule,
+        },
+        status: {
+            success: resultado.sucesso,
+            score: resultado.resumo_operacional.scoreMedio,
+            confidence: resultado.resumo_operacional.confiancaGeral,
+            belowFloor: resultado.resumo_operacional.pontuacaoAbaixoDoPiso,
+            belowTarget: resultado.resumo_operacional.pontuacaoAbaixoDoAlvo,
+            blocks: resultado.resumo_operacional.travasPontuacao,
+        },
+        counts: {
+            modules: resultado.modulos.length,
+            tasks: resultado.tasks.length,
+            validImplementations: resultado.impls_validos.length,
+            brokenImplementations: resultado.impls_quebrados.length,
+            validLinks: resultado.vinculos_validos.length,
+            brokenLinks: resultado.vinculos_quebrados.length,
+            outOfScopeLinks: resultado.vinculos_fora_do_escopo.length,
+            divergentRoutes: resultado.rotas_divergentes.length,
+            validResources: resultado.recursos_validos.length,
+            divergentResources: resultado.recursos_divergentes.length,
+            realPersistence: resultado.persistencia_real.length,
+        },
+        blockers: {
+            implementations: resultado.impls_quebrados.map((item) => compactarRegistro(item, ["modulo", "task", "origem", "caminho", "arquivo", "simbolo", "caminhoResolvido", "candidatos"])),
+            links: resultado.vinculos_quebrados.map((item) => compactarRegistro(item, ["modulo", "donoTipo", "dono", "tipo", "valor", "arquivo", "simbolo", "status", "confianca"])),
+            routes: resultado.rotas_divergentes.map((item) => compactarRegistro(item, ["modulo", "route", "metodo", "caminho", "motivo"])),
+            resources: resultado.recursos_divergentes.map((item) => compactarRegistro(item, ["modulo", "task", "categoria", "alvo", "arquivo", "origem", "tipo", "status"])),
+            diagnostics: resultado.diagnosticos.map((item) => compactarRegistro(item, ["tipo", "modulo", "task", "route", "arquivo", "severidade", "mensagem"])),
+            tasksWithoutImplementation: tarefas,
+        },
+        guidance: {
+            touchFirst: resultado.resumo_operacional.oQueTocar,
+            validate: resultado.resumo_operacional.oQueValidar,
+            loose: resultado.resumo_operacional.oQueEstaFrouxo,
+            inferred: resultado.resumo_operacional.oQueFoiInferido,
+            risks: resultado.resumo_operacional.riscosPrincipais,
+        },
+        authority: {
+            semaRemainsAuthority: true,
+            rawDriftForwarded: false,
+            freshValidationRequired: true,
+            omitted: [
+                "implementações válidas detalhadas",
+                "vínculos válidos detalhados",
+                "catálogo de arquivos e bytes lidos",
+                "cache interno e candidatos não bloqueantes",
+            ],
+        },
+    };
+    const packChars = JSON.stringify(base).length;
+    const rawDriftChars = options.rawDriftChars ?? 0;
+    return {
+        ...base,
+        telemetry: {
+            packChars,
+            packEstimatedTokens: estimarTokens(packChars),
+            estimateMethod: "chars_div_4",
+            rawDriftEstimatedTokens: estimarTokens(rawDriftChars),
+            reductionPercent: rawDriftChars === 0 ? 0 : Math.round((1 - packChars / rawDriftChars) * 10000) / 100,
+            selectedFields: [
+                "source",
+                "status",
+                "counts",
+                "blockers",
+                "guidance",
+                "authority",
+            ],
+        },
+    };
+}
+//# sourceMappingURL=driftPack.js.map

package/dist/entrypointPack.d.ts

@@ -0,0 +1,47 @@
+import type { AgentContextPack, CapacidadeIa } from "./agentContextTipos.js";
+export type EntrypointPack = {
+    schema: "sema.ai.entrypoint-pack/v1";
+    selection: "deterministic_capacity_allowlist";
+    capacity: CapacidadeIa;
+    source: {
+        command: "contexto-ia";
+        entrypoint: string;
+        version: number;
+    };
+    context: {
+        objective: string;
+        readingOrder: string[];
+        capacityGuide: string[];
+        mandatoryRules: string[];
+        prohibitions: string[];
+        priorities: string[];
+        failClosed: string[];
+        policies: {
+            language: string;
+            governedCode: string;
+            timeout: string;
+            platform: string;
+            design: string;
+        };
+        onDemand: string[];
+    };
+    authority: {
+        semaRemainsAuthority: true;
+        rawAgentContextForwarded: false;
+        freshValidationRequired: true;
+        omitted: string[];
+    };
+    telemetry: {
+        packChars: number;
+        packEstimatedTokens: number;
+        estimateMethod: "chars_div_4";
+        rawAgentContextEstimatedTokens: number;
+        reductionPercent: number;
+        selectedFields: string[];
+    };
+};
+export declare function criarEntrypointPack(input: {
+    agentContextPack: AgentContextPack;
+    capacity: CapacidadeIa;
+    rawAgentContextChars?: number;
+}): EntrypointPack;

package/dist/entrypointPack.js

@@ -0,0 +1,79 @@
+function estimarTokens(chars) {
+    return Math.ceil(chars / 4);
+}
+export function criarEntrypointPack(input) {
+    const source = input.agentContextPack;
+    const base = {
+        schema: "sema.ai.entrypoint-pack/v1",
+        selection: "deterministic_capacity_allowlist",
+        capacity: input.capacity,
+        source: {
+            command: "contexto-ia",
+            entrypoint: source.entrypointCodex,
+            version: source.versao,
+        },
+        context: {
+            objective: source.objetivo,
+            readingOrder: source.ordemLeitura,
+            capacityGuide: source.guiaPorCapacidade[input.capacity],
+            mandatoryRules: source.regrasObrigatorias,
+            prohibitions: source.proibicoes,
+            priorities: source.prioridades,
+            failClosed: source.failClosed,
+            policies: {
+                language: source.politicaIdioma.regra,
+                governedCode: source.politicaCodigoGovernado.porCapacidade[input.capacity],
+                timeout: source.politicaTimeoutResumo.porCapacidade[input.capacity],
+                platform: source.politicaPlataforma.porCapacidade[input.capacity],
+                design: source.politicaDesignVisual.porCapacidade[input.capacity],
+            },
+            onDemand: [
+                "AGENTS.md",
+                "SEMA_BOOT.md",
+                "AGENT_CONTEXT_PACK.json",
+                "SEMA_INDEX.json",
+                "exemplos/",
+                "contratos/",
+            ],
+        },
+        authority: {
+            semaRemainsAuthority: true,
+            rawAgentContextForwarded: false,
+            freshValidationRequired: true,
+            omitted: [
+                "fontes e descoberta completas",
+                "exemplos oficiais completos",
+                "texto bruto sob demanda",
+                "guias e aliases de outras capacidades",
+                "políticas duplicadas fora da capacidade selecionada",
+            ],
+        },
+    };
+    const packChars = JSON.stringify(base).length;
+    const rawAgentContextChars = input.rawAgentContextChars ?? 0;
+    return {
+        ...base,
+        telemetry: {
+            packChars,
+            packEstimatedTokens: estimarTokens(packChars),
+            estimateMethod: "chars_div_4",
+            rawAgentContextEstimatedTokens: estimarTokens(rawAgentContextChars),
+            reductionPercent: rawAgentContextChars === 0 ? 0 : Math.round((1 - packChars / rawAgentContextChars) * 10000) / 100,
+            selectedFields: [
+                "capacity",
+                "source",
+                "context.objective",
+                "context.readingOrder",
+                "context.capacityGuide",
+                "context.mandatoryRules",
+                "context.prohibitions",
+                "context.priorities",
+                "context.failClosed",
+                "context.policies",
+                "context.onDemand",
+                "authority",
+            ],
+        },
+    };
+}
+//# sourceMappingURL=entrypointPack.js.map

package/dist/index.part03.d.ts

@@ -13,6 +13,7 @@ export declare function resumirDriftPorModulo(modulo: string | null, caminho: st
     implsQuebrados: number;
     vinculosValidos: number;
     vinculosQuebrados: number;
+    vinculosForaDoEscopo: number;
     recursosValidos: number;
     recursosDivergentesCount: number;
     tasksSemImplementacao: number;
@@ -31,6 +32,7 @@ export declare function resumirDriftPorModulo(modulo: string | null, caminho: st
     rotasDivergentes: import("./drift.part01.js").RegistroRotaDivergente[];
     recursosDivergentes: import("./drift.part01.js").RegistroRecursoDrift[];
     vinculosQuebradosDetalhes: import("./drift.part01.js").RegistroVinculoDrift[];
+    vinculosForaDoEscopoDetalhes: import("./drift.part01.js").RegistroVinculoDrift[];
 };
 export declare function criarBriefingAgente(arquivo: string, modulo: string, ir: IrModulo | null, resumoDrift: ReturnType<typeof resumirDriftPorModulo>, resultadoDrift: Awaited<ReturnType<typeof analisarDriftLegado>>): {
     arquivo: string;

package/dist/index.part03.js

@@ -112,6 +112,9 @@ export function resumirDriftPorModulo(modulo, caminho, resultadoDrift) {
     const vinculosQuebrados = modulo
         ? resultadoDrift.vinculos_quebrados.filter((vinculo) => vinculo.modulo === modulo)
         : [];
+    const vinculosForaDoEscopo = modulo
+        ? resultadoDrift.vinculos_fora_do_escopo.filter((vinculo) => vinculo.modulo === modulo)
+        : [];
     const rotasDivergentes = modulo
         ? resultadoDrift.rotas_divergentes.filter((rota) => rota.modulo === modulo)
         : [];
@@ -136,6 +139,7 @@ export function resumirDriftPorModulo(modulo, caminho, resultadoDrift) {
             ...implsValidos.map((impl) => impl.arquivo).filter((item) => Boolean(item)),
             ...implsQuebrados.flatMap((impl) => impl.candidatos?.map((candidato) => candidato.arquivo) ?? []),
             ...vinculosValidos.map((vinculo) => vinculo.arquivo).filter((item) => Boolean(item)),
+            ...vinculosForaDoEscopo.map((vinculo) => vinculo.arquivo).filter((item) => Boolean(item)),
             ...recursosValidos.map((recurso) => recurso.arquivo).filter(Boolean),
             ...recursosDivergentes.map((recurso) => recurso.arquivo).filter(Boolean),
         ])].sort((a, b) => a.localeCompare(b, "pt-BR"));
@@ -176,6 +180,7 @@ export function resumirDriftPorModulo(modulo, caminho, resultadoDrift) {
         implsQuebrados: implsQuebrados.length,
         vinculosValidos: vinculosValidos.length,
         vinculosQuebrados: vinculosQuebrados.length,
+        vinculosForaDoEscopo: vinculosForaDoEscopo.length,
         recursosValidos: recursosValidos.length,
         recursosDivergentesCount: recursosDivergentes.length,
         tasksSemImplementacao: tasks.filter((task) => task.semImplementacao).length,
@@ -198,6 +203,7 @@ export function resumirDriftPorModulo(modulo, caminho, resultadoDrift) {
         rotasDivergentes,
         recursosDivergentes,
         vinculosQuebradosDetalhes: vinculosQuebrados,
+        vinculosForaDoEscopoDetalhes: vinculosForaDoEscopo,
     };
 }
 export function criarBriefingAgente(arquivo, modulo, ir, resumoDrift, resultadoDrift) {

package/dist/index.part05.js

@@ -8,9 +8,10 @@ import { importarProjetoLegado, resumoImportacao } from "./importador.js";
 import { analisarDriftLegado, assistirRenomeacaoSemantica, gerarMapaImpactoSemantico, } from "./drift.js";
 import { escreverArquivos, formatarAvisoArtefatosGeradosAcimaDoLimite, } from './fsGovernado.js';
 import { carregarModulos } from './carregarModulos.js';
-import { obterOpcao } from './cliArgs.js';
+import { obterOpcao, possuiFlag } from './cliArgs.js';
 import { resumirDriftPorModulo } from "./index.part03.js";
 import { resolverAnaliseDriftConsultaCli, resolverOpcoesDriftCli } from "./index.part01.js";
+import { criarDriftPack } from "./driftPack.js";
 export async function comandoInspecionar(entrada, emJson, cwd = process.cwd(), args = []) {
     const analiseDrift = resolverAnaliseDriftConsultaCli(args, "inspecionar");
     const alvo = entrada ? path.resolve(cwd, entrada) : cwd;
@@ -135,6 +136,11 @@ export async function comandoDrift(entrada, args, emJson, cwd = process.cwd()) {
         adiarDescobertaCodigo: opcoes.escopo !== "projeto",
     });
     const resultado = await analisarDriftLegado(contextoProjeto, opcoes);
+    if (possuiFlag(args, "--pacote")) {
+        const pacote = criarDriftPack(resultado, { rawDriftChars: JSON.stringify(resultado).length });
+        console.log(JSON.stringify(pacote, null, 2));
+        return resultado.sucesso ? 0 : 1;
+    }
     if (emJson) {
         console.log(JSON.stringify(resultado, null, 2));
         return resultado.sucesso ? 0 : 1;
@@ -173,6 +179,7 @@ export async function comandoDrift(entrada, args, emJson, cwd = process.cwd()) {
     console.log(`- Impl quebrados: ${resultado.impls_quebrados.length}`);
     console.log(`- Vinculos validos: ${resultado.vinculos_validos.length}`);
     console.log(`- Vinculos quebrados: ${resultado.vinculos_quebrados.length}`);
+    console.log(`- Vinculos fora do escopo (informativo): ${resultado.vinculos_fora_do_escopo.length}`);
     console.log(`- Rotas divergentes: ${resultado.rotas_divergentes.length}`);
     console.log(`- Recursos vivos validos: ${resultado.recursos_validos.length}`);
     console.log(`- Recursos vivos divergentes: ${resultado.recursos_divergentes.length}`);
@@ -229,6 +236,12 @@ export async function comandoDrift(entrada, args, emJson, cwd = process.cwd()) {
             console.log(`  - ${vinculo.modulo}.${vinculo.dono} :: ${vinculo.tipo}=${vinculo.valor}`);
         }
     }
+    if (resultado.vinculos_fora_do_escopo.length > 0) {
+        console.log("- Vinculos fora do escopo (arquivo existe fora dos diretoriosCodigo; informativo):");
+        for (const vinculo of resultado.vinculos_fora_do_escopo) {
+            console.log(`  - ${vinculo.modulo}.${vinculo.dono} :: ${vinculo.tipo}=${vinculo.valor} :: adicione "${vinculo.diretorioSugerido ?? "./"}" a diretoriosCodigo`);
+        }
+    }
     if (resultado.resumo_operacional.oQueTocar.length > 0) {
         console.log("- O que tocar primeiro:");
         for (const alvo of resultado.resumo_operacional.oQueTocar.slice(0, 8)) {