@maestro-ai/cli 1.0.0 → 1.2.0

package/content/workflows/maestro.md

@@ -0,0 +1,77 @@
+---
+description: Workflow universal inteligente que detecta estado e toma a próxima ação
+---
+
+# 🤖 Workflow Universal - /maestro
+
+## Objetivo
+
+Detectar automaticamente o estado do projeto Maestro, validar se o estado reflete os fluxos MCP (7/13/17 fases + Stitch) e decidir a ação adequada, respondendo no chat com contexto completo.
+
+## Sincronização com os fluxos MCP
+
+Antes de qualquer decisão:
+
+1. Ler `.maestro/estado.json` **e** o template original em `packages/cli/content/templates/estado-template.json` para entender a estrutura completa.
+2. Ler `src/src/flows/types.ts` para conhecer `FLUXO_SIMPLES`, `FLUXO_MEDIO`, `FLUXO_COMPLEXO` e a inserção opcional de Stitch (`getFluxoComStitch`).
+3. Verificar se `estado.fases` segue a mesma ordem e quantidade de fases do fluxo correspondente. Se detectar divergências (fase faltando, numeração diferente), listar no resumo e sugerir ao usuário rodar `/iniciar-projeto` ou ajustar manualmente.
+
+## Como funciona
+
+1. **Ler estado** em `.maestro/estado.json` (se não existir, classificar como `novo_projeto`).
+2. **Validar consistência** comparando `estado.fases` com o fluxo MCP adequado.
+3. **Classificar estado** usando a função mental abaixo.
+4. **Mapear ação** (`/iniciar-projeto`, `/continuar-fase`, `/avancar-fase`).
+5. **Responder** com resumo e próxima ação sugerida.
+
+```javascript
+const estado = lerJson('.maestro/estado.json');
+const fluxo = estado?.projeto
+  ? getFluxoComStitch(estado.projeto.complexidade, estado.projeto.usarStitch)
+  : null;
+
+if (!estado || !estado.projeto?.nome) {
+  return { status: 'novo_projeto', proximaAcao: '/iniciar-projeto' };
+}
+
+const faseAtual = estado.fases[estado.faseAtual];
+if (!faseAtual || faseAtual.status !== 'concluida') {
+  return {
+    status: 'fase_incompleta',
+    proximaAcao: '/continuar-fase',
+    fase: estado.faseAtual,
+    arquivoFoco: faseAtual?.artefatos?.slice(-1)[0] || fluxo?.fases?.find(f => f.numero === estado.faseAtual)?.entregavel_esperado,
+    divergenciasFluxo: compararComFluxo(estado.fases, fluxo?.fases)
+  };
+}
+
+return {
+  status: 'pronto_para_avancar',
+  proximaAcao: '/avancar-fase',
+  fase: estado.faseAtual,
+  proximaFase: estado.faseAtual + 1,
+  divergenciasFluxo: compararComFluxo(estado.fases, fluxo?.fases)
+};
+```
+
+## Template de resposta
+
+```
+📋 **Status Detectado:** {status}
+- Projeto: {estado.projeto.nome}
+- Fase atual: {estado.faseAtual}/{totalFases} - {faseAtual.nome}
+- Especialista: {faseAtual.especialista}
+- Arquivo foco: {arquivoFoco}
+
+🎯 **Próxima ação sugerida:** {proximaAcao}
+➡️ Execute o comando correspondente ou peça um ajuste específico.
+
+{divergenciasFluxo?.length ? `⚠️ Divergências detectadas entre estado e fluxo MCP:
+- ${divergenciasFluxo.join('\n- ')}` : ''}
+```
+
+## Regras rápidas
+
+- Sempre verificar se há bloqueios (`faseAtual.status === 'bloqueado'`) e destacar no resumo.
+- Se detectar `novo_projeto`, **não** tentar gerar estado: apenas orientar o usuário a rodar `/iniciar-projeto`.
+- Se o usuário preferir outra ação, respeitar e registrar no histórico (se aplicável).

package/content/workflows/{mcp-feature.md → nova-feature.md}

@@ -2,12 +2,27 @@
 description: Adicionar nova feature com fluxo estruturado (Análise → Implementação → Deploy)
 ---
 
