# MORPH Tasks - FASE 4

Quebre a especificação em tasks executáveis, defina ordem de execução e estabeleça checkpoints.

## Uso

```
/morph-tasks {feature-name}
```

## Pré-requisitos

- [ ] FASE 3 (Clarify) concluída
- [ ] `spec.md` atualizado com clarificações
- [ ] Todos os edge cases documentados

## Workflow

### Passo 1: Analisar Spec

Leia `.morph/project/outputs/{feature}/spec.md` e identifique:

1. **Requisitos funcionais** (FR001, FR002, ...)
2. **Componentes técnicos** (Entities, Services, Controllers, Pages)
3. **Infraestrutura** (Bicep, migrations, configs)
4. **Testes** (Unit tests, integration tests)

### Passo 2: Quebrar em Tasks

Crie tasks no formato **T{NNN}** seguindo ordem lógica de implementação.

#### 2.1. Estrutura de Task

```json
{
  "id": "T001",
  "title": "Criar Entity {Nome}",
  "description": "Implementar entity {Nome} com propriedades X, Y, Z seguindo padrões EF Core",
  "category": "domain",
  "dependencies": [],
  "estimatedMinutes": 30,
  "status": "pending",
  "files": [
    "Domain/Entities/{Nome}.cs",
    "Infrastructure/Data/Configurations/{Nome}Configuration.cs"
  ]
}
```

#### 2.2. Categorias de Tasks

| Categoria | Descrição | Exemplos |
|-----------|-----------|----------|
| **domain** | Entities, Value Objects, Enums | Entity, DomainException |
| **application** | Services, DTOs, Interfaces | Service, Validator, Mapper |
| **infrastructure** | DbContext, Repositories, External APIs | EF Config, Repository impl |
| **presentation** | Controllers, Pages, Components | API endpoint, Blazor page |
| **tests** | Unit tests, Integration tests | Service tests, API tests |
| **infra** | Bicep, Migrations, Scripts | Azure resources, DB migration |
| **docs** | README, API docs, Swagger | OpenAPI spec, README update |

#### 2.3. Ordem de Implementação

**Bottom-up approach:**
```
1. Domain (Entities, Enums, Value Objects)
   ↓
2. Infrastructure (Repositories, DbContext configs)
   ↓
3. Application (Services, DTOs, Business logic)
   ↓
4. Presentation (Controllers, Pages, Components)
   ↓
5. Tests (Unit → Integration)
   ↓
6. Infra (Bicep, Migrations, Deploy scripts)
   ↓
7. Docs (README, Swagger, Comments)
```

### Passo 3: Definir Dependências

Para cada task, especifique dependências:

```json
{
  "id": "T005",
  "title": "Criar {Nome}Service",
  "dependencies": ["T001", "T002"], // Precisa de Entities primeiro
  "status": "pending"
}
```

**Regra:** Task só pode ser executada quando todas as dependências estão `completed`.

### Passo 4: Estabelecer Checkpoints

Defina checkpoints a cada **3 tasks** ou **marcos significativos**:

```json
{
  "id": "CHECKPOINT_001",
  "title": "Domain Layer Completo",
  "afterTasks": ["T001", "T002", "T003"],
  "validations": [
    "Todas as entities criadas",
    "Migrations aplicadas",
    "Testes de domain passando"
  ]
}
```

**Checkpoints obrigatórios:**
- Após domain layer
- Após infrastructure layer
- Após application layer
- Após presentation layer
- Antes de deploy (final)

### Passo 5: Estimar Esforço

Para cada task, estime tempo em minutos:

| Complexidade | Tempo Estimado |
|--------------|----------------|
| Trivial (CRUD básico) | 15-30 min |
| Simples (Service, Controller) | 30-60 min |
| Média (Business logic, validações) | 60-120 min |
| Complexa (Integrações, AI) | 120-240 min |

**Total:** Some todos os tempos para estimar esforço total da feature.

### Passo 6: Gerar `tasks.json`

Crie `.morph/project/outputs/{feature}/tasks.json`:

```json
{
  "feature": "{feature-name}",
  "totalTasks": 15,
  "estimatedHours": 8.5,
  "checkpoints": [
    {
      "id": "CHECKPOINT_001",
      "title": "Domain Layer Completo",
      "afterTasks": ["T001", "T002", "T003"]
    },
    {
      "id": "CHECKPOINT_002",
      "title": "Application Layer Completo",
      "afterTasks": ["T006", "T007", "T008"]
    }
  ],
  "tasks": [
    {
      "id": "T001",
      "title": "Criar Entity {Nome}",
      "description": "...",
      "category": "domain",
      "dependencies": [],
      "estimatedMinutes": 30,
      "status": "pending",
      "files": ["Domain/Entities/{Nome}.cs"]
    },
    {
      "id": "T002",
      "title": "Configurar EF para {Nome}",
      "description": "...",
      "category": "infrastructure",
      "dependencies": ["T001"],
      "estimatedMinutes": 20,
      "status": "pending",
      "files": ["Infrastructure/Data/Configurations/{Nome}Configuration.cs"]
    }
    // ... mais tasks
  ]
}
```

### Passo 7: Incluir Tasks de IaC (se necessário)

Se houver recursos Azure:

```json
{
  "id": "T050",
  "title": "Criar Bicep para Azure SQL",
  "description": "Bicep module para Azure SQL Database Basic tier",
  "category": "infra",
  "dependencies": ["T001", "T002"], // Domain entities devem existir
  "estimatedMinutes": 45,
  "status": "pending",
  "files": [
    "infra/modules/sql-database.bicep",
    "infra/parameters.dev.json"
  ]
},
{
  "id": "T051",
  "title": "Criar migration inicial",
  "description": "EF Core migration com todas as entities",
  "category": "infra",
  "dependencies": ["T002", "T003"],
  "estimatedMinutes": 15,
  "status": "pending",
  "files": ["Infrastructure/Data/Migrations/"]
}
```

### Passo 8: Atualizar State

```bash
# Marcar fase como tasks
node bin/state-manager.js set {feature-name} phase tasks

# Definir total de tasks
node bin/state-manager.js set {feature-name} tasks.total {N}

# Marcar output tasks criado
node bin/state-manager.js mark-output {feature-name} tasks
```

## Outputs Gerados

- `.morph/project/outputs/{feature}/tasks.json` - Breakdown completo de tasks

**Resumo em formato texto:**

Gere também um resumo visual em `.morph/project/outputs/{feature}/tasks-summary.md`:

```markdown
# Tasks Breakdown - {Feature Name}

## Overview
- **Total Tasks:** 15
- **Estimated Time:** 8.5 hours
- **Checkpoints:** 3

## Tasks by Category

### Domain (3 tasks, 1.5h)
- T001: Criar Entity {Nome} (30min)
- T002: Configurar EF para {Nome} (20min)
- T003: Criar Enum {Status} (15min)

### Infrastructure (4 tasks, 2h)
- T004: Criar Repository interface (30min)
- T005: Implementar Repository (60min)
- ...

### Application (5 tasks, 3h)
- T006: Criar {Nome}Service (90min)
- T007: Criar DTOs (45min)
- ...

### Presentation (3 tasks, 2h)
- T010: Criar API Controller (60min)
- T011: Criar Blazor Page (60min)
- ...

## Checkpoints

### CHECKPOINT_001: Domain Layer Completo
**After:** T001, T002, T003
**Validations:**
- [ ] Entities criadas
- [ ] EF configurations ok
- [ ] Compile sem erros

### CHECKPOINT_002: Application Layer Completo
**After:** T006, T007, T008
**Validations:**
- [ ] Services implementados
- [ ] DTOs validados
- [ ] Testes unitários passando

## Execution Order

```
T001 → T002 → T003 → CHECKPOINT_001
  ↓
T004 → T005
  ↓
T006 → T007 → T008 → CHECKPOINT_002
  ↓
T010 → T011 → T012
  ↓
T013 → T014 → T015 → CHECKPOINT_003
```
```

## ⛔ PAUSA OBRIGATÓRIA

Apresente ao usuário 3 ações sugeridas:

1. ✅ **Aprovar breakdown e iniciar implementação**
   Prosseguir para `/morph-apply` (FASE 5)

2. 🔀 **Repriorizar tasks**
   Mudar ordem de execução se necessário

3. ➕ **Adicionar/remover tasks**
   Ajustar escopo se alguma task foi esquecida ou é desnecessária

## Critérios de Avanço

- [x] `tasks.json` criado com todas as tasks
- [x] Tasks categorizadas corretamente
- [x] Dependências mapeadas
- [x] Checkpoints definidos (a cada 3 tasks)
- [x] Esforço estimado por task
- [x] Ordem de execução clara
- [x] Tasks de IaC incluídas (se aplicável)
- [x] State atualizado com total de tasks
- [x] Usuário aprovou breakdown

---

**Feature:** $ARGUMENTS
