@semacode/cli 2.3.0 → 3.0.0

package/dist/pipelineConteudo/command.d.ts

@@ -1,3 +1,4 @@
+export { criarAjudaPipelineConteudo } from "./help.js";
 import { HEAD_GENESIS_LEDGER_CONTEUDO } from "./ledger.js";
 export declare function comandoPipelineConteudo(_posicionaisGlobais: string[], args: string[], emJson: boolean): Promise<number>;
 export { HEAD_GENESIS_LEDGER_CONTEUDO };

package/dist/pipelineConteudo/command.js

@@ -1,8 +1,10 @@
-// SEMA-GOVERNED: sema.produto.pipeline_conteudo.cli
+// SEMA-GOVERNED: sema.produto.pipeline_conteudo.cli, sema.produto.cli_invocacao_publica
 // Descrição: CLI declarativa do pipeline de conteúdo; não executa agentes, ferramentas ou publicação.
 import { appendFile, mkdir, readFile, writeFile } from "node:fs/promises";
 import { existsSync, realpathSync } from "node:fs";
 import path from "node:path";
+import { criarAjudaPipelineConteudo } from "./help.js";
+export { criarAjudaPipelineConteudo } from "./help.js";
 import { digestEnvelopeConteudo, hashCanonicoConteudo, } from "./canonical.js";
 import { CAPABILITIES_CONTEUDO_PADRAO, } from "./adapters.js";
 import { anexarEventoLedgerConteudo, HEAD_GENESIS_LEDGER_CONTEUDO, validarLedgerConteudo, validarPayloadEventoConteudo, } from "./ledger.js";
@@ -35,36 +37,6 @@ const SUBCOMANDOS_CONTEUDO = new Set([
     "status",
     "projetar",
 ]);
