@polymorphism-tech/morph-spec 4.10.0 → 4.10.2

package/framework/skills/level-1-workflows/morph-phase-implement/SKILL.md

@@ -6,423 +6,304 @@ disable-model-invocation: true
 context: fork
 agent: general-purpose
 user-invocable: false
-cliVersion: "4.10.0"
-allowed-tools: Read, Write, Edit, Bash, Glob, Grep
+cliVersion: "4.10.2"
+allowed-tools: Read, Write, Edit, Bash, Glob, Grep, AskUserQuestion, Agent
 ---
 
-# MORPH Implement - FASE 5
+# MORPH Implement — Phase 5
 
 > INTERNAL: Workflow skill used by /morph-apply during automated phase orchestration. Not a user command.
 
-Implemente as tasks definidas na FASE 4, com checkpoints a cada 3 tasks e recap final.
+Implement the tasks defined in Phase 4, with checkpoints every 3 tasks and a final recap.
 
-## Pré-requisitos
+## Prerequisites
 
-- [ ] FASE 4 (Tasks) concluída
-- [ ] `tasks.md` ou `tasks.json` aprovado pelo usuário
-- [ ] Tasks gate (`morph-spec approve $ARGUMENTS tasks`) aprovado
-- [ ] Todos os outputs de design existem (spec.md, contracts.cs, decisions.md)
+- [ ] Phase 4 (Tasks) completed
+- [ ] `tasks.md` approved by user
+- [ ] Tasks gate approved (`morph-spec approve $ARGUMENTS tasks`)
+- [ ] All design outputs exist (spec.md, contracts.cs/.ts, decisions.md)
 
-## Passo 0: Garantir fase implement
+## Step 0: Ensure Implement Phase
 
-**PASSO 0 (ANTES de qualquer leitura ou escrita) — Garantir fase implement:**
+**Before any reads or writes — verify the current phase:**
 
 ```bash
 npx morph-spec state get $ARGUMENTS
 ```
 
-Verifique o campo `"phase"` no output:
+Check the `"phase"` field:
 
-**Se `"phase": "implement"`** → ✅ fase correta, prossiga.
+**If `"phase": "implement"`** → correct phase, proceed.
 
-**Se `"phase": "tasks"`** → execute em sequência:
+**If `"phase": "tasks"`** → run in sequence:
 1. `npx morph-spec state mark-output $ARGUMENTS tasks`
 2. `npx morph-spec approve $ARGUMENTS tasks`
 3. `npx morph-spec phase advance $ARGUMENTS` (→ implement)
 
-**Qualquer outro valor** → ⛔ não prossiga — estado inconsistente, reporte ao usuário.
+**Any other value** → STOP — inconsistent state, report to user.
 
-> **Regra:** Nunca escreva em `5-implement/` enquanto a fase não for `implement`. O hook bloqueará a escrita.
+> **Rule:** Never write to `5-implement/` until the phase is `implement`. The hook will block writes.
 
 ---
 
-## Pre-flight — Validação Mecânica (OBRIGATÓRIO)
+## Pre-flight Validation (MANDATORY)
 
-Antes de qualquer task, valide que as fases anteriores estão realmente completas. O `state.json` pode ter sido setado manualmente — estes comandos verificam os artefatos reais no filesystem.
+Before any task work, validate that prior phases are truly complete. `state.json` may have been set manually — these commands verify actual filesystem artifacts.
 
 ```bash
-# 1. Verifica outputs obrigatórios de todas as fases anteriores
+# 1. Verify mandatory outputs from all prior phases
 npx morph-spec validate-feature $ARGUMENTS
 
-# 2. Confirma que todos os approval gates foram aprovados
+# 2. Confirm all approval gates passed
 npx morph-spec approval-status $ARGUMENTS
+
+# 3. Verify activeAgents are populated
+npx morph-spec state get $ARGUMENTS | grep -A5 activeAgents
 ```
 
-Se qualquer check falhar → **STOP**. Não inicie nenhuma task. Reporte ao usuário o que está faltando e quais comandos rodar para resolver:
+If any check fails → **STOP**. Do not start any task. Report what's missing:
 
-| Problema | Comando de resolução |
-|----------|---------------------|
-| Output faltando (spec.md, contracts, etc.) | Volte à fase correspondente e gere o output |
-| Gate não aprovado (design, tasks) | `npx morph-spec approve $ARGUMENTS <gate>` |
-| Phase inválida | `npx morph-spec phase advance $ARGUMENTS` |
+| Problem | Resolution |
+|---------|-----------|
+| Missing output (spec.md, contracts, etc.) | Return to corresponding phase and generate it |
+| Gate not approved (design, plan, tasks) | `npx morph-spec approve $ARGUMENTS <gate>` |
+| Invalid phase | `npx morph-spec phase advance $ARGUMENTS` |
+| Empty activeAgents | Run `/phase-setup $ARGUMENTS` first |
 
-**Esta etapa não é opcional.** Só prossiga quando ambos os comandos retornarem sem erros.
+**This step is not optional.** Only proceed when all commands return without errors.
 
-## Ferramentas Recomendadas
+---
 
-> **Ref:** `framework/skills/level-0-meta/morph-tool-usage-guide/SKILL.md` para guia completo.
-> **Ref:** `framework/standards/integration/mcp/mcp-tools.md` para referência MCP.
-> **Example:** `references/recap-example.md` — filled-in recap.md showing expected output quality.
+## Pre-flight MCP — Connection Validation
 