-# /mcp-feature - Nova Feature MCP
+# /nova-feature - Nova Feature Maestro
 
 $ARGUMENTS
 
 ---
 
+## Pré-requisitos e integração com o Maestro
+
+1. Execute `/maestro` para garantir que o estado esteja sincronizado com os fluxos MCP (7/13/17 + Stitch).
+2. Carregue o estado antes de qualquer tool:
+   ```javascript
+   const estado = lerJson('.maestro/estado.json');
+   function salvarEstado(novoEstado) {
+     escreverJson('.maestro/estado.json', novoEstado, { spaces: 2 });
+   }
+   ```
+3. Use `content/guides/fases-mapeamento.md` para alinhar especialistas, prompts e templates de suporte a features.
+4. Todos os artefatos criados devem ficar dentro de `docs/features/FEATURE-ID/` e ser registrados em `estado.historico`.
+
+---
+
 ## Objetivo
 
 Adicionar nova funcionalidade em projeto existente usando fluxo estruturado de 6 fases do MCP Maestro.
@@ -21,9 +36,9 @@ Adicionar nova funcionalidade em projeto existente usando fluxo estruturado de 6
 - Feature que precisa de análise de impacto
 
 **NÃO usar para:**
-- Correção de bugs → Use `/mcp-debug`
-- Melhorias de código → Use `/mcp-refactor`
-- Novo projeto → Use `/mcp-start`
+- Correção de bugs → Use `/corrigir-bug`
+- Melhorias de código → Use `/refatorar-codigo`
+- Novo projeto → Use `/iniciar-projeto`
 
 ---
 
@@ -68,7 +83,7 @@ Adicionar nova funcionalidade em projeto existente usando fluxo estruturado de 6
 **Se forneceu argumentos:**
 
 ```bash
-/mcp-feature Sistema de notificações push
+/nova-feature Sistema de notificações push
 ```
 
 → Usar como descrição, pedir apenas impacto
@@ -77,13 +92,22 @@ Adicionar nova funcionalidade em projeto existente usando fluxo estruturado de 6
 
 ### Passo 2: Iniciar Fluxo de Feature
 
+> [!IMPORTANT]
+> **Protocolo stateless:** sempre envie `estado_json` carregado do disco para os tools MCP.
+
 ```typescript
+const estadoJson = lerArquivo('.maestro/estado.json');
+
 await mcp_maestro_nova_feature({
   descricao: "[descrição fornecida]",
-  impacto_estimado: "[baixo/médio/alto]"
+  impacto_estimado: "[baixo/médio/alto]",
+  estado_json: estadoJson,
+  diretorio: process.cwd()
 });
 ```
 
+Após a resposta, atualize `estado.historico` com `acao: "feature_iniciada"`, registrando `feature_id` e impacto.
+
 **MCP cria contexto separado para a feature e retorna:**
 
 ```json
@@ -146,25 +170,42 @@ Vamos começar. Que **entidades** ou **tabelas** serão afetadas?
 
 ### Passo 4: Avançar Entre Fases (Frontend-First)
 
-**Usar `/mcp-next` para cada fase:**
+**Usar `/avancar-fase` (via `/maestro`) para conectar com o fluxo principal**
+
+Quando estiver trabalhando dentro da feature, o acompanhamento das fases internas segue o mesmo padrão do Maestro. Utilize:
 
 ```
 Fase 1: Análise ✅
-  ↓ /mcp-next
+  ↓ /avancar-fase (passando o artefato docs/features/FEATURE-ID/01-impacto.md)
 Fase 2: Requisitos ✅
-  ↓ /mcp-next
-Fase 3: Design ✅
-  ✓ Gera: Contrato de API (OpenAPI)
-  ↓ /mcp-next
+  ↓ /avancar-fase
+...
+```
+
+Caso precise apenas retomar o trabalho da feature antes de avançar, use `/continuar-fase` com o arquivo da subfase correspondente.
+
+---
+
+### Passo 4: Avançar Entre Fases (Frontend-First)
+
+**Mapeie especialistas e templates** usando `guides/fases-mapeamento.md` para cada etapa abaixo e carregue os prompts adequados (ex.: Contrato API → especialista "Contrato de API").
+
+```
+Fase 1: Análise ✅
+  ↓ /avancar-fase (ou `/maestro` → sugere avanço)
+Fase 2: Requisitos ✅
+  ↓ /avancar-fase
+Fase 3: Design ✅ (gera contrato OpenAPI)
+  ↓ /avancar-fase
 Fase 4: Implementação
   ├─ US-001-CONT (Contrato) ✅
   ├─ US-001-FE (Frontend) 🔄 ← Paralelo