-const USOS_PIPELINE_CONTEUDO = [
-    "sema conteudo capabilities --json",
-    "sema conteudo validar <definition.json> --json",
-    "sema conteudo planejar <definition.json> --alvos-arquivo <targets.json> --json",
-    "sema conteudo validar-envelope --envelope-arquivo <envelope.json> --confianca-arquivo <trust.json> --trust-root-digest <sha256:...> --revocation-digest <sha256:...> --payload-type <type> --json",
-    "sema conteudo registrar <ledger.ndjson> --envelope-arquivo <envelope.json> --politica-arquivo <policy-envelope.json> --confianca-arquivo <trust.json> --trust-root-digest <sha256:...> --revocation-digest <sha256:...> --ledger-id <id> --expected-head <sha256:...> --json",
-    "sema conteudo status <definition.json> --politica-arquivo <policy-envelope.json> --confianca-arquivo <trust.json> --trust-root-digest <sha256:...> --revocation-digest <sha256:...> --ledger-arquivo <ledger.ndjson> --expected-head <sha256:...> --json",
-    "sema conteudo projetar <definition.json> --politica-arquivo <policy-envelope.json> --confianca-arquivo <trust.json> --trust-root-digest <sha256:...> --revocation-digest <sha256:...> --ledger-arquivo <ledger.ndjson> --expected-head <sha256:...> --saida <manifest.json> --json",
-];
-function ajudaPipelineConteudo() {
-    const mensagem = [
-        "Sema Content Pipeline — controle AI-native multicanal e multiformato.",
-        "",
-        "Uso:",
-        ...USOS_PIPELINE_CONTEUDO.map((uso) => `  ${uso}`),
-        "",
-        "O runner é externo e avança somente pelos nextActions derivados pelo Sema.",
-        "Evidências entram como envelopes assinados; vereditos e transições não são escritos manualmente.",
-        "Não existe revisão humana nativa. Chaves privadas permanecem nos processos signatários independentes.",
-    ].join("\n");
-    return {
-        sucesso: true,
-        comando: "ajuda",
-        mensagem,
-        usos: USOS_PIPELINE_CONTEUDO,
-        nativeHumanReview: false,
-        runner: "external",
-        canonicalState: "signed_hash_chained_ledger",
-    };
-}
 const CAUSAS_PUBLICAS_CONTEUDO = [
     "expected_head_divergente",
     "trust_root_digest_divergente",
@@ -401,7 +373,7 @@ export async function comandoPipelineConteudo(_posicionaisGlobais, args, emJson)
         let payload;
         switch (subcomando) {
             case "ajuda":
-                payload = ajudaPipelineConteudo();
+                payload = criarAjudaPipelineConteudo();
                 break;
             case "capabilities":
                 payload = {

package/dist/pipelineConteudo/help.d.ts

@@ -0,0 +1,2 @@
+export declare const USOS_PIPELINE_CONTEUDO: readonly ["sema conteudo capabilities --json", "sema conteudo validar <definition.json> --json", "sema conteudo planejar <definition.json> --alvos-arquivo <targets.json> --json", "sema conteudo validar-envelope --envelope-arquivo <envelope.json> --confianca-arquivo <trust.json> --trust-root-digest <sha256:...> --revocation-digest <sha256:...> --payload-type <type> --json", "sema conteudo registrar <ledger.ndjson> --envelope-arquivo <envelope.json> --politica-arquivo <policy-envelope.json> --confianca-arquivo <trust.json> --trust-root-digest <sha256:...> --revocation-digest <sha256:...> --ledger-id <id> --expected-head <sha256:...> --json", "sema conteudo status <definition.json> --politica-arquivo <policy-envelope.json> --confianca-arquivo <trust.json> --trust-root-digest <sha256:...> --revocation-digest <sha256:...> --ledger-arquivo <ledger.ndjson> --expected-head <sha256:...> --json", "sema conteudo projetar <definition.json> --politica-arquivo <policy-envelope.json> --confianca-arquivo <trust.json> --trust-root-digest <sha256:...> --revocation-digest <sha256:...> --ledger-arquivo <ledger.ndjson> --expected-head <sha256:...> --saida <manifest.json> --json"];
+export declare function criarAjudaPipelineConteudo(): Record<string, unknown>;

package/dist/pipelineConteudo/help.js

@@ -0,0 +1,33 @@
+// SEMA-GOVERNED: sema.produto.pipeline_conteudo.cli, sema.produto.cli_invocacao_publica
+// Descrição: renderiza a ajuda pública do pipeline de conteúdo sem carregar o runtime operacional.
+export const USOS_PIPELINE_CONTEUDO = [
+    "sema conteudo capabilities --json",
+    "sema conteudo validar <definition.json> --json",
+    "sema conteudo planejar <definition.json> --alvos-arquivo <targets.json> --json",
+    "sema conteudo validar-envelope --envelope-arquivo <envelope.json> --confianca-arquivo <trust.json> --trust-root-digest <sha256:...> --revocation-digest <sha256:...> --payload-type <type> --json",
+    "sema conteudo registrar <ledger.ndjson> --envelope-arquivo <envelope.json> --politica-arquivo <policy-envelope.json> --confianca-arquivo <trust.json> --trust-root-digest <sha256:...> --revocation-digest <sha256:...> --ledger-id <id> --expected-head <sha256:...> --json",
+    "sema conteudo status <definition.json> --politica-arquivo <policy-envelope.json> --confianca-arquivo <trust.json> --trust-root-digest <sha256:...> --revocation-digest <sha256:...> --ledger-arquivo <ledger.ndjson> --expected-head <sha256:...> --json",
+    "sema conteudo projetar <definition.json> --politica-arquivo <policy-envelope.json> --confianca-arquivo <trust.json> --trust-root-digest <sha256:...> --revocation-digest <sha256:...> --ledger-arquivo <ledger.ndjson> --expected-head <sha256:...> --saida <manifest.json> --json",
+];
+export function criarAjudaPipelineConteudo() {
+    const mensagem = [
+        "Sema Content Pipeline — controle AI-native multicanal e multiformato.",
+        "",
+        "Uso:",
+        ...USOS_PIPELINE_CONTEUDO.map((uso) => `  ${uso}`),
+        "",
+        "O runner é externo e avança somente pelos nextActions derivados pelo Sema.",
+        "Evidências entram como envelopes assinados; vereditos e transições não são escritos manualmente.",
+        "Não existe revisão humana nativa. Chaves privadas permanecem nos processos signatários independentes.",
+    ].join("\n");
+    return {
+        sucesso: true,
+        comando: "ajuda",
+        mensagem,
+        usos: USOS_PIPELINE_CONTEUDO,
+        nativeHumanReview: false,
+        runner: "external",
+        canonicalState: "signed_hash_chained_ledger",
+    };
+}
+//# sourceMappingURL=help.js.map

package/dist/profileAuthorCommand.js

@@ -1,9 +1,5 @@
-// SEMA-GOVERNED: sema.governanca_ia_contexto
-// Descricao: codigo governado pelo Sema; consulte contratos/sema/governanca_ia_contexto.sema antes de editar.
-// SEMA-GOVERNED
-// M?dulo: sema.produto.orcamento_semantico
-// Contrato: contratos/sema/orcamento_semantico.sema
-// Descricao: comandos de profiles semanticos e Author, com gates de score e decis?o de agente.
+// SEMA-GOVERNED: sema.governanca_ia_contexto, sema.produto.governanca_ia.drift.cache.modos
+// Descrição: comando Author com próximos passos explícitos de drift fresh.
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { formatarDiagnosticos, temErros } from "@sema/nucleo";
@@ -123,7 +119,7 @@ export async function criarAuthorBriefing(entrada, preset = null) {
             "sema author validar-narrativa <arquivo> --texto <texto> --json",
             "sema author validar-proibicoes <arquivo> --texto <texto> --json",
             "sema validar <arquivo> --json",
-            "sema drift <arquivo> --json",
+            "sema drift <arquivo> --cache fresh --json",
         ],
         diagnosticos: escolhido.resultado.diagnosticos,
     };

package/dist/profileCommand.js

@@ -1,9 +1,5 @@
-// SEMA-GOVERNED: sema.governanca_ia_contexto
-// Descricao: codigo governado pelo Sema; consulte contratos/sema/governanca_ia_contexto.sema antes de editar.
-// SEMA-GOVERNED
-// M?dulo: sema.produto.orcamento_semantico
-// Contrato: contratos/sema/orcamento_semantico.sema
-// Descricao: comando profile da CLI e renderiza??o de valida??o sem?ntica por profile.
+// SEMA-GOVERNED: sema.produto.orquestracao_profiles, sema.produto.governanca_ia.drift.cache.modos
+// Descrição: comando de profiles com fechamento explícito por drift fresh.
 import { readFile } from "node:fs/promises";
 import path from "node:path";
 import { temErros } from "@sema/nucleo";
@@ -98,7 +94,7 @@ export async function validarProfileSemantico(entrada, profile, opcoes) {
         checks: [
             `sema profile validar ${profile} <arquivo> --preset ${preset ?? "<opcional>"} --artefato-arquivo <artefato> --json`,
             "sema validar <arquivo> --json",
-            "sema drift <arquivo> --escopo modulo --json",
+            "sema drift <arquivo> --escopo modulo --cache fresh --json",
             "sema contexto-ia <arquivo>",
         ],
         diagnosticos: escolhido.resultado.diagnosticos,

package/dist/projeto.d.ts

@@ -1,4 +1,4 @@
-export type { ConfiguracaoPersistenciaProjeto, ConfiguracaoProjetoCarregada, ContextoProjetoCarregado, SemaConfigProjeto, } from './projetoTipos.js';
+export type { ConfiguracaoPersistenciaProjeto, ConfiguracaoProjetoCarregada, ContextoProjetoCarregado, EscopoCarregamentoProjeto, ModuloProjetoCarregado, OpcoesCarregarProjeto, SemaConfigProjeto, } from './projetoTipos.js';
 export { carregarConfiguracaoProjeto, localizarConfiguracaoProjeto, normalizarEstruturaSaida, normalizarFrameworkGeracao, } from './projetoConfig.js';
 export { carregarProjeto } from './projetoCarregar.js';
 export { resolverAlvoPadrao, resolverAlvosVerificacao, resolverEstruturaSaidaPadrao, resolverFrameworkPadrao, resolverSaidaPadrao, } from './projetoResolucao.js';

package/dist/projetoCarregar.d.ts

@@ -1,2 +1,2 @@
-import type { ContextoProjetoCarregado } from './projetoTipos.js';
-export declare function carregarProjeto(entrada: string | undefined, cwd: string): Promise<ContextoProjetoCarregado>;
+import type { ContextoProjetoCarregado, OpcoesCarregarProjeto } from './projetoTipos.js';
+export declare function carregarProjeto(entrada: string | undefined, cwd: string, opcoes?: OpcoesCarregarProjeto): Promise<ContextoProjetoCarregado>;

package/dist/projetoCarregar.js

@@ -1,50 +1,91 @@
-// SEMA-GOVERNED: sema.produto.governanca_ia.contexto
-// Descrição: orquestra leitura de contratos, compila??o e sele??o de m?dulos do projeto.
+// SEMA-GOVERNED: sema.produto.governanca_ia.contexto, sema.produto.governanca_ia.drift.cache.modos
+// Descrição: orquestra leitura de contratos, compilação e seleção de módulos do projeto.
 import { stat } from 'node:fs/promises';
 import path from 'node:path';
-import { compilarProjeto, lerArquivoTexto, listarArquivosSema } from '@sema/nucleo';
-import { carregarConfiguracaoProjeto, normalizarModoAdocao } from './projetoConfig.js';
+import { compilarProjeto, listarArquivosSema } from '@sema/nucleo';
+import { canonicalizarContratosNoProjeto, carregarFechamentoContratosSema, carregarFontesContratos, } from './projetoCatalogo.js';
+import { carregarConfiguracaoProjeto, normalizarFonteLegado, normalizarModoAdocao } from './projetoConfig.js';
 import { inferirFontesLegado } from './projetoLegado.js';
-import { inferirDiretoriosCodigo, listarArquivosDeOrigens, resolverBaseProjeto, resolverEntradaPadrao, resolverOrigensProjeto, } from './projetoOrigens.js';
-export async function carregarProjeto(entrada, cwd) {
+import { inferirDiretoriosCodigo, listarArquivosDeOrigens, resolverBaseProjeto, resolverDiretoriosCodigoConfigurados, resolverEntradaPadrao, resolverOrigensProjeto, resolverRaizesLogicasCodigoSemCaminhada, } from './projetoOrigens.js';
+async function resolverDiretoriosCodigoSemCaminhada(baseProjeto, configCarregada) {
+    const declarados = await resolverDiretoriosCodigoConfigurados(baseProjeto, configCarregada);
+    return declarados.length > 0
+        ? declarados
+        : resolverRaizesLogicasCodigoSemCaminhada(baseProjeto);
+}
+function resolverFontesLegadoDeclaradas(configCarregada) {
+    return [...new Set((configCarregada?.config.fontesLegado ?? [])
+            .map((fonte) => normalizarFonteLegado(fonte))
+            .filter((fonte) => Boolean(fonte)))]
+        .sort((a, b) => a.localeCompare(b, "pt-BR"));
+}
+export async function carregarProjeto(entrada, cwd, opcoes = {}) {
     const entradaBase = entrada ? path.resolve(cwd, entrada) : cwd;
     const configCarregada = await carregarConfiguracaoProjeto(entradaBase);
     const entradaResolvida = entrada ? path.resolve(cwd, entrada) : await resolverEntradaPadrao(cwd, configCarregada);
     const baseProjeto = await resolverBaseProjeto(entradaResolvida, configCarregada);
     const infoEntrada = await stat(entradaResolvida);
-    const origensProjeto = await resolverOrigensProjeto(baseProjeto, entradaResolvida, configCarregada);
-    const arquivosProjeto = await listarArquivosDeOrigens(origensProjeto);
-    const diretoriosCodigo = await inferirDiretoriosCodigo(baseProjeto, configCarregada);
-    const fontesLegado = await inferirFontesLegado(diretoriosCodigo, baseProjeto, configCarregada);
-    const modoAdocao = normalizarModoAdocao(configCarregada?.config.modoAdocao);
-    const arquivosSelecionados = infoEntrada.isFile()
-        ? new Set([path.resolve(entradaResolvida)])
-        : new Set((configCarregada && path.resolve(entradaResolvida) === path.resolve(configCarregada.baseDiretorio)
-            ? arquivosProjeto
-            : await listarArquivosSema(entradaResolvida)).map((arquivo) => path.resolve(arquivo)));
-    const fontes = [];
-    for (const arquivo of arquivosProjeto) {
-        const codigo = await lerArquivoTexto(arquivo);
-        fontes.push({ caminho: arquivo, codigo });
+    if (infoEntrada.isFile() && path.extname(entradaResolvida).toLowerCase() !== ".sema") {
+        throw new Error(`Entrada de contrato precisa terminar em .sema: ${entradaResolvida}`);
     }
+    const escopo = opcoes.escopo ?? (infoEntrada.isFile() ? "modulo" : "projeto");
+    const carregarProjetoCompleto = !infoEntrada.isFile() || escopo === "projeto";
+    const origensBase = infoEntrada.isFile()
+        ? await resolverOrigensProjeto(baseProjeto, baseProjeto, configCarregada)
+        : await resolverOrigensProjeto(baseProjeto, entradaResolvida, configCarregada);
+    const origensProjeto = [...new Set([
+            ...origensBase,
+            ...(infoEntrada.isFile() ? [path.dirname(entradaResolvida)] : []),
+        ].map((origem) => path.resolve(origem)))]
+        .sort((a, b) => a.localeCompare(b, "pt-BR"));
+    const arquivosDescobertosSet = new Set(await listarArquivosDeOrigens(origensProjeto));
+    if (infoEntrada.isFile()) {
+        arquivosDescobertosSet.add(path.resolve(entradaResolvida));
+    }
+    const arquivosDescobertos = await canonicalizarContratosNoProjeto(baseProjeto, [...arquivosDescobertosSet]);
+    const entradaContrato = infoEntrada.isFile()
+        ? (await canonicalizarContratosNoProjeto(baseProjeto, [entradaResolvida]))[0]
+        : undefined;
+    // Escopos estreitos recebem apenas raizes logicas declaradas (ou a raiz local)
+    // para que o planner decida o que pode ser tocado antes de qualquer caminhada.
+    const adiarDescobertaCodigo = opcoes.adiarDescobertaCodigo === true;
+    const diretoriosCodigo = adiarDescobertaCodigo
+        ? await resolverDiretoriosCodigoSemCaminhada(baseProjeto, configCarregada)
+        : await inferirDiretoriosCodigo(baseProjeto, configCarregada);
+    const fontesLegado = adiarDescobertaCodigo
+        ? resolverFontesLegadoDeclaradas(configCarregada)
+        : await inferirFontesLegado(diretoriosCodigo, baseProjeto, configCarregada);
+    const modoAdocao = normalizarModoAdocao(configCarregada?.config.modoAdocao);
+    const arquivosSelecionados = carregarProjetoCompleto && escopo === "projeto"
+        ? new Set(arquivosDescobertos.map((arquivo) => path.resolve(arquivo)))
+        : infoEntrada.isFile()
+            ? new Set([entradaContrato])
+            : new Set((configCarregada && path.resolve(entradaResolvida) === path.resolve(configCarregada.baseDiretorio)
+                ? arquivosDescobertos
+                : await listarArquivosSema(entradaResolvida)).map((arquivo) => path.resolve(arquivo)));
+    const fontes = carregarProjetoCompleto
+        ? await carregarFontesContratos(arquivosDescobertos)
+        : (await carregarFechamentoContratosSema([entradaContrato], arquivosDescobertos)).fontes;
     const resultadoProjeto = compilarProjeto(fontes);
     const resultados = new Map(resultadoProjeto.modulos.map((modulo) => [path.resolve(modulo.caminho), modulo]));
+    const modulosCarregados = fontes.map((fonte) => ({
+        caminho: fonte.caminho,
+        codigo: fonte.codigo,
+        resultado: resultados.get(path.resolve(fonte.caminho)),
+    }));
     return {
         entradaResolvida,
         baseProjeto,
         configCarregada,
-        arquivosProjeto,
+        arquivosProjeto: fontes.map((fonte) => fonte.caminho),
+        arquivosDescobertos,
         origensProjeto,
         diretoriosCodigo,
         fontesLegado,
         modoAdocao,
-        modulosSelecionados: fontes
-            .filter((fonte) => arquivosSelecionados.has(path.resolve(fonte.caminho)))
-            .map((fonte) => ({
-            caminho: fonte.caminho,
-            codigo: fonte.codigo,
-            resultado: resultados.get(path.resolve(fonte.caminho)),
-        })),
+        modulosCarregados,
+        modulosSelecionados: modulosCarregados
+            .filter((modulo) => arquivosSelecionados.has(path.resolve(modulo.caminho))),
     };
 }
 //# sourceMappingURL=projetoCarregar.js.map

package/dist/projetoCatalogo.d.ts

@@ -0,0 +1,8 @@
+import { type FonteProjeto } from "@sema/nucleo";
+export interface FechamentoContratosSema {
+    fontes: FonteProjeto[];
+    dependenciasNaoResolvidas: string[];
+}
+export declare function canonicalizarContratosNoProjeto(baseProjeto: string, arquivos: string[]): Promise<string[]>;
+export declare function carregarFontesContratos(arquivos: string[]): Promise<FonteProjeto[]>;
+export declare function carregarFechamentoContratosSema(arquivosAlvo: string[], arquivosDescobertos: string[]): Promise<FechamentoContratosSema>;

package/dist/projetoCatalogo.js

@@ -0,0 +1,164 @@
+// SEMA-GOVERNED: sema.produto.governanca_ia.contexto
+// Descricao: descobre contratos por caminho e carrega apenas o fechamento transitivo de uses do alvo.
+import path from "node:path";
+import { realpath } from "node:fs/promises";
+import { listarCandidatosUseRelativo, lerArquivoTexto, parsear, tokenizar, } from "@sema/nucleo";
+function caminhoEstaContido(base, alvo) {
+    const relativo = path.relative(base, alvo);
+    return relativo === "" || (relativo !== ".."
+        && !relativo.startsWith(`..${path.sep}`)
+        && !path.isAbsolute(relativo));
+}
+function chaveCaminhoReal(caminho) {
+    return process.platform === "win32" ? caminho.toLocaleLowerCase("en-US") : caminho;
+}
+export async function canonicalizarContratosNoProjeto(baseProjeto, arquivos) {
+    const baseReal = await realpath(path.resolve(baseProjeto));
+    const canonicos = new Map();
+    for (const arquivo of arquivos) {
+        const caminhoReal = await realpath(path.resolve(arquivo));
+        if (!caminhoEstaContido(baseReal, caminhoReal)) {
+            throw new Error(`Contrato resolve fora da base do projeto: ${arquivo}`);
+        }
+        if (path.extname(caminhoReal).toLowerCase() !== ".sema") {
+            throw new Error(`Entrada de contrato precisa terminar em .sema: ${arquivo}`);
+        }
+        canonicos.set(chaveCaminhoReal(caminhoReal), caminhoReal);
+    }
+    return [...canonicos.values()].sort((a, b) => a.localeCompare(b, "pt-BR"));
+}
+function normalizarChaveArquivo(valor) {
+    return valor
+        .normalize("NFD")
+        .replace(/[\u0300-\u036f]/g, "")
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "_")
+        .replace(/^_+|_+$/g, "");
+}
+function chavesSufixoModulo(nomeModulo) {
+    const partes = nomeModulo.split(".").map(normalizarChaveArquivo).filter(Boolean);
+    return partes.map((_, indice) => partes.slice(indice).join("_"));
+}
+function criarIndiceSufixos(arquivos) {
+    const indice = new Map();
+    for (const arquivo of arquivos) {
+        const chave = normalizarChaveArquivo(path.basename(arquivo, path.extname(arquivo)));
+        const atuais = indice.get(chave) ?? [];
+        atuais.push(path.resolve(arquivo));
+        indice.set(chave, atuais);
+    }
+    for (const caminhos of indice.values()) {
+        caminhos.sort((a, b) => a.localeCompare(b, "pt-BR"));
+    }
+    return indice;
+}
+export async function carregarFontesContratos(arquivos) {
+    const fontes = [];
+    for (const arquivo of arquivos) {
+        const caminho = path.resolve(arquivo);
+        fontes.push({ caminho, codigo: await lerArquivoTexto(caminho) });
+    }
+    return fontes;
+}
+export async function carregarFechamentoContratosSema(arquivosAlvo, arquivosDescobertos) {
+    const descobertos = [...new Set(arquivosDescobertos.map((arquivo) => path.resolve(arquivo)))]
+        .sort((a, b) => a.localeCompare(b, "pt-BR"));
+    const indiceSufixos = criarIndiceSufixos(descobertos);
+    const leituras = new Map();
+    const caminhosPorModulo = new Map();
+    const lerContrato = (arquivo) => {
+        const caminho = path.resolve(arquivo);
+        const existente = leituras.get(caminho);
+        if (existente) {
+            return existente;
+        }
+        const leitura = (async () => {
+            const codigo = await lerArquivoTexto(caminho);
+            const resultadoLexer = tokenizar(codigo, caminho);
+            const resultadoParser = parsear(resultadoLexer.tokens);
+            if (resultadoParser.modulo) {
+                const caminhos = caminhosPorModulo.get(resultadoParser.modulo.nome) ?? new Set();
+                caminhos.add(caminho);
+                caminhosPorModulo.set(resultadoParser.modulo.nome, caminhos);
+            }
+            return {
+                fonte: { caminho, codigo },
+                modulo: resultadoParser.modulo,
+            };
+        })();
+        leituras.set(caminho, leitura);
+        return leitura;
+    };
+    const resolverArquivoModulo = async (nomeModulo, moduloAtual) => {
+        const nomesCandidatos = [
+            nomeModulo,
+            ...listarCandidatosUseRelativo(moduloAtual, nomeModulo),
+        ];
+        for (const nomeCandidato of nomesCandidatos) {
+            const tentados = new Set();
+            const encontrados = new Set(caminhosPorModulo.get(nomeCandidato) ?? []);
+            for (const chave of chavesSufixoModulo(nomeCandidato)) {
+                for (const candidato of indiceSufixos.get(chave) ?? []) {
+                    tentados.add(candidato);
+                    const contrato = await lerContrato(candidato);
+                    if (contrato.modulo?.nome === nomeCandidato) {
+                        encontrados.add(candidato);
+                    }
+                }
+            }
+            // Fallback raro para workspaces que nao seguem a convencao modulo -> nome do arquivo.
+            // Ele so acontece quando o indice deterministico nao encontrou o modulo desta prioridade.
+            if (encontrados.size === 0) {
+                for (const candidato of descobertos) {
+                    if (tentados.has(candidato)) {
+                        continue;
+                    }
+                    const contrato = await lerContrato(candidato);
+                    if (contrato.modulo?.nome === nomeCandidato) {
+                        encontrados.add(candidato);
+                    }
+                }
+            }
+            if (encontrados.size > 1) {
+                const caminhos = [...encontrados].sort((a, b) => a.localeCompare(b, "pt-BR"));
+                throw new Error(`Modulo Sema ambiguo "${nomeCandidato}" em: ${caminhos.join(", ")}`);
+            }
+            if (encontrados.size === 1) {
+                return [...encontrados][0];
+            }
+        }
+        return undefined;
+    };
+    const fila = arquivosAlvo.map((arquivo) => path.resolve(arquivo));
+    const carregados = new Set();
+    const fontes = [];
+    const dependenciasNaoResolvidas = new Set();
+    while (fila.length > 0) {
+        const arquivo = fila.shift();
+        if (carregados.has(arquivo)) {
+            continue;
+        }
+        carregados.add(arquivo);
+        const contrato = await lerContrato(arquivo);
+        fontes.push(contrato.fonte);
+        const usesSema = contrato.modulo?.uses
+            .filter((use) => use.origem === "sema")
+            .map((use) => use.caminho) ?? [];
+        for (const use of usesSema) {
+            const dependencia = await resolverArquivoModulo(use, contrato.modulo.nome);
+            if (!dependencia) {
+                dependenciasNaoResolvidas.add(use);
+                continue;
+            }
+            if (!carregados.has(dependencia)) {
+                fila.push(dependencia);
+            }
+        }
+    }
+    return {
+        fontes,
+        dependenciasNaoResolvidas: [...dependenciasNaoResolvidas]
+            .sort((a, b) => a.localeCompare(b, "pt-BR")),
+    };
+}
+//# sourceMappingURL=projetoCatalogo.js.map

package/dist/projetoOrigens.d.ts

@@ -1,4 +1,6 @@
 import type { ConfiguracaoProjetoCarregada } from './projetoTipos.js';
+export declare function resolverRaizesLogicasCodigoSemCaminhada(baseProjeto: string): string[];
+export declare function resolverDiretoriosCodigoConfigurados(baseProjeto: string, configCarregada?: ConfiguracaoProjetoCarregada): Promise<string[]>;
 export declare function resolverEntradaPadrao(cwd: string, configCarregada?: ConfiguracaoProjetoCarregada): Promise<string>;
 export declare function listarArquivosDeOrigens(origens: string[]): Promise<string[]>;
 export declare function resolverBaseProjeto(entradaResolvida: string, configCarregada?: ConfiguracaoProjetoCarregada): Promise<string>;

package/dist/projetoOrigens.js

@@ -1,6 +1,6 @@
 // SEMA-GOVERNED: sema.produto.governanca_ia.contexto
 // Descrição: resolve base, origens de contratos e diret?rios de c?digo do projeto.
-import { readdir, stat } from 'node:fs/promises';
+import { readdir, realpath, stat } from 'node:fs/promises';
 import path from 'node:path';
 import { listarArquivosSema } from '@sema/nucleo';
 import { caminhoExiste, DIRETORIOS_CODIGO_IGNORADOS, EXTENSOES_CODIGO, listarDiretoriosFilhos, } from './projetoBusca.js';
@@ -10,7 +10,12 @@ const DIRETORIOS_CODIGO_FIXOS = [
     "app",
     "apps",
     "backend",
+    "frontend",
+    "client",
+    "web",
     "lib",
+    "packages",
+    "pacotes",
     "api",
     "server",
     "services",
@@ -21,6 +26,59 @@ const DIRETORIOS_CODIGO_FIXOS = [
     "functions",
     "scripts",
 ];
+export function resolverRaizesLogicasCodigoSemCaminhada(baseProjeto) {
+    return [path.resolve(baseProjeto), ...DIRETORIOS_CODIGO_FIXOS
+            .map((segmento) => path.resolve(baseProjeto, segmento))];
+}
+function caminhoEstaDentro(raiz, alvo) {
+    const relativo = path.relative(path.resolve(raiz), path.resolve(alvo));
+    return relativo === "" || (relativo !== ".."
+        && !relativo.startsWith(`..${path.sep}`)
+        && !path.isAbsolute(relativo));
+}
+function erroEhAusencia(erro) {
+    return ["ENOENT", "ENOTDIR"].includes(erro.code ?? "");
+}
+async function resolverDiretoriosConfiguradosConfinados(baseProjeto, baseConfiguracao, declarados, campo) {
+    const baseLogica = path.resolve(baseProjeto);
+    const baseReal = await realpath(baseLogica);
+    const resolvidos = new Map();
+    for (const [indice, declarado] of declarados.entries()) {
+        const identificadorSeguro = `${campo}[${indice}]`;
+        const absoluto = path.resolve(baseConfiguracao, declarado);
+        if (!caminhoEstaDentro(baseLogica, absoluto)) {
+            throw new Error(`${identificadorSeguro} aponta para fora da base do projeto`);
+        }
+        let canonico = absoluto;
+        try {
+            const [real, informacao] = await Promise.all([realpath(absoluto), stat(absoluto)]);
+            if (!informacao.isDirectory()) {
+                throw new Error(`${identificadorSeguro} nao e diretorio`);
+            }
+            if (!caminhoEstaDentro(baseReal, real)) {
+                throw new Error(`${identificadorSeguro} resolve fora da base do projeto`);
+            }
+            canonico = real;
+        }
+        catch (erro) {
+            if (!erroEhAusencia(erro)) {
+                throw erro;
+            }
+        }
+        const chave = process.platform === "win32" ? canonico.toLowerCase() : canonico;
+        if (!resolvidos.has(chave)) {
+            resolvidos.set(chave, canonico);
+        }
+    }
+    return [...resolvidos.values()].sort((a, b) => a.localeCompare(b, "pt-BR"));
+}
+export async function resolverDiretoriosCodigoConfigurados(baseProjeto, configCarregada) {
+    const declarados = configCarregada?.config.diretoriosCodigo ?? [];
+    if (declarados.length === 0) {
+        return [];
+    }
+    return resolverDiretoriosConfiguradosConfinados(baseProjeto, configCarregada.baseDiretorio, declarados, "diretoriosCodigo");
+}
 export async function resolverEntradaPadrao(cwd, configCarregada) {
     if (configCarregada) {
         return configCarregada.baseDiretorio;
@@ -100,18 +158,19 @@ async function descobrirOrigemPadrao(baseProjeto, entradaResolvida) {
 }
 export async function resolverOrigensProjeto(baseProjeto, entradaResolvida, configCarregada) {
     if (configCarregada) {
+        const confinar = (origens) => resolverDiretoriosConfiguradosConfinados(baseProjeto, configCarregada.baseDiretorio, origens, "origens");
         const infoEntrada = await stat(entradaResolvida);
         if (infoEntrada.isFile()) {
-            return [path.resolve(path.dirname(entradaResolvida))];
+            return confinar([path.dirname(entradaResolvida)]);
         }
         if (path.resolve(entradaResolvida) !== path.resolve(configCarregada.baseDiretorio)) {
-            return [path.resolve(entradaResolvida)];
+            return confinar([entradaResolvida]);
         }
         const declaradas = configCarregada.config.origens ?? (configCarregada.config.origem ? [configCarregada.config.origem] : []);
         if (declaradas.length > 0) {
-            return declaradas.map((origem) => path.resolve(configCarregada.baseDiretorio, origem));
+            return confinar(declaradas);
         }
-        return [configCarregada.baseDiretorio];
+        return confinar([configCarregada.baseDiretorio]);
     }
     const infoEntrada = await stat(entradaResolvida);
     if (infoEntrada.isFile()) {
@@ -149,10 +208,7 @@ async function diretorioTemArquivosCodigo(diretorioBase, profundidadeMaxima = 4)
 }
 export async function inferirDiretoriosCodigo(baseProjeto, configCarregada) {
     if (configCarregada?.config.diretoriosCodigo?.length) {
-        return [...new Set(configCarregada.config.diretoriosCodigo
-                .map((diretorio) => path.resolve(configCarregada.baseDiretorio, diretorio))
-                .filter(Boolean))]
-            .sort((a, b) => a.localeCompare(b, "pt-BR"));
+        return resolverDiretoriosCodigoConfigurados(baseProjeto, configCarregada);
     }
     const candidatosFixos = DIRETORIOS_CODIGO_FIXOS
         .map((segmento) => path.join(baseProjeto, segmento));

package/dist/projetoTipos.d.ts

@@ -1,6 +1,11 @@
 import type { EngineBanco, ResultadoCompilacaoProjetoModulo } from '@sema/nucleo';
 import type { AlvoGeracao, FrameworkGeracao } from '@sema/padroes';
 import type { EstruturaSaida, FonteLegado, ModoAdocao } from './tipos.js';
+export type EscopoCarregamentoProjeto = "arquivo" | "modulo" | "projeto";
+export interface OpcoesCarregarProjeto {
+    escopo?: EscopoCarregamentoProjeto;
+    adiarDescobertaCodigo?: boolean;
+}
 export interface ConfiguracaoPersistenciaProjeto {
     enginesHabilitados?: EngineBanco[];
     adaptersPorEngine?: Partial<Record<EngineBanco, string>>;
@@ -30,18 +35,23 @@ export interface ConfiguracaoProjetoCarregada {
     baseDiretorio: string;
     config: SemaConfigProjeto;
 }
+export interface ModuloProjetoCarregado {
+    caminho: string;
+    codigo: string;
+    resultado: ResultadoCompilacaoProjetoModulo;
+}
 export interface ContextoProjetoCarregado {
     entradaResolvida: string;
     baseProjeto: string;
     configCarregada?: ConfiguracaoProjetoCarregada;
+    /** Contratos efetivamente lidos e compilados nesta execucao. */
     arquivosProjeto: string[];
+    /** Contratos encontrados nas origens, inclusive os que ficaram fora do escopo carregado. */
+    arquivosDescobertos: string[];
     origensProjeto: string[];
     diretoriosCodigo: string[];
     fontesLegado: FonteLegado[];
     modoAdocao: ModoAdocao;
-    modulosSelecionados: Array<{
-        caminho: string;
-        codigo: string;
-        resultado: ResultadoCompilacaoProjetoModulo;
-    }>;
+    modulosCarregados: ModuloProjetoCarregado[];
+    modulosSelecionados: ModuloProjetoCarregado[];
 }

package/dist/resultadoCli.d.ts

@@ -0,0 +1,20 @@
+export declare const SCHEMA_RESULTADO_CLI_V1: "sema.cli.result/v1";
+export declare const CODIGO_SAIDA_FATAL_RUNTIME_CLI: 70;
+export type TipoResultadoCliV1 = "SUCCESS" | "DOMAIN_ERROR";
+export interface EnvelopeResultadoCliV1 {
+    readonly schemaVersion: typeof SCHEMA_RESULTADO_CLI_V1;
+    readonly ok: boolean;
+    readonly kind: TipoResultadoCliV1;
+    readonly command: string;
+    readonly code: "CLI_SUCCESS" | "CLI_DOMAIN_ERROR";
+    readonly message: string | null;
+    readonly exitCode: number;
+    readonly payload: unknown;
+}
+export interface EntradaEnvelopeResultadoCliV1 {
+    readonly comando: string;
+    readonly codigoSaida: number;
+    readonly stdout: string;
+}
+export declare function interpretarPayloadRuntimeCli(stdout: string): unknown;
+export declare function criarEnvelopeResultadoCliV1(entrada: EntradaEnvelopeResultadoCliV1): EnvelopeResultadoCliV1;