-| Ação | Ferramenta | Alternativa |
-|------|------------|-------------|
-| Verificar modo de execução (single/subagents/agent-teams) | **Bash** `npx morph-spec dispatch-agents $ARGUMENTS implement` | Grupos de tasks + prompts de subagents |
-| **Dispatch implementadores por domínio** (subagents) | **Agent** `subagent_type=<taskGroups[grupo].agentId>` + `prompt=taskPrompt` do dispatch config | Backend + frontend + infra em paralelo |
-| **Criar Agent Team** (features críticas multi-domínio) | Linguagem natural — veja Passo 0.5b | — |
-| Ler task details | **Read** tasks.json, spec.md, contracts.cs | — |
-| Criar novos arquivos | **Write** source files | — |
-| Modificar arquivos existentes | **Edit** source files | — |
-| Consultar API de biblioteca | **Context7 MCP** `query_docs()` | **WebSearch** + **WebFetch** |
-| Executar migrations | **Supabase MCP** `query()` | **Bash** `npx supabase migration ...` |
-| Build do projeto | **Bash** `dotnet build` ou `npm run build` | — |
-| Rodar testes | **Bash** `dotnet test` ou `npm test` | — |
-| Checkpoint validation | **Bash** `npx morph-spec validate-feature ...` | — |
-| Marcar task concluída | **Bash** `npx morph-spec task done $ARGUMENTS T001` | — |
-| Smoke test no browser | **Playwright MCP** `browser_navigate()` + `browser_snapshot()` | Manual |
-| Verificar erros de console | **Playwright MCP** `browser_console_messages()` | — |
-| Screenshot para recap | **Playwright MCP** `browser_take_screenshot()` | — |
-| Deploy e logs Vercel | **Vercel MCP** `list_projects()`, `get_deployments()`, `manage_env_vars()` | **Bash** `vercel deploy` |
-| Criar PR | **Bash** `gh pr create ...` | **GitHub MCP** `create_pull_request()` |
-| Atualizar state | **Bash** `npx morph-spec state set ...` | — |
-
-**MCPs desta fase:** Supabase (migrations, RLS), Context7 (API lookup), Playwright (smoke test), GitHub (PRs), Vercel (deploy, logs, env vars).
-
-**Anti-padrões:**
-- ❌ Task agent para editar um único arquivo (use Edit direto)
-- ✅ Task agent para implementar service layer em 5+ arquivos (multi-file legítimo)
-- ✅ Task agents paralelos quando `tasks.total ≥ 6` e feature tem 2+ domínios ativos
-- ✅ Agent Teams quando backend e frontend precisam coordenar contratos de API
-- ❌ Agent Teams para features single-domain (subagents são suficientes)
-- ❌ Agent Teams sem plan approval (cria risco de implementações divergentes)
-- ❌ Bash `cat` para criar arquivos (use Write tool)
-- ❌ Bash `sed` para modificar código (use Edit tool)
-- ❌ Implementar sem ler contracts.cs primeiro (contracts são a fonte de verdade!)
-- ❌ Implementar tasks de backend e frontend sequencialmente quando são independentes
-- ❌ **(VSA)** Criar Application Service layer — handler acessa IRepository diretamente
-- ❌ **(VSA)** Registrar handlers/endpoints manualmente no Program.cs — auto-discovery via reflection
-- ❌ **(VSA)** Colocar Request/Response em arquivos separados do Handler
-- ❌ **(VSA)** Usar `Guid.NewGuid()` — use `Guid.CreateVersion7()`
-- ❌ **Tentar corrigir um bug sem invocar `systematic-debugging` primeiro** — "a mudança é pequena" não é justificativa
-- ✅ Ao encontrar bug: `Skill(superpowers:systematic-debugging)` → causa raiz → fix mínimo → verificar
+Before starting tasks, verify that MCPs needed for the implement phase are working.
 
----
+**1. Collect MCPs for the implement phase:**
+- Read `framework/skills/level-0-meta/mcp-registry.json` → `phaseMatrix.implement`
+- Read `.claude/settings.local.json` → identify configured MCPs
 
-## Pre-flight MCP — Validacao de Conexoes
+**2. For each CONFIGURED MCP in `phaseMatrix.implement`:**
+1. Look for a tool matching `healthCheck.toolPattern`
+2. If found → run `healthCheck.testCall` with `healthCheck.testParams`
+3. Evaluate:
 
-Antes de iniciar as tasks, verifique que os MCPs necessarios para a fase implement estao funcionando.
+| Result | Action |
+|--------|--------|
+| **Success** | `✓ {MCP} — ready` |
+| **Tool not found** | `○ {MCP} — needs restart` |
+| **Error** | → **AskUserQuestion** (below) |
 
-**1. Coletar MCPs da fase implement:**
-- Leia `framework/skills/level-0-meta/mcp-registry.json` → campo `phaseMatrix.implement`
-- Leia `.claude/settings.local.json` → identifique quais MCPs estao configurados
+**On error — ask the user:**
 
-**2. Para cada MCP CONFIGURADO que aparece em `phaseMatrix.implement`:**
-1. Procure nas ferramentas disponiveis por uma que contenha `healthCheck.toolPattern` no nome
-2. Se encontrada → execute `healthCheck.testCall` com `healthCheck.testParams`
-3. Avalie:
+Use `AskUserQuestion` with header `"{MCP}"` and options:
+- **Continue without {MCP}** — Show `fallback` from registry. Implementation will use the fallback automatically.
+- **Reconfigure credentials** — Collect credentials and update `.claude/settings.local.json`. Re-test after reconfiguring.
+- **Stop implementation** — Abort. User must fix the MCP and re-run `/morph-apply`.
 