-  ├─ US-001-BE (Backend) 🔄  ← Paralelo
+  ├─ US-001-BE (Backend) 🔄 ← Paralelo
   └─ INT-001 (Integração) ⏳ ← Após FE+BE
-  ↓ /mcp-next
+  ↓ /avancar-fase
 Fase 5: Testes ✅
-  ↓ /mcp-next
-Fase 6: Deploy ✅
+  ↓ /avancar-fase
+Fase 6: Deploy ✅ (encerra feature e atualiza estado)
 ```
 
 **Protocolo Frontend-First:**
@@ -191,29 +232,41 @@ Fase 6: Deploy ✅
 **Na Fase 4 (Implementação):**
 
 ```typescript
+const estadoJson = lerArquivo('.maestro/estado.json');
+
 // Contrato
 await mcp_maestro_implementar_historia({
   historia_id: "US-001-CONT",
-  modo: "iniciar"
+  modo: "iniciar",
+  estado_json: estadoJson,
+  diretorio: process.cwd()
 });
 
 // Frontend (pode iniciar em paralelo após contrato)
 await mcp_maestro_implementar_historia({
   historia_id: "US-001-FE",
-  modo: "iniciar"
+  modo: "iniciar",
+  estado_json: estadoJson,
+  diretorio: process.cwd()
 });
 
 // Backend (pode iniciar em paralelo após contrato)
 await mcp_maestro_implementar_historia({
   historia_id: "US-001-BE",
-  modo: "iniciar"
+  modo: "iniciar",
+  estado_json: estadoJson,
+  diretorio: process.cwd()
 });
 
 // Integração (somente após FE e BE finalizados)
 await mcp_maestro_implementar_historia({
   historia_id: "INT-001",
-  modo: "iniciar"
+  modo: "iniciar",
+  estado_json: estadoJson,
+  diretorio: process.cwd()
 });
+
+salvarEstado(atualizarHistorico(estado, { acao: 'feature_historia_iniciada', historia: 'INT-001' }));
 ```
 
 ---
@@ -223,7 +276,7 @@ await mcp_maestro_implementar_historia({
 ### Exemplo 1: Feature Simples (Impacto Baixo)
 
 ```
-User: /mcp-feature Adicionar filtro de data na listagem de pedidos
+User: /nova-feature Adicionar filtro de data na listagem de pedidos
 
 AI: Qual o impacto estimado? (baixo/médio/alto)
 
@@ -244,13 +297,13 @@ AI: ✅ Fluxo de Feature Iniciado (FEAT-001)
 
 User: Sim
 
-AI: [Avança para Fase 2 com /mcp-next]
+AI: [Avança para Fase 2 executando `/maestro` → `/avancar-fase`]
 ```
 
 ### Exemplo 2: Feature Complexa (Impacto Alto)
 
 ```
-User: /mcp-feature Sistema de notificações push em tempo real
+User: /nova-feature Sistema de notificações push em tempo real
 
 AI: Qual o impacto estimado?
 
@@ -290,10 +343,10 @@ AI: ✅ Fluxo de Feature Iniciado (FEAT-002)
 ## Comandos Relacionados
 
 ```
-/mcp-feature [descrição]    → Inicia fluxo de feature
-/mcp-next                   → Avança entre fases
-/mcp-status                 → Ver status da feature
-/mcp-debug                  → Se bug aparecer durante feature
+/nova-feature [descrição] → Inicia fluxo de feature alinhado ao estado
+/continuar-fase          → Retoma etapa corrente da feature
+/avancar-fase            → Valida gate e registra próxima fase
+/corrigir-bug            → Se surgir bug durante a feature
 ```
 
 ---
