@polymorphism-tech/morph-spec 4.8.19 → 4.10.0

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

@@ -1,12 +1,12 @@
 ---
-name: phase-implement
+name: morph:phase-implement
 description: MORPH-SPEC Phase 5 (Implement). Executes feature tasks using TDD with checkpoint validation every 3 tasks, smoke tests via Playwright, and generates code + recap.md. Use after task list approval when starting feature implementation.
 argument-hint: "[feature-name]"
 disable-model-invocation: true
 context: fork
 agent: general-purpose
 user-invocable: false
-cliVersion: "4.8.19"
+cliVersion: "4.10.0"
 allowed-tools: Read, Write, Edit, Bash, Glob, Grep
 ---
 
@@ -23,16 +23,61 @@ Implemente as tasks definidas na FASE 4, com checkpoints a cada 3 tasks e recap
 - [ ] Tasks gate (`morph-spec approve $ARGUMENTS tasks`) aprovado
 - [ ] Todos os outputs de design existem (spec.md, contracts.cs, decisions.md)
 
+## Passo 0: Garantir fase implement
+
+**PASSO 0 (ANTES de qualquer leitura ou escrita) — Garantir fase implement:**
+
+```bash
+npx morph-spec state get $ARGUMENTS
+```
+
+Verifique o campo `"phase"` no output:
+
+**Se `"phase": "implement"`** → ✅ fase correta, prossiga.
+
+**Se `"phase": "tasks"`** → execute em sequência:
+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.
+
+> **Regra:** Nunca escreva em `5-implement/` enquanto a fase não for `implement`. O hook bloqueará a escrita.
+
+---
+
+## Pre-flight — Validação Mecânica (OBRIGATÓRIO)
+
+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.
+
+```bash
+# 1. Verifica outputs obrigatórios de todas as fases anteriores
+npx morph-spec validate-feature $ARGUMENTS
+
+# 2. Confirma que todos os approval gates foram aprovados
+npx morph-spec approval-status $ARGUMENTS
+```
+
+Se qualquer check falhar → **STOP**. Não inicie nenhuma task. Reporte ao usuário o que está faltando e quais comandos rodar para resolver:
+
+| 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` |
+
+**Esta etapa não é opcional.** Só prossiga quando ambos os comandos retornarem sem erros.
+
 ## Ferramentas Recomendadas
 
-> **Ref:** `framework/skills/level-0-meta/tool-usage-guide/SKILL.md` para guia completo.
+> **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.
 
 | 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) | **Task** subagents — um por grupo | Backend + frontend + infra em paralelo |
+| **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 | — |
@@ -46,10 +91,11 @@ Implemente as tasks definidas na FASE 4, com checkpoints a cada 3 tasks e recap
 | 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).
+**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)
@@ -66,6 +112,47 @@ Implemente as tasks definidas na FASE 4, com checkpoints a cada 3 tasks e recap
 - ❌ **(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
+
+---
+
+## Pre-flight MCP — Validacao de Conexoes
+
+Antes de iniciar as tasks, verifique que os MCPs necessarios para a fase implement estao funcionando.
+
+**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
+
+**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:
+
+| Resultado | Acao |
+|-----------|------|
+| **Sucesso** | `✓ {MCP} — pronto` |
+| **Ferramenta nao encontrada** | `○ {MCP} — precisa restart` |
+| **Erro** | → **AskUserQuestion** (abaixo) |
+
+**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`.
+
+**3. Resumo MCP Readiness:**
+```
+MCP Readiness (implement phase):
+  ✓ context7 — pronto
+  ✓ supabase — pronto
+  ○ playwright — precisa restart (fallback: manual testing)
+  — docker — nao configurado
+```
+
+> **Design:** Este check e fail-open — consistente com a filosofia morph-spec. O usuario tem escolha explicita em vez de tasks falhando silenciosamente.
 
 ---
 
