@maestro-ai/mcp-server 2.6.1 → 5.0.0

package/dist/stdio.js

@@ -5,46 +5,73 @@
  * Uso: node dist/stdio.js [diretorio]
  * Ou via npx após publicar no npm
  *
- * Se nenhum diretório for fornecido, usa o diretório de trabalho atual
+ * v5: Skills como MCP Resources, MCP Prompts capability,
+ *     tools consolidadas (8 públicas + legadas backward-compatible)
+ *
+ * NOTA: Usa router centralizado (router.ts) para roteamento de tools.
+ * Não duplicar switch/case aqui - todas as tools são registradas no router.
  */
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { ListResourcesRequestSchema, ReadResourceRequestSchema, ListToolsRequestSchema, CallToolRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { ListResourcesRequestSchema, ReadResourceRequestSchema, ListToolsRequestSchema, CallToolRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
 import { listarEspecialistas, listarTemplates, listarGuias, lerEspecialista, lerTemplate, lerGuia, lerPrompt, setProjectDirectory, } from "./utils/files.js";
-import { iniciarProjeto, confirmarProjeto } from "./tools/iniciar-projeto.js";
-import { carregarProjeto } from "./tools/carregar-projeto.js";
-import { proximo } from "./tools/proximo.js";
-import { status } from "./tools/status.js";
-import { validarGate } from "./tools/validar-gate.js";
-import { contexto } from "./tools/contexto.js";
-import { classificar } from "./tools/classificar.js";
-import { salvar } from "./tools/salvar.js";
-import { injetar_conteudo } from "./tools/injetar-conteudo.js";
-// 🆕 FASE 1: Knowledge Base
-import { recordADR, recordADRSchema, recordPattern, recordPatternSchema, getContext, getContextSchema, searchKnowledge, searchKnowledgeSchema, } from "./tools/fase1/knowledge.tools.js";
-// 🆕 FASE 1: Checkpoint
-import { createCheckpoint, createCheckpointSchema, rollbackTotal, rollbackTotalSchema, rollbackPartial, rollbackPartialSchema, listCheckpoints, listCheckpointsSchema, } from "./tools/fase1/checkpoint.tools.js";
-// 🆕 FASE 1: Validation
-import { validateDependencies, validateDependenciesSchema, validateSecurity, validateSecuritySchema, checkCompliance, checkComplianceSchema, } from "./tools/fase1/validation.tools.js";
-// 🆕 FASE 1: Risk, AutoFix, Discovery
-import { evaluateRisk, evaluateRiskSchema, autoFix, autoFixSchema, discoverCodebase, discoverCodebaseSchema, } from "./tools/fase1/misc.tools.js";
+import { routeToolCall, getRegisteredTools, getToolCount } from "./router.js";
+import { ContentResolverService } from "./services/content-resolver.service.js";
+import { SkillLoaderService } from "./services/skill-loader.service.js";
+import { createStateService } from "./services/state.service.js";
+import { getSpecialistPersona } from "./services/specialist.service.js";
+import { getFaseComStitch } from "./flows/types.js";
 // Criar servidor MCP
 const server = new Server({
     name: "mcp-maestro",
-    version: "1.0.0",
+    version: "5.0.0",
 }, {
     capabilities: {
         resources: {},
         tools: {},
+        prompts: {},
     },
 });
-// ==================== RESOURCES ====================
+// ==================== RESOURCES (v5: Skills expandidas) ====================
 server.setRequestHandler(ListResourcesRequestSchema, async () => {
     const especialistas = await listarEspecialistas();
     const templates = await listarTemplates();
     const guias = await listarGuias();
+    // v5: Listar skills como resources estruturados
+    const contentResolver = new ContentResolverService(projectsDir);
+    const skills = await contentResolver.listAvailableSkills();
+    const skillResources = [];
+    for (const skillName of skills) {
+        // SKILL.md principal
+        skillResources.push({
+            uri: `maestro://skills/${skillName}/SKILL.md`,
+            name: `Skill: ${skillName}`,
+            mimeType: "text/markdown",
+        });
+        // Templates da skill
+        const skillTemplates = await contentResolver.listSkillResources(skillName, "templates");
+        for (const t of skillTemplates) {
+            skillResources.push({
+                uri: `maestro://skills/${skillName}/templates/${t}`,
+                name: `${skillName} Template: ${t}`,
+                mimeType: "text/markdown",
+            });
+        }
+        // Checklists da skill
+        const checklists = await contentResolver.listSkillResources(skillName, "checklists");
+        for (const c of checklists) {
+            skillResources.push({
+                uri: `maestro://skills/${skillName}/checklists/${c}`,
+                name: `${skillName} Checklist: ${c}`,
+                mimeType: "text/markdown",
+            });
+        }
+    }
     return {
         resources: [
+            // v5: Skills estruturadas (prioridade)
+            ...skillResources,
+            // Legacy: especialistas, templates, guias
             ...especialistas.map((e) => ({
                 uri: `maestro://especialista/${encodeURIComponent(e)}`,
                 name: `Especialista: ${e}`,
@@ -70,6 +97,30 @@ server.setRequestHandler(ListResourcesRequestSchema, async () => {
 });
 server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
     const { uri } = request.params;
+    // v5: Skills como resources
+    if (uri.startsWith("maestro://skills/")) {
+        const path = uri.replace("maestro://skills/", "");
+        const parts = path.split("/");
+        const skillName = parts[0];
+        const contentResolver = new ContentResolverService(projectsDir);
+        if (parts.length === 2 && parts[1] === "SKILL.md") {
+            // maestro://skills/{skill}/SKILL.md
+            const content = await contentResolver.readSkillFile(skillName, "SKILL.md");
+            if (!content)
+                throw new Error(`SKILL.md não encontrado: ${skillName}`);
+            return { contents: [{ uri, mimeType: "text/markdown", text: content }] };
+        }
+        if (parts.length === 3) {
+            // maestro://skills/{skill}/{tipo}/{arquivo}
+            const tipo = parts[1];
+            const arquivo = parts[2];
+            const content = await contentResolver.readSkillResource(skillName, tipo, arquivo);
+            if (!content)
+                throw new Error(`Resource não encontrado: ${uri}`);
+            return { contents: [{ uri, mimeType: "text/markdown", text: content }] };
+        }
+    }
+    // Legacy: especialistas
     if (uri.startsWith("maestro://especialista/")) {
         const nome = decodeURIComponent(uri.replace("maestro://especialista/", ""));
         const conteudo = await lerEspecialista(nome);
@@ -92,445 +143,286 @@ server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
         return { contents: [{ uri, mimeType: "text/markdown", text: conteudo }] };
     }
     if (uri === "maestro://system-prompt") {
-        const conteudo = `# Maestro - Instruções para IA (Modo Stateless)
+        const conteudo = `# Maestro v5 — Instruções para IA
 
-Você está usando o Maestro, um guia de desenvolvimento assistido por IA.
+Você está usando o Maestro v5, um orquestrador de desenvolvimento assistido por IA.
 
-## Modo Stateless
+## Modo Híbrido (v5)
 
-Este MCP opera em modo stateless. A IA deve:
-1. Ler arquivos de estado do projeto (.maestro/estado.json)
-2. Passar o conteúdo como parâmetro nas chamadas de tools
-3. Salvar os arquivos retornados no campo \`files\` das respostas
+O Maestro v5 opera em modo híbrido:
+- **Estado carregado automaticamente** de .maestro/estado.json (não precisa passar como parâmetro)
+- **Skills injetadas ativamente** nas respostas das tools (não precisa ler manualmente)
+- **Persistência automática** — o MCP salva estado e arquivos diretamente
+- **Fallback stateless** — estado_json como parâmetro ainda aceito para compatibilidade
 
 ## Comportamentos Automáticos
 
 Quando o usuário disser "próximo", "avançar", "terminei" ou "pronto":
-1. Leia .maestro/estado.json do projeto
-2. Identifique o entregável desenvolvido
-3. Chame \`proximo\` passando entregavel, estado_json e diretorio
-4. Salve os arquivos retornados
+1. Chame \`avancar(diretorio: "<path>")\`
+2. O Maestro detecta contexto automaticamente
+3. O contexto do especialista já vem incluído na resposta
+4. Siga as instruções do especialista e template retornados
 
-## Tools Disponíveis (Stateless)
+## Tools Disponíveis (v5 Consolidadas)
 
-- \`iniciar_projeto(nome, diretorio)\` - Inicia novo projeto
-- \`carregar_projeto(estado_json, diretorio)\` - Carrega projeto existente
-- \`proximo(entregavel, estado_json, diretorio)\` - Salva e avança fase
-- \`status(estado_json, diretorio)\` - Retorna estado atual
-- \`validar_gate(estado_json, diretorio)\` - Valida checklist
-- \`classificar(estado_json, diretorio)\` - Reclassifica projeto
-- \`contexto(estado_json, diretorio)\` - Retorna contexto
-- \`salvar(conteudo, tipo, estado_json, diretorio)\` - Salva rascunhos/anexos
+| Tool | Descrição |
+|------|-----------|
+| \`maestro(diretorio)\` | Entry point inteligente — detecta contexto e guia |
+| \`avancar(diretorio, entregavel?)\` | Avança fase (onboarding ou desenvolvimento) |
+| \`status(diretorio)\` | Status completo do projeto |
+| \`validar(diretorio, tipo?)\` | Valida gate, entregável ou compliance |
+| \`contexto(diretorio)\` | Contexto acumulado (ADRs, padrões) |
+| \`salvar(diretorio, conteudo, tipo)\` | Salva rascunhos/anexos |
+| \`checkpoint(diretorio, acao)\` | Gerencia checkpoints e rollbacks |
+| \`analisar(diretorio, tipo?)\` | Análise de código (segurança, qualidade, etc.) |
+
+> **Nota:** Tools legadas (proximo, validar_gate, etc.) ainda funcionam para backward compatibility.
 `;
         return { contents: [{ uri, mimeType: "text/markdown", text: conteudo }] };
     }
     throw new Error(`Resource não encontrado: ${uri}`);
 });
-// ==================== TOOLS ====================
-server.setRequestHandler(ListToolsRequestSchema, async () => ({
-    tools: [
-        {
-            name: "iniciar_projeto",
-            description: "Inicia novo projeto (stateless). Retorna arquivos para IA salvar.",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    nome: { type: "string", description: "Nome do projeto" },
-                    descricao: { type: "string", description: "Descrição opcional" },
-                    diretorio: { type: "string", description: "Diretório absoluto do projeto" },
-                    ide: { type: "string", enum: ["windsurf", "cursor", "antigravity"], description: "IDE alvo para injection" },
-                },
-                required: ["nome", "diretorio"],
-            },
-        },
-        {
-            name: "confirmar_projeto",
-            description: "Confirma criação do projeto com tipo e complexidade. Injeta conteúdo automaticamente.",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    nome: { type: "string", description: "Nome do projeto" },
-                    descricao: { type: "string", description: "Descrição opcional" },
-                    diretorio: { type: "string", description: "Diretório absoluto do projeto" },
-                    tipo_artefato: { type: "string", enum: ["poc", "script", "internal", "product"], description: "Tipo de artefato" },
-                    nivel_complexidade: { type: "string", enum: ["simples", "medio", "complexo"], description: "Nível de complexidade" },
-                    ide: { type: "string", enum: ["windsurf", "cursor", "antigravity"], description: "IDE alvo para injection" },
-                },
-                required: ["nome", "diretorio", "tipo_artefato", "nivel_complexidade", "ide"],
-            },
-        },
-        {
-            name: "carregar_projeto",
-            description: "Carrega projeto existente (stateless). Requer estado_json.",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    estado_json: { type: "string", description: "Conteúdo de .maestro/estado.json" },
-                    diretorio: { type: "string", description: "Diretório do projeto" },
-                },
-                required: ["estado_json", "diretorio"],
-            },
-        },
-        {
-            name: "proximo",
-            description: "Salva entregável e avança fase (stateless). Requer estado_json.",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    entregavel: { type: "string", description: "Conteúdo do entregável" },
-                    estado_json: { type: "string", description: "Conteúdo de .maestro/estado.json" },
-                    diretorio: { type: "string", description: "Diretório do projeto" },
-                    nome_arquivo: { type: "string", description: "Nome do arquivo" },
-                },
-                required: ["entregavel", "estado_json", "diretorio"],
-            },
-        },
-        {
-            name: "status",
-            description: "Retorna status do projeto (stateless). Requer estado_json.",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    estado_json: { type: "string", description: "Conteúdo de .maestro/estado.json" },
-                    diretorio: { type: "string", description: "Diretório do projeto" },
-                },
-                required: ["estado_json", "diretorio"],
-            },
-        },
-        {
-            name: "validar_gate",
-            description: "Valida checklist de saída (stateless). Requer estado_json.",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    fase: { type: "number", description: "Número da fase" },
-                    entregavel: { type: "string", description: "Conteúdo para validar" },
-                    estado_json: { type: "string", description: "Conteúdo de .maestro/estado.json" },
-                    diretorio: { type: "string", description: "Diretório do projeto" },
-                },
-                required: ["estado_json", "diretorio"],
-            },
-        },
-        {
-            name: "contexto",
-            description: "Retorna contexto do projeto (stateless). Requer estado_json.",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    estado_json: { type: "string", description: "Conteúdo de .maestro/estado.json" },
-                    diretorio: { type: "string", description: "Diretório do projeto" },
-                },
-                required: ["estado_json", "diretorio"],
-            },
-        },
-        {
-            name: "classificar",
-            description: "Reclassifica complexidade (stateless). Requer estado_json.",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    prd: { type: "string", description: "Conteúdo do PRD" },
-                    nivel: { type: "string", enum: ["simples", "medio", "complexo"] },
-                    estado_json: { type: "string", description: "Conteúdo de .maestro/estado.json" },
-                    diretorio: { type: "string", description: "Diretório do projeto" },
-                },
-                required: ["estado_json", "diretorio"],
+// ==================== PROMPTS (v5: System Prompt Automático) ====================
+server.setRequestHandler(ListPromptsRequestSchema, async () => {
+    return {
+        prompts: [
+            {
+                name: "maestro-specialist",
+                description: "Persona + instruções do especialista da fase atual do projeto",
+                arguments: [
+                    {
+                        name: "diretorio",
+                        description: "Diretório do projeto",
+                        required: true,
+                    },
+                ],
             },
-        },
-        {
-            name: "salvar",
-            description: "Salva conteúdo (stateless). Requer estado_json.",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    conteudo: { type: "string", description: "Conteúdo a salvar" },
-                    tipo: { type: "string", enum: ["rascunho", "anexo", "entregavel"] },
-                    estado_json: { type: "string", description: "Conteúdo de .maestro/estado.json" },
-                    diretorio: { type: "string", description: "Diretório do projeto" },
-                },
-                required: ["conteudo", "tipo", "estado_json", "diretorio"],
+            {
+                name: "maestro-context",
+                description: "Contexto completo do projeto para a sessão de trabalho",
+                arguments: [
+                    {
+                        name: "diretorio",
+                        description: "Diretório do projeto",
+                        required: true,
+                    },
+                ],
             },
-        },
-        {
-            name: "injetar_conteudo",
-            description: "Injeta conteúdo base (especialistas, templates, guias) no projeto. Use force:true para sobrescrever.",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    diretorio: { type: "string", description: "Diretório absoluto do projeto" },
-                    source: { type: "string", enum: ["builtin", "custom"], description: "Fonte do conteúdo (padrão: builtin)" },
-                    custom_path: { type: "string", description: "Caminho customizado se source=custom" },
-                    force: { type: "boolean", description: "Sobrescrever se já existe (padrão: false)" },
-                },
-                required: ["diretorio"],
+            {
+                name: "maestro-template",
+                description: "Template do entregável esperado para a fase atual",
+                arguments: [
+                    {
+                        name: "diretorio",
+                        description: "Diretório do projeto",
+                        required: true,
+                    },
+                ],
             },
-        },
-        // 🆕 FASE 1: KNOWLEDGE BASE
-        {
-            name: "record_adr",
-            description: "Registra Architecture Decision Record com decisão, contexto, alternativas e consequências",
-            inputSchema: recordADRSchema,
-        },
-        {
-            name: "record_pattern",
-            description: "Registra padrão identificado com contexto, problema e solução",
-            inputSchema: recordPatternSchema,
-        },
-        {
-            name: "get_context",
-            description: "Retorna contexto relevante para fase específica (ADRs, padrões, decisões)",
-            inputSchema: getContextSchema,
-        },
-        {
-            name: "search_knowledge",
-            description: "Busca na base de conhecimento por query",
-            inputSchema: searchKnowledgeSchema,
-        },
-        // 🆕 FASE 1: CHECKPOINT
-        {
-            name: "create_checkpoint",
-            description: "Cria checkpoint do projeto antes de mudanças arriscadas",
-            inputSchema: createCheckpointSchema,
-        },
-        {
-            name: "rollback_total",
-            description: "Rollback total para um checkpoint",
-            inputSchema: rollbackTotalSchema,
-        },
-        {
-            name: "rollback_partial",
-            description: "Rollback parcial (apenas módulos específicos)",
-            inputSchema: rollbackPartialSchema,
-        },
-        {
-            name: "list_checkpoints",
-            description: "Lista todos os checkpoints disponíveis",
-            inputSchema: listCheckpointsSchema,
-        },
-        // 🆕 FASE 1: VALIDATION
-        {
-            name: "validate_dependencies",
-            description: "Valida dependências e detecta hallucinations",
-            inputSchema: validateDependenciesSchema,
-        },
-        {
-            name: "validate_security",
-            description: "Valida segurança contra OWASP Top 10",
-            inputSchema: validateSecuritySchema,
-        },
-        {
-            name: "check_compliance",
-            description: "Verifica compliance (LGPD, PCI-DSS, HIPAA)",
-            inputSchema: checkComplianceSchema,
-        },
-        // 🆕 FASE 1: RISK, AUTOFIX, DISCOVERY
-        {
-            name: "evaluate_risk",
-            description: "Avalia risco de uma operação",
-            inputSchema: evaluateRiskSchema,
-        },
-        {
-            name: "auto_fix",
-            description: "Tenta corrigir automaticamente erros de código",
-            inputSchema: autoFixSchema,
-        },
-        {
-            name: "discover_codebase",
-            description: "Analisa codebase e detecta arquitetura/stack",
-            inputSchema: discoverCodebaseSchema,
-        },
-    ],
-}));
-server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    const { name, arguments: args } = request.params;
-    const a = args;
-    const typedArgs = a || {};
+        ],
+    };
+});
+server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+    const { name, arguments: promptArgs } = request.params;
+    const diretorio = promptArgs?.diretorio || projectsDir;
+    if (name === "maestro-specialist") {
+        return await buildSpecialistPrompt(diretorio);
+    }
+    if (name === "maestro-context") {
+        return await buildContextPrompt(diretorio);
+    }
+    if (name === "maestro-template") {
+        return await buildTemplatePrompt(diretorio);
+    }
+    throw new Error(`Prompt não encontrado: ${name}`);
+});
+/**
+ * Constrói prompt dinâmico do especialista da fase atual.
+ */
+async function buildSpecialistPrompt(diretorio) {
+    const stateService = createStateService(diretorio);
+    const estado = await stateService.load();
+    if (!estado) {
+        return {
+            description: "Nenhum projeto encontrado",
+            messages: [{
+                    role: "user",
+                    content: { type: "text", text: "Nenhum projeto ativo neste diretório. Use `maestro(diretorio)` para começar." },
+                }],
+        };
+    }
+    const faseInfo = getFaseComStitch(estado.nivel, estado.fase_atual, estado.usar_stitch);
+    if (!faseInfo) {
+        return {
+            description: `Projeto: ${estado.nome}`,
+            messages: [{
+                    role: "user",
+                    content: { type: "text", text: `Projeto ${estado.nome} — fase ${estado.fase_atual} não encontrada no fluxo.` },
+                }],
+        };
+    }
+    const mode = (estado.config?.mode || "balanced");
+    const contentResolver = new ContentResolverService(diretorio);
+    const skillLoader = new SkillLoaderService(contentResolver);
     try {
-        switch (name) {
-            case "iniciar_projeto":
-                return await iniciarProjeto({
-                    nome: typedArgs.nome,
-                    descricao: typedArgs.descricao,
-                    diretorio: typedArgs.diretorio,
-                    ide: typedArgs.ide,
-                    modo: typedArgs.modo,
-                });
-            case "confirmar_projeto":
-                return await confirmarProjeto({
-                    nome: typedArgs.nome,
-                    descricao: typedArgs.descricao,
-                    diretorio: typedArgs.diretorio,
-                    tipo_artefato: typedArgs.tipo_artefato,
-                    nivel_complexidade: typedArgs.nivel_complexidade,
-                    ide: typedArgs.ide,
-                    modo: typedArgs.modo,
-                });
-            case "carregar_projeto":
-                return await carregarProjeto({
-                    estado_json: typedArgs.estado_json,
-                    diretorio: typedArgs.diretorio,
-                });
-            case "proximo":
-                return await proximo({
-                    entregavel: typedArgs.entregavel,
-                    estado_json: typedArgs.estado_json,
-                    diretorio: typedArgs.diretorio,
-                    nome_arquivo: typedArgs.nome_arquivo,
-                });
-            case "status":
-                return await status({
-                    estado_json: typedArgs.estado_json,
-                    diretorio: typedArgs.diretorio,
-                });
-            case "validar_gate":
-                return await validarGate({
-                    fase: typedArgs.fase,
-                    entregavel: typedArgs.entregavel,
-                    estado_json: typedArgs.estado_json,
-                    diretorio: typedArgs.diretorio,
-                });
-            case "contexto":
-                return await contexto({
-                    estado_json: typedArgs.estado_json,
-                    diretorio: typedArgs.diretorio,
-                });
-            case "classificar":
-                return await classificar({
-                    prd: typedArgs.prd,
-                    nivel: typedArgs.nivel,
-                    estado_json: typedArgs.estado_json,
-                    diretorio: typedArgs.diretorio,
-                });
-            case "salvar":
-                return await salvar({
-                    conteudo: typedArgs.conteudo,
-                    tipo: typedArgs.tipo,
-                    estado_json: typedArgs.estado_json,
-                    diretorio: typedArgs.diretorio,
-                    nome_arquivo: typedArgs.nome_arquivo,
-                });
-            case "injetar_conteudo":
-                return await injetar_conteudo({
-                    diretorio: typedArgs.diretorio,
-                    source: typedArgs.source,
-                    custom_path: typedArgs.custom_path,
-                    force: typedArgs.force,
-                });
-            // 🆕 FASE 1: KNOWLEDGE BASE
-            case "record_adr":
-                return await recordADR({
-                    decision: typedArgs.decision,
-                    context: typedArgs.context,
-                    alternatives: typedArgs.alternatives,
-                    consequences: typedArgs.consequences,
-                    risks: typedArgs.risks,
-                    estado_json: typedArgs.estado_json,
-                    diretorio: typedArgs.diretorio,
-                });
-            case "record_pattern":
-                return await recordPattern({
-                    name: typedArgs.name,
-                    context: typedArgs.context,
-                    problem: typedArgs.problem,
-                    solution: typedArgs.solution,
-                    examples: typedArgs.examples,
-                    relatedPatterns: typedArgs.relatedPatterns,
-                    estado_json: typedArgs.estado_json,
-                    diretorio: typedArgs.diretorio,
-                });
-            case "get_context":
-                return await getContext({
-                    fase: typedArgs.fase,
-                    estado_json: typedArgs.estado_json,
-                    diretorio: typedArgs.diretorio,
-                });
-            case "search_knowledge":
-                return await searchKnowledge({
-                    query: typedArgs.query,
-                    estado_json: typedArgs.estado_json,
-                    diretorio: typedArgs.diretorio,
-                });
-            // 🆕 FASE 1: CHECKPOINT
-            case "create_checkpoint":
-                return await createCheckpoint({
-                    reason: typedArgs.reason,
-                    auto: typedArgs.auto,
-                    estado_json: typedArgs.estado_json,
-                    diretorio: typedArgs.diretorio,
-                });
-            case "rollback_total":
-                return await rollbackTotal({
-                    checkpointId: typedArgs.checkpointId,
-                    estado_json: typedArgs.estado_json,
-                    diretorio: typedArgs.diretorio,
-                });
-            case "rollback_partial":
-                return await rollbackPartial({
-                    checkpointId: typedArgs.checkpointId,
-                    modules: typedArgs.modules,
-                    estado_json: typedArgs.estado_json,
-                    diretorio: typedArgs.diretorio,
-                });
-            case "list_checkpoints":
-                return await listCheckpoints({
-                    estado_json: typedArgs.estado_json,
-                    diretorio: typedArgs.diretorio,
-                });
-            // 🆕 FASE 1: VALIDATION
-            case "validate_dependencies":
-                return await validateDependencies({
-                    code: typedArgs.code,
-                    language: typedArgs.language,
-                    estado_json: typedArgs.estado_json,
-                    diretorio: typedArgs.diretorio,
-                });
-            case "validate_security":
-                return await validateSecurity({
-                    code: typedArgs.code,
-                    language: typedArgs.language,
-                    estado_json: typedArgs.estado_json,
-                    diretorio: typedArgs.diretorio,
-                });
-            case "check_compliance":
-                return await checkCompliance({
-                    code: typedArgs.code,
-                    standard: typedArgs.standard,
-                    estado_json: typedArgs.estado_json,
-                    diretorio: typedArgs.diretorio,
-                });
-            // 🆕 FASE 1: RISK, AUTOFIX, DISCOVERY
-            case "evaluate_risk":
-                return await evaluateRisk({
-                    operation: typedArgs.operation,
-                    context: typedArgs.context,
-                    estado_json: typedArgs.estado_json,
-                    diretorio: typedArgs.diretorio,
-                });
-            case "auto_fix":
-                return await autoFix({
-                    code: typedArgs.code,
-                    error: typedArgs.error,
-                    estado_json: typedArgs.estado_json,
-                    diretorio: typedArgs.diretorio,
-                });
-            case "discover_codebase":
-                return await discoverCodebase({
-                    estado_json: typedArgs.estado_json,
-                    diretorio: typedArgs.diretorio,
-                });
-            default:
-                return {
-                    content: [{ type: "text", text: `Tool não encontrada: ${name}` }],
-                    isError: true,
-                };
+        const contextPkg = await skillLoader.loadForPhase(faseInfo.nome, mode);
+        if (contextPkg) {
+            return {
+                description: `Especialista: ${contextPkg.specialist?.name || faseInfo.nome} — Fase ${estado.fase_atual}/${estado.total_fases}`,
+                messages: [{
+                        role: "user",
+                        content: {
+                            type: "text",
+                            text: `# Especialista da Fase: ${faseInfo.nome}\n\n${skillLoader.formatAsMarkdown(contextPkg)}`,
+                        },
+                    }],
+            };
         }
     }
     catch (error) {
+        console.warn("[Prompt] Falha ao carregar skill:", error);
+    }
+    // Fallback: persona básica
+    const specialist = getSpecialistPersona(faseInfo.nome);
+    return {
+        description: `Especialista: ${specialist?.name || faseInfo.nome}`,
+        messages: [{
+                role: "user",
+                content: {
+                    type: "text",
+                    text: specialist
+                        ? `# ${specialist.name}\n\n**Tom:** ${specialist.tone}\n**Expertise:** ${specialist.expertise.join(", ")}\n**Instruções:** ${specialist.instructions}`
+                        : `Fase ${estado.fase_atual}: ${faseInfo.nome}`,
+                },
+            }],
+    };
+}
+/**
+ * Constrói prompt de contexto completo do projeto.
+ */
+async function buildContextPrompt(diretorio) {
+    const stateService = createStateService(diretorio);
+    const estado = await stateService.load();
+    if (!estado) {
+        return {
+            description: "Nenhum projeto encontrado",
+            messages: [{
+                    role: "user",
+                    content: { type: "text", text: "Nenhum projeto ativo neste diretório." },
+                }],
+        };
+    }
+    const faseInfo = getFaseComStitch(estado.nivel, estado.fase_atual, estado.usar_stitch);
+    const contextText = `# Contexto do Projeto: ${estado.nome}
+
+## Estado
+| Campo | Valor |
+|-------|-------|
+| **Nível** | ${estado.nivel.toUpperCase()} |
+| **Fase Atual** | ${estado.fase_atual}/${estado.total_fases} — ${faseInfo?.nome || "N/A"} |
+| **Gates Validados** | ${estado.gates_validados?.join(", ") || "nenhum"} |
+
+## Entregáveis Salvos
+${Object.entries(estado.entregaveis || {}).map(([k, v]) => `- **${k}:** ${v}`).join("\n") || "Nenhum ainda."}
+
+## Próximo Passo
+Trabalhe com o especialista **${faseInfo?.especialista || "N/A"}** para gerar: **${faseInfo?.entregavel_esperado || "N/A"}**
+`;
+    return {
+        description: `Projeto: ${estado.nome} — Fase ${estado.fase_atual}/${estado.total_fases}`,
+        messages: [{
+                role: "user",
+                content: { type: "text", text: contextText },
+            }],
+    };
+}
+/**
+ * Constrói prompt do template da fase atual.
+ */
+async function buildTemplatePrompt(diretorio) {
+    const stateService = createStateService(diretorio);
+    const estado = await stateService.load();
+    if (!estado) {
+        return {
+            description: "Nenhum projeto encontrado",
+            messages: [{
+                    role: "user",
+                    content: { type: "text", text: "Nenhum projeto ativo neste diretório." },
+                }],
+        };
+    }
+    const faseInfo = getFaseComStitch(estado.nivel, estado.fase_atual, estado.usar_stitch);
+    if (!faseInfo) {
         return {
-            content: [{ type: "text", text: `Erro: ${String(error)}` }],
-            isError: true,
+            description: `Projeto: ${estado.nome}`,
+            messages: [{
+                    role: "user",
+                    content: { type: "text", text: `Projeto ${estado.nome} — fase ${estado.fase_atual} não encontrada.` },
+                }],
         };
     }
+    const contentResolver = new ContentResolverService(diretorio);
+    const skillLoader = new SkillLoaderService(contentResolver);
+    try {
+        const templateContent = await skillLoader.loadTemplate(faseInfo.nome);
+        if (templateContent) {
+            return {
+                description: `Template: ${faseInfo.entregavel_esperado || faseInfo.nome}`,
+                messages: [{
+                        role: "user",
+                        content: {
+                            type: "text",
+                            text: `# Template do Entregável: ${faseInfo.entregavel_esperado || faseInfo.nome}
+
+## Fase ${estado.fase_atual}/${estado.total_fases}: ${faseInfo.nome}
+
+Use este template como base para gerar o entregável:
+
+---
+
+${templateContent}
+
+---
+
+> 💡 Dica: Preencha todas as seções marcadas com [...] ou indicadores de conteúdo.`,
+                        },
+                    }],
+            };
+        }
+    }
+    catch (error) {
+        console.warn("[Prompt] Falha ao carregar template:", error);
+    }
+    // Fallback: estrutura básica
+    return {
+        description: `Template: ${faseInfo.entregavel_esperado || faseInfo.nome}`,
+        messages: [{
+                role: "user",
+                content: {
+                    type: "text",
+                    text: `# Template do Entregável: ${faseInfo.entregavel_esperado || faseInfo.nome}
+
+## Fase ${estado.fase_atual}/${estado.total_fases}: ${faseInfo.nome}
+
+### Estrutura Esperada
+
+${faseInfo.gate_checklist.map((item, i) => `${i + 1}. ${item}`).join("\n")}
+
+---
+
+> ℹ️ Template específico não disponível. Use a lista acima como guia.`,
+                },
+            }],
+    };
+}
+// ==================== TOOLS (via Router Centralizado) ====================
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: getRegisteredTools(),
+}));
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    const rawArgs = args || {};
+    return await routeToolCall(name, rawArgs);
 });
 // ==================== START ====================
 // Obter diretório dos argumentos ou usar cwd
@@ -540,7 +432,7 @@ setProjectDirectory(projectsDir);
 async function main() {
     const transport = new StdioServerTransport();
     await server.connect(transport);
-    console.error(`MCP Maestro (stdio) iniciado - Modo Stateless`);
+    console.error(`MCP Maestro v5 (stdio) iniciado — ${getToolCount()} tools públicas`);
     console.error(`Diretório de projetos: ${projectsDir}`);
 }
 main().catch(console.error);