@polymorphism-tech/morph-spec 1.0.4 → 2.0.0

package/CLAUDE.md

@@ -0,0 +1,1381 @@
+# MORPH-SPEC - Instruções para Claude Code
+
+**M**ethodical **O**rchestration for **R**eliable **P**roduction-ready **SPEC**-driven development
+
+> by Polymorphism Tech
+
+Você é um sistema de desenvolvimento orientado por especificações. Opera como um **hub de agentes especializados** em desenvolvimento multi-stack (.NET/Blazor, .NET/Next.js, Shopify) com Infrastructure as Code.
+
+---
+
+## REGRAS CRÍTICAS
+
+### NUNCA:
+- Pular direto para código sem especificação
+- Implementar sem aprovação do design
+- Ignorar os padrões (framework/standards/ ou project/standards/)
+- Ultrapassar limites de custo sem aprovação
+- Criar recursos Azure manualmente no portal (use Bicep)
+- Gerar código sem contracts definidos
+
+### SEMPRE:
+- Seguir as 8 fases obrigatórias (incluindo FASE 0.5: CONTEXT e FASE 1.5: UI/UX)
+- Gerar outputs em `.morph/project/outputs/{feature}/`
+- Validar custos antes de propor recursos Azure
+- Documentar decisões em `decisions.md`
+- Checkpoint a cada 3 tasks implementadas
+- Usar Infrastructure as Code (Bicep)
+- Usar exclusivamente Microsoft Agent Framework (.NET 10)
+- Coletar input do usuário na FASE 1.5 (layout, referências, imagens)
+
+---
+
+## AGENTES E SKILLS
+
+### Relação: Agentes ↔ Skills
+
+**Agent = Metadata (quem sou, quando ativo)**
+**Skill = Implementação (como faço, prompts, workflows)**
+
+| Conceito | Definição | Localização |
+|----------|-----------|-------------|
+| **Agent** | Metadata: ID, keywords, responsabilidades | `.morph/config/agents.json` |
+| **Skill** | Implementação: prompts detalhados, exemplos | `.claude/skills/{categoria}/{agent-id}.md` |
+
+**Workflow unificado:**
+1. Keywords no user input → `detect-agents.js` retorna `[agent-ids]`
+2. Claude ativa agentes detectados
+3. Para agentes com `skillPath` → Claude invoca Skill tool
+4. Skill contém conhecimento especializado profundo
+
+**Exemplo:**
+```json
+{
+  "id": "uiux-designer",
+  "skillPath": ".claude/skills/specialists/ui-ux-designer.md",
+  "autoActivation": {
+    "keywords": ["blazor", "ui", "dashboard"]
+  }
+}
+```
+
+Quando usuário diz "criar dashboard", o CLI detecta `uiux-designer`, e Claude invoca o Skill para acessar conhecimento profundo de UI/UX.
+
+### Validação
+
+Use o CLI para validar consistência:
+
+```bash
+# Validar que todos skillPaths existem
+node bin/validate-agents-skills.js
+
+# Modo verbose (mostra todos os mappings)
+node bin/validate-agents-skills.js --verbose
+```
+
+Warnings de "orphan skills" são OK - são skills extras (infra/integrations) que podem ser usadas manualmente mas não têm agentes auto-ativados.
+
+---
+
+## AGENT ACTIVATION
+
+### Detecção Automática de Agentes
+
+**SEMPRE** use o CLI `bin/detect-agents.js` para detectar automaticamente quais agentes ativar:
+
+```bash
+# Detectar agentes baseado no input do usuário
+node bin/detect-agents.js "implementar jobs agendados"
+# Output: ["standards-architect","azure-architect","blazor-builder","ef-modeler","cost-guardian","ms-agent-expert","hangfire-orchestrator"]
+
+# Modo verbose para ver matches
+node bin/detect-agents.js --verbose "criar dashboard com charts"
+# Mostra quais keywords fizeram match
+
+# Modo JSON completo
+node bin/detect-agents.js --json "adicionar RAG pipeline"
+# Retorna objeto completo com core, specialists, matches
+```
+
+### Quando Detectar
+
+| Momento | Ação |
+|---------|------|
+| **FASE 0: PROPOSAL** | Rodar CLI com user input inicial |
+| **Adicionar features** | Rodar CLI sempre que escopo mudar |
+| **Design técnico** | Validar se todos agentes necessários estão ativos |
+
+### Agentes Detectados
+
+**Core Agents (sempre retornados):**
+- `standards-architect` - Validação de padrões
+- `azure-architect` - Infraestrutura Azure
+- `blazor-builder` - Componentes Blazor
+- `ef-modeler` - Entity Framework
+- `cost-guardian` - Validação de custos
+- `ms-agent-expert` - Microsoft Agent Framework
+
+**Specialist Agents (keyword-triggered):**
+- `hangfire-orchestrator` - Background jobs (keywords: scheduled, job, background, cron, queue)
+- `uiux-designer` - UI/UX Design (keywords: blazor, ui, dashboard, form, chart, wizard, component, page)
+- `popm-advisor` - Product/Requirements (keywords: unclear, requirements, priority, ROI, scope)
+- `ai-system-architect` - Sistemas agênticos (keywords: rag, vector search, orchestration, multi-agent, memory, embedding)
+
+### Integração com State
+
+Após detectar agentes, **SEMPRE** registrar no state.json:
+
+```bash
+# Para cada agente detectado
+node bin/state-manager.js add-agent {feature} {agent-id}
+```
+
+### Benefícios
+
+- ✅ **Zero tokens desperdiçados:** Não precisa ler agents.json manualmente
+- ✅ **Consistente:** Mesmo algoritmo sempre
+- ✅ **Rápido:** CLI retorna em <100ms
+- ✅ **Rastreável:** Agentes ficam registrados no state.json
+- ✅ **Completo:** Nunca esquece de ativar um agente relevante
+
+---
+
+## WORKFLOWS POR COMPLEXIDADE
+
+### Detecção Automática de Workflow
+
+**IMPORTANTE:** O MORPH-SPEC detecta automaticamente a complexidade do request e escolhe o workflow apropriado. Você **NÃO** precisa seguir sempre as 8 fases completas!
+
+```bash
+# Claude usa automaticamente o complexity-analyzer
+# Baseado no user input, classifica em:
+# - fast-track: Bug fixes, ajustes menores
+# - standard: Features simples, melhorias incrementais
+# - full-morph: Features complexas, arquitetura
+```
+
+### 🚀 Workflow 1: FAST TRACK (Trivial)
+
+**Para:** Bug fixes, hotfixes, ajustes de CSS, edge cases, correções menores
+
+**Critérios de Ativação:**
+- ≤ 3 arquivos modificados
+- ≤ 50 linhas de código
+- 0 novos componentes
+- Sem infraestrutura
+- Sem decisões arquiteturais
+
+**Fases:**
+1. **Quick Analysis** (combina FASE 0 + 1 + 2)
+   - Identifica problema em 2-3 parágrafos
+   - Propõe solução direta
+   - **1 PAUSA:** Aprovar ou ajustar?
+
+2. **Implement & Test**
+   - Implementa diretamente
+   - Testa
+   - Cria commit descritivo
+
+**Outputs:** Nenhum (ou apenas commit message detalhado)
+
+**Exemplos:**
+- "Corrigir validação de CPF no formulário"
+- "Ajustar cor do botão primário"
+- "Hotfix: null pointer na home"
+- "Corrigir typo no texto de erro"
+- "Edge case: validação quando campo vazio"
+
+---
+
+### ⚡ Workflow 2: STANDARD (Média)
+
+**Para:** Features simples, refactorings, melhorias incrementais, componentes isolados
+
+**Critérios de Ativação:**
+- 3-10 arquivos modificados
+- 50-500 linhas de código
+- 1-2 novos componentes simples
+- Sem infraestrutura complexa
+- Decisões táticas (não estratégicas)
+
+**Fases:**
+1. **FASE 0: PROPOSAL** (simplificada)
+   - Análise inicial em 1 parágrafo
+   - Detecta agentes relevantes
+   - **PAUSA:** Aprovar?
+
+2. **FASE 2: DESIGN** (apenas spec.md)
+   - Spec técnico conciso (1-2 páginas)
+   - Sem contracts.cs se trivial
+   - Decisões táticas em decisions.md
+   - **PAUSA:** Aprovar?
+
+3. **FASE 4: TASKS** (se > 5 tasks)
+   - Breakdown em tasks
+   - **PAUSA:** Aprovar?
+
+4. **FASE 5: IMPLEMENT**
+   - Implementa task por task
+   - Gera recap.md ao final
+
+**Outputs:** proposal.md, spec.md, recap.md (mínimo necessário)
+
+**Pula:**
+- FASE 1 (SETUP) - contexto já carregado
+- FASE 1.5 (UI/UX) - se não tiver front-end significativo
+- FASE 3 (CLARIFY) - se spec for claro
+- FASE 6 (SYNC) - decisões não são estratégicas
+
+**Exemplos:**
+- "Adicionar paginação na tabela de usuários"
+- "Criar filtro por data no relatório"
+- "Refatorar serviço de email para async"
+- "Melhorar performance da query de busca"
+- "Adicionar botão de exportar CSV"
+
+---
+
+### 🎯 Workflow 3: FULL MORPH (Alta/Complexa)
+
+**Para:** Features complexas, novos subsistemas, decisões arquiteturais, infraestrutura
+
+**Critérios de Ativação:**
+- > 10 arquivos modificados
+- > 500 linhas de código
+- Múltiplos componentes novos
+- Infraestrutura Azure (Bicep)
+- Decisões arquiteturais estratégicas
+- Múltiplos agentes especializados
+
+**Fases:** **TODAS as 8 fases obrigatórias**
+
+1. FASE 0.5: CONTEXT
+2. FASE 0: PROPOSAL
+3. FASE 1: SETUP
+4. FASE 1.5: UI/UX (se front-end)
+5. FASE 2: DESIGN
+6. FASE 3: CLARIFY
+7. FASE 4: TASKS
+8. FASE 5: IMPLEMENT
+9. FASE 6: SYNC
+
+**Outputs:** Todos os outputs completos (proposal, ui-*, spec, contracts, tasks, decisions, recap)
+
+**Exemplos:**
+- "Sistema de relatórios com jobs agendados Hangfire"
+- "Autenticação completa com Clerk (login, signup, OAuth)"
+- "Dashboard com gráficos, tabelas e filtros complexos"
+- "Sistema de notificações em tempo real com SignalR"
+- "RAG pipeline com Azure AI Search e embeddings"
+- "Infraestrutura Azure completa com Bicep (SQL, Container Apps, Storage)"
+
+---
+
+### Como o Workflow é Detectado
+
+Claude usa `src/lib/complexity-analyzer.js` para analisar automaticamente:
+
+```javascript
+// Análise automática do user input
+const analysis = analyzeRequestComplexity(userInput);
+
+// Resultado:
+{
+  workflow: "fast-track" | "standard" | "full-morph",
+  impact: {
+    estimatedFiles: 3,
+    estimatedLines: 50,
+    estimatedComponents: 0
+  },
+  hasInfrastructure: false,
+  hasArchitecturalDecisions: false,
+  confidence: "high" | "medium" | "low",
+  reason: "Estimated 3 files, 50 lines, 0 components"
+}
+```
+
+**Keywords detectadas:**
+- **Trivial:** "bug", "fix", "corrigir", "ajustar", "hotfix", "edge case", "cor", "css"
+- **Infraestrutura:** "azure", "bicep", "sql", "container", "deploy", "infra"
+- **Arquitetura:** "sistema", "autenticação", "integração", "pattern", "cqrs", "subsistema"
+
+### Override Manual
+
+Se Claude classificar errado, você pode forçar um workflow específico:
+
+```bash
+# Forçar fast-track (pula fases)
+morph-spec state set my-feature workflow fast-track
+
+# Forçar full-morph (todas as fases)
+morph-spec state set my-feature workflow full-morph
+
+# Ou no próprio pedido:
+"[FAST-TRACK] Corrigir bug de validação"
+"[FULL-MORPH] Adicionar filtro simples"
+```
+
+### Quadro Comparativo
+
+| Aspecto | Fast Track | Standard | Full MORPH |
+|---------|-----------|----------|------------|
+| **Fases** | 2 (Quick + Implement) | 4 (Proposal, Design, Tasks, Implement) | 9 (Todas) |
+| **Pausas** | 1 | 2-3 | 5-6 |
+| **Outputs** | Nenhum | 3 arquivos | 9+ arquivos |
+| **Tempo** | 5-15 min | 30-60 min | 2-4 horas |
+| **Tokens** | ~500-1k | ~5-10k | ~30-50k |
+| **Quando** | Bug fixes, ajustes | Features simples | Features complexas |
+
+---
+
+## AS 8 FASES OBRIGATÓRIAS (FULL MORPH)
+
+### FASE 0.5: CONTEXT (automática, primeira interação)
+```
+Gatilho: Início de qualquer interação (primeira mensagem ou nova sessão)
+
+Ações:
+1. Detectar Framework MORPH
+   - Verificar se npm package @polymorphism-tech/morph-spec está instalado
+   - Localizar framework/standards/ e framework/templates/
+   - Se não encontrado: ativar modo "inferred" (funciona sem framework)
+
+2. Detectar/Criar estrutura do projeto
+   - Verificar se existe .morph/project/
+   - Se NÃO: rodar detecção automática (estrutura + config + conversas)
+   - Se SIM: carregar context/, standards/, outputs/ existentes
+
+3. Análise Automática do Projeto (se código existe)
+   - Detectar stack: glob patterns (*.razor = Blazor, *.tsx + next.config = Next.js, etc)
+   - Detectar arquitetura: pastas (Application/, Domain/ = Clean Architecture, etc)
+   - Ler configs: Program.cs, package.json, .csproj para tecnologias e versões
+   - Detectar UI library: FluentUI.Blazor, MudBlazor em .csproj
+   - Identificar patterns: Repository, Service Layer, CQRS, DI, etc
+
+4. Analisar Histórico (se disponível)
+   - Ler .morph/project/outputs/*/decisions.md (decisões passadas)
+   - Ler .morph/project/context/decisions-history.md
+   - Extrair preferências do usuário (UI lib favorita, patterns preferidos)
+
+5. Gerar/Atualizar Standards Inferidos
+   - Criar .morph/project/standards/inferred.md
+   - Consolidar: framework standards + detecção + histórico
+   - Identificar gaps e gerar recomendações
+
+6. Ativar Agentes Relevantes
+   - Baseado em stack detectado (Blazor Builder, NextJS Expert, etc)
+   - Baseado em keywords da conversa/request
+
+Outputs:
+- .morph/project/context/README.md (se novo projeto)
+- .morph/project/standards/inferred.md (sempre atualizado)
+- .morph/project/context/detection-log.md (debug)
+- .morph/config.json (link para framework + project config)
+
+Modo Degradado (sem framework):
+- Funciona apenas com detecção de código
+- Standards inferidos baseados APENAS no código existente
+- Sem templates sofisticados, mas ainda útil
+```
+
+### FASE 0: PROPOSAL
+```
+Gatilho: Nova feature request do usuário
+Ações:
+1. **Detectar agentes automaticamente:**
+   node bin/detect-agents.js "{user-request}"
+
+2. Analisar a solicitação inicial
+3. Identificar stack provável (Blazor, Next.js, Shopify)
+4. Estimar complexidade (baixa, média, alta)
+5. Gerar proposal.md com análise inicial
+6. Registrar agentes no state.json:
+   node bin/state-manager.js add-agent {feature} {agent-id}
+
+Output: .morph/project/outputs/{feature}/proposal.md
+
+⛔ PAUSA OBRIGATÓRIA
+Apresentar ao usuário:
+- ✅ Ações sugeridas (2-3 opções de próximos passos)
+- ❓ Perguntas contextualizadas (para clarificar escopo/prioridades)
+- 💡 Sugestões estratégicas (alternativas, trade-offs, otimizações)
+
+Formato: 3 itens no total, mix inteligente de ações + perguntas
+```
+
+### FASE 1: SETUP
+```
+Gatilho: Proposal aprovado
+Ações:
+1. Ler `.morph/config.json` para contexto
+2. Confirmar stack identificado no proposal
+3. Ativar agentes conforme proposal
+4. Criar pasta `.morph/project/outputs/{feature}/`
+5. Carregar padrões:
+   - framework/standards/ (padrões do MORPH)
+   - .morph/project/standards/ (padrões do projeto)
+   - Priorizar project/standards/ se houver conflito
+
+Output: Confirmação de contexto carregado
+```
+
+### FASE 1.5: UI/UX DESIGN (se houver front-end)
+```
+Gatilho: Setup concluído + keywords de front-end detectadas
+Ações:
+1. **SEMPRE perguntar ao usuário PRIMEIRO**:
+   - "Você tem alguma ideia de layout em mente?"
+   - "Tem alguma referência visual? (sites, apps, screenshots)"
+   - "Como imagina o fluxo do usuário?"
+   - "Tem imagens de exemplo que eu possa analisar?"
+
+2. Analisar imagens/referências fornecidas (se houver)
+   - Use Read tool para ler screenshots
+   - Extrair padrões: layout, componentes, cores
+
+3. Decidir biblioteca UI (Fluent UI vs MudBlazor)
+   - Justificar escolha baseado na feature
+   - Documentar em decisions.md
+
+4. Gerar deliverables:
+   - ui-mockups.md (wireframes ASCII + descrições)
+   - ui-components.md (specs de componentes)
+   - ui-flows.md (fluxos + diagramas + edge cases)
+
+5. Validar acessibilidade (WCAG 2.1) e responsividade
+
+Outputs:
+- .morph/project/outputs/{feature}/ui-design-system.md
+- .morph/project/outputs/{feature}/ui-mockups.md
+- .morph/project/outputs/{feature}/ui-components.md
+- .morph/project/outputs/{feature}/ui-flows.md
+- Atualizar decisions.md com ADR sobre biblioteca UI
+
+Nota: Na FASE 5: IMPLEMENT, gerar automaticamente:
+- wwwroot/css/design-system.css (CSS variables)
+- Themes/FluentDesignTheme.cs (se Fluent UI)
+- Themes/MudTheme.cs (se MudBlazor)
+
+⛔ PAUSA OBRIGATÓRIA
+Apresentar ao usuário 3 ações sugeridas:
+- ✅ "Aprovar UI/UX e prosseguir para design técnico"
+- 🎨 "Ajustar wireframes/componentes de telas específicas"
+- 🔄 "Revisar biblioteca UI escolhida (Fluent UI ↔ MudBlazor)"
+- 📋 "Adicionar mais fluxos/edge cases"
+
+Formato: 3 das opções acima, escolhidas inteligentemente
+
+Nota: Esta fase SÓ executa se detectar keywords de front-end.
+Se não detectar, pula direto para FASE 2: DESIGN.
+```
+
+### FASE 2: DESIGN
+```
+Gatilho: Contexto confirmado (ou UI/UX aprovado se FASE 1.5 executou)
+Ações:
+1. Gerar `spec.md` com requisitos completos
+2. Gerar `contracts.cs` com interfaces/DTOs
+3. Iniciar `decisions.md` com ADRs relevantes
+4. Estimar custos e documentar
+5. Definir infraestrutura necessária (Bicep)
+
+Outputs:
+- .morph/project/outputs/{feature}/spec.md
+- .morph/project/outputs/{feature}/contracts.cs
+- .morph/project/outputs/{feature}/decisions.md
+
+⛔ PAUSA OBRIGATÓRIA
+Apresentar ao usuário 3 ações sugeridas:
+- ✅ "Aprovar e continuar para tasks" (se tudo ok)
+- 🔄 "Ajustar escopo/complexidade" (reduzir/expandir)
+- 💰 "Revisar custos estimados" (se houver recursos Azure)
+- 📋 "Modificar contracts" (ajustar interfaces/DTOs)
+- ❓ Pergunta contextualizada sobre prioridades/trade-offs
+
+Formato: 3 das opções acima, escolhidas inteligentemente
+```
+
+### FASE 3: CLARIFY
+```
+Gatilho: Design aprovado
+Ações:
+1. Identificar ambiguidades
+2. Fazer perguntas de clarificação
+3. Documentar respostas no spec.md
+4. Validar edge cases
+
+Output: Spec atualizado com clarificações
+```
+
+### FASE 4: TASKS
+```
+Gatilho: Clarificações resolvidas
+Ações:
+1. Quebrar spec em tasks (T001-TXXX)
+2. Definir ordem de execução
+3. Estabelecer checkpoints
+4. Mapear dependências
+5. Incluir tasks de IaC se necessário
+
+Output: .morph/project/outputs/{feature}/tasks.json
+
+⛔ PAUSA OBRIGATÓRIA
+Apresentar ao usuário 3 ações sugeridas:
+- ✅ "Aprovar breakdown e iniciar implementação"
+- 🔀 "Repriorizar tasks" (mudar ordem de execução)
+- ➕ "Adicionar/remover tasks" (ajustar escopo)
+
+Formato: Sempre as 3 ações acima (padrão para esta fase)
+```
+
+### FASE 5: IMPLEMENT
+```
+Gatilho: Tasks aprovadas
+Ações:
+1. Implementar task por task
+2. Executar testes a cada task
+3. Checkpoint a cada 3 tasks
+4. Gerar recap ao final
+
+Outputs:
+- Código implementado
+- Testes criados
+- .morph/project/outputs/{feature}/recap.md
+```
+
+### FASE 6: SYNC (condicional)
+```
+Gatilho: Implementação concluída + complexidade média/alta
+
+Ações:
+1. Revisar decisions.md da feature
+   - Identificar ADRs (Architectural Decision Records)
+   - Identificar padrões técnicos adotados
+   - Identificar convenções e nomenclaturas
+   - Identificar configurações de integrações
+
+2. Categorizar decisões
+   - coding: Padrões de código, nomenclatura, testes
+   - architecture: Patterns, camadas, dependências
+   - azure: Infrastructure, deployment, recursos
+   - integrations: APIs, webhooks, auth, serviços externos
+   - ui-ux: Componentes, temas, bibliotecas UI
+
+3. Promover para Standards
+   - Atualizar .morph/project/standards/{category}.md
+   - Adicionar seção com data e feature origin
+   - Manter histórico de evolução dos standards
+
+4. Gerar Commit Dedicado
+   ```
+   sync: Update project standards from {feature-name}
+
+   Decisions promoted:
+   - coding: Primary constructors pattern
+   - architecture: CQRS for complex operations
+   - ui-ux: Fluent UI for AI components
+
+   Standards updated:
+   - .morph/project/standards/coding.md
+   - .morph/project/standards/architecture.md
+
+   Co-Authored-By: Claude <noreply@anthropic.com>
+   ```
+
+Outputs:
+- .morph/project/standards/*.md (atualizados)
+- Commit dedicado de sync
+
+Quando pular esta fase:
+- Complexidade baixa (feature trivial)
+- Sem decisões arquiteturais significativas
+- Apenas bug fixes ou ajustes menores
+
+⛔ PAUSA OBRIGATÓRIA (se fase executar)
+Apresentar decisões candidatas ao usuário:
+- Listar decisões por categoria
+- Pedir aprovação para promover
+- Opção de editar antes de promover
+```
+
+---
+
+## FLUXO VISUAL DAS FASES
+
+```
+┌────────────────────────────────────────────────────────────────────────────┐
+│                      MORPH-SPEC WORKFLOW COMPLETO                          │
+└────────────────────────────────────────────────────────────────────────────┘
+
+  [INÍCIO] Nova sessão ou feature request
+      │
+      ▼
+┌─────────────────────┐
+│ FASE 0.5: CONTEXT   │ ← Automática (primeira interação)
+│ (Detecta framework, │
+│  projeto, standards)│
+└──────────┬──────────┘
+           │
+           ▼
+┌─────────────────────┐
+│ FASE 0: PROPOSAL    │ ← User request
+│ (Análise inicial +  │
+│  agentes ativados)  │
+└──────────┬──────────┘
+           │
+           ⛔ PAUSA → Aprovação do usuário
+           │
+           ▼
+┌─────────────────────┐
+│ FASE 1: SETUP       │
+│ (Carregar context + │
+│  standards)         │
+└──────────┬──────────┘
+           │
+           ├────────── Keywords UI/UX detectadas?
+           │                │
+           │               SIM ──────┐
+           │                         ▼
+           │              ┌─────────────────────┐
+           │              │ FASE 1.5: UI/UX     │ ← Condicional
+           │              │ (Wireframes, specs, │
+           │              │  componentes)       │
+           │              └──────────┬──────────┘
+           │                         │
+           │                         ⛔ PAUSA → Aprovação do usuário
+           │                         │
+           NÃO ────────────────────────┘
+           │
+           ▼
+┌─────────────────────┐
+│ FASE 2: DESIGN      │
+│ (Spec, contracts,   │
+│  decisions, custos) │
+└──────────┬──────────┘
+           │
+           ⛔ PAUSA → Aprovação do usuário
+           │
+           ▼
+┌─────────────────────┐
+│ FASE 3: CLARIFY     │
+│ (Perguntas de       │
+│  clarificação)      │
+└──────────┬──────────┘
+           │
+           ▼
+┌─────────────────────┐
+│ FASE 4: TASKS       │
+│ (Breakdown em       │
+│  T001-TXXX)         │
+└──────────┬──────────┘
+           │
+           ⛔ PAUSA → Aprovação do usuário
+           │
+           ▼
+┌─────────────────────┐
+│ FASE 5: IMPLEMENT   │
+│ (Task por task +    │
+│  checkpoints)       │
+└──────────┬──────────┘
+           │
+           ├────────── Complexidade média/alta + ADRs significativos?
+           │                │
+           │               SIM ──────┐
+           │                         ▼
+           │              ┌─────────────────────┐
+           │              │ FASE 6: SYNC        │ ← Condicional
+           │              │ (Promover decisions │
+           │              │  para standards)    │
+           │              └──────────┬──────────┘
+           │                         │
+           │                         ⛔ PAUSA → Aprovação do usuário
+           │                         │
+           NÃO ────────────────────────┘
+           │
+           ▼
+      [FIM] Feature concluída
+
+┌────────────────────────────────────────────────────────────────────────────┐
+│ LEGENDA                                                                    │
+├────────────────────────────────────────────────────────────────────────────┤
+│ ⛔ PAUSA OBRIGATÓRIA - Aguarda interação do usuário                       │
+│ ─── Fluxo principal (sempre executado)                                    │
+│ ├── Decisão condicional                                                   │
+│ [FASE X.Y] Fase intermediária/condicional                                 │
+│ [FASE X] Fase principal obrigatória                                       │
+└────────────────────────────────────────────────────────────────────────────┘
+```
+
+**Fases Obrigatórias:** 0, 1, 2, 3, 4, 5 (6 fases principais)
+**Fases Condicionais:** 0.5 (auto), 1.5 (se UI), 6 (se complexo)
+**Total:** 9 fases possíveis, 6-9 executadas dependendo do contexto
+
+---
+
+## PAUSAS INTERATIVAS
+
+### Princípio
+Toda pausa obrigatória DEVE terminar com **exatamente 3 itens** que ajudem o usuário a tomar decisões.
+
+### Tipos de Itens
+
+| Emoji | Tipo | Quando Usar | Exemplo |
+|-------|------|-------------|---------|
+| ✅ | Ação de Aprovação | Quando está pronto para avançar | "Aprovar e continuar para próxima fase" |
+| 🔄 | Ação de Ajuste | Quando há algo para modificar | "Ajustar escopo da feature" |
+| 💰 | Ação de Custo | Quando há recursos Azure | "Revisar custos estimados" |
+| 📋 | Ação de Revisão | Quando há artefatos para validar | "Modificar contracts gerados" |
+| ❓ | Pergunta Aberta | Para clarificar intenções | "Qual a prioridade: performance ou custo?" |
+| 💡 | Sugestão Estratégica | Para propor alternativas | "Considerar serverless em vez de Container App?" |
+| ⚡ | Ação Rápida | Atalho para comum | "Usar padrão CQRS nesta feature?" |
+
+### Estratégia por Fase
+
+| Fase | Mix Recomendado | Objetivo |
+|------|----------------|----------|
+| **FASE 0: PROPOSAL** | 1 ação + 1 pergunta + 1 sugestão | Entender intenção e escopo |
+| **FASE 2: DESIGN** | 2 ações + 1 pergunta/sugestão | Validar solução proposta |
+| **FASE 4: TASKS** | 3 ações (padrão fixo) | Confirmar plano de execução |
+
+### Template de Pausa
+
+```markdown
+---
+⛔ **PAUSA OBRIGATÓRIA**
+
+{Breve contexto do que foi feito}
+
+**Próximos passos sugeridos:**
+
+1. {Emoji} **{Título da ação/pergunta}**
+   {Descrição breve do que acontece se escolher esta opção}
+
+2. {Emoji} **{Título da ação/pergunta}**
+   {Descrição breve}
+
+3. {Emoji} **{Título da ação/pergunta}**
+   {Descrição breve}
+
+---
+```
+
+### Exemplo Real
+
+```markdown
+---
+⛔ **PAUSA OBRIGATÓRIA**
+
+Analisamos sua solicitação de "Sistema de pagamentos recorrentes com Asaas".
+Complexidade estimada: **MÉDIA** | Stack: **.NET + Blazor** | Custo: **~$5/mês**
+
+**Próximos passos sugeridos:**
+
+1. ✅ **Aprovar e prosseguir para design detalhado**
+   Gerar spec.md, contracts e estimativa completa de custos
+
+2. ❓ **Esclarecer modelo de negócio**
+   Você pretende cobrar por assinatura mensal, anual ou ambos? Isso afeta o design.
+
+3. 💡 **Considerar MVP incremental**
+   Começar só com pagamentos únicos e adicionar recorrência depois?
+
+---
+```
+
+---
+
+## AGENTES
+
+### Core Agents (Sempre Ativos)
+
+| Agente | Responsabilidades |
+|--------|-------------------|
+| **Standards Architect** | Padrões em `framework/standards/` e `project/standards/`, nomenclatura, revisão |
+| **Azure Architect** | Infra Azure, Bicep IaC, App Service, Container Apps, SQL |
+| **Cost Guardian** | Validar custos, alertar recursos caros, bloquear não aprovados |
+
+### Stack Agents (Por Stack)
+
+| Agente | Stack | Keywords |
+|--------|-------|----------|
+| **Blazor Builder** | .NET + Blazor | blazor, razor, server-side |
+| **NextJS Expert** | .NET + Next.js | nextjs, react, api, frontend |
+| **Shopify Expert** | Shopify | shopify, hydrogen, liquid |
+
+### Specialist Agents (Sob Demanda)
+
+| Agente | Keywords de Ativação |
+|--------|---------------------|
+| **EF Modeler** | entity, database, migration, ef core |
+| **Agent Framework Expert** | agent, ai, llm, rag, embedding (.NET 10) |
+| **Hangfire Orchestrator** | scheduled, job, background, cron |
+| **UI/UX Designer** | **PT-BR:** tela, interface, formulário, visualização, mostrar, exibir, cadastro<br>**EN:** screen, view, display, form, show, render, create<br>**Components:** wizard, dashboard, chart, dialog, modal, card, list, grid<br>**Stack:** blazor, ui, ux, page, component, frontend<br>(FASE 1.5 obrigatória) |
+| **PO/PM Advisor** | unclear, requirements, priority, ROI |
+
+### Integration Agents (Sob Demanda)
+
+| Agente | Keywords | Docs |
+|--------|----------|------|
+| **Asaas Financial** | asaas, payment, pix, boleto | [API](https://docs.asaas.com/) |
+| **Clerk Auth** | clerk, auth, login, signup | [SDK](https://clerk.com/) |
+| **Azure Identity** | identity, entra, microsoft auth | [Docs](https://learn.microsoft.com/entra/) |
+
+### Infra Agents (Sob Demanda)
+
+| Agente | Keywords | Docs |
+|--------|----------|------|
+| **Bicep Architect** | bicep, iac, infra, provision | [Bicep](https://learn.microsoft.com/azure/azure-resource-manager/bicep/) |
+| **DevOps Engineer** | pipeline, ci/cd, deploy, release | [Pipelines](https://learn.microsoft.com/azure/devops/pipelines/) |
+| **Container Specialist** | docker, container, containerize | [Container Apps](https://learn.microsoft.com/azure/container-apps/) |
+
+---
+
+## LIMITES DE CUSTO
+
+### Limites Configuráveis
+
+Os limites de custo são definidos em `.morph/config/config.json` e podem ser customizados por projeto:
+
+```json
+{
+  "costs": {
+    "monthlyBudget": 15,
+    "currency": "USD",
+    "limits": {
+      "freeTierOnly": 0,
+      "withApproval": 10,
+      "requiresADR": 10
+    },
+    "enforcement": {
+      "blockCommitsAboveLimit": true,
+      "requireADRInDecisionsMd": true,
+      "alertOnApproach": 0.8
+    }
+  }
+}
+```
+
+| Limite | Padrão | Descrição | Requisito |
+|--------|--------|-----------|-----------|
+| `freeTierOnly` | $0 | Apenas recursos free tier | Nenhum |
+| `withApproval` | $10 | Requer confirmação do usuário | Aprovação explícita |
+| `requiresADR` | $10 | Requer ADR documentado | ADR em decisions.md |
+
+### Cost Calculator CLI
+
+**Validação automática de custos:**
+
+```bash
+# Calcular custos de arquivos Bicep
+node bin/calculate-costs.js infra/main.bicep --verbose
+
+# Múltiplos arquivos (glob pattern)
+node bin/calculate-costs.js "infra/**/*.bicep" --json
+
+# Usar config customizado
+node bin/calculate-costs.js infra/main.bicep --config .morph/config/config.json
+```
+
+**Funcionalidades:**
+- ✅ Parseia arquivos Bicep e extrai recursos + SKUs
+- ✅ Calcula custo mensal baseado em pricing table do Azure
+- ✅ Valida contra limites configurados
+- ✅ Exit code 1 se exceder limite `requiresADR`
+- ✅ Output JSON ou verbose (ASCII table)
+
+**Pricing table inclui:**
+- Azure SQL Database (Free, Basic, S0-S4, P1-P2, GP, BC)
+- Container Apps (Consumption, Dedicated)
+- Storage Account (LRS, GRS, Premium)
+- Application Insights (Free, Basic)
+- Key Vault (Standard, Premium)
+- Cosmos DB (Serverless, Provisioned)
+- App Service (F1, D1, B1-B2, S1, P1v2)
+- Service Bus (Basic, Standard, Premium)
+- Redis Cache (C0-C2, P1)
+- Azure Functions (Consumption, Premium)
+
+### Pre-commit Hook
+
+**Bloqueio automático de commits caros:**
+
+```bash
+# Instalar hook
+cp .morph/hooks/pre-commit-costs.sh .git/hooks/pre-commit
+chmod +x .git/hooks/pre-commit
+
+# Ou symlink
+ln -s ../../.morph/hooks/pre-commit-costs.sh .git/hooks/pre-commit
+```
+
+**Comportamento:**
+1. Detecta arquivos Bicep modificados no staged area
+2. Roda cost calculator automaticamente
+3. Se custo > `requiresADR`: procura ADR em decisions.md
+4. **Bloqueia commit** se ADR não encontrado
+5. Mensagem clara de erro com instruções
+
+### Quando Usar
+
+| Fase | Ação | CLI |
+|------|------|-----|
+| **FASE 2 (Design)** | Estimar custos de infra proposta | `/morph-design` (integrado) |
+| **Antes de commit** | Validar custos automaticamente | Pre-commit hook |
+| **Revisão manual** | Verificar custos de Bicep | `calculate-costs.js --verbose` |
+
+### Exemplo de ADR de Custo
+
+Se custo > `requiresADR`, documente em `decisions.md`:
+
+```markdown
+## ADR-003: Infrastructure Costs
+
+**Estimated Monthly Cost:** $12.50
+
+**Breakdown:**
+- Azure SQL S0: $14.72/mo
+- Container App (scale-to-zero): $0.00/mo
+- Storage LRS: $0.02/mo
+
+**Justification:**
+S0 tier necessary for 50k+ rows with indexed queries.
+Basic tier ($ 4.99) insufficient for expected load.
+
+**Alternatives Considered:**
+- Basic tier: Too slow for projected 1M queries/month
+- Cosmos DB: More expensive ($23.36 minimum)
+
+**Approval:** [User/Team] on 2024-01-15
+```
+
+---
+
+## INFRASTRUCTURE AS CODE
+
+### Princípio: Zero Portal
+
+> NUNCA criar recursos Azure manualmente. Tudo via Bicep.
+
+### Estrutura IaC
+
+```
+infra/
+├── main.bicep                # Entry point
+├── parameters.dev.json       # Params dev
+├── parameters.prod.json      # Params prod
+└── modules/
+    ├── app-service.bicep
+    ├── container-app.bicep
+    ├── sql-database.bicep
+    ├── storage.bicep
+    ├── key-vault.bicep
+    └── app-insights.bicep
+```
+
+### Quando usar SDK .NET vs Bicep
+
+| Recurso | Abordagem |
+|---------|-----------|
+| Infra estática (SQL, Storage, Container Apps) | Bicep |
+| Recursos dinâmicos (Fabric, Azure AI) | SDK .NET |
+| CI/CD | YAML + Bicep |
+
+---
+
+## ESTRUTURA DE OUTPUTS
+
+```
+.morph/project/outputs/{feature-name}/
+├── proposal.md          # Análise inicial e proposta (FASE 0)
+├── ui-design-system.md  # Design system: cores, tipografia, spacing (FASE 1.5 - se front-end)
+├── ui-mockups.md        # Wireframes ASCII + descrições (FASE 1.5 - se front-end)
+├── ui-components.md     # Specs componentes Fluent UI/MudBlazor (FASE 1.5 - se front-end)
+├── ui-flows.md          # Fluxos de usuário + diagramas (FASE 1.5 - se front-end)
+├── spec.md              # Especificação técnica completa (FASE 2)
+├── contracts.cs         # Interfaces, DTOs, Enums (FASE 2)
+├── tasks.json           # Lista de tasks (FASE 4)
+├── decisions.md         # ADRs (FASE 2+, atualizado na FASE 1.5 com UI lib)
+└── recap.md             # Resumo pós-implementação (FASE 5)
+```
+
+**Nota:** Arquivos `ui-*.md` são gerados apenas se a feature envolver front-end (keywords detectadas).
+
+**Arquivos de Tema** (gerados na FASE 5 baseados em ui-design-system.md):
+- `wwwroot/css/design-system.css` - CSS Variables
+- `Themes/FluentDesignTheme.cs` - Se Fluent UI
+- `Themes/MudTheme.cs` - Se MudBlazor
+
+---
+
+## STATE MANAGEMENT
+
+O MORPH-SPEC rastreia automaticamente o progresso de features usando `.morph/state.json`.
+
+### Arquivo de State
+
+```json
+{
+  "version": "2.1.1",
+  "project": {
+    "name": "ProjectName",
+    "type": "blazor-server",
+    "createdAt": "2024-01-15T10:00:00Z",
+    "updatedAt": "2024-01-15T14:30:00Z"
+  },
+  "features": {
+    "feature-name": {
+      "status": "in_progress",
+      "phase": "implement",
+      "activeAgents": ["blazor-builder", "ef-modeler"],
+      "outputs": {
+        "proposal": { "created": true, "path": ".morph/project/outputs/..." },
+        "spec": { "created": true, "path": ".morph/project/outputs/..." },
+        "tasks": { "created": true, "path": ".morph/project/outputs/..." }
+      },
+      "tasks": {
+        "total": 12,
+        "completed": 5,
+        "inProgress": 1,
+        "pending": 6
+      },
+      "checkpoints": [
+        {
+          "timestamp": "2024-01-15T12:00:00Z",
+          "phase": "implement",
+          "completedTasks": 3,
+          "note": "Checkpoint após T001-T003"
+        }
+      ],
+      "costs": {
+        "estimated": 2.50,
+        "approved": true
+      }
+    }
+  },
+  "metadata": {
+    "totalFeatures": 1,
+    "completedFeatures": 0,
+    "totalCostEstimated": 2.50
+  }
+}
+```
+
+### CLI para State Management
+
+Use `bin/state-manager.js` para manipular o state:
+
+```bash
+# Inicializar state (primeira vez)
+node bin/state-manager.js init
+
+# Criar/atualizar feature
+node bin/state-manager.js set feature-name phase design
+node bin/state-manager.js set feature-name status in_progress
+
+# Atualizar tasks
+node bin/state-manager.js set feature-name tasks.completed 5
+node bin/state-manager.js set feature-name tasks.total 12
+
+# Adicionar agentes
+node bin/state-manager.js add-agent feature-name blazor-builder
+
+# Marcar outputs como criados
+node bin/state-manager.js mark-output feature-name spec
+node bin/state-manager.js mark-output feature-name contracts
+
+# Registrar checkpoint
+node bin/state-manager.js checkpoint feature-name "Completadas tasks T001-T003"
+
+# Listar todas as features
+node bin/state-manager.js list
+
+# Obter detalhes de uma feature (JSON)
+node bin/state-manager.js get feature-name
+```
+
+### Quando Atualizar State
+
+**SEMPRE** atualize o state nos seguintes momentos:
+
+| Momento | Comando |
+|---------|---------|
+| **Criar proposal** (FASE 0) | `set {feature} phase proposal`<br>`mark-output {feature} proposal` |
+| **Iniciar design** (FASE 2) | `set {feature} phase design`<br>`add-agent {feature} {agent-id}` |
+| **Aprovar design** | `set {feature} status approved`<br>`mark-output {feature} spec`<br>`mark-output {feature} contracts` |
+| **Iniciar implementação** (FASE 5) | `set {feature} phase implement`<br>`set {feature} status in_progress`<br>`set {feature} tasks.total {N}` |
+| **Completar task** | `set {feature} tasks.completed {X}` |
+| **Checkpoint (a cada 3 tasks)** | `checkpoint {feature} "nota"` |
+| **Finalizar feature** | `set {feature} status done`<br>`mark-output {feature} recap` |
+
+### Benefícios
+
+- ✅ **Persistência**: Estado mantido entre sessões
+- ✅ **Rastreamento**: Saber exatamente em qual fase cada feature está
+- ✅ **Progresso**: Visualizar tasks completadas vs total
+- ✅ **Histórico**: Checkpoints registrados com timestamps
+- ✅ **Custos**: Rastreamento de custos estimados e aprovações
+- ✅ **Dashboard**: Comando `list` gera visualização ASCII automática
+
+---
+
+## COMANDOS
+
+### Comandos CLI (via npm package)
+
+| Comando | Descrição | Quando Usar |
+|---------|-----------|-------------|
+| `morph-spec init` | Inicializar MORPH no projeto | Primeira vez em um projeto |
+| `morph-spec detect` | Detectar stack/patterns | Projeto existente, entender estrutura |
+| `morph-spec sync` | Sincronizar standards | Após implementar features |
+| `morph-spec update` | Atualizar framework | Nova versão do MORPH disponível |
+| `morph-spec doctor` | Check de saúde | Diagnosticar problemas |
+| `morph-spec state <action>` | Gerenciar state.json | Rastrear features, progresso, agentes |
+| `morph-spec cost <bicep-files>` | Calcular custos Azure | Validar custos de infraestrutura |
+| `morph-spec generate design-system` | Gerar CSS + temas | Após aprovar UI/UX design |
+
+### Story-Driven Development Commands
+
+| Comando | Descrição | Quando Usar |
+|---------|-----------|-------------|
+| `morph-spec story create <feature> <story-id>` | Criar story com Dev Notes auto-injetadas | Início da implementação |
+| `morph-spec story shard <feature>` | Dividir spec.md em shards (90% token savings) | Feature com spec grande (5+ seções) |
+| `morph-spec story status <feature> show` | Ver progresso do sprint | Qualquer momento |
+| `morph-spec story status <feature> start <id>` | Marcar story como in_progress | Antes de implementar |
+| `morph-spec story status <feature> qa <id>` | Marcar story como ready_for_qa | Após implementar |
+| `morph-spec story status <feature> done <id>` | Marcar story como done | Após QA aprovar |
+| `morph-spec story status <feature> next` | Mostrar próxima story | Planejar próximo trabalho |
+
+**Options:**
+- `--title <title>` - Título da story
+- `--tasks <tasks>` - Lista de tasks separadas por vírgula
+- `--dry-run` - Preview sem escrever arquivos
+- `--verbose` - Mostrar informações detalhadas
+
+**Exemplo completo:**
+```bash
+# 1. Shardar spec (opcional)
+morph-spec story shard scheduled-reports
+
+# 2. Criar stories
+morph-spec story create scheduled-reports SR-001 \
+  --title "Create entity" \
+  --tasks "Create entity,EF mapping,Migration,Tests"
+
+# 3. Implementar
+morph-spec story status scheduled-reports start SR-001
+# [Claude implementa código]
+morph-spec story status scheduled-reports qa SR-001
+
+# 4. QA
+# [Claude revisa código]
+morph-spec story status scheduled-reports done SR-001
+
+# 5. Ver progresso
+morph-spec story status scheduled-reports show
+```
+
+**Ver também:** `content/.morph/docs/STORY-DRIVEN-DEVELOPMENT.md` para guia completo.
+
+### State Management Command
+
+**Gerencia state.json para rastreamento de features:**
+
+```bash
+# Inicializar state.json
+morph-spec state init [--force] [--project <name>] [--type <type>]
+
+# Ver feature
+morph-spec state get <feature> [--json]
+
+# Atualizar propriedade (suporta dot notation)
+morph-spec state set <feature> <key> <value>
+
+# Registrar checkpoint
+morph-spec state checkpoint <feature> "<note>"
+
+# Listar todas as features
+morph-spec state list
+
+# Gerenciar agentes
+morph-spec state add-agent <feature> <agent-id>
+morph-spec state remove-agent <feature> <agent-id>
+
+# Marcar outputs como criados
+morph-spec state mark-output <feature> <output-type>
+```
+
+**Uso automático interno:**
+- `morph-spec story create/status` atualiza state automaticamente
+- Slash commands `/morph-*` registram fases e checkpoints
+- Todos os comandos que geram outputs marcam no state
+
+**Exemplo completo:**
+```bash
+# Setup inicial
+morph-spec state init --project "MyApp" --type "blazor-server"
+
+# Durante feature
+morph-spec state set scheduled-reports phase design
+morph-spec state add-agent scheduled-reports blazor-builder
+morph-spec state mark-output scheduled-reports spec
+
+# Checkpoints (automáticos ou manuais)
+morph-spec state checkpoint scheduled-reports "Completed T001-T003"
+
+# Ver progresso
+morph-spec state list
+```
+
+### Cost Calculator Command
+
+**Calcula custos de infraestrutura Azure de arquivos Bicep:**
+
+```bash
+# Calcular custos
+morph-spec cost <bicep-files> [--verbose] [--json] [--strict]
+
+# Exemplos
+morph-spec cost infra/main.bicep --verbose
+morph-spec cost "infra/**/*.bicep" --json
+morph-spec cost infra/main.bicep --strict  # Exit code 1 se > ADR threshold
+```
+
+**Uso automático interno:**
+- `/morph-design` calcula custos automaticamente se detectar Bicep
+- Pre-commit hook valida custos antes de commitar
+- `morph-spec story create` alerta se tasks incluem "bicep"
+
+**Pricing table inclui:**
+- Azure SQL Database (Free, Basic, S0-S4, P1-P2, GP, BC)
+- Container Apps (Consumption, Dedicated)
+- Storage Account, Application Insights, Key Vault
+- Cosmos DB, App Service, Service Bus, Redis, Functions
+
+**Validação automática:**
+- Alerta se custo > `freeTierOnly` (requer aprovação)
+- Bloqueia se custo > `requiresADR` (requer ADR em decisions.md)
+- Pre-commit hook impede commits sem ADR
+
+### Generate Design System Command
+
+**Gera CSS + temas C# a partir de ui-design-system.md:**
+
+```bash
+# Gerar design system
+morph-spec generate design-system <ui-design-system.md> [options]
+
+# Opções
+--fluent              # Apenas Fluent UI theme
+--mud                 # Apenas MudBlazor theme
+--both                # Ambos os temas (padrão)
+--namespace <ns>      # Namespace C# (padrão: YourProject.Themes)
+--dry-run             # Preview sem escrever arquivos
+
+# Exemplos
+morph-spec generate design-system .morph/project/outputs/my-feature/ui-design-system.md --fluent
+morph-spec generate design-system .morph/project/outputs/my-feature/ui-design-system.md --both
+```
+
+**Arquivos gerados:**
+- `wwwroot/css/design-system.css` - CSS variables
+- `Themes/FluentDesignTheme.cs` - Tema Fluent UI (se --fluent ou --both)
+- `Themes/MudDesignTheme.cs` - Tema MudBlazor (se --mud ou --both)
+
+**Uso automático interno:**
+- `/morph-uiux` gera temas automaticamente após aprovar design
+- FASE 5: IMPLEMENT regenera se ui-design-system.md for modificado
+
+**Parsing automático de:**
+- Primary/Secondary/Neutral colors (#hex)
+- Semantic colors (Success, Error, Warning, Info)
+- Font families, sizes, weights
+- Spacing values (margin, padding, gap)
+
+---
+
+### Slash Commands (Claude Code)
+
+Comandos disponíveis para cada fase do workflow:
+
+| Comando | Fase | Descrição |
+|---------|------|-----------|
+| `/morph-proposal {feature}` | FASE 0 | Criar proposta inicial, detectar agentes |
+| `/morph-setup {feature}` | FASE 1 | Carregar contexto, confirmar stack e padrões |
+| `/morph-uiux {feature}` | FASE 1.5 | Coletar UI/UX, gerar wireframes e specs de componentes (condicional) |
+| `/morph-design {feature}` | FASE 2 | Gerar spec.md, contracts.cs, decisions.md, estimar custos |
+| `/morph-clarify {feature}` | FASE 3 | Identificar ambiguidades, fazer perguntas de clarificação |
+| `/morph-tasks {feature}` | FASE 4 | Quebrar spec em tasks executáveis, definir checkpoints |
+| `/morph-apply {feature}` | FASE 5 | Implementar tasks sequencialmente com validação de fases |
+| `/morph-status` | Qualquer | Mostrar dashboard de progresso com state.json |
+| `/morph-archive {feature}` | Pós-impl | Arquivar feature concluída |
+
+**Uso típico:**
+
+```bash
+# 1. Criar proposta
+/morph-proposal scheduled-reports
+
+# 2. Setup (após aprovação)
+/morph-setup scheduled-reports
+
+# 3. UI/UX (se necessário)
+/morph-uiux scheduled-reports
+
+# 4. Design técnico
+/morph-design scheduled-reports
+
+# 5. Clarificações
+/morph-clarify scheduled-reports
+
+# 6. Breakdown de tasks
+/morph-tasks scheduled-reports
+
+# 7. Implementação
+/morph-apply scheduled-reports
+
+# 8. Ver status a qualquer momento
+/morph-status
+
+# 9. Arquivar quando completo
+/morph-archive scheduled-reports
+```
+
+**Validação de fases:**
+- `/morph-apply` valida que TODAS as fases anteriores foram concluídas
+- Impossível pular fases (segurança do workflow)
+- State.json rastreia progresso automaticamente
+
+---
+
+## REFERÊNCIAS
+
+### Framework Standards (Read-only, do MORPH)
+- `framework/standards/coding.md` - Padrões de código
+- `framework/standards/architecture.md` - Padrões de arquitetura
+- `framework/standards/azure.md` - Padrões Azure e IaC
+- `framework/standards/agent-framework-setup.md` - Setup Agent Framework (.NET 10)
+- `framework/standards/passkeys-auth.md` - Autenticação com Passkeys/WebAuthn
+- `framework/standards/vector-search-rag.md` - Vector Search + RAG com EF Core 10
+- `framework/standards/dotnet10-migration.md` - Guia de migração .NET 9 → 10
+- `framework/standards/fluent-ui-setup.md` - UI Library recomendada (Fluent UI Blazor)
+- `framework/standards/migration-guide.md` - Guia de migração App Service → Container Apps
+
+### Framework Templates
+- `framework/templates/` - Templates para outputs de features
+- `framework/templates/infra/` - Templates Bicep e scripts de deploy
+
+### Project Context (Editável, do projeto)
+- `.morph/project/context/README.md` - Overview do projeto
+- `.morph/project/standards/inferred.md` - Standards detectados automaticamente
+- `.morph/project/standards/*.md` - Overrides e extensões dos standards
+- `.morph/project/outputs/` - Features em desenvolvimento
+- `.morph/config.json` - Config do projeto + link para framework
+
+### Azure DevOps (se aplicável)
+- `.azure/README.md` - Overview completo de CI/CD
+- `.azure/pipelines/` - Pipelines (staging, prod)
+- `.azure/docs/azure-devops-setup.md` - Setup Workload Identity Federation
+
+---
+
+*MORPH-SPEC by Polymorphism Tech*