@@ -75,10 +162,11 @@ Implemente as tasks definidas na FASE 4, com checkpoints a cada 3 tasks e recap
 
 ```
 # Uma única chamada, não sequencial:
-Read: .morph/features/{feature}/3-tasks/tasks.md
+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/config/config.json                       (→ architecture.style)
+    + Read: .morph/features/{feature}/3-plan/plan.md
 ```
 
 ### 2. Criar native tasks individuais por T001-T00N
@@ -110,26 +198,38 @@ TaskUpdate(taskId="<id de T003>", addBlockedBy=["<id de T001>", "<id de T002>"])
 
 ### Passo 0.5: Planejar Modo de Execução
 
-**Execute antes de qualquer implementação:**
-
-```bash
-npx morph-spec dispatch-agents $ARGUMENTS implement
+**Ler estratégia do plano:**
 ```
+Read: .morph/features/{feature}/3-plan/plan.md → extrair campo "Execution Strategy"
+```
+
+A estratégia já foi definida e aprovada na fase Plan. Use-a diretamente:
 
-**O output inclui um campo `mode` que determina o caminho de execução:**
+**O campo `Execution Strategy` determina o caminho de execução:**
 
-| `mode` | Açã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:
+
+```bash
+npx morph-spec dispatch-agents $ARGUMENTS implement
+```
+
+**O output inclui um campo `mode` equivalente à estratégia do plano.**
+
 ---
 
 #### Modo `"subagents"` (se `mode: "subagents"` no output):
 
 1. Leia os `taskGroups` retornados (ex: `backend`, `frontend`, `infra`)
-2. Para cada grupo com ≥ 3 tasks e sem dependências cruzadas, use **Task tool** com o `taskPrompt` do dispatch config:
+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:
+
+> **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]
@@ -155,6 +255,7 @@ Para cada task do grupo, em ordem:
 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")
 
@@ -234,22 +335,29 @@ Sintetize os resultados de todos os teammates no recap.md (Passo 6).
 - [ ] `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)
 
 ```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
 ```
 
 **❌ Se alguma checkbox NÃO estiver marcada:**
 → Voltar para a fase correspondente
 
+**❌ 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
+
 ---
 
 ### Passo 1: Carregar Contexto Completo
 
 Leia todos os outputs antes de implementar:
 
-1. `.morph/features/$ARGUMENTS/3-tasks/tasks.md` — Lista de tasks
+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
@@ -296,6 +404,12 @@ Para cada task (T001 → T00N):
 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:
+   ```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:**
    ```bash
    npx morph-spec task done $ARGUMENTS T001