@@ -369,7 +422,7 @@ FEAT-001: Sistema de Notificações (Épico)
 ├─ FEAT-001-B: Frontend (UI)
 └─ FEAT-001-C: Integração (Push)
 
-Implementar um por vez com /mcp-feature
+Implementar um por vez com `/nova-feature`
 ```
 
 ### Conflito com Feature em Andamento

package/content/workflows/{mcp-refactor.md → refatorar-codigo.md}

@@ -2,12 +2,28 @@
 description: Refatoração estruturada de código (Análise → Testes → Refactor → Validação)
 ---
 
-# /mcp-refactor - Refatoração MCP
+# /refatorar-codigo - Refatoração Maestro
 
 $ARGUMENTS
 
 ---
 
+## Integração obrigatória com o Maestro
+
+1. **Sincronize o estado** executando `/maestro` antes de começar. Garanta que não há gates bloqueados.
+2. **Carregue o estado e defina helpers**:
+   ```javascript
+   const estado = lerJson('.maestro/estado.json');
+   function salvarEstado(novoEstado) {
+     escreverJson('.maestro/estado.json', novoEstado, { spaces: 2 });
+   }
+   ```
+3. Sempre passe `estado_json` ao chamar qualquer tool MCP (`mcp_maestro_refatorar`, `mcp_maestro_avancar_refatoracao`, etc.).
+4. Atualize `estado.historico` com eventos como `refatoracao_iniciada`, `refatoracao_passo_concluido` e `refatoracao_finalizada`, armazenando `refactor_id` e arquivos afetados.
+5. Use `content/guides/fases-mapeamento.md` para escolher especialistas de apoio (Arquitetura, Performance, Testes) conforme o foco da refatoração.
+
+---
+
 ## Objetivo
 
 Refatorar código de forma segura e estruturada usando fluxo de 5 fases do MCP Maestro, com testes de caracterização e validação contínua.
@@ -22,8 +38,8 @@ Refatorar código de forma segura e estruturada usando fluxo de 5 fases do MCP M
 - Migrar para novo padrão ou arquitetura
 
 **NÃO usar para:**
-- Adicionar funcionalidade → Use `/mcp-feature`
-- Corrigir bugs → Use `/mcp-debug`
+- Adicionar funcionalidade → Use `/nova-feature`
+- Corrigir bugs → Use `/corrigir-bug`
 
 ---
 
@@ -75,10 +91,16 @@ Refatorar código de forma segura e estruturada usando fluxo de 5 fases do MCP M
 ### Passo 2: Iniciar Fluxo de Refatoração
 
 ```typescript
+const estadoJson = lerArquivo('.maestro/estado.json');
+
 await mcp_maestro_refatorar({
   area: "[área fornecida]",
-  motivo: "[motivo]"
+  motivo: "[motivo]",
+  estado_json: estadoJson,
+  diretorio: process.cwd()
 });
+
+salvarEstado(registrarHistorico(estado, { acao: 'refatoracao_iniciada', area, motivo }));
 ```
 
 **MCP cria contexto e retorna:**
@@ -397,7 +419,7 @@ Use: `/deploy production`
 ### Exemplo 1: Refatorar Serviço Complexo
 
 ```
-User: /mcp-refactor
+User: /refatorar-codigo
 
 AI: Qual área deseja refatorar?
 
@@ -435,7 +457,7 @@ AI: [Fase 2: Cria testes de caracterização]
     
     Todos passando. Pronto para refatorar!
 
-User: /mcp-next
+User: /avancar-fase (ou `/maestro` para validar e avançar)
 
 AI: [Fase 3: Refatoração]
     
@@ -463,7 +485,7 @@ AI: [Fase 3: Refatoração]
 ### Exemplo 2: Migração de Padrão
 
 ```
-User: /mcp-refactor Migrar de callback para async/await
+User: /refatorar-codigo Migrar de callback para async/await
 
 AI: Motivo?
 
@@ -496,9 +518,10 @@ AI: ✅ Refactor initiated
 ## Comandos Relacionados
 
 ```