-| Resultado | Acao |
-|-----------|------|
-| **Sucesso** | `✓ {MCP} — pronto` |
-| **Ferramenta nao encontrada** | `○ {MCP} — precisa restart` |
-| **Erro** | → **AskUserQuestion** (abaixo) |
+> **Design:** This check is fail-open — consistent with morph-spec philosophy. The user gets explicit choice instead of tasks failing silently.
 
-**Em caso de erro — pergunte ao usuario:**
+---
 
-Use `AskUserQuestion` com header `"{MCP}"` e opcoes:
-- **Continuar sem {MCP}** — Mostre `fallback` do registry (ex: "Bash `gh` CLI" para GitHub). A implementacao usara o fallback automaticamente.
-- **Reconfigurar credenciais** — Colete credenciais e atualize `.claude/settings.local.json`. Re-teste apos reconfigurar.
-- **Parar implementacao** — Aborte. Usuario deve corrigir o MCP e re-rodar `/morph-apply`.
+## Recommended Tools
 
-**3. Resumo MCP Readiness:**
-```
-MCP Readiness (implement phase):
-  ✓ context7 — pronto
-  ✓ supabase — pronto
-  ○ playwright — precisa restart (fallback: manual testing)
-  — docker — nao configurado
-```
+> **Ref:** `framework/skills/level-0-meta/morph-tool-usage-guide/SKILL.md` for complete guide.
+> **Ref:** `framework/standards/integration/mcp/mcp-tools.md` for MCP reference.
+> **Example:** `references/recap-example.md` — filled-in recap.md showing expected output quality.
 
-> **Design:** Este check e fail-open — consistente com a filosofia morph-spec. O usuario tem escolha explicita em vez de tasks falhando silenciosamente.
+| Action | Tool | Alternative |
+|--------|------|-------------|
+| Check execution mode (single/subagents/agent-teams) | **Bash** `npx morph-spec dispatch-agents $ARGUMENTS implement` | Task groups + subagent prompts |
+| **Dispatch implementers by domain** (subagents) | **Agent** `subagent_type=<taskGroups[group].agentId>` + `prompt=taskPrompt` from dispatch config | Backend + frontend + infra in parallel |
+| **Create Agent Team** (critical multi-domain features) | Natural language — see Step 0.5b | — |
+| Read task details | **Read** tasks.md, spec.md, contracts.cs/.ts | — |
+| Create new files | **Write** source files | — |
+| Modify existing files | **Edit** source files | — |
+| Look up library API | **Context7 MCP** `query_docs()` | **WebSearch** + **WebFetch** |
+| Run migrations | **Supabase MCP** `query()` | **Bash** `npx supabase migration ...` |
+| Build project | **Bash** `dotnet build` or `npm run build` | — |
+| Run tests | **Bash** `dotnet test` or `npm test` | — |
+| Checkpoint validation | **Bash** `npx morph-spec validate-feature ...` | — |
+| Mark task complete | **Bash** `npx morph-spec task done $ARGUMENTS T001` | — |
+| Smoke test in browser | **Playwright MCP** `browser_navigate()` + `browser_snapshot()` | Manual |
+| Check console errors | **Playwright MCP** `browser_console_messages()` | — |
+| Screenshot for recap | **Playwright MCP** `browser_take_screenshot()` | — |
+| Deploy and logs Vercel | **Vercel MCP** `list_projects()`, `get_deployments()`, `manage_env_vars()` | **Bash** `vercel deploy` |
+| Create PR | **Bash** `gh pr create ...` | **GitHub MCP** `create_pull_request()` |
+| Update state | **Bash** `npx morph-spec state set ...` | — |
+
+**Phase MCPs:** Supabase (migrations, RLS), Context7 (API lookup), Playwright (smoke test), GitHub (PRs), Vercel (deploy, logs, env vars).
+
+**Anti-patterns:**
+- Task agent for editing a single file (use Edit directly)
+- Agent Teams for single-domain features (subagents suffice)
+- Agent Teams without plan approval (creates risk of divergent implementations)
+- `Bash cat` to create files (use Write tool)
+- `Bash sed` to modify code (use Edit tool)
+- Implementing without reading contracts.cs/.ts first (contracts are the source of truth!)
+- Running backend and frontend tasks sequentially when they are independent
+- **(VSA)** Creating Application Service layer — handler accesses IRepository directly
+- **(VSA)** Manually registering handlers/endpoints in Program.cs — use auto-discovery via reflection
+- **(VSA)** Placing Request/Response in separate files from Handler
+- **(VSA)** Using `Guid.NewGuid()` — use `Guid.CreateVersion7()`
+- Trying to fix a bug without invoking `systematic-debugging` first
 
 ---
 
-## ✅ PRÉ-VOO OBRIGATÓRIO (antes de iniciar implementação)
+## Context Loading
 
-### 1. Ler contexto completo em PARALELO
+### 1. Read full context in PARALLEL
 
 ```
-# Uma única chamada, não sequencial:
+# Single parallel call, not sequential:
 Read: .morph/features/{feature}/4-tasks/tasks.md
     + Read: .morph/features/{feature}/1-design/spec.md
-    + Read: .morph/features/{feature}/1-design/contracts.cs
+    + Read: .morph/features/{feature}/1-design/contracts.cs  (or contracts.ts for TypeScript projects)
     + Read: .morph/config/config.json                       (→ architecture.style)
     + Read: .morph/features/{feature}/3-plan/plan.md
 ```
 
