@semacode/cli 3.13.1 → 4.1.0

package/dist/cliGrammar.js

@@ -35,6 +35,7 @@ const ESTRUTURAS = new Set(["flat", "modulos", "backend"]);
 const ESCOPOS = new Set(["arquivo", "modulo", "projeto"]);
 const MODOS_CACHE = new Set(["none", "cache", "fresh", "off", "auto", "refresh"]);
 const MODOS_RESUMO = new Set(["resumo", "onboarding", "review", "mudanca", "bug", "arquitetura"]);
+const CAPACIDADES_IA = new Set(["fraca", "media", "forte"]);
 const MATURIDADES = new Set([
     "draft", "rascunho", "prototype", "prototipo", "production", "producao",
     "critical", "critico", "critica",
@@ -416,15 +417,21 @@ function validarInterativo(args) {
 }
 function validarResumo(args, promptCurto) {
     const parsed = parsearArgumentos(args, {
-        opcoes: promptCurto ? ["--para"] : ["--para", "--saida", "--drift", "--cache"],
-        flags: promptCurto ? ["--micro", "--curto", "--medio"] : ["--micro", "--curto", "--medio", "--raiz", "--com-drift"],
+        opcoes: promptCurto ? ["--para"] : ["--para", "--saida", "--drift", "--cache", "--pedido"],
+        flags: promptCurto ? ["--micro", "--curto", "--medio"] : ["--micro", "--curto", "--medio", "--raiz", "--com-drift", "--pacote", "--somente-pacote"],
         maxPosicionais: 1,
     });
     if (!parsed)
         return false;
     const tamanhos = ["--micro", "--curto", "--medio"].filter((flag) => parsed.flags.has(flag));
     const modo = valorOpcao(parsed, "--para");
-    return tamanhos.length <= 1 && (!modo || MODOS_RESUMO.has(modo)) && (promptCurto || validarModoCache(parsed, "--drift"));
+    const pacote = parsed.flags.has("--pacote");
+    const somentePacote = parsed.flags.has("--somente-pacote");
+    const pedido = valorOpcao(parsed, "--pedido");
+    return tamanhos.length <= 1
+        && (!modo || MODOS_RESUMO.has(modo))
+        && (promptCurto || validarModoCache(parsed, "--drift"))
+        && (promptCurto ? !pacote && !pedido && !somentePacote : true);
 }
 function validarComandoBasico(comando, args) {
     const aliasesGeracao = { "-a": "--alvo", "-s": "--saida" };
@@ -433,7 +440,11 @@ function validarComandoBasico(comando, args) {
         case "ast":
         case "ir":
         case "diagnosticos": return parsearArgumentos(args, { minPosicionais: 1, maxPosicionais: 1 }) !== null;
-        case "contexto-ia": return parsearArgumentos(args, { opcoes: ["--saida"], minPosicionais: 1, maxPosicionais: 1 }) !== null;
+        case "contexto-ia": {
+            const parsed = parsearArgumentos(args, { opcoes: ["--saida", "--capacidade"], flags: ["--pacote"], minPosicionais: 1, maxPosicionais: 1 });
+            const capacidade = parsed ? valorOpcao(parsed, "--capacidade") : undefined;
+            return parsed !== null && (!capacidade || CAPACIDADES_IA.has(capacidade));
+        }
         case "compilar":
         case "testar": {
             const parsed = parsearArgumentos(args, { opcoes: ["--alvo", "--saida", "--estrutura", "--framework"], aliases: aliasesGeracao, minPosicionais: comando === "testar" ? 1 : 0, maxPosicionais: 1 });
@@ -458,7 +469,7 @@ function validarComandoBasico(comando, args) {
             return parsed !== null && validarModoCache(parsed, "--drift");
         }
         case "drift": {
-            const parsed = parsearArgumentos(args, { opcoes: ["--escopo", "--cache", "--drift"], flags: ["--incluir-worktrees", "--incluir-consumidores-laterais"], maxPosicionais: 1 });
+            const parsed = parsearArgumentos(args, { opcoes: ["--escopo", "--cache", "--drift"], flags: ["--incluir-worktrees", "--incluir-consumidores-laterais", "--pacote"], maxPosicionais: 1 });
             const escopo = parsed ? valorOpcao(parsed, "--escopo") : undefined;
             return parsed !== null && (!escopo || ESCOPOS.has(escopo)) && validarModoCache(parsed, "--cache");
         }

package/dist/cliHelpTexto.js

@@ -102,6 +102,7 @@ export function criarAjudaRaiz(versao) {
             "fraca: sema resumo <arquivo> --micro --drift none --json (contrato compacto; implementação não avaliada)",
             "média: sema resumo <arquivo> --curto --drift none --json + sema drift <arquivo> --cache fresh --json",
             "forte: sema contexto-ia <arquivo.sema> --saida <diretorio> --json",
+            "context-pack: sema resumo <arquivo.sema> --micro --para mudanca --drift none --json (compactação determinística automática; use --pedido para focar a seleção)",
         ]),
         "",
         renderizarSecaoAscii("Comandos principais", [
@@ -110,7 +111,7 @@ export function criarAjudaRaiz(versao) {
             "pipelines: sema pipeline <listar|descrever> [id] [--json]",
             "todas as capacidades: sema capabilities [--json]",
             "distribuição global: sema skill <status|sync> [--json] (status é somente leitura; sync repara launcher e skill)",
-            "auditoria: sema drift <arquivo-ou-pasta> [--escopo <arquivo|modulo|projeto>] [--cache <none|cache|fresh>] [--incluir-worktrees] [--incluir-consumidores-laterais] [--json]",
+            "auditoria: sema drift <arquivo-ou-pasta> [--escopo <arquivo|modulo|projeto>] [--cache <none|cache|fresh>] [--incluir-worktrees] [--incluir-consumidores-laterais] [--pacote] [--json]",
             "modos: drift direto usa fresh por padrão; --cache none ainda executa sem cache persistente; resumo/inspecionar usam --drift none por padrão e não fabricam evidência",
             "impacto: sema impacto <arquivo-ou-pasta> --alvo <token> [--mudanca <descricao>] [--escopo <arquivo|modulo|projeto>] [--json]",
             "renomeação: sema renomear-semantico <arquivo-ou-pasta> --de <nome-atual> --para <nome-novo> [--escopo <arquivo|modulo|projeto>] [--json]",
@@ -133,14 +134,14 @@ export function criarAjudaRaiz(versao) {
         renderizarSecaoAscii("Ajuda IA-first", [
             "sema ajuda-ia",
             "sema starter-ia",
-            "sema resumo <arquivo-ou-pasta> [--micro|--curto|--medio] [--para <resumo|onboarding|review|mudanca|bug|arquitetura>] [--drift <none|cache|fresh>] [--saida <diretorio>] [--raiz] [--json]",
+            "sema resumo <arquivo-ou-pasta> [--micro|--curto|--medio] [--para <resumo|onboarding|review|mudanca|bug|arquitetura>] [--drift <none|cache|fresh>] [--saida <diretorio>] [--raiz] [--pedido <intencao>] [--somente-pacote] [--json]",
             "sema prompt-curto <arquivo-ou-pasta> [--micro|--curto|--medio] [--para <resumo|onboarding|review|mudanca|bug|arquitetura>] [--json]",
             "sema prompt-ia",
             "sema prompt-ia-ui",
             "sema prompt-ia-react",
             "sema prompt-ia-sema-primeiro",
             "sema exemplos-prompt-ia",
-            "sema contexto-ia <arquivo.sema> [--saida <diretorio>] [--json]",
+            "sema contexto-ia <arquivo.sema> [--saida <diretorio>] [--capacidade <fraca|media|forte>] [--pacote] [--json]",
             "sema sync-codex [--json]",
             "sema instalar-exemplos [--json]",
             "sema sessao [intencao] [entrada] [--json]",

package/dist/contextPack.d.ts

@@ -0,0 +1,75 @@
+import type { ResumoSemanticoModuloIa, TamanhoResumoIa } from "./index.part01.js";
+type ResumoEntrada = Partial<ResumoSemanticoModuloIa>;
+export type ContextPackPayload = {
+    geradoEm?: string;
+    arquivo?: string;
+    modulo?: string;
+    modo?: string;
+    tamanho?: string;
+    analiseDrift?: {
+        modo?: string;
+        executada?: boolean;
+        sucesso?: boolean | null;
+        aviso?: string | null;
+    };
+    guiaPorCapacidade?: unknown;
+    texto?: string;
+    resumo?: ResumoEntrada;
+};
+export type ContextPack = {
+    schema: "sema.ai.context-pack/v1";
+    selection: "deterministic_allowlist";
+    request: string;
+    source: {
+        command: "resumo";
+        mode: string;
+        size: string;
+        drift: string;
+        generatedAt: string | null;
+        contract: string | null;
+    };
+    context: {
+        module: string | null;
+        purpose: string | null;
+        relevantTasks: string[];
+        criticalRules: string[];
+        effects: string[];
+        entities: string[];
+        risks: string[];
+        likelyFiles: string[];
+        requiredChecks: string[];
+        minimumTests: string[];
+        compatibilityProfile: string | null;
+        knownGaps: string[];
+    };
+    authority: {
+        semaRemainsAuthority: true;
+        rawSummaryForwarded: false;
+        executionRequiresFreshValidation: true;
+        omitted: string[];
+    };
+    telemetry: {
+        packChars: number;
+        packEstimatedTokens: number;
+        estimateMethod: "chars_div_4";
+        selectedFields: string[];
+    };
+};
+export type ContextPackResult = {
+    pack: ContextPack;
+    rawSummaryChars: number;
+    rawSummaryEstimatedTokens: number;
+    rawSummaryEstimateMethod: "chars_div_4";
+    reductionPercent: number;
+};
+export declare function selecionarContexto(payload: ContextPackPayload, request: string): ContextPackResult;
+export declare function criarContextPackAPartirDoResumo(input: {
+    resumo: ResumoSemanticoModuloIa;
+    pedido?: string;
+    modo: string;
+    tamanho: TamanhoResumoIa;
+    analiseDrift: ContextPackPayload["analiseDrift"];
+    guiaPorCapacidade: unknown;
+    texto: string;
+}): ContextPackResult;
+export {};

package/dist/contextPack.js

@@ -0,0 +1,133 @@
+function list(value) {
+    return Array.isArray(value)
+        ? value.filter((item) => typeof item === "string" && item.length > 0)
+        : [];
+}
+function text(value) {
+    return typeof value === "string" && value.length > 0 ? value : null;
+}
+function normalizedTokens(value) {
+    return value
+        .toLocaleLowerCase("pt-BR")
+        .normalize("NFD")
+        .replace(/[\u0300-\u036f]/g, "")
+        .split(/[^a-z0-9_]+/)
+        .filter((token) => token.length >= 4);
+}
+function selectRelevantTasks(tasks, request) {
+    if (request.startsWith("resumo:"))
+        return tasks.slice(0, 8);
+    const requestTokens = new Set(normalizedTokens(request));
+    const intentRoots = ["cancel", "notific", "export", "reagend", "registr", "consult"];
+    const rootedMatches = intentRoots
+        .filter((root) => [...requestTokens].some((token) => token.startsWith(root)))
+        .flatMap((root) => tasks.filter((task) => normalizedTokens(task).some((token) => token.startsWith(root))));
+    if (rootedMatches.length > 0)
+        return [...new Set(rootedMatches)];
+    const scored = tasks.map((task, index) => {
+        const taskTokens = normalizedTokens(task);
+        const score = taskTokens.reduce((total, token) => total + (requestTokens.has(token) ? 1 : 0), 0);
+        return { task, index, score };
+    });
+    const selected = scored
+        .filter((item) => item.score > 0)
+        .sort((a, b) => b.score - a.score || a.index - b.index)
+        .map((item) => item.task);
+    return selected.length > 0 ? selected : tasks.slice(0, 3);
+}
+function estimateTokens(chars) {
+    return Math.ceil(chars / 4);
+}
+export function selecionarContexto(payload, request) {
+    const resumo = payload.resumo ?? {};
+    const context = {
+        module: text(resumo.modulo) ?? text(payload.modulo),
+        purpose: text(resumo.faz),
+        relevantTasks: selectRelevantTasks(list(resumo.tarefasPrincipais), request),
+        criticalRules: list(resumo.regrasCriticas),
+        effects: list(resumo.efeitos),
+        entities: list(resumo.entidadesAfetadas),
+        risks: list(resumo.riscosPrincipais),
+        likelyFiles: list(resumo.arquivosProvaveis),
+        requiredChecks: list(resumo.checksSugeridos),
+        minimumTests: list(resumo.testesMinimos),
+        compatibilityProfile: text(resumo.perfilCompatibilidade),
+        knownGaps: list(resumo.lacunas),
+    };
+    const packWithoutTelemetry = {
+        schema: "sema.ai.context-pack/v1",
+        selection: "deterministic_allowlist",
+        request,
+        source: {
+            command: "resumo",
+            mode: text(payload.modo) ?? "mudanca",
+            size: text(payload.tamanho) ?? "micro",
+            drift: text(payload.analiseDrift?.modo) ?? "none",
+            generatedAt: text(resumo.geradoEm) ?? text(payload.geradoEm),
+            contract: text(resumo.arquivo) ?? text(payload.arquivo),
+        },
+        context,
+        authority: {
+            semaRemainsAuthority: true,
+            rawSummaryForwarded: false,
+            executionRequiresFreshValidation: true,
+            omitted: [
+                "cli_result_envelope",
+                "guiaPorCapacidade",
+                "texto_bruto_do_resumo",
+                "metadados_fora_do_escopo",
+            ],
+        },
+    };
+    const packChars = JSON.stringify(packWithoutTelemetry).length;
+    const selectedFields = [
+        "request",
+        "source.module",
+        "source.contract",
+        "context.module",
+        "context.purpose",
+        "context.relevantTasks",
+        "context.criticalRules",
+        "context.effects",
+        "context.entities",
+        "context.risks",
+        "context.likelyFiles",
+        "context.requiredChecks",
+        "context.minimumTests",
+        "context.compatibilityProfile",
+        "context.knownGaps",
+        "authority",
+    ];
+    const pack = {
+        ...packWithoutTelemetry,
+        telemetry: {
+            packChars,
+            packEstimatedTokens: estimateTokens(packChars),
+            estimateMethod: "chars_div_4",
+            selectedFields,
+        },
+    };
+    const rawSummaryChars = JSON.stringify(payload).length;
+    return {
+        pack,
+        rawSummaryChars,
+        rawSummaryEstimatedTokens: estimateTokens(rawSummaryChars),
+        rawSummaryEstimateMethod: "chars_div_4",
+        reductionPercent: rawSummaryChars === 0 ? 0 : Math.round((1 - packChars / rawSummaryChars) * 10000) / 100,
+    };
+}
+export function criarContextPackAPartirDoResumo(input) {
+    const pedido = input.pedido?.trim() || `resumo:${input.tamanho}`;
+    return selecionarContexto({
+        geradoEm: input.resumo.geradoEm,
+        arquivo: input.resumo.arquivo,
+        modulo: input.resumo.modulo,
+        modo: input.modo,
+        tamanho: input.tamanho,
+        analiseDrift: input.analiseDrift,
+        guiaPorCapacidade: input.guiaPorCapacidade,
+        texto: input.texto,
+        resumo: input.resumo,
+    }, pedido);
+}
+//# sourceMappingURL=contextPack.js.map

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.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;