@semacode/cli 2.3.1 → 3.5.0

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";
@@ -26,6 +28,7 @@ const OPCOES_COM_VALOR_CONTEUDO = new Set([
     "--revocation-digest",
 ]);
 const SUBCOMANDOS_CONTEUDO = new Set([
+    "ajuda",
     "capabilities",
     "validar",
     "planejar",
@@ -363,11 +366,15 @@ async function registrarEnvelopeLocal(args, ledgerArquivo) {
 }
 export async function comandoPipelineConteudo(_posicionaisGlobais, args, emJson) {
     const posicionais = posicionaisConteudo(args);
-    const subcomando = posicionais[0] ?? "capabilities";
+    const solicitouAjuda = args.includes("--help") || args.includes("-h") || posicionais[0] === "help" || posicionais[0] === "ajuda";
+    const subcomando = solicitouAjuda ? "ajuda" : posicionais[0] ?? "capabilities";
     const comandoPublico = SUBCOMANDOS_CONTEUDO.has(subcomando) ? subcomando : "desconhecido";
     try {
         let payload;
         switch (subcomando) {
+            case "ajuda":
+                payload = criarAjudaPipelineConteudo();
+                break;
             case "capabilities":
                 payload = {
                     sucesso: true,

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/projetoCarregar.js

@@ -1,18 +1,33 @@
-// 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, listarArquivosSema } from '@sema/nucleo';
-import { carregarFechamentoContratosSema, carregarFontesContratos } from './projetoCatalogo.js';
-import { carregarConfiguracaoProjeto, normalizarModoAdocao } from './projetoConfig.js';
+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';
+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);
+    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()
@@ -27,27 +42,30 @@ export async function carregarProjeto(entrada, cwd, opcoes = {}) {
     if (infoEntrada.isFile()) {
         arquivosDescobertosSet.add(path.resolve(entradaResolvida));
     }
-    const arquivosDescobertos = [...arquivosDescobertosSet]
-        .sort((a, b) => a.localeCompare(b, "pt-BR"));
-    const possuiDiretoriosCodigoExplicitos = Boolean(configCarregada?.config.diretoriosCodigo?.length);
-    const possuiFontesLegadoExplicitas = Boolean(configCarregada?.config.fontesLegado?.length);
-    const diretoriosCodigo = carregarProjetoCompleto || possuiDiretoriosCodigoExplicitos
-        ? await inferirDiretoriosCodigo(baseProjeto, configCarregada)
-        : [];
-    const fontesLegado = carregarProjetoCompleto || possuiFontesLegadoExplicitas
-        ? await inferirFontesLegado(diretoriosCodigo, baseProjeto, configCarregada)
-        : [];
+    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([path.resolve(entradaResolvida)])
+            ? 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([entradaResolvida], arquivosDescobertos)).fontes;
+        : (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) => ({

package/dist/projetoCatalogo.d.ts

@@ -3,5 +3,6 @@ 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

@@ -1,7 +1,32 @@
 // 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 { lerArquivoTexto, parsear, tokenizar, } from "@sema/nucleo";
+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")
@@ -40,7 +65,7 @@ export async function carregarFechamentoContratosSema(arquivosAlvo, arquivosDesc
         .sort((a, b) => a.localeCompare(b, "pt-BR"));
     const indiceSufixos = criarIndiceSufixos(descobertos);
     const leituras = new Map();
-    const caminhoPorModulo = new Map();
+    const caminhosPorModulo = new Map();
     const lerContrato = (arquivo) => {
         const caminho = path.resolve(arquivo);
         const existente = leituras.get(caminho);
@@ -52,7 +77,9 @@ export async function carregarFechamentoContratosSema(arquivosAlvo, arquivosDesc
             const resultadoLexer = tokenizar(codigo, caminho);
             const resultadoParser = parsear(resultadoLexer.tokens);
             if (resultadoParser.modulo) {
-                caminhoPorModulo.set(resultadoParser.modulo.nome, caminho);
+                const caminhos = caminhosPorModulo.get(resultadoParser.modulo.nome) ?? new Set();
+                caminhos.add(caminho);
+                caminhosPorModulo.set(resultadoParser.modulo.nome, caminhos);
             }
             return {
                 fonte: { caminho, codigo },
@@ -62,30 +89,42 @@ export async function carregarFechamentoContratosSema(arquivosAlvo, arquivosDesc
         leituras.set(caminho, leitura);
         return leitura;
     };
-    const resolverArquivoModulo = async (nomeModulo) => {
-        const jaConhecido = caminhoPorModulo.get(nomeModulo);
-        if (jaConhecido) {
-            return jaConhecido;
-        }
-        const tentados = new Set();
-        for (const chave of chavesSufixoModulo(nomeModulo)) {
-            for (const candidato of indiceSufixos.get(chave) ?? []) {
-                tentados.add(candidato);
-                const contrato = await lerContrato(candidato);
-                if (contrato.modulo?.nome === nomeModulo) {
-                    return candidato;
+    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 depois que todos os sufixos deterministas falharam.
-        for (const candidato of descobertos) {
-            if (tentados.has(candidato)) {
-                continue;
+            // 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(", ")}`);
             }
-            const contrato = await lerContrato(candidato);
-            if (contrato.modulo?.nome === nomeModulo) {
-                return candidato;
+            if (encontrados.size === 1) {
+                return [...encontrados][0];
             }
         }
         return undefined;
@@ -106,7 +145,7 @@ export async function carregarFechamentoContratosSema(arquivosAlvo, arquivosDesc
             .filter((use) => use.origem === "sema")
             .map((use) => use.caminho) ?? [];
         for (const use of usesSema) {
-            const dependencia = await resolverArquivoModulo(use);
+            const dependencia = await resolverArquivoModulo(use, contrato.modulo.nome);
             if (!dependencia) {
                 dependenciasNaoResolvidas.add(use);
                 continue;

package/dist/projetoConfig.js

@@ -74,6 +74,8 @@ export function normalizarFonteLegado(valor) {
         return "typescript";
     }
     if (valor === "nestjs"
+        || valor === "express"
+        || valor === "fastify"
         || valor === "fastapi"
         || valor === "flask"
         || valor === "nextjs"

package/dist/projetoLegado.js

@@ -17,6 +17,14 @@ export async function inferirFontesLegado(diretoriosCodigo, baseProjeto, configC
         if (/@nestjs\/common|@nestjs\/core/.test(packageJsonRaiz)) {
             encontrados.add("nestjs");
         }
+        if (/"express"\s*:/.test(packageJsonRaiz)) {
+            encontrados.add("express");
+            encontrados.add("typescript");
+        }
+        if (/"fastify"\s*:/.test(packageJsonRaiz)) {
+            encontrados.add("fastify");
+            encontrados.add("typescript");
+        }
         if (/typescript/.test(packageJsonRaiz)) {
             encontrados.add("typescript");
         }
@@ -64,6 +72,10 @@ export async function inferirFontesLegado(diretoriosCodigo, baseProjeto, configC
             const relacoesTs = arquivosTsJs.map((arquivo) => path.relative(diretorio, arquivo).replace(/\\/g, "/"));
             const temNest = textosPackage.some((texto) => /@nestjs\/common|@nestjs\/core/.test(texto ?? ""))
                 || amostrasTs.some((texto) => /@nestjs\/common|@nestjs\/core|@Controller\(|@Get\(|@Post\(|@Put\(|@Patch\(|@Delete\(/.test(texto ?? ""));
+            const temExpress = textosPackage.some((texto) => /"express"\s*:/.test(texto ?? ""))
+                || amostrasTs.some((texto) => /(?:from\s+["']express["']|require\(\s*["']express["']\s*\)|\bexpress\s*\(\s*\))/.test(texto ?? ""));
+            const temFastify = textosPackage.some((texto) => /"fastify"\s*:/.test(texto ?? ""))
+                || amostrasTs.some((texto) => /(?:from\s+["']fastify["']|require\(\s*["']fastify["']\s*\)|\bfastify\s*\(\s*\{)/.test(texto ?? ""));
             const temNext = textosPackage.some((texto) => /"next"\s*:/.test(texto ?? ""))
                 || nextConfigs.length > 0
                 || relacoesTs.some((relacao) => /(?:^|\/)(?:src\/)?app\/api\/.+\/route\.(?:ts|tsx|js|jsx)$/.test(relacao));
@@ -86,6 +98,12 @@ export async function inferirFontesLegado(diretoriosCodigo, baseProjeto, configC
             if (temNest) {
                 encontrados.add("nestjs");
             }
+            if (temExpress) {
+                encontrados.add("express");
+            }
+            if (temFastify) {
+                encontrados.add("fastify");
+            }
             if (temNext) {
                 encontrados.add("nextjs");
             }

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

@@ -4,6 +4,7 @@ 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[];

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;

package/dist/resultadoCli.js

@@ -0,0 +1,57 @@
+// SEMA-GOVERNED: sema.produto.cli_invocacao_publica.resultados
+// Descrição: modela o envelope único de resultados JSON da CLI pública 3.0.
+export const SCHEMA_RESULTADO_CLI_V1 = "sema.cli.result/v1";
+export const CODIGO_SAIDA_FATAL_RUNTIME_CLI = 70;
+const COMANDO_CANONICO_VALIDO = /^[a-z][a-z0-9-]{0,63}$/u;
+const MENSAGEM_PUBLICA_ERRO_DOMINIO = "O comando Sema não foi concluído.";
+const SCHEMAS_ENVELOPE_CLI = new Set([
+    SCHEMA_RESULTADO_CLI_V1,
+    "sema.cli.control/v1",
+]);
+function validarComandoCanonico(comando) {
+    if (!COMANDO_CANONICO_VALIDO.test(comando)) {
+        throw new TypeError("Comando canônico inválido.");
+    }
+    return comando;
+}
+function validarCodigoSaida(codigoSaida) {
+    if (!Number.isSafeInteger(codigoSaida) || codigoSaida < 0 || codigoSaida > 255) {
+        throw new TypeError("Código de saída inválido.");
+    }
+    return codigoSaida;
+}
+export function interpretarPayloadRuntimeCli(stdout) {
+    if (stdout.trim().length === 0)
+        return null;
+    let payload;
+    try {
+        payload = JSON.parse(stdout);
+    }
+    catch {
+        return stdout;
+    }
+    if (payload !== null
+        && typeof payload === "object"
+        && !Array.isArray(payload)
+        && Object.prototype.hasOwnProperty.call(payload, "schemaVersion")
+        && SCHEMAS_ENVELOPE_CLI.has(payload.schemaVersion)) {
+        throw new TypeError("Payload não pode conter outro envelope público da CLI.");
+    }
+    return payload;
+}
+export function criarEnvelopeResultadoCliV1(entrada) {
+    const command = validarComandoCanonico(entrada.comando);
+    const exitCode = validarCodigoSaida(entrada.codigoSaida);
+    const sucesso = exitCode === 0;
+    return {
+        schemaVersion: SCHEMA_RESULTADO_CLI_V1,
+        ok: sucesso,
+        kind: sucesso ? "SUCCESS" : "DOMAIN_ERROR",
+        command,
+        code: sucesso ? "CLI_SUCCESS" : "CLI_DOMAIN_ERROR",
+        message: sucesso ? null : MENSAGEM_PUBLICA_ERRO_DOMINIO,
+        exitCode,
+        payload: interpretarPayloadRuntimeCli(entrada.stdout),
+    };
+}
+//# sourceMappingURL=resultadoCli.js.map

package/dist/saidaCli.d.ts

@@ -0,0 +1,35 @@
+import { type EntradaEnvelopeResultadoCliV1, type EnvelopeResultadoCliV1 } from "./resultadoCli.js";
+export { CODIGO_SAIDA_FATAL_RUNTIME_CLI, SCHEMA_RESULTADO_CLI_V1, criarEnvelopeResultadoCliV1, interpretarPayloadRuntimeCli, type EntradaEnvelopeResultadoCliV1, type EnvelopeResultadoCliV1, type TipoResultadoCliV1, } from "./resultadoCli.js";
+export declare const SCHEMA_CONTROLE_CLI_V1: "sema.cli.control/v1";
+export type TipoControleCli = "HELP" | "UNKNOWN_COMMAND" | "ARGUMENT_ERROR" | "FATAL_ERROR";
+export interface EnvelopeControleJsonV1 {
+    readonly schemaVersion: typeof SCHEMA_CONTROLE_CLI_V1;
+    readonly ok: boolean;
+    readonly kind: TipoControleCli;
+    readonly code: string;
+    readonly message: string;
+    readonly exitCode: number;
+}
+export interface EntradaEnvelopeControleJsonV1 {
+    readonly categoria: TipoControleCli;
+    readonly codigoPublico: string;
+    readonly mensagemPublica: string;
+    readonly codigoSaida: number;
+}
+export interface OpcoesInvocacaoPublica {
+    readonly resultado: TipoControleCli;
+    readonly modoJson: boolean;
+    readonly envelopeControle?: EnvelopeControleJsonV1;
+    readonly mensagemTexto?: string;
+}
+export interface RelatorioInvocacaoPublica {
+    readonly codigoSaida: number;
+    readonly envelopeControleEmitido: boolean;
+    readonly stderrVazio: boolean;
+    readonly handlerExecutado: boolean;
+    readonly politicaControleJsonV1Respeitada: boolean;
+    readonly politicaHelpPuroRespeitada: boolean;
+}
+export declare function criarEnvelopeControleJsonV1(entrada: EntradaEnvelopeControleJsonV1): EnvelopeControleJsonV1;
+export declare function emitirResultadoCliJsonV1(entrada: EntradaEnvelopeResultadoCliV1): EnvelopeResultadoCliV1;
+export declare function executarInvocacaoPublica(opcoes: OpcoesInvocacaoPublica): RelatorioInvocacaoPublica;