-### 2. Criar native tasks individuais por T001-T00N
+### 2. Create native tasks for each T001-T00N
 
-Após ler `tasks.md` no passo 1, crie **uma native task por task encontrada**:
+After reading `tasks.md`, create **one native task per task found**:
 
 ```
-# Para cada task em tasks.md (T001, T002, ..., T00N):
-TaskCreate: "{T001}: {título da task}"    → description: descrição completa → activeForm: "Implementando T001"
-TaskCreate: "{T002}: {título da task}"    → description: descrição completa → activeForm: "Implementando T002"
-... (uma TaskCreate por task)
-
-# Tarefas orquestrais sempre ao final:
-TaskCreate: "Checkpoints e validação"     → activeForm: "Validando checkpoint"
-TaskCreate: "Gerar recap.md"              → activeForm: "Gerando recap"
-```
+# For each task in tasks.md (T001, T002, ..., T00N):
+TaskCreate: "{T001}: {task title}"    → description: full description → activeForm: "Implementing T001"
+TaskCreate: "{T002}: {task title}"    → description: full description → activeForm: "Implementing T002"
+... (one TaskCreate per task)
 
-**Após criar todas as tasks, configure dependências espelhando `tasks.md`:**
-```
-# Para cada task com `dependencies: [T00X, T00Y]` em tasks.md:
-TaskUpdate(taskId="<id de T003>", addBlockedBy=["<id de T001>", "<id de T002>"])
+# Orchestral tasks always at the end:
+TaskCreate: "Checkpoints and validation" → activeForm: "Validating checkpoint"
+TaskCreate: "Generate recap.md"          → activeForm: "Generating recap"
 ```
 
-> Guarde o mapeamento `{T001 → taskId}` internamente para usar nos TaskUpdates do loop.
-
----
-
-## Workflow
-
-### Passo 0.5: Planejar Modo de Execução
-
-**Ler estratégia do plano:**
+**After creating all tasks, configure dependencies mirroring `tasks.md`:**
 ```
-Read: .morph/features/{feature}/3-plan/plan.md → extrair campo "Execution Strategy"
+# For each task with `dependencies: [T00X, T00Y]` in tasks.md:
+TaskUpdate(taskId="<id of T003>", addBlockedBy=["<id of T001>", "<id of T002>"])
 ```
 
-A estratégia já foi definida e aprovada na fase Plan. Use-a diretamente:
-
-**O campo `Execution Strategy` determina o caminho de execução:**
-
-| Estratégia | Ação |
-|--------|------|
-| `"single"` | → Continue para o workflow sequencial normal (Passo 1) |
-| `"subagents"` | → Dispatch Task subagents em paralelo (abaixo) |
-| `"agent-teams"` | → Crie Agent Team com plan approval (Passo 0.5b) |
-
-Se `plan.md` não existir ou o campo não estiver presente, execute como fallback:
+### 3. Detect architecture style
 
 ```bash
-npx morph-spec dispatch-agents $ARGUMENTS implement
+cat .morph/config/config.json | grep architecture
 ```
 
-**O output inclui um campo `mode` equivalente à estratégia do plano.**
+If `config.architecture.style === "vertical-slice"` → follow **Step 1.5** before implementing.
+Otherwise → go directly to the task loop.
 
----
-
-#### Modo `"subagents"` (se `mode: "subagents"` no output):
+### Step 1.5: VSA Implementation Guide (only if `style: "vertical-slice"`)
 
-1. Leia os `taskGroups` retornados (ex: `backend`, `frontend`, `infra`)
-2. Para cada grupo com ≥ 3 tasks e sem dependências cruzadas, use o **Agent tool** com o `subagent_type=<agentId>` do grupo e o `taskPrompt` do dispatch config:
+> For the complete slice structure and VSA rules, see `references/vsa-implementation-guide.md`
 