-/mcp-refactor [área]        → Inicia refatoração
-/mcp-next                   → Avança entre fases/passos
-/mcp-status                 → Ver progresso da refatoração
+/refatorar-codigo [área]  → Inicia refatoração integrada ao estado
+/continuar-fase          → Retoma passo atual (usa análise do artefato)
+/avancar-fase            → Valida gate pós-refatoração
+/status-projeto          → Ver progresso e métricas
 ```
 
 ---

package/content/workflows/status-projeto.md

@@ -0,0 +1,54 @@
+---
+description: Mostra o status completo do projeto Maestro e recomenda próximas ações
+---
+
+# 📊 Workflow de Status - /status-projeto
+
+## 1. Ler estado
+
+```javascript
+const estado = lerJson('.maestro/estado.json');
+if (!estado) throw new Error('Projeto ainda não inicializado. Execute /iniciar-projeto.');
+const fases = Object.values(estado.fases || {});
+```
+
+## 2. Calcular métricas
+
+- Fases concluídas (`status === 'concluida'`).
+- Progresso percentual: `concluidas / totalFases`.
+- Score médio (ignorar `null`).
+- Bloqueios: fases com `status === 'bloqueado'`.
+- Próxima ação sugerida: se há bloqueio → listar; se fase atual não concluída → `/continuar-fase`; caso contrário → `/avancar-fase`.
+
+## 3. Resposta padrão
+
+```
+🎯 **Projeto:** {estado.projeto.nome}
+📈 **Progresso:** {progresso}% ({fasesConcluidas}/{totalFases})
+🔄 **Fase Atual:** {faseAtual.numero}/{totalFases} - {faseAtual.nome}
+👤 **Especialista:** {faseAtual.especialista}
+📊 **Score Médio:** {scoreMedio}
+
+## 📋 Detalhes
+| Fase | Status | Score | Especialista | Últ. Atualização |
+|------|--------|-------|--------------|------------------|
+{linhas}
+
+{bloqueios ? `⚠️ Bloqueios detectados:` + lista : ''}
+
+🎯 **Próximas ações sugeridas:**
+- {acao1}
+- {acao2}
+```
+
+## 4. Recomendações
+
+Baseie-se em heurísticas simples:
+- Ritmo lento (`diasFase > media`) → sugerir revisão.
+- Score baixo (< mínimo + 5) → recomendar `/continuar-fase` focando na validação.
+- Próxima fase crítica (ex.: Prototipagem, Arquitetura) → antecipar especialistas/artefatos.
+
+## 5. Complementos
+
+- Se o usuário pedir filtros (ex.: "status completo"), incluir lista detalhada dos artefatos por fase.
+- Caso não exista `estado.fases`, instruir execução de `/iniciar-projeto`.

package/dist/commands/init.d.ts

@@ -1,6 +1,7 @@
 interface InitOptions {
     force?: boolean;
     minimal?: boolean;
+    ide?: 'windsurf' | 'cursor' | 'antigravity';
 }
-export declare function init(options?: InitOptions): Promise<void>;
+export declare function init(options: InitOptions): Promise<void>;
 export {};

package/dist/commands/init.js

@@ -5,7 +5,27 @@ import fse from 'fs-extra';
 import chalk from 'chalk';
 import ora from 'ora';
 const __dirname = dirname(fileURLToPath(import.meta.url));
-export async function init(options = {}) {
+const IDE_CONFIGS = {
+    windsurf: {
+        path: '.windsurfrules',
+        header: '',
+        workflowsDir: '.windsurf/workflows',
+        skillsDir: '.windsurf/skills'
+    },
+    cursor: {
+        path: '.cursorrules',
+        header: '',
+        workflowsDir: '.cursor/commands',
+        skillsDir: '.cursor/skills'
+    },
+    antigravity: {
+        path: '.gemini/GEMINI.md',
+        header: '---\ntrigger: always_on\nsystem: maestro\nversion: 1.0.0\n---\n\n',
+        workflowsDir: '.agent/workflows',
+        skillsDir: '.agent/skills'
+    }
+};
+export async function init(options) {
     const cwd = process.cwd();
     const spinner = ora();
     console.log(chalk.blue.bold('\n🎯 Maestro - Inicializando projeto\n'));
@@ -25,7 +45,8 @@ export async function init(options = {}) {
         await fse.writeJSON(join(cwd, '.maestro', 'config.json'), {
             version: '1.0.0',
             initialized: new Date().toISOString(),
-            mcpServer: 'https://maestro.deluna.dev.br/mcp'
+            ide: options.ide || 'windsurf',
+            mcpFree: true
         }, { spaces: 2 });
         spinner.succeed('Estrutura .maestro/ criada');
         // 2. Copiar content para .maestro/content/ (se não minimal)
@@ -42,29 +63,41 @@ export async function init(options = {}) {
             }
             spinner.succeed('Content copiado para .maestro/content/');
         }
-        // 3. Copiar skills para .agent/skills/
-        spinner.start('Copiando skills para .agent/skills/...');
-        const skillsSrc = join(contentSource, 'skills');
-        const skillsDest = join(cwd, '.agent', 'skills');
-        if (await fse.pathExists(skillsSrc)) {
-            await fse.copy(skillsSrc, skillsDest, { overwrite: options.force });
+        // 4. Configurar IDE específica
+        const ideConfig = IDE_CONFIGS[options.ide];
+        spinner.start(`Configurando IDE: ${options.ide}...`);
+        // Ler RULES.md base
+        const rulesPath = join(contentSource, 'rules', 'RULES.md');
+        let rulesContent = '';
+        if (await fse.pathExists(rulesPath)) {
+            rulesContent = await fse.readFile(rulesPath, 'utf-8');
+        }
+        else {
+            rulesContent = generateDefaultRules();
         }
-        spinner.succeed('Skills copiados para .agent/skills/');
-        // 4. Copiar workflows para .agent/workflows/
-        spinner.start('Copiando workflows para .agent/workflows/...');
+        // Criar diretórios específicos da IDE
+        await fse.ensureDir(join(cwd, dirname(ideConfig.path)));
+        await fse.ensureDir(join(cwd, ideConfig.workflowsDir));
+        await fse.ensureDir(join(cwd, ideConfig.skillsDir));
+        // Copiar workflows para diretório específico da IDE
         const workflowsSrc = join(contentSource, 'workflows');
-        const workflowsDest = join(cwd, '.agent', 'workflows');
+        const workflowsDest = join(cwd, ideConfig.workflowsDir);
         if (await fse.pathExists(workflowsSrc)) {
             await fse.copy(workflowsSrc, workflowsDest, { overwrite: options.force });
         }
-        spinner.succeed('Workflows copiados para .agent/workflows/');
-        // 5. Gerar GEMINI.md
-        spinner.start('Gerando GEMINI.md...');
-        const geminiContent = generateGeminiMd();
-        await fse.writeFile(join(cwd, 'GEMINI.md'), geminiContent);
-        spinner.succeed('GEMINI.md gerado');
+        // Copiar skills para diretório específico da IDE
+        const skillsSrc = join(contentSource, 'skills');
+        const skillsDest = join(cwd, ideConfig.skillsDir);
+        if (await fse.pathExists(skillsSrc)) {
+            await fse.copy(skillsSrc, skillsDest, { overwrite: options.force });
+        }
+        // Gerar arquivo de regras
+        const targetPath = join(cwd, ideConfig.path);
+        const content = ideConfig.header + rulesContent;
+        await fse.writeFile(targetPath, content);
+        spinner.succeed(`IDE ${options.ide} configurada com sucesso!`);
         // Resumo
-        console.log(chalk.green.bold('\n✅ Maestro inicializado com sucesso!\n'));
+        console.log(chalk.green.bold(`\n✅ Maestro inicializado para ${options.ide}\n`));
         console.log(chalk.dim('Estrutura criada:'));
         console.log(chalk.dim('  .maestro/'));
         console.log(chalk.dim('    ├── config.json'));
@@ -76,14 +109,13 @@ export async function init(options = {}) {
             console.log(chalk.dim('        ├── guides/'));
             console.log(chalk.dim('        └── prompts/'));
         }
-        console.log(chalk.dim('  .agent/'));
-        console.log(chalk.dim('    ├── skills/'));
-        console.log(chalk.dim('    └── workflows/'));
-        console.log(chalk.dim('  GEMINI.md'));
-        console.log(chalk.blue('\n📋 Próximos passos:'));
-        console.log('  1. Configure o MCP na sua IDE:');
-        console.log(chalk.gray('     "mcpServers": { "maestro": { "serverUrl": "https://maestro.deluna.dev.br/mcp" } }'));
-        console.log('  2. Inicie um novo projeto com: @mcp:maestro iniciar_projeto');
+        console.log(chalk.dim(`  ${ideConfig.workflowsDir}/`));
+        console.log(chalk.dim(`  ${ideConfig.skillsDir}/`));
+        console.log(chalk.dim(`  ${ideConfig.path}`));
+        console.log(chalk.blue('\n🎯 Próximos passos:'));
+        console.log(`  1. Abra sua ${options.ide}`);
+        console.log('  2. Digite: /maestro');
+        console.log(' 3. Comece a desenvolver!');
         console.log('');
     }
     catch (error) {
@@ -92,47 +124,59 @@ export async function init(options = {}) {
         process.exit(1);
     }
 }
-function generateGeminiMd() {
-    return `---
-trigger: always_on
-system: maestro
-version: 1.0.0
----
-
-# Maestro - Desenvolvimento Assistido por IA
-
-> Este projeto utiliza o sistema Maestro para desenvolvimento estruturado.
+function generateDefaultRules() {
+    return `# Maestro File System - AI Rules
 
-## Configuração MCP
-
-\`\`\`json
-{
-  "mcpServers": {
-    "maestro": {
-      "serverUrl": "https://maestro.deluna.dev.br/mcp"
-    }
-  }
-}
-\`\`\`
+> Este arquivo define como a IA deve se comportar ao trabalhar com o sistema Maestro File System.
 
 ## Como Usar
 
-1. **Iniciar projeto**: Use \`iniciar_projeto\` para começar
-2. **Avançar fases**: Use \`proximo\` para salvar e avançar
-3. **Ver status**: Use \`status\` para ver onde está
+1. **Iniciar projeto**: Use \`/iniciar-projeto\` para começar
+2. **Avançar fases**: Use \`/avancar-fase\` para avançar
+3. **Ver status**: Use \`/status-projeto\` para ver progresso
+4. **Continuar**: Use \`/continuar\` para retomar trabalho
 
 ## Estrutura Local
 
 | Pasta | Conteúdo |
 |-------|----------|
 | \`.maestro/estado.json\` | Estado do projeto (fonte da verdade) |
-| \`.maestro/SYSTEM.md\` | Contexto atual para IA |
 | \`.maestro/content/\` | Especialistas, templates, prompts |
-| \`.agent/skills/\` | Skills disponíveis |
-| \`.agent/workflows/\` | Workflows automatizados |
+| \`.windsurf/workflows/\` | Workflows para Windsurf |
+| \`.windsurf/skills/\` | Skills especializadas |
+| \`.cursor/commands/\` | Commands para Cursor |
+| \`.cursor/skills/\` | Skills especializadas |
+| \`.agent/workflows/\` | Workflows para Antigravity |
+| \`.agent/skills/\` | Skills especializadas |
+
+## Comandos Disponíveis
+
+### Gerenciamento de Projeto
+- \`/maestro\` - Comando universal inteligente
+- \`/iniciar-projeto\` - Iniciar novo projeto
+- \`/avancar-fase\` - Avançar para próxima fase
+- \`/status-projeto\` - Ver status e progresso
+- \`/continuar\` - Continuar fase atual
+
+### Desenvolvimento
+- \`/nova-feature\` - Criar nova funcionalidade
+- \`/corrigir-bug\` - Debugging estruturado
+- \`/refatorar-codigo\` - Refatoração segura
+
+## Especialistas IA
+
+- Gestão de Produto
+- Engenharia de Requisitos
+- UX Design
+- Arquitetura de Software
+- E mais 20 especialistas disponíveis
+
+## Orquestração Local
+
+Este sistema opera 100% localmente, sem dependência de MCP remoto. A IA detecta automaticamente os arquivos e workflows disponíveis.
 
 ## Estado do Projeto
 
-O estado é mantido em \`.maestro/estado.json\` e deve ser passado como \`estado_json\` em todos os tools MCP.
+O estado é mantido em \`.maestro/estado.json\` e serve como fonte da verdade para o progresso do projeto.
 `;
 }