@@ -389,6 +503,7 @@ Execute o skill `post-implementation` antes de criar o PR. Ele orquestra:
 - `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
 
 ### Passo 9: Frontend Review (NEXTJS/FULLSTACK)
@@ -404,17 +519,43 @@ screenshots responsivos (mobile/tablet/desktop), e verificação de SEO metadata
 
 ---
 
-## Integração com Superpowers
+## Dispatch Morph-Nativo
+
+O morph-spec usa seus próprios agentes e validadores para implementação, dispatch e review.
+
+### Implementação
+
+Implementadores são despachados via `dispatch-agents`:
+```bash
+npx morph-spec dispatch-agents $ARGUMENTS implement
+```
+
+Use o `agentId` de cada grupo como `subagent_type` no Agent tool:
+```
+Agent(subagent_type=<agentId>, prompt=<conteúdo de prompts/implementer-prompt.md preenchido>)
+```
+
+### Review (Two-Stage)
+
+**Stage 1 — Spec Compliance (obrigatório):**
+```
+Agent(subagent_type=<tier-4 validator>, prompt=<conteúdo de prompts/spec-reviewer-prompt.md>)
+```
+Use validadores do `dispatch-agents --mode validate`. Spec compliance DEVE passar antes de prosseguir.
+
+**Stage 2 — Code Quality (obrigatório):**
+```
+Agent(subagent_type=standards-architect, prompt=<conteúdo de prompts/code-quality-reviewer-prompt.md>)
+```
+Issues `critical` bloqueiam. Issues `important` devem ser corrigidas. `suggestion` é opcional.
 
-> Disponível quando o plugin `superpowers` está instalado.
+### Prompt Templates
 
-| Skill | Quando Usar | Invocação |
-|-------|-------------|-----------|
-| `test-driven-development` | Para cada task de implementação | `Skill(superpowers:test-driven-development)` |
-| `systematic-debugging` | Quando testes falham ou erros inesperados | `Skill(superpowers:systematic-debugging)` |
-| `requesting-code-review` | Após implementação completa | `Skill(superpowers:requesting-code-review)` |
-| `verification-before-completion` | Antes de marcar feature como done | Use `verification-before-completion` (morph-spec version) |
-| `post-implementation` | Antes de criar o PR (scans + smoke test + review) | `/post-implementation {feature}` |
+| 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 |
 
 ---
 
@@ -422,7 +563,7 @@ screenshots responsivos (mobile/tablet/desktop), e verificação de SEO metadata
 
 - Código fonte implementado (vários arquivos)
 - Testes unitários e de integração
-- `.morph/features/$ARGUMENTS/4-implement/recap.md` — Resumo da implementação
+- `.morph/features/$ARGUMENTS/5-implement/recap.md` — Resumo da implementação
 
 ## Critérios de Conclusão
 
@@ -433,7 +574,7 @@ screenshots responsivos (mobile/tablet/desktop), e verificação de SEO metadata
 - [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)
+- [x] `/post-implementation` executado sem BLOCKs (smoke test, scans, code review, `morph-checklist`)
 
 ---
 
@@ -442,9 +583,9 @@ screenshots responsivos (mobile/tablet/desktop), e verificação de SEO metadata
 <!-- morph:outputs:implement -->
 | Output | Caminho |
 |--------|---------|
-| `recap` | `.morph/features/{feature}/4-implement/recap.md` |
+| `recap` | `.morph/features/{feature}/5-implement/recap.md` |
 <!-- /morph:outputs -->
 
 ---
 
-Feature completa! Considere criar um PR e rodar `morph-spec session-summary $ARGUMENTS`.
+Feature completa! Considere criar um PR e rodar `morph-spec generate recap $ARGUMENTS`.

package/framework/skills/level-1-workflows/morph-phase-implement/prompts/code-quality-reviewer-prompt.md

@@ -0,0 +1,50 @@
+# Morph-Spec Code Quality Review
+
+You are the standards-architect reviewer for feature '{{FEATURE_NAME}}'.
+
+## Review Scope
+
+Review the implementation for code quality, architecture compliance, and adherence to project standards.
+
+## Reference Documents
+
+Read these before reviewing:
+- `.morph/context/standards.md` — Project coding standards
+- `.morph/context/README.md` — Project architecture overview
+- `framework/standards/` — Framework-level standards (reference as needed)
+
+## Review Checklist
+
+1. **Naming Conventions** — PascalCase for types, camelCase for variables, kebab-case for files (or as defined in standards)
+2. **Architecture Compliance** — Code follows the project's architecture pattern (VSA slices, DDD layers, etc.)
+3. **Async Patterns** — CancellationToken propagated, no fire-and-forget, proper await
+4. **Error Handling** — Appropriate exceptions, no swallowed errors, consistent patterns
+5. **Security** — No hardcoded secrets, SQL injection, XSS vectors, or OWASP top 10 issues
+6. **DI Lifetimes** — Correct service registration (Scoped for DB, Singleton for config, etc.)
+7. **Test Quality** — Tests follow Arrange-Act-Assert, meaningful assertions, no test duplication
+
+## Output Format
+
+```json
+{
+  "passed": true/false,
+  "issues": [
+    {
+      "severity": "critical|important|suggestion",
+      "file": "path/to/file",
+      "line": 42,
+      "description": "What the issue is",
+      "fix": "How to fix it"
+    }
+  ]
+}
+```
+
+## Rules
+
+- `critical` issues MUST be fixed before merge
+- `important` issues SHOULD be fixed
+- `suggestion` issues are optional improvements
+- Only `critical` issues cause `passed: false`
+- Be specific — always include file path and line number
+- Prefer minimal fixes over refactoring

package/framework/skills/level-1-workflows/morph-phase-implement/prompts/implementer-prompt.md

@@ -0,0 +1,45 @@
+# Morph-Spec Implementer Dispatch
+
+You are implementing tasks for the feature '{{FEATURE_NAME}}' as agent '{{AGENT_ID}}'.
+
+## Context
+
+**Spec:** Read `.morph/features/{{FEATURE_NAME}}/1-design/spec.md`
+**Contracts:** Read `.morph/features/{{FEATURE_NAME}}/1-design/contracts.cs`
+**Plan:** Read `.morph/features/{{FEATURE_NAME}}/3-plan/plan.md`
+**Standards:** Read `.morph/context/standards.md` and relevant files in `framework/standards/`
+
+## Agent Briefing
+
+{{AGENT_BRIEFING}}
+
+## Tasks Assigned
+
+{{TASK_LIST}}
+
+## Execution Rules
+
+1. Before starting each task:
+   - Execute: `npx morph-spec task start {{FEATURE_NAME}} {{TASK_ID}}`
+
+2. For each task, follow TDD:
+   - Write the failing test first
+   - Run it to verify it fails
+   - Write minimal implementation to pass
+   - Run tests to verify they pass
+   - Commit
+
+3. Before marking any task done:
+   - Verify build compiles: `dotnet build` or `npm run build`
+   - Run relevant tests
+   - Execute: `npx morph-spec task done {{FEATURE_NAME}} {{TASK_ID}}`
+
+4. Every 3 tasks:
+   - Execute: `npx morph-spec checkpoint-save {{FEATURE_NAME}}`
+   - Execute: `npx morph-spec validate-feature {{FEATURE_NAME}} --phase implement`
+
+5. Contracts are the source of truth — all DTOs, interfaces, and types MUST match `contracts.cs` exactly
+
+6. Modify ONLY files listed in your assigned tasks. Do NOT touch files outside your domain.
+
+7. If you encounter a dependency on another agent's work, STOP and report it.

package/framework/skills/level-1-workflows/morph-phase-implement/prompts/spec-reviewer-prompt.md

@@ -0,0 +1,47 @@
+# Morph-Spec Spec Compliance Review
+
+You are a Tier-4 spec reviewer for feature '{{FEATURE_NAME}}'.
+
+## Review Scope
+
+Review the implementation against the specification. Your job is to ensure the code matches the spec EXACTLY — no more, no less.
+
+## Reference Documents
+
+Read these before reviewing:
+- `.morph/features/{{FEATURE_NAME}}/1-design/spec.md` — The specification
+- `.morph/features/{{FEATURE_NAME}}/1-design/contracts.cs` — The contracts (source of truth)
+- `.morph/features/{{FEATURE_NAME}}/3-plan/plan.md` — The implementation plan
+
+## Review Checklist
+
+For each task implemented, verify:
+
+1. **Completeness** — All acceptance criteria from spec.md are implemented
+2. **Correctness** — DTOs, interfaces, and types match contracts.cs exactly
+3. **No over-building** — No features, flags, or abstractions not in the spec
+4. **No under-building** — No missing error handling, validations, or edge cases from the spec
+5. **Naming** — All names match the contracts (exact casing and spelling)
+
+## Output Format
+
+```json
+{
+  "passed": true/false,
+  "issues": [
+    {
+      "severity": "error|warning",
+      "file": "path/to/file",
+      "description": "What doesn't match the spec",
+      "specReference": "Which section of spec.md"
+    }
+  ]
+}
+```
+
+## Rules
+
+- Only flag issues that represent spec non-compliance
+- Do NOT flag style preferences or minor improvements
+- Every issue MUST reference a specific section of spec.md or contracts.cs
+- If the implementation matches the spec, output `{ "passed": true, "issues": [] }`