-> **Mapeamento:** `taskGroups[grupo].agentId` do dispatch config = `subagent_type` no Agent tool.
-> Exemplo: `agentId: "dotnet-senior"` → `Agent(subagent_type=dotnet-senior, prompt=taskPrompt)`.
-
-```
-[Task tool — grupo backend, por exemplo]
-Prompt do dispatch config enriquecido:
-
-Você é o implementador do grupo BACKEND da feature '$ARGUMENTS'.
-
-Contexto completo:
-- Spec: [conteúdo de .morph/features/$ARGUMENTS/1-design/spec.md]
-- Contracts: [conteúdo de .morph/features/$ARGUMENTS/1-design/contracts.cs]
-- Tasks do grupo: [lista de TXXX do grupo backend]
-
-# No início deste subagent (grupo BACKEND):
-# 1. Criar native task por task do grupo:
-#    TaskCreate: "{T00X}: {título}" → activeForm: "Implementando T00X"
-# 2. Configurar dependências do grupo via TaskUpdate:
-#    TaskUpdate(taskId="<id de T003>", addBlockedBy=["<id de T001>", "<id de T002>"])
-# Guarde o mapeamento {T00X → taskId} para usar no loop abaixo.
-
-Para cada task do grupo, em ordem:
-1. TaskUpdate(taskId="<native id de T00X>", status="in_progress")
-2. Execute: npx morph-spec task start $ARGUMENTS TXXX
-3. Leia a descrição completa da task
-4. Implemente os arquivos — use Write (novo) ou Edit (existente)
-5. Verifique build: [dotnet build / npm run build]
-5b. Invoke Skill(verification-before-completion) — só prossiga para o passo 6 se passar
-6. Execute: npx morph-spec task done $ARGUMENTS TXXX
-7. Se task done retornar sem erro: TaskUpdate(taskId="<native id de T00X>", status="completed")
-
-A cada 3 tasks:
-- Execute: npx morph-spec checkpoint-save $ARGUMENTS
-- Execute: npx morph-spec validate-feature $ARGUMENTS --phase implement
-- Reporte qualquer falha de validação antes de continuar
-
-Restrições OBRIGATÓRIAS:
-- Modifique APENAS os arquivos listados nas tasks do grupo BACKEND
-- NÃO toque em arquivos de frontend, UI ou infra
-- Se encontrar dependência em outro grupo, pause e reporte
-```
-
-3. Dispare os Task subagents dos grupos em **paralelo** (quando sem dependências entre si)
-4. Após todos completarem, valide integração: `npx morph-spec validate-feature $ARGUMENTS --phase implement`
-
-**Se `mode: "single"`** (feature pequena ou single-domain):
-→ Continue para o workflow sequencial normal abaixo.
+Structure: `Features/{Entity}Feature/{Op}/` with Handler (+ Request/Response records) + Validator + Endpoint per slice. Everything `sealed`. `Guid.CreateVersion7()`. `result.Match()` in endpoints. No Application Service layer — handler accesses IRepository directly. Auto-discovery via reflection: do not manually register in Program.cs.
 
 ---
 
-### Passo 0.5b: Agent Teams (features críticas multi-domínio)
-
-**Quando usar:** `mode: "agent-teams"` no output de `dispatch-agents`
-**Requisito:** `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1` no `.claude/settings.local.json` (instalado pelo morph-spec)
-
-**Por que Agent Teams em vez de subagents:**
-Agent Teams têm TaskList compartilhada, mensagens diretas entre teammates e hooks `TeammateIdle`. Subagents são fire-and-forget. Para features onde backend e frontend precisam coordenar contratos de API, Agent Teams garantem que o frontend não implemente chamadas antes do backend estabilizar os DTOs.
+## Workflow
 
-**1. Crie o Agent Team com linguagem natural:**
+### Step 0.5: Plan Execution Mode
 
+**Read the plan's execution strategy:**
 ```
-Crie um agent team para implementar a feature '$ARGUMENTS' com teammates:
-- Backend teammate (dotnet-senior): Implemente as tasks do grupo backend.
-  Contexto: .morph/features/$ARGUMENTS/1-design/spec.md, contracts.cs, standards/coding.md
-  Restrição: Modifique APENAS arquivos de backend/domain/application.
-  Antes de implementar interfaces compartilhadas, envie mensagem ao frontend teammate.
-- Frontend teammate (blazor-builder OU nextjs-expert): Implemente as tasks do grupo frontend.
-  Contexto: .morph/features/$ARGUMENTS/1-design/spec.md, design-system.md, standards/frontend/
-  Restrição: Modifique APENAS arquivos de UI/components/pages.
-  Aguarde confirmação do backend teammate antes de implementar chamadas de API.
-- Quality teammate (standards-architect): Revise o output de cada teammate e execute validate-feature.
-  Exija plan approval antes de cada implementação.
-  Só aprove planos que correspondam ao contracts.cs e spec.md.
+Read: .morph/features/{feature}/3-plan/plan.md → extract "Execution Strategy" field
 ```
 
-**2. Protocolo de coordenação entre teammates:**
+The strategy was defined and approved in the Plan phase. Use it directly:
 
-- Backend deve completar definição de DTOs/interfaces ANTES do frontend implementar chamadas de API
-- Para qualquer interface compartilhada: backend envia mensagem ao frontend confirmando contratos estáveis
-- Se frontend precisar de um endpoint que não existe → instrua a enviar mensagem ao backend teammate
-- Conflitos de contratos → escalone ao quality teammate para resolver
+| Strategy | Action |
+|----------|--------|
+| `"single"` | → Continue to the sequential task loop (Step 2) |
+| `"subagents"` | → Dispatch Task subagents in parallel (below) |
+| `"agent-teams"` | → Create Agent Team with plan approval (Step 0.5b) |
 
-**3. Configurações obrigatórias ao criar o team:**
-
-- Habilite **plan approval**: "Require plan approval before each teammate implements"
-- Gate de qualidade: "Only approve plans that match contracts.cs and spec.md"
-- Restrição de domínio por teammate: cada um modifica APENAS arquivos do seu domínio
-
-**4. Após todos os teammates completarem:**
+If `plan.md` doesn't exist or the field is missing, run as fallback:
 
 ```bash
-npx morph-spec validate-feature $ARGUMENTS --phase implement
+npx morph-spec dispatch-agents $ARGUMENTS implement
 ```
 
-Sintetize os resultados de todos os teammates no recap.md (Passo 6).
-
 ---
 
-### CHECKPOINT DE ENTRADA: Verificar Pré-requisitos
+#### Subagents Mode (if strategy is `"subagents"`):
 
-**⏸️ Antes de iniciar implementação:**
+1. Read `taskGroups` from dispatch config (e.g., `backend`, `frontend`, `infra`)
+2. For each group with >= 3 tasks and no cross-group dependencies, use **Agent tool** with `subagent_type=<agentId>` and `taskPrompt` from dispatch config:
 
