@semacode/cli 2.3.1 → 3.5.0

package/node_modules/@sema/gerador-php/dist/index.js

@@ -120,43 +120,43 @@ function coletarTiposExternos(modulo) {
 function gerarClasseDados(nome, campos) {
     const classe = paraPascalCase(nome);
     if (campos.length === 0) {
-        return `final class ${classe}
-{
-    public function __construct()
-    {
-    }
-}
+        return `final class ${classe}
+{
+    public function __construct()
+    {
+    }
+}
 `;
     }
     const parametros = ordenarCamposConstrutor(campos).map((campo) => {
         const tipo = tipoParametroPhp(campo);
         const padrao = campo.modificadores.includes("required") ? "" : ` = ${valorPadraoPhp(campo)}`;
-        return `        /** @var ${tipoDocPhp(campo)} */
+        return `        /** @var ${tipoDocPhp(campo)} */
         public ${tipo} $${campo.nome}${padrao}`;
     }).join(",\n");
-    return `final class ${classe}
-{
-    public function __construct(
-${parametros}
-    ) {
-    }
-}
+    return `final class ${classe}
+{
+    public function __construct(
+${parametros}
+    ) {
+    }
+}
 `;
 }
 function gerarEnum(enumeracao) {
     const constantes = enumeracao.valores.map((valor) => `    public const ${paraConstantePhp(valor)} = ${literalPhp(valor)};`).join("\n");
-    return `final class ${paraPascalCase(enumeracao.nome)}
-{
-${constantes || "    public const VAZIO = \"\";"}
-}
+    return `final class ${paraPascalCase(enumeracao.nome)}
+{
+${constantes || "    public const VAZIO = \"\";"}
+}
 `;
 }
 function gerarLiteralCamposPhp(campos) {
     if (campos.length === 0) {
         return "[]";
     }
-    return `[
-${campos.map((campo) => `        ["nome" => ${literalPhp(campo.nome)}, "tipo" => ${literalPhp(campo.tipo)}, "obrigatorio" => ${campo.modificadores.includes("required") ? "true" : "false"}],`).join("\n")}
+    return `[
+${campos.map((campo) => `        ["nome" => ${literalPhp(campo.nome)}, "tipo" => ${literalPhp(campo.tipo)}, "obrigatorio" => ${campo.modificadores.includes("required") ? "true" : "false"}],`).join("\n")}
     ]`;
 }
 function gerarArrayStringsPhp(valores) {
@@ -170,8 +170,8 @@ function gerarMapaErrosPhp(erros) {
     if (entradas.length === 0) {
         return "[]";
     }
-    return `[
-${entradas.map(([codigo, mensagem]) => `        ${literalPhp(codigo)} => ${literalPhp(mensagem)},`).join("\n")}
+    return `[
+${entradas.map(([codigo, mensagem]) => `        ${literalPhp(codigo)} => ${literalPhp(mensagem)},`).join("\n")}
     ]`;
 }
 function resolverReferenciaPhp(referencia, variavel) {
@@ -248,15 +248,15 @@ function gerarValidacoes(task) {
     const linhas = [
         ...task.input
             .filter((campo) => campo.modificadores.includes("required"))
-            .map((campo) => `    if ($entrada->${campo.nome} === null) {
-        throw new \\InvalidArgumentException(${literalPhp(`Campo obrigatorio ausente: ${campo.nome}`)});
+            .map((campo) => `    if ($entrada->${campo.nome} === null) {
+        throw new \\InvalidArgumentException(${literalPhp(`Campo obrigatorio ausente: ${campo.nome}`)});
     }`),
         ...task.regrasEstruturadas.map((regra) => {
             if (regra.tipo === "predicado") {
                 return `    // Predicado declarado em Sema: ${regra.textoOriginal}`;
             }
-            return `    if (!(${resolverExpressaoPhp(regra, camposEntrada, "entrada")})) {
-        throw new \\InvalidArgumentException(${literalPhp(`Regra violada: ${regra.textoOriginal}`)});
+            return `    if (!(${resolverExpressaoPhp(regra, camposEntrada, "entrada")})) {
+        throw new \\InvalidArgumentException(${literalPhp(`Regra violada: ${regra.textoOriginal}`)});
     }`;
         }),
         ...task.rules
@@ -276,8 +276,8 @@ function gerarGarantias(task) {
             if (!garantiaComparacaoExecutavel(garantia, camposSaidaMap)) {
                 return `    // Garantia condicional declarada em Sema: ${garantia.textoOriginal}`;
             }
-            return `    if (!(${resolverExpressaoPhp(garantia, camposSaida, "saida")})) {
-        throw new \\RuntimeException(${literalPhp(`Garantia violada: ${garantia.textoOriginal}`)});
+            return `    if (!(${resolverExpressaoPhp(garantia, camposSaida, "saida")})) {
+        throw new \\RuntimeException(${literalPhp(`Garantia violada: ${garantia.textoOriginal}`)});
     }`;
         }),
         ...task.guarantees
@@ -300,33 +300,33 @@ function classeErroTask(task, codigo) {
     return `${paraPascalCase(task.nome)}${paraPascalCase(codigo)}Erro`;
 }
 function gerarClassesErro(task) {
-    return [...coletarErrosTask(task).entries()].map(([codigo, mensagem]) => `final class ${classeErroTask(task, codigo)} extends \\RuntimeException
-{
-    public string $codigo = ${literalPhp(codigo)};
-
-    public function __construct()
-    {
-        parent::__construct(${literalPhp(mensagem)});
-    }
-}
+    return [...coletarErrosTask(task).entries()].map(([codigo, mensagem]) => `final class ${classeErroTask(task, codigo)} extends \\RuntimeException
+{
+    public string $codigo = ${literalPhp(codigo)};
+
+    public function __construct()
+    {
+        parent::__construct(${literalPhp(mensagem)});
+    }
+}
 `).join("\n");
 }
 function gerarMetadadosTask(task) {
     const nome = normalizarNomeParaSimbolo(task.nome);
     const efeitos = task.efeitosEstruturados.map((efeito) => `${efeito.categoria}:${efeito.alvo}${efeito.detalhe ? `:${efeito.detalhe}` : ""}`);
     const impl = task.implementacoesExternas.map((item) => `${item.origem}:${item.caminho}[${item.statusImpl ?? "nao_verificado"}]`);
-    return `function contrato_${nome}(): array
-{
-    return [
-        "nome" => ${literalPhp(task.nome)},
-        "input" => ${gerarLiteralCamposPhp(task.input)},
-        "output" => ${gerarLiteralCamposPhp(task.output)},
-        "effects" => ${gerarArrayStringsPhp(efeitos)},
-        "impl" => ${gerarArrayStringsPhp(impl)},
-        "errors" => ${gerarMapaErrosPhp(Object.fromEntries(coletarErrosTask(task)))},
-        "guarantees" => ${gerarArrayStringsPhp(task.guarantees)},
-    ];
-}
+    return `function contrato_${nome}(): array
+{
+    return [
+        "nome" => ${literalPhp(task.nome)},
+        "input" => ${gerarLiteralCamposPhp(task.input)},
+        "output" => ${gerarLiteralCamposPhp(task.output)},
+        "effects" => ${gerarArrayStringsPhp(efeitos)},
+        "impl" => ${gerarArrayStringsPhp(impl)},
+        "errors" => ${gerarMapaErrosPhp(Object.fromEntries(coletarErrosTask(task)))},
+        "guarantees" => ${gerarArrayStringsPhp(task.guarantees)},
+    ];
+}
 `;
 }
 function gerarPreparacaoSaida(task) {
@@ -348,37 +348,37 @@ function gerarPreparacaoSaida(task) {
 function gerarTask(task) {
     const nome = normalizarNomeParaSimbolo(task.nome);
     const erros = [...coletarErrosTask(task).keys()];
-    const blocosErroContexto = erros.map((codigo) => `    if (($contexto["erro_esperado"] ?? null) === ${literalPhp(codigo)}) {
-        throw new ${classeErroTask(task, codigo)}();
+    const blocosErroContexto = erros.map((codigo) => `    if (($contexto["erro_esperado"] ?? null) === ${literalPhp(codigo)}) {
+        throw new ${classeErroTask(task, codigo)}();
     }`).join("\n");
     const efeitos = task.efeitosEstruturados.length > 0
         ? task.efeitosEstruturados.map((efeito) => `    // Efeito estruturado: categoria=${efeito.categoria} alvo=${efeito.alvo}${efeito.detalhe ? ` detalhe=${efeito.detalhe}` : ""}${efeito.criticidade ? ` criticidade=${efeito.criticidade}` : ""}`).join("\n")
         : task.effects.map((efeito) => `    // Efeito declarado: ${efeito}`).join("\n") || "    // Nenhum efeito declarado.";
-    return `
-${gerarClasseDados(`${task.nome}_entrada`, task.input)}
-${gerarClasseDados(`${task.nome}_saida`, task.output)}
-${gerarClassesErro(task)}
-${gerarMetadadosTask(task)}
-
-function validar_${nome}(${paraPascalCase(`${task.nome}_entrada`)} $entrada): void
-{
-${gerarValidacoes(task)}
-}
-
-function verificar_garantias_${nome}(${paraPascalCase(`${task.nome}_saida`)} $saida): void
-{
-${gerarGarantias(task)}
-}
-
-function executar_${nome}(${paraPascalCase(`${task.nome}_entrada`)} $entrada, array $contexto = []): ${paraPascalCase(`${task.nome}_saida`)}
-{
-${blocosErroContexto ? `${blocosErroContexto}\n` : ""}    validar_${nome}($entrada);
-${task.stateContract ? `    // Vinculo de estado: ${task.stateContract.nomeEstado ?? "nao_definido"}\n    // Transicoes declaradas: ${task.stateContract.transicoes.map((transicao) => `${transicao.origem}->${transicao.destino}`).join(", ") || "nenhuma"}\n` : ""}${task.implementacoesExternas.map((impl) => `    // Implementacao externa: origem=${impl.origem} caminho=${impl.caminho} status=${impl.statusImpl ?? "nao_verificado"}`).join("\n")}
-${efeitos}
-${gerarPreparacaoSaida(task)}
-    verificar_garantias_${nome}($saida);
-    return $saida;
-}
+    return `
+${gerarClasseDados(`${task.nome}_entrada`, task.input)}
+${gerarClasseDados(`${task.nome}_saida`, task.output)}
+${gerarClassesErro(task)}
+${gerarMetadadosTask(task)}
+
+function validar_${nome}(${paraPascalCase(`${task.nome}_entrada`)} $entrada): void
+{
+${gerarValidacoes(task)}
+}
+
+function verificar_garantias_${nome}(${paraPascalCase(`${task.nome}_saida`)} $saida): void
+{
+${gerarGarantias(task)}
+}
+
+function executar_${nome}(${paraPascalCase(`${task.nome}_entrada`)} $entrada, array $contexto = []): ${paraPascalCase(`${task.nome}_saida`)}
+{
+${blocosErroContexto ? `${blocosErroContexto}\n` : ""}    validar_${nome}($entrada);
+${task.stateContract ? `    // Vinculo de estado: ${task.stateContract.nomeEstado ?? "nao_definido"}\n    // Transicoes declaradas: ${task.stateContract.transicoes.map((transicao) => `${transicao.origem}->${transicao.destino}`).join(", ") || "nenhuma"}\n` : ""}${task.implementacoesExternas.map((impl) => `    // Implementacao externa: origem=${impl.origem} caminho=${impl.caminho} status=${impl.statusImpl ?? "nao_verificado"}`).join("\n")}
+${efeitos}
+${gerarPreparacaoSaida(task)}
+    verificar_garantias_${nome}($saida);
+    return $saida;
+}
 `;
 }
 function formatarLiteralTestePhp(valor, tipoDeclarado) {
@@ -453,45 +453,45 @@ function gerarTestesPhp(modulo, arquivoModulo) {
         const entrada = gerarInstanciaEntradaTeste(task, caso.given);
         const tipoErro = caso.error?.campos.find((campo) => campo.nome === "tipo")?.tipo ?? caso.error?.campos[0]?.tipo;
         if (tipoErro) {
-            return `function ${nomeTeste}(): void
-{
-    try {
-        executar_${normalizarNomeParaSimbolo(task.nome)}(${entrada}, ["erro_esperado" => ${literalPhp(tipoErro)}]);
-    } catch (${classeErroTask(task, tipoErro)} $erro) {
-        assert_sema($erro->codigo === ${literalPhp(tipoErro)}, "codigo de erro inesperado");
-        return;
-    }
-    throw new \\RuntimeException(${literalPhp(`Caso ${caso.nome} deveria falhar com ${tipoErro}`)});
+            return `function ${nomeTeste}(): void
+{
+    try {
+        executar_${normalizarNomeParaSimbolo(task.nome)}(${entrada}, ["erro_esperado" => ${literalPhp(tipoErro)}]);
+    } catch (${classeErroTask(task, tipoErro)} $erro) {
+        assert_sema($erro->codigo === ${literalPhp(tipoErro)}, "codigo de erro inesperado");
+        return;
+    }
+    throw new \\RuntimeException(${literalPhp(`Caso ${caso.nome} deveria falhar com ${tipoErro}`)});
 }`;
         }
-        return `function ${nomeTeste}(): void
-{
-    $resultado = executar_${normalizarNomeParaSimbolo(task.nome)}(${entrada});
-    assert_sema($resultado !== null, ${literalPhp(`Caso ${caso.nome} nao retornou resultado`)});
+        return `function ${nomeTeste}(): void
+{
+    $resultado = executar_${normalizarNomeParaSimbolo(task.nome)}(${entrada});
+    assert_sema($resultado !== null, ${literalPhp(`Caso ${caso.nome} nao retornou resultado`)});
 }`;
     });
     const lista = testes.map(({ task, caso, indice }) => `    [${literalPhp(caso.nome)}, "test_${normalizarNomeParaSimbolo(task.nome)}_${indice + 1}"],`).join("\n");
-    return `${gerarCabecalhoSemaPhp(modulo, "teste")}require_once __DIR__ . "/${path.posix.basename(arquivoModulo)}";
-
-function assert_sema(bool $condicao, string $mensagem): void
-{
-    if (!$condicao) {
-        throw new \\RuntimeException($mensagem);
-    }
-}
-
-${funcoes.join("\n\n")}
-
-$testes = [
-${lista}
-];
-
-foreach ($testes as [$nome, $funcao]) {
-    fwrite(STDOUT, "test " . $nome . PHP_EOL);
-    $funcao();
-}
-
-fwrite(STDOUT, "ok " . count($testes) . " testes" . PHP_EOL);
+    return `${gerarCabecalhoSemaPhp(modulo, "teste")}require_once __DIR__ . "/${path.posix.basename(arquivoModulo)}";
+
+function assert_sema(bool $condicao, string $mensagem): void
+{
+    if (!$condicao) {
+        throw new \\RuntimeException($mensagem);
+    }
+}
+
+${funcoes.join("\n\n")}
+
+$testes = [
+${lista}
+];
+
+foreach ($testes as [$nome, $funcao]) {
+    fwrite(STDOUT, "test " . $nome . PHP_EOL);
+    $funcao();
+}
+
+fwrite(STDOUT, "ok " . count($testes) . " testes" . PHP_EOL);
 `;
 }
 function gerarCabecalhoSemaPhp(modulo, tipo = "contrato") {
@@ -516,9 +516,9 @@ export function gerarPhp(modulo) {
     const nomeBase = normalizarNomeModulo(modulo.nome).replace(/\./g, "_");
     const estrutura = descreverEstruturaModulo(modulo.nome);
     const interops = modulo.interoperabilidades.map((interop) => `// Interop externo ${interop.origem}: ${interop.caminho}`).join("\n");
-    const tiposExternos = coletarTiposExternos(modulo).map((tipo) => `final class ${paraPascalCase(tipo)}
-{
-}
+    const tiposExternos = coletarTiposExternos(modulo).map((tipo) => `final class ${paraPascalCase(tipo)}
+{
+}
 `).join("\n");
     const tipos = modulo.types.map((tipo) => gerarClasseDados(tipo.nome, tipo.definicao.campos)).join("\n");
     const entidades = modulo.entities.map((entity) => gerarClasseDados(entity.nome, entity.campos)).join("\n");

package/node_modules/@sema/nucleo/dist/ir/conversor.part01.js

@@ -242,53 +242,52 @@ export function converterDatabase(database) {
             .filter((item) => Boolean(item)),
     };
 }
+const ORIGENS_INTEROP_IMPLEMENTACAO = {
+    ts: "ts",
+    typescript: "ts",
+    js: "js",
+    javascript: "js",
+    py: "py",
+    python: "py",
+    dart: "dart",
+    lua: "lua",
+    cs: "cs",
+    csharp: "cs",
+    dotnet: "cs",
+    java: "java",
+    go: "go",
+    golang: "go",
+    rust: "rust",
+    rs: "rust",
+    cpp: "cpp",
+    cxx: "cpp",
+    cc: "cpp",
+    "c++": "cpp",
+    php: "php",
+};
+const PAPEIS_IMPLEMENTACAO_IR = new Set(["rota", "servico", "persistencia", "repositorio"]);
 export function converterImplementacoes(bloco) {
     const implementacoes = [];
     for (const campo of bloco?.campos ?? []) {
-        const origem = campo.nome.toLowerCase();
-        if (origem === "ts" || origem === "typescript") {
-            implementacoes.push({ origem: "ts", caminho: campo.valor, resolucaoImpl: campo.valor, statusImpl: "nao_verificado" });
+        const segmentos = campo.nome.toLowerCase().split("_");
+        if (segmentos.length > 2) {
             continue;
         }
-        if (origem === "js" || origem === "javascript") {
-            implementacoes.push({ origem: "js", caminho: campo.valor, resolucaoImpl: campo.valor, statusImpl: "nao_verificado" });
+        const origem = ORIGENS_INTEROP_IMPLEMENTACAO[segmentos[0] ?? ""];
+        if (!origem) {
             continue;
         }
-        if (origem === "py" || origem === "python") {
-            implementacoes.push({ origem: "py", caminho: campo.valor, resolucaoImpl: campo.valor, statusImpl: "nao_verificado" });
+        const papel = segmentos[1];
+        if (papel !== undefined && !PAPEIS_IMPLEMENTACAO_IR.has(papel)) {
             continue;
         }
-        if (origem === "dart") {
-            implementacoes.push({ origem: "dart", caminho: campo.valor, resolucaoImpl: campo.valor, statusImpl: "nao_verificado" });
-            continue;
-        }
-        if (origem === "lua") {
-            implementacoes.push({ origem: "lua", caminho: campo.valor, resolucaoImpl: campo.valor, statusImpl: "nao_verificado" });
-            continue;
-        }
-        if (origem === "cs" || origem === "csharp" || origem === "dotnet") {
-            implementacoes.push({ origem: "cs", caminho: campo.valor, resolucaoImpl: campo.valor, statusImpl: "nao_verificado" });
-            continue;
-        }
-        if (origem === "java") {
-            implementacoes.push({ origem: "java", caminho: campo.valor, resolucaoImpl: campo.valor, statusImpl: "nao_verificado" });
-            continue;
-        }
-        if (origem === "go" || origem === "golang") {
-            implementacoes.push({ origem: "go", caminho: campo.valor, resolucaoImpl: campo.valor, statusImpl: "nao_verificado" });
-            continue;
-        }
-        if (origem === "rust" || origem === "rs") {
-            implementacoes.push({ origem: "rust", caminho: campo.valor, resolucaoImpl: campo.valor, statusImpl: "nao_verificado" });
-            continue;
-        }
-        if (origem === "cpp" || origem === "cxx" || origem === "cc" || origem === "c++") {
-            implementacoes.push({ origem: "cpp", caminho: campo.valor, resolucaoImpl: campo.valor, statusImpl: "nao_verificado" });
-            continue;
-        }
-        if (origem === "php") {
-            implementacoes.push({ origem: "php", caminho: campo.valor, resolucaoImpl: campo.valor, statusImpl: "nao_verificado" });
-        }
+        implementacoes.push({
+            origem,
+            papel: papel,
+            caminho: campo.valor,
+            resolucaoImpl: campo.valor,
+            statusImpl: "nao_verificado",
+        });
     }
     return implementacoes;
 }

package/node_modules/@sema/nucleo/dist/ir/modelos.d.ts

@@ -24,6 +24,7 @@ export interface IrCampo {
 export interface IrImplementacaoTask {
     origem: "ts" | "js" | "py" | "dart" | "lua" | "cs" | "java" | "go" | "rust" | "cpp" | "php";
     caminho: string;
+    papel?: "rota" | "servico" | "persistencia" | "repositorio";
     origemArquivo?: string;
     origemSimbolo?: string;
     resolucaoImpl?: string;

package/node_modules/@sema/nucleo/dist/semantico/analisador.d.ts

@@ -1,3 +1,4 @@
 export { SimboloSemantico, CampoSemantico, ErroSemanticoTask, ResumoTaskSemantico, InteropSemantico, ImplementacaoTaskSemantica, ContextoSemantico, ResultadoSemantico, OpcoesAnaliseSemantica } from "./analisador.part01.js";
 export { criarContextoLocal, validarTesteSemanticoForte, emitirDiagnosticosContratoFrouxo } from "./analisador.part07.js";
+export { listarCandidatosUseRelativo } from "./analisador.part04.js";
 export { analisarSemantica } from "./analisador.part08.js";

package/node_modules/@sema/nucleo/dist/semantico/analisador.js

@@ -1,3 +1,4 @@
 export { criarContextoLocal, validarTesteSemanticoForte, emitirDiagnosticosContratoFrouxo } from "./analisador.part07.js";
+export { listarCandidatosUseRelativo } from "./analisador.part04.js";
 export { analisarSemantica } from "./analisador.part08.js";
 //# sourceMappingURL=analisador.js.map

package/node_modules/@sema/nucleo/dist/semantico/analisador.part01.d.ts

@@ -32,6 +32,7 @@ export interface InteropSemantico {
 export interface ImplementacaoTaskSemantica {
     origem: "ts" | "js" | "py" | "dart" | "lua" | "cs" | "java" | "go" | "rust" | "cpp" | "php";
     caminho: string;
+    papel?: "rota" | "servico" | "persistencia" | "repositorio";
 }
 export interface ContextoSemantico {
     modulo: string;
@@ -83,6 +84,12 @@ export declare function converterCampoSemantico(campo: CampoAst): CampoSemantico
 export declare function indicesCampos(campos: CampoSemantico[]): Map<string, CampoSemantico>;
 export declare function indiceErros(erros: ErroSemanticoTask[]): Map<string, ErroSemanticoTask>;
 export declare function coletarErrosTask(task: TaskAst): ErroSemanticoTask[];
+export declare const PAPEIS_IMPLEMENTACAO_SUPORTADOS: Set<"servico" | "persistencia" | "rota" | "repositorio">;
+export interface NomeCampoImplementacao {
+    origem: ImplementacaoTaskSemantica["origem"];
+    papel?: ImplementacaoTaskSemantica["papel"];
+}
+export declare function normalizarNomeCampoImplementacao(valor: string): NomeCampoImplementacao | undefined;
 export declare function coletarResumoTask(task: TaskAst): ResumoTaskSemantico;
 export declare function validarImplementacoesTask(task: TaskAst, diagnosticos: Diagnostico[]): void;
 export declare function validarVinculos(bloco: BlocoGenericoAst | undefined, diagnosticos: Diagnostico[], contexto: string): void;

package/node_modules/@sema/nucleo/dist/semantico/analisador.part01.js

@@ -236,6 +236,25 @@ export function coletarErrosTask(task) {
     }
     return [...erros.values()];
 }
+export const PAPEIS_IMPLEMENTACAO_SUPORTADOS = new Set(["rota", "servico", "persistencia", "repositorio"]);
+export function normalizarNomeCampoImplementacao(valor) {
+    const segmentos = valor.toLowerCase().split("_");
+    if (segmentos.length > 2) {
+        return undefined;
+    }
+    const origem = normalizarOrigemImplementacao(segmentos[0] ?? "");
+    if (!origem) {
+        return undefined;
+    }
+    const papel = segmentos[1];
+    if (papel === undefined) {
+        return { origem };
+    }
+    if (!PAPEIS_IMPLEMENTACAO_SUPORTADOS.has(papel)) {
+        return undefined;
+    }
+    return { origem, papel: papel };
+}
 export function coletarResumoTask(task) {
     return {
         input: (task.input?.campos ?? []).map(converterCampoSemantico),
@@ -244,8 +263,10 @@ export function coletarResumoTask(task) {
         guarantees: (task.guarantees?.linhas ?? []).map((linha) => linha.conteudo),
         implementacoes: (task.impl?.campos ?? [])
             .map((campo) => {
-            const origem = normalizarOrigemImplementacao(campo.nome);
-            return origem ? { origem, caminho: campo.valor } : undefined;
+            const nome = normalizarNomeCampoImplementacao(campo.nome);
+            return nome
+                ? { origem: nome.origem, ...(nome.papel ? { papel: nome.papel } : {}), caminho: campo.valor }
+                : undefined;
         })
             .filter((item) => Boolean(item)),
     };
@@ -254,20 +275,22 @@ export function validarImplementacoesTask(task, diagnosticos) {
     if (!task.impl) {
         return;
     }
-    const origens = new Set();
+    const chaves = new Set();
     for (const campo of task.impl.campos) {
-        const origem = normalizarOrigemImplementacao(campo.nome);
-        if (!origem) {
-            diagnosticos.push(criarDiagnostico("SEM059", `Task "${task.nome}" declarou implementacao externa invalida em impl: "${campo.nome}".`, "erro", campo.intervalo, "Use apenas ts, js, py, dart, lua, cs, java, go, rust, cpp ou php dentro do bloco impl."));
+        const nome = normalizarNomeCampoImplementacao(campo.nome);
+        if (!nome) {
+            diagnosticos.push(criarDiagnostico("SEM059", `Task "${task.nome}" declarou implementacao externa invalida em impl: "${campo.nome}".`, "erro", campo.intervalo, "Use ts, js, py, dart, lua, cs, java, go, rust, cpp ou php, opcionalmente com papel: ts_rota, ts_servico, ts_persistencia ou ts_repositorio."));
             continue;
         }
-        if (origens.has(origem)) {
-            diagnosticos.push(criarDiagnostico("SEM060", `Task "${task.nome}" declarou mais de uma implementacao ${origem} no bloco impl.`, "erro", campo.intervalo, "Cada origem externa deve aparecer no maximo uma vez dentro de impl."));
+        const rotulo = nome.papel ? `${nome.origem}_${nome.papel}` : nome.origem;
+        const chave = `${nome.origem}:${nome.papel ?? "-"}`;
+        if (chaves.has(chave)) {
+            diagnosticos.push(criarDiagnostico("SEM060", `Task "${task.nome}" declarou mais de uma implementacao ${rotulo} no bloco impl.`, "erro", campo.intervalo, "Cada combinacao de origem e papel deve aparecer no maximo uma vez; use papeis distintos como ts_rota e ts_servico para camadas diferentes."));
             continue;
         }
-        origens.add(origem);
+        chaves.add(chave);
         if (!PADRAO_CAMINHO_INTEROP.test(campo.valor)) {
-            diagnosticos.push(criarDiagnostico("SEM061", `Task "${task.nome}" declarou caminho invalido para impl ${origem}: "${campo.valor}".`, "erro", campo.intervalo, "Use um identificador de implementacao como pacote.modulo.funcao ou app.servico.metodo."));
+            diagnosticos.push(criarDiagnostico("SEM061", `Task "${task.nome}" declarou caminho invalido para impl ${rotulo}: "${campo.valor}".`, "erro", campo.intervalo, "Use um identificador de implementacao como pacote.modulo.funcao ou app.servico.metodo."));
         }
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@semacode/cli",
-  "version": "2.3.1",
+  "version": "3.5.0",
   "description": "Codex-native local semantic governance CLI for contracts, drift, impact, documentation gates, and code generation.",
   "type": "module",
   "icon": "logo.png",
@@ -34,7 +34,7 @@
     "access": "public"
   },
   "bin": {
-    "sema": "dist/index.js"
+    "sema": "dist/bin.js"
   },
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -45,10 +45,15 @@
       "default": "./dist/index.js"
     }
   },
+  "scripts": {
+    "postinstall": "node scripts/postinstall.mjs"
+  },
   "files": [
     "dist",
     "docs",
     "exemplos",
+    "skills",
+    "scripts/postinstall.mjs",
     "logo.png",
     "README.md",
     "LICENSE"
@@ -63,8 +68,8 @@
     "@sema/gerador-html": "1.5.53",
     "@sema/gerador-css": "1.5.53",
     "@sema/gerador-php": "1.5.55",
-    "@sema/gerador-dotnet": "2.3.1",
-    "@sema/gerador-cpp": "2.3.1",
+    "@sema/gerador-dotnet": "2.1.0",
+    "@sema/gerador-cpp": "2.1.0",
     "@sema/padroes": "1.5.53",
     "typescript": "^5.8.3"
   },