-- [ ] `tasks.md` ou `tasks.json` existe e foi aprovado?
-- [ ] Tasks gate aprovado (`morph-spec approve $ARGUMENTS tasks`)?
-- [ ] `spec.md` atualizado com clarificações?
-- [ ] `contracts.cs` corresponde ao schema real?
-- [ ] Build base do projeto compila sem erros?
-- [ ] `activeAgents` estão populados? (`morph-spec state get $ARGUMENTS` → campo `activeAgents` não vazio)
+> **Mapping:** `taskGroups[group].agentId` = `subagent_type` in Agent tool.
+> Example: `agentId: "dotnet-senior"` → `Agent(subagent_type=dotnet-senior, prompt=taskPrompt)`.
 
-```bash
-npx morph-spec state get $ARGUMENTS
-npx morph-spec approval-status $ARGUMENTS
-# Se activeAgents estiver vazio → pare aqui e execute /phase-setup $ARGUMENTS primeiro
-npx morph-spec state get $ARGUMENTS | grep -A5 activeAgents
-```
+Each subagent receives a prompt with:
+- Full spec.md and contracts.cs/.ts content
+- The group's task list
+- Instructions to create native tasks, follow the task loop (start → implement → verify → done), checkpoint every 3 tasks
+- Domain isolation: modify ONLY files in their domain
+- **MANDATORY verification before every `task done`** (see Step 2, item 6b)
 
-**❌ Se alguma checkbox NÃO estiver marcada:**
-→ Voltar para a fase correspondente
+3. Dispatch subagents for groups in **parallel** (when no cross-group dependencies)
+4. After all complete, validate integration: `npx morph-spec validate-feature $ARGUMENTS --phase implement`
 
-**❌ Se `activeAgents` estiver vazio:**
-→ Execute o skill `phase-setup` primeiro: `/phase-setup $ARGUMENTS`
-→ Agentes não detectados = standards não carregados = implementação sem contexto correto
+**If strategy is `"single"`** → continue to sequential task loop below.
 
 ---
 
-### Passo 1: Carregar Contexto Completo
-
-Leia todos os outputs antes de implementar:
+#### Step 0.5b: Agent Teams (critical multi-domain features)
 
-1. `.morph/features/$ARGUMENTS/4-tasks/tasks.md` — Lista de tasks
-2. `.morph/features/$ARGUMENTS/1-design/spec.md` — Especificação completa
-3. `.morph/features/$ARGUMENTS/1-design/contracts.cs` — Interfaces e DTOs
-4. `.morph/features/$ARGUMENTS/1-design/decisions.md` — ADRs
-5. `.morph/features/$ARGUMENTS/1-design/schema-analysis.md` — Schema real (se existir)
-6. `.morph/features/$ARGUMENTS/2-ui/design-system.md` — Design tokens (se existir)
+**When:** strategy is `"agent-teams"`
+**Requirement:** `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1` in `.claude/settings.local.json`
 
-**Detectar estilo de arquitetura:**
-```bash
-# Leia config para saber se é VSA ou DDD:
-cat .morph/config/config.json | grep architecture
-```
+**Why Agent Teams over subagents:**
+Agent Teams have a shared TaskList, direct teammate messaging, and `TeammateIdle` hooks. Subagents are fire-and-forget. For features where backend and frontend need to coordinate API contracts, Agent Teams ensure frontend doesn't implement calls before backend stabilizes DTOs.
 
-Se `config.architecture.style === "vertical-slice"` → siga o **Passo 1.5** antes de implementar.
-Caso contrário → vá direto para o Passo 2.
+Create the team with natural language specifying:
+- Backend teammate (dotnet-senior): backend/domain/application files only
+- Frontend teammate (blazor-builder or nextjs-expert): UI/components/pages files only
+- Quality teammate (standards-architect): review + validate-feature after each implementation
+- Enable **plan approval**: teammates must get plans approved before implementing
+- Gate: only approve plans matching contracts.cs/.ts and spec.md
 
-### Passo 1.5: Guia de Implementação VSA (somente se `style: "vertical-slice"`)
+After all teammates complete: `npx morph-spec validate-feature $ARGUMENTS --phase implement`
 
-> Para a estrutura completa de slices e regras VSA, veja `references/vsa-implementation-guide.md`
-
-Estrutura: `Features/{Entity}Feature/{Op}/` com Handler (+ Request/Response records) + Validator + Endpoint por slice. Tudo `sealed`. `Guid.CreateVersion7()`. `result.Match()` nos endpoints. Sem Application Service layer — handler acessa IRepository diretamente. Auto-discovery via reflection: não registrar manualmente no Program.cs.
-
-Após cada slice completo, verificar build:
-```bash
-dotnet build
-```
+---
 
-### Passo 2: Iniciar Primeira Task
+### Step 2: Task Loop
 
 ```bash
 npx morph-spec task next $ARGUMENTS
 ```
 
-Para cada task (T001 → T00N):
+For each task (T001 → T00N):
 
-1. **Marcar como em progresso (native task):**
+1. **Mark as in-progress (native task):**
    ```
-   TaskUpdate(taskId="<native id de T001>", status="in_progress")
+   TaskUpdate(taskId="<native id>", status="in_progress")
    ```
-2. **Iniciar via CLI:**
+2. **Start via CLI:**
    ```bash
    npx morph-spec task start $ARGUMENTS T001
    ```
-3. **Ler a task description** completa
-4. **Ler contracts.cs** para DTOs/interfaces relevantes
-5. **Implementar** usando Write (novo) ou Edit (existente)
-6. **Verificar** — build, lint, testes
-6b. **⚠️ OBRIGATÓRIO — Verificação antes de `task done`:**
-   Invoke `Skill(verification-before-completion)` ou execute manualmente:
+3. **Read the task description** + contracts.cs/.ts for relevant DTOs/interfaces
+4. **Implement** using Write (new) or Edit (existing)
+5. **Verify** — build, lint, tests
+6. **MANDATORY — Verification before `task done`:**
+   Run `validate-feature` before marking ANY task as done. This is non-negotiable — it catches broken code, missing files, and spec violations before they compound across tasks.
    ```bash
    npx morph-spec validate-feature $ARGUMENTS --phase implement
    ```
-   Só prossiga para o passo 7 se a verificação passar. Se falhar → corrija antes de marcar `task done`.
-7. **Marcar como done via CLI:**
+   Only proceed to step 7 if verification passes. If it fails → fix before marking `task done`.
+7. **Mark as done via CLI:**
    ```bash
    npx morph-spec task done $ARGUMENTS T001
    ```
-8. **Se `task done` retornar sem erro, marcar native task como concluída:**
+8. **If `task done` returns without error, mark native task as completed:**
    ```
-   TaskUpdate(taskId="<native id de T001>", status="completed")
+   TaskUpdate(taskId="<native id>", status="completed")
    ```
-   > **Nota:** `TaskUpdate(completed)` só ocorre se `task done` retornar sem erro (validação passou).
+   > `TaskUpdate(completed)` only happens if `task done` returns without error (validation passed).
 
-### Passo 3: Checkpoint a Cada 3 Tasks
+### Step 3: Checkpoint Every 3 Tasks
 
-**A cada 3 tasks completadas:**
+**After every 3 completed tasks:**
 
 ```bash
 # Save checkpoint
@@ -432,21 +313,21 @@ npx morph-spec checkpoint-save $ARGUMENTS
 npx morph-spec validate-feature $ARGUMENTS --phase implement
 ```
 
-**Se validação falhar:**
-1. NÃO avançar para próxima task
-2. Corrigir issues reportados
-3. Re-rodar validação
-4. Só então prosseguir
+**If validation fails:**
+1. Do NOT advance to the next task
+2. Fix reported issues
+3. Re-run validation
+4. Only then proceed
 
-### Passo 4: Test-Driven Development (Recomendado)
+### Step 4: Test-Driven Development (Recommended)
 
-Para cada task de implementação:
+For each implementation task:
 
-1. **Escrever teste primeiro** (unit test para service/domain)
-2. **Rodar teste** — deve falhar (RED)
-3. **Implementar** o mínimo para passar
-4. **Rodar teste** — deve passar (GREEN)
-5. **Refatorar** se necessário (REFACTOR)
+1. **Write test first** (unit test for service/domain)
+2. **Run test** — should fail (RED)
+3. **Implement** the minimum to pass
+4. **Run test** — should pass (GREEN)
+5. **Refactor** if needed (REFACTOR)
 
 ```bash
 # .NET
@@ -456,136 +337,136 @@ dotnet test --filter "FullyQualifiedName~{TestClass}"
 npm test -- test/path/to/test.js
 ```
 
-### Passo 5: Smoke Test com Playwright (se UI)
+### Step 5: Smoke Test with Playwright (if UI)
 
-Após implementar componentes visuais:
+After implementing visual components:
 
 ```javascript
-// Navegar para a página
+// Navigate to the page
 await mcp__playwright__browser_navigate({ url: 'http://localhost:5000/feature-page' });
 
-// Capturar estado da página
+// Capture page state
 await mcp__playwright__browser_snapshot();
 
-// Verificar erros de console
+// Check console errors
 await mcp__playwright__browser_console_messages({ level: 'error' });
 
-// Screenshot para recap
+// Screenshot for recap
 await mcp__playwright__browser_take_screenshot({ type: 'png' });
 ```
 
-### Passo 6: Gerar `recap.md`
+### Step 6: Generate `recap.md`
 
-Após TODAS as tasks completadas:
+After ALL tasks completed:
 
 ```bash
 npx morph-spec generate recap $ARGUMENTS
 ```
 
-> Para o formato completo do recap, veja `references/recap-example.md`
+> For the full recap format, see `references/recap-example.md`
 
-### Passo 7: Atualizar State
+### Step 7: Update State
 
 ```bash
 npx morph-spec state set $ARGUMENTS status done
 npx morph-spec state mark-output $ARGUMENTS recap
 ```
 
-### Passo 8: Revisão Pós-Implementação (obrigatório antes do PR)
+### Step 8: Post-Implementation Review (mandatory before PR)
 
 ```bash
 /post-implementation $ARGUMENTS
 ```
 
-Execute o skill `post-implementation` antes de criar o PR. Ele orquestra:
-- Scans automáticos (CRITICAL findings bloqueiam PR)
-- Test suite completo
-- `validate-feature` final
-- Smoke test via Playwright (obrigatório se dev server ativo)
-- Checklist de code review (CRITICAL + HIGH)
-- **`morph-checklist`** — compliance (segurança, SEO, performance, acessibilidade, LGPD)
-- Checkpoint + recap final
+Run the `post-implementation` skill before creating the PR. It orchestrates:
+- Automated scans (CRITICAL findings block PR)
+- Full test suite
+- Final `validate-feature`
+- Smoke test via Playwright (mandatory if dev server active)
+- Code review checklist (CRITICAL + HIGH)
+- **`morph-checklist`** — compliance (security, SEO, performance, accessibility, LGPD)
+- Checkpoint + final recap
 
-### Passo 9: Frontend Review (NEXTJS/FULLSTACK)
+### Step 9: Frontend Review (NEXTJS/FULLSTACK)
 
-Se stack for NEXTJS ou FULLSTACK:
+If stack is NEXTJS or FULLSTACK:
 
 ```bash
 /frontend-review $ARGUMENTS
 ```
 
-Complementa o `post-implementation` com: scan de acessibilidade (static + axe-core runtime),
-screenshots responsivos (mobile/tablet/desktop), e verificação de SEO metadata.
+Complements `post-implementation` with: accessibility scan (static + axe-core runtime),
+responsive screenshots (mobile/tablet/desktop), and SEO metadata verification.
 
 ---
 
-## Dispatch Morph-Nativo
+## Morph-Native Dispatch
 
-O morph-spec usa seus próprios agentes e validadores para implementação, dispatch e review.
+morph-spec uses its own agents and validators for implementation, dispatch, and review.
 
-### Implementação
+### Implementation
 
-Implementadores são despachados via `dispatch-agents`:
+Implementers are dispatched via `dispatch-agents`:
 ```bash
 npx morph-spec dispatch-agents $ARGUMENTS implement
 ```
 
-Use o `agentId` de cada grupo como `subagent_type` no Agent tool:
+Use the `agentId` from each group as `subagent_type` in the Agent tool:
 ```
-Agent(subagent_type=<agentId>, prompt=<conteúdo de prompts/implementer-prompt.md preenchido>)
+Agent(subagent_type=<agentId>, prompt=<filled prompts/implementer-prompt.md>)
 ```
 
 ### Review (Two-Stage)
 
-**Stage 1 — Spec Compliance (obrigatório):**
+**Stage 1 — Spec Compliance (mandatory):**
 ```
-Agent(subagent_type=<tier-4 validator>, prompt=<conteúdo de prompts/spec-reviewer-prompt.md>)
+Agent(subagent_type=<tier-4 validator>, prompt=<filled prompts/spec-reviewer-prompt.md>)
 ```
-Use validadores do `dispatch-agents --mode validate`. Spec compliance DEVE passar antes de prosseguir.
+Use validators from `dispatch-agents --mode validate`. Spec compliance MUST pass before proceeding.
 
-**Stage 2 — Code Quality (obrigatório):**
+**Stage 2 — Code Quality (mandatory):**
 ```
-Agent(subagent_type=standards-architect, prompt=<conteúdo de prompts/code-quality-reviewer-prompt.md>)
+Agent(subagent_type=standards-architect, prompt=<filled prompts/code-quality-reviewer-prompt.md>)
 ```
-Issues `critical` bloqueiam. Issues `important` devem ser corrigidas. `suggestion` é opcional.
+`critical` issues block. `important` issues must be fixed. `suggestion` is optional.
 
 ### Prompt Templates
 
-| Template | Uso |
-|----------|-----|
-| `prompts/implementer-prompt.md` | Dispatch para agentes implementadores |
-| `prompts/spec-reviewer-prompt.md` | Review de compliance com spec |
-| `prompts/code-quality-reviewer-prompt.md` | Review de qualidade de código |
+| Template | Usage |
+|----------|-------|
+| `prompts/implementer-prompt.md` | Dispatch to implementer agents |
+| `prompts/spec-reviewer-prompt.md` | Spec compliance review |
+| `prompts/code-quality-reviewer-prompt.md` | Code quality review |
 
 ---
 
-## Outputs Gerados
+## Outputs
 
-- Código fonte implementado (vários arquivos)
-- Testes unitários e de integração
-- `.morph/features/$ARGUMENTS/5-implement/recap.md` — Resumo da implementação
+- Implemented source code (various files)
+- Unit and integration tests
+- `.morph/features/$ARGUMENTS/5-implement/recap.md` — Implementation summary
 
-## Critérios de Conclusão
+## Completion Criteria
 
-- [x] Todas as tasks completadas
-- [x] Build compila sem erros
-- [x] Testes passando
-- [x] Validation pipeline passa
-- [x] `recap.md` gerado
-- [x] State atualizado para `status: done`
-- [x] Checkpoints salvos a cada 3 tasks
-- [x] `/post-implementation` executado sem BLOCKs (smoke test, scans, code review, `morph-checklist`)
+- [x] All tasks completed
+- [x] Build compiles without errors
+- [x] Tests passing
+- [x] Validation pipeline passes
+- [x] `recap.md` generated
+- [x] State updated to `status: done`
+- [x] Checkpoints saved every 3 tasks
+- [x] `/post-implementation` executed without BLOCKs
 
 ---
 
-## Outputs desta Fase
+## Phase Outputs
 
 <!-- morph:outputs:implement -->
-| Output | Caminho |
-|--------|---------|
+| Output | Path |
+|--------|------|
 | `recap` | `.morph/features/{feature}/5-implement/recap.md` |
 <!-- /morph:outputs -->
 
 ---
 
-Feature completa! Considere criar um PR e rodar `morph-spec generate recap $ARGUMENTS`.
+Feature complete! Consider creating a PR and running `morph-spec generate recap $ARGUMENTS`.