@polymorphism-tech/morph-spec 4.22.0 → 6.0.0

package/framework/phases.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.0.0",
+  "version": "5.0.0",
   "phases": {
     "proposal": {
       "id": "proposal",
@@ -7,20 +7,16 @@
       "folder": "0-proposal",
       "displayName": "Proposal",
       "goals": [
-        "Understand the feature scope",
-        "Agree on high-level approach",
-        "Produce initial proposal document"
+        "Understand the business problem and user flows",
+        "Detect existing stack (brownfield) or assume default stack (greenfield)",
+        "Produce proposal.md and reach Gate 1"
       ],
       "requiredOutputs": ["proposal"],
-      "optionalOutputs": [],
-      "recommendedMCPs": ["context7"],
+      "optionalOutputs": ["migrationPlan", "stackScan"],
       "pausePoints": [
-        { "id": "proposal", "label": "Approve Proposal" }
+        { "id": "proposal", "label": "Gate 1 — Approve proposal" }
       ],
-      "agentTiers": [1],
-      "requiredSkills": [
-        { "trigger": "beforePhaseStart", "skill": "morph-brainstorming" }
-      ]
+      "skill": "morph-brainstorming"
     },
     "uiux": {
       "id": "uiux",
@@ -29,134 +25,64 @@
       "displayName": "UI/UX Design",
       "optional": true,
       "goals": [
-        "Define visual design and design system",
-        "Create component inventory and style guide",
-        "Produce wireframes and user flows"
+        "Define design system tokens and components",
+        "Produce mockups and user flows"
       ],
       "requiredOutputs": ["uiDesignSystem"],
-      "optionalOutputs": ["uiMockups", "uiComponents", "uiFlows", "stitchHtml"],
-      "recommendedMCPs": ["playwright", "context7", "stitch"],
-      "pausePoints": [
-        { "id": "uiux", "label": "Approve UI/UX Design" }
-      ],
-      "agentTiers": [1, 2, 3],
-      "requiredSkills": [
-        { "trigger": "beforeArchitecturalDecision", "skill": "morph-brainstorming" },
-        { "trigger": "beforePhaseComplete",         "skill": "morph-frontend-review" }
-      ]
-    },
-    "design": {
-      "id": "design",
-      "index": 2,
-      "folder": "2-design",
-      "displayName": "Technical Design",
-      "goals": [
-        "Write technical specification",
-        "Define contracts and interfaces",
-        "Analyse schema changes",
-        "Document architectural decisions"
-      ],
-      "requiredOutputs": ["spec", "contracts"],
-      "optionalOutputs": ["schemaAnalysis", "decisions"],
-      "recommendedMCPs": ["context7", "github"],
+      "optionalOutputs": ["uiMockups", "uiComponents", "uiFlows"],
       "pausePoints": [
-        { "id": "design", "label": "Approve Design Spec" }
+        { "id": "uiux", "label": "Approve UI/UX" }
       ],
-      "agentTiers": [1, 2, 3, 4],
-      "requiredSkills": [
-        { "trigger": "beforePhaseStart",             "skill": "morph-phase-design" },
-        { "trigger": "beforePhaseStart",             "skill": "morph-phase-codebase-analysis" },
-        { "trigger": "beforeArchitecturalDecision",  "skill": "morph-brainstorming" },
-        { "trigger": "onExternalServiceIntegration", "skill": "morph-simulation-checklist" },
-        { "trigger": "beforePhaseComplete",          "skill": "morph-verification-before-completion" }
-      ]
+      "skill": null
     },
     "plan": {
       "id": "plan",
-      "index": 3,
-      "folder": "3-plan",
-      "displayName": "Implementation Plan",
-      "goals": [
-        "Create detailed implementation plan with exact file paths and code",
-        "Define bite-sized TDD tasks with test-first approach",
-        "Establish execution strategy based on project analysis"
-      ],
-      "requiredOutputs": ["plan"],
-      "optionalOutputs": [],
-      "recommendedMCPs": ["context7", "github"],
-      "pausePoints": [
-        { "id": "plan", "label": "Approve Implementation Plan" }
-      ],
-      "agentTiers": [1, 2],
-      "requiredSkills": [
-        { "trigger": "beforePhaseStart",    "skill": "morph-phase-plan" },
-        { "trigger": "beforePhaseComplete", "skill": "morph-verification-before-completion" }
-      ]
-    },
-    "tasks": {
-      "id": "tasks",
-      "index": 4,
-      "folder": "4-tasks",
-      "displayName": "Task Breakdown",
+      "index": 2,
+      "folder": "2-plan",
+      "displayName": "Plan",
       "goals": [
-        "Break approved spec into numbered, atomic tasks",
-        "Order tasks by dependency",
-        "Assign tasks to agent tiers"
+        "Write spec.md (technical spec)",
+        "Write mandate.md (implementation contract with stack defaults + forbidden patterns)",
+        "Write tasks.md (ordered task breakdown)"
       ],
-      "requiredOutputs": ["tasks"],
-      "optionalOutputs": [],
-      "recommendedMCPs": ["context7", "github"],
+      "requiredOutputs": ["spec", "mandate", "tasks"],
+      "optionalOutputs": ["decisions"],
       "pausePoints": [
-        { "id": "tasks", "label": "Approve Task List" }
+        { "id": "plan", "label": "Gate 2 — Approve spec + mandate + tasks" }
       ],
-      "agentTiers": [1, 2, 3],
-      "requiredSkills": [
-        { "trigger": "onParallelTasksIdentified", "skill": "superpowers:dispatching-parallel-agents" },
-        { "trigger": "beforePhaseComplete",       "skill": "morph-verification-before-completion" }
-      ]
+      "skill": "morph-plan"
     },
     "implement": {
       "id": "implement",
-      "index": 5,
-      "folder": "5-implement",
+      "index": 3,
+      "folder": "3-implement",
       "displayName": "Implementation",
       "goals": [
-        "Execute approved tasks in order",
-        "Follow framework standards at each step",
-        "Checkpoint every 3 tasks",
-        "Write implementation recap"
+        "Execute tasks in order with auto-advance between tasks",
+        "Apply morph-eval after each task",
+        "Maintain recap.md and execution trace"
       ],
       "requiredOutputs": ["recap"],
       "optionalOutputs": [],
-      "recommendedMCPs": ["context7", "playwright", "github", "vercel"],
       "pausePoints": [],
-      "agentTiers": [1, 2, 3, 4],
-      "requiredSkills": [
-        { "trigger": "beforeEachTask",    "skill": "superpowers:test-driven-development" },
-        { "trigger": "beforeTaskDone",    "skill": "morph-verification-before-completion" },
-        { "trigger": "onBugOrUnexpected", "skill": "superpowers:systematic-debugging" },
-        { "trigger": "afterAllTasks",     "skill": "morph-post-implementation" },
-        { "trigger": "afterAllTasks",     "skill": "superpowers:requesting-code-review" },
-        { "trigger": "beforePR",          "skill": "morph-checklist" }
-      ]
+      "skill": "morph-implement"
     },
-    "sync": {
-      "id": "sync",
-      "index": 6,
-      "folder": null,
-      "displayName": "Sync Standards",
-      "optional": true,
+    "review": {
+      "id": "review",
+      "index": 4,
+      "folder": "4-review",
+      "displayName": "Review",
       "goals": [
-        "Update framework standards from feature learnings",
-        "Capture new patterns to learning library",
-        "Archive completed feature"
+        "Verify implementation against mandate",
+        "Apply morph-eval at phase scope to produce dimension scores",
+        "Produce review-report.md and present Gate 3"
       ],
-      "requiredOutputs": [],
+      "requiredOutputs": ["reviewReport"],
       "optionalOutputs": [],
-      "recommendedMCPs": [],
-      "pausePoints": [],
-      "agentTiers": [1],
-      "requiredSkills": []
+      "pausePoints": [
+        { "id": "review", "label": "Gate 3 — Approve review-report" }
+      ],
+      "skill": "morph-review"
     }
   }
 }

package/framework/rubrics/eval-rubric.json

@@ -0,0 +1,66 @@
+{
+  "id": "eval",
+  "version": "1.0.0",
+  "description": "Eval rubric for morph-eval system. Scores phase outputs across structural and semantic dimensions.",
+  "categories": {
+    "structural_compliance": {
+      "weight": 0.25,
+      "description": "Required sections, headers, formatting present in phase outputs",
+      "dimensions": {
+        "proposal": ["has_problem_statement", "has_proposed_solution", "min_length_300"],
+        "spec": ["has_overview", "has_functional_requirements", "has_fr_sections", "has_data_model"],
+        "tasks": ["has_task_headers", "has_fr_references", "no_duplicate_ids"],
+        "contracts": ["has_type_definitions", "correct_naming_conventions"]
+      }
+    },
+    "content_quality": {
+      "weight": 0.30,
+      "description": "LLM-as-judge: completeness, specificity, actionability of outputs",
+      "dimensions": {
+        "completeness": "Covers all aspects of the feature request",
+        "specificity": "Requirements are concrete and testable, not vague",
+        "actionability": "A developer could implement from this alone",
+        "architecture_depth": "Component boundaries, data flow, error handling clear"
+      }
+    },
+    "cross_phase_consistency": {
+      "weight": 0.25,
+      "description": "Alignment between spec, tasks, mandate, and contracts",
+      "dimensions": {
+        "fr_coverage": "Every spec FR referenced by at least one task",
+        "mandate_integrity": "Mandate includes all tasks with acceptance criteria",
+        "contract_alignment": "Spec Data Model entities appear in contracts",
+        "dependency_ordering": "Task dependencies are topologically valid"
+      }
+    },
+    "stack_appropriateness": {
+      "weight": 0.20,
+      "description": "Outputs match the target technology stack",
+      "dimensions": {
+        "correct_language": "Contracts use the right language for the stack (TS vs CS)",
+        "framework_patterns": "Architecture follows stack conventions (App Router, VSA, etc.)",
+        "tool_chain": "Build/test commands match the stack"
+      }
+    }
+  },
+  "thresholds": {
+    "approve": 8.0,
+    "retry": 6.0,
+    "max_iterations": 3,
+    "regression_tolerance": 0.5
+  },
+  "scoring": {
+    "structural": {
+      "method": "binary_checklist",
+      "description": "Each dimension is pass/fail. Score = (passed / total) * 10"
+    },
+    "llm_judge": {
+      "method": "evidence_based",
+      "description": "LLM scores 1-10 per dimension with evidence quotes and gap descriptions"
+    },
+    "cross_phase": {
+      "method": "ratio_based",
+      "description": "FR coverage ratio, mandate inclusion ratio. Score = ratio * 10"
+    }
+  }
+}

package/framework/skills/README.md

@@ -1,64 +1,39 @@
-# MORPH-SPEC Skills
-
-Skills installed to `.claude/skills/` during `morph-spec init` (or `morph-spec update`).
-
-Each skill is a directory: `{name}/SKILL.md` + optional `scripts/`, `references/`, `assets/`.
-
----
-
-## level-0-meta — Utilities & Meta-Skills
-
-| Skill | Description |
-|-------|-------------|
-| `tool-usage-guide` | Tool selection flowchart — which tool for which action |
-| `morph-checklist` | Pre-session checklist for MORPH-SPEC projects |
-| `simulation-checklist` | Checklist for AI simulation / prompt testing |
-| `brainstorming` | Collaborative ideation → spec via dialogue |
-| `verification-before-completion` | Gate check before marking any work done |
-| `code-review` | .NET/C# review checklist (naming, arch, async, DI, DTOs) |
-
-
-### level-0-meta extras
-
-| Skill | File | Purpose |
-|-------|------|---------|
-| `brainstorming` | `references/proposal-example.md` | Filled-in proposal.md example |
-| `verification-before-completion` | `scripts/check-phase-outputs.mjs` | Validate required phase outputs exist |
-| `code-review` | `references/review-example.md` | Filled-in review with finding format |
-| `code-review` | `scripts/scan-csharp.mjs` | Scan .cs files for CRITICAL/HIGH violations |
-
----
-
-## level-1-workflows — Phase Workflow Skills
-
-Invoked internally by `/morph-proposal` and `/morph-apply`. Not user-invocable.
-
-| Skill | Phase | Description |
-|-------|-------|-------------|
-| `phase-codebase-analysis` | 0 | Analyse existing codebase before design |
-| `phase-design` | 2 | Technical spec + contracts + decisions + clarification |
-| `phase-uiux` | 1 | UI/UX design system + mockups + components |
-| `phase-plan` | 3 | Implementation plan with exact paths and TDD |
-| `phase-tasks` | 4 | Break spec into ordered task list (tasks.md) |
-| `phase-implement` | 5 | Implement tasks with TDD + checkpoints + recap |
-
-### level-1-workflows extras
-
-| Skill | File | Purpose |
-|-------|------|---------|
-| `phase-design` | `references/spec-example.md` | Filled-in spec.md example |
-| `phase-tasks` | `references/tasks-example.md` | Filled-in tasks.md with T### format |
-| `phase-tasks` | `scripts/validate-tasks.mjs` | Validate tasks.md structure and IDs |
-| `phase-implement` | `references/recap-example.md` | Filled-in recap.md example |
-
----
-
-## Domain Agents
-
-Domain specialist agents (`framework/agents/`) are installed separately as `.claude/agents/morph-domain-{name}.md` — they are subagents, not skills.
-
-See `framework/agents/README.md` for the full list.
-
----
-
-*MORPH-SPEC by Polymorphism Tech*
+# MORPH-SPEC Skills
+
+Skills installed to `.claude/skills/` during `morph-spec init` (or `morph-spec update`).
+
+Each skill is a directory: `{name}/SKILL.md` + optional `scripts/`, `references/`, `assets/`.
+
+---
+
+## core/ — NLH Skills (Single Source of Truth)
+
+These are the only skills the harness needs. MORPH.md references them by path.
+
+| Skill                | Purpose                                                              | User-invocable |
+|----------------------|----------------------------------------------------------------------|----------------|
+| `morph-brainstorming` | Business understanding + brownfield scan → proposal.md (Gate 1)     | yes            |
+| `morph-stack-scan`    | Detect stack drift in existing projects, generate migration-plan.md  | yes            |
+| `morph-plan`          | Produce spec.md + mandate.md + tasks.md (Gate 2)                     | yes            |
+| `morph-implement`     | Execute each task with standard + persona, auto-advance between tasks| no             |
+| `morph-eval`          | Score work 0-10 across 4 dimensions, silence on score >= 8           | no             |
+| `morph-review`        | Final review report with scores + recommendation (Gate 3)            | yes            |
+| `morph-standards`     | Locate and load a specific standard on demand                        | no             |
+
+The legacy `level-0-meta/` and `level-1-workflows/` skill trees were removed
+in v5 — their useful content was consolidated into `core/`. MORPH.md is the
+single charter that ties everything together.
+
+---
+
+## Domain Agents
+
+Domain specialist agents (`framework/agents/`) are installed separately as
+`.claude/agents/morph-{name}.md` — they are subagents dispatched via the
+`Agent` tool, not skills.
+
+See `framework/agents.json` for the full list and persona definitions.
+
+---
+
+*MORPH-SPEC by Polymorphism Tech*

package/framework/skills/core/README.md

@@ -0,0 +1,3 @@
+# skills/core
+Part of morph-spec NLH.
+See `framework/MORPH.md` for full documentation.

package/framework/skills/core/morph-brainstorming/SKILL.md

@@ -0,0 +1,102 @@
+---
+name: morph-brainstorming
+description: Entende o negócio, os usuários e a arquitetura antes de qualquer planejamento técnico. Para projetos existentes, detecta desvios de stack e propõe plano de compliance.
+version: core
+when-to-invoke: ao receber um novo request de feature, antes de morph-plan
+user-invokable: true
+---
+
+# morph-brainstorming
+
+## Objetivo
+Garantir que o planejamento técnico parta de entendimento real do negócio e do contexto técnico existente — não de suposições. Output é o `proposal.md` aprovado pelo Gate 1.
+
+## Quando invocar
+Ao iniciar uma nova feature — antes de qualquer especificação técnica ou planejamento.
+
+## Stack padrão (baked in)
+
+O harness conhece o stack por padrão. Não pergunte sobre tecnologia a menos que haja ambiguidade real.
+
+| Camada | Stack |
+|--------|-------|
+| Backend | .NET 10, VSA (feature-folder: handler + validator + endpoint + errors + tests) |
+| ORM | EF Core + Neon (Postgres), `Guid.CreateVersion7()`, `sealed` classes, `result.Match()` |
+| IA | Microsoft Agent Framework (MAF) — quando a feature envolve agentes |
+| Frontend | Next.js App Router + Tailwind + Framer Motion + Shadcn |
+| Jobs async | Hangfire — apenas se a feature requer processamento em background |
+
+**Padrões proibidos:** `Guid.NewGuid()`, classes não-sealed sem justificativa, exceptions sem result pattern, Repository pattern (VSA usa handlers diretos).
+
+## O que fazer
+
+### Parte 1 — Entendimento de negócio
+
+1. Faça até 4 perguntas ao usuário via `AskUserQuestion` para entender:
+   - Qual problema de negócio esta feature resolve?
+   - Quem são os usuários afetados e quais são os fluxos críticos deles?
+   - Qual é o critério de sucesso — como saberemos que a feature está pronta?
+   - Há integrações externas, dependências de outras features ou restrições de prazo?
+
+   Se as respostas forem claras e suficientes, siga para a Parte 2 sem perguntas adicionais.
+
+### Parte 2 — Detecção de contexto (greenfield vs brownfield)
+
+2. Use um `Explore` subagent para varrer o projeto com este prompt:
+
+   ```
+   Varredura de codebase para morph-brainstorming.
+
+   Procure e reporte:
+   1. Stack atual: leia .csproj (TargetFramework, PackageReferences), package.json (dependencies), 
+      migrations/ (ORM em uso). Liste tecnologias encontradas.
+   2. Estrutura de pastas: o projeto segue VSA (feature-folder) ou outra arquitetura?
+   3. Padrões em uso: Guid.NewGuid() ou Guid.CreateVersion7()? Classes sealed? Result pattern ou exceptions?
+   4. Features existentes: liste as pastas em src/ ou equivalente para mapear slices já implementados.
+   5. Dependências relevantes para esta feature: o que já existe que esta feature vai usar ou modificar?
+
+   Retorne apenas fatos observados — sem sugestões ou opiniões.
+   ```
+
+3. Com base na varredura:
+   - **Se o projeto não existe ainda (greenfield):** siga direto para a Parte 3.
+   - **Se o projeto existe e segue o stack padrão:** siga para a Parte 3.
+   - **Se o projeto existe mas desvia do stack padrão:** gere um `migration-plan.md` em `.morph/features/{feature}/0-proposal/` listando o que migrar e em que ordem. Faça UMA pergunta via `AskUserQuestion`: "A migração de stack deve ser incluída nesta feature ou tratada numa feature separada?" Registre a decisão e siga para a Parte 3.
+
+### Parte 3 — Produção do proposal.md
+
+4. Produza `proposal.md` em `.morph/features/{feature}/0-proposal/` com:
+   - **Problema:** o que está sendo resolvido e para quem (máx. 2 parágrafos)
+   - **Escopo:** o que está incluído e o que está explicitamente excluído
+   - **Usuários e fluxos críticos:** quem usa e qual é o caminho principal
+   - **Critérios de aceite:** condições verificáveis que indicam que a feature está pronta
+   - **Stack:** confirme o stack padrão ou documente desvios aprovados
+   - **Riscos e dependências:** o que pode dar errado, o que esta feature depende
+   - **Compliance de stack:** "Em compliance" ou lista de desvios detectados e plano de resolução
+
+   Um bom proposal.md tem no máximo 2 páginas. Se está crescendo além disso, o escopo precisa ser cortado.
+
+5. Apresente o Gate 1:
+
+   ```
+   ## Gate 1 — Proposta pronta para revisão
+
+   **Feature:** {nome}
+   **Problema:** {1 frase}
+   **Escopo:** {incluído} | Excluído: {exclusões explícitas}
+   **Stack:** {Em compliance / Desvios: X, Y}
+   **Riscos:** {principal risco identificado}
+
+   Aprovado? Responda "aprovado" para avançar para o planejamento.
+   ```
+
+   Aguarde aprovação explícita. Se o usuário pedir ajustes, aplique e reapresente o gate.
+
+## Output esperado
+- `.morph/features/{feature}/0-proposal/proposal.md` — proposta aprovada
+- `.morph/features/{feature}/0-proposal/migration-plan.md` — apenas se houver desvio de stack
+- Gate 1 apresentado e aprovado
+
+## Referências
+- `framework/MORPH.md` — seções 1 (Papéis), 2 (Fases), 5 (Gates)
+- `framework/standards/STANDARDS.json` — para referência de standards relevantes à stack

package/framework/skills/core/morph-eval/SKILL.md

@@ -0,0 +1,57 @@
+---
+name: morph-eval
+description: Avalia a qualidade de uma tarefa ou fase com rubricas graduadas 0-10
+version: core
+when-to-invoke: ao completar uma tarefa ou ao finalizar uma fase de implementação
+user-invokable: false
+---
+
+# morph-eval
+
+## Objetivo
+Produzir um score 0-10 por dimensão e uma ação clara baseada no score.
+O objetivo não é punir — é identificar o que melhorar antes de seguir adiante.
+
+## Quando invocar
+Após concluir uma tarefa ou ao finalizar a fase de implementação.
+Também invocado ao receber o retorno de um sub-agent com auto-score < 7.
+
+## O que fazer
+
+1. Identifique o escopo da avaliação: tarefa única ou fase completa.
+
+2. Para cada dimensão, leia a rubrica correspondente em `framework/evals/rubrics/`:
+   - `architecture.md` — peso 30% — vertical slice, separação de responsabilidades, infra
+   - `contracts.md` — peso 25% — tipos, validação, tratamento de erros, naming
+   - `code-quality.md` — peso 25% — naming, ausência de code smells, padrões do stack
+   - `test-coverage.md` — peso 20% — happy path, edge cases, isolamento, naming de testes
+
+3. Atribua um score de 1 a 10 para cada dimensão seguindo as bandas da rubrica.
+
+4. Calcule o score composto: (arch × 0.30) + (contracts × 0.25) + (quality × 0.25) + (tests × 0.20).
+
+5. Aja conforme o score composto:
+   - **8-10:** Aprovado — nenhuma saída necessária no contexto, siga para próxima tarefa.
+   - **6-7.9:** Feedback priorizado — liste o que melhorar (bloqueantes primeiro), modelo continua.
+   - **< 6:** Escale para revisão humana — produza relatório detalhado com scores por dimensão e itens bloqueantes.
+
+6. Registre o score no recap.md da tarefa avaliada.
+
+7. Atualize o trace de execução em `.morph/traces/YYYY-MM-DD-{feature}-{phase}.json`:
+   - Encontre a entrada da task avaliada em `tasks[]` pelo `id`
+   - Preencha `eval_score` com o score composto calculado no passo 4
+   - Preencha `eval_dimensions` com os scores individuais por dimensão
+
+## Output esperado
+- Score composto 0-10 com scores por dimensão
+- Ação tomada com base no score (aprovado / feedback / escalado)
+- Entrada no recap.md com scores
+- Trace atualizado com `eval_score` e `eval_dimensions`
+
+## Referências
+- `framework/evals/rubrics/architecture.md` — rubrica de arquitetura (30%)
+- `framework/evals/rubrics/contracts.md` — rubrica de contratos (25%)
+- `framework/evals/rubrics/code-quality.md` — rubrica de qualidade (25%)
+- `framework/evals/rubrics/test-coverage.md` — rubrica de cobertura (20%)
+- `framework/evals/trace-schema.md` — formato canônico do trace
+- `framework/MORPH.md` — seção 1 (papel Evaluator)

package/framework/skills/core/morph-implement/SKILL.md

@@ -0,0 +1,83 @@
+---
+name: morph-implement
+description: Guia a execução de cada tarefa de implementação com standard e persona adequados
+version: core
+when-to-invoke: ao iniciar cada tarefa de implementação listada no tasks.md
+user-invokable: false
+---
+
+# morph-implement
+
+## Objetivo
+Garantir que cada tarefa seja executada com o standard correto, a persona de agente adequada,
+e que o resultado seja registrado no recap.md ao final.
+
+## Quando invocar
+Ao iniciar cada tarefa do tasks.md — antes de escrever qualquer código.
+
+## O que fazer
+
+1. Leia o mandate.md em `.morph/features/{feature}/2-plan/mandate.md`.
+   Identifique os standards obrigatórios e patterns proibidos para esta feature.
+
+2. Identifique o standard mais relevante para a tarefa atual:
+   - Consulte `framework/standards/STANDARDS.json` — filtre por `category` e `tags`.
+   - Leia apenas o arquivo `.md` do standard identificado (campo `path` no JSON).
+   - Se nenhum standard cobrir o caso, registre no decisions.md e adote o critério mais conservador.
+
+3. Identifique a persona de agente adequada para a tarefa:
+   - Consulte `framework/agents.json` — encontre o agente cujo `domains` cobre o domínio da tarefa.
+   - Leia o campo `persona` do agente e adote esse ponto de vista durante a implementação.
+
+4. Avalie se a tarefa se qualifica para sub-agent dispatch (ver critérios em `framework/MORPH.md` seção 6):
+   - Duração estimada > 5 minutos
+   - Mais de 3 tentativas de correção falharam no mesmo problema
+   - Análise de arquivo com > 500 linhas
+   - Tarefa repetitiva com > 3 instâncias do mesmo padrão
+   - Risco de contaminar o contexto principal com detalhes de baixo nível irrelevantes para o fluxo
+
+   **Se sim — despache sub-agent com este template:**
+   ```
+   Implementar [ID da tarefa]: [título da tarefa]
+
+   Spec: [O que deve ser feito em 3-5 frases, extraído do tasks.md]
+   Standard: [path do .md do standard identificado no passo 2]
+   Arquivos relevantes: [lista de paths que o sub-agent precisa ler ou modificar]
+   Done quando: [critério verificável do tasks.md]
+
+   Retorne APENAS: (1) o que foi feito em 2-3 frases, (2) arquivos modificados,
+   (3) problemas encontrados e como foram resolvidos, (4) auto-score 0-10.
+   ```
+   Após receber o retorno: se auto-score < 7, aplique `morph-eval` antes de aceitar. Se >= 7, integre ao recap.md e vá para o passo 7.
+
+   **Se não — siga para o passo 5.**
+
+5. Implemente a tarefa seguindo o standard e a persona identificados.
+   Se encontrar ambiguidade de escopo não coberta pelo mandate, registre no decisions.md
+   e resolva da forma mais conservadora — não pause para perguntar, a menos que seja bloqueante.
+
+6. Ao concluir a tarefa, atualize `recap.md` em `.morph/features/{feature}/3-implement/`:
+   - ID da tarefa concluída
+   - O que foi feito (2-3 frases)
+   - Arquivos modificados
+   - Standard consultado
+   - Problemas encontrados e como foram resolvidos
+
+7. Registre a entrada no trace de execução em `.morph/traces/YYYY-MM-DD-{feature}-implement.json`:
+   - Crie o arquivo se não existir (use o schema em `framework/evals/trace-schema.md`)
+   - Adicione entrada em `tasks[]` com: `id`, `title`, `status`, `standards_consulted`, `agent_persona`, `files_modified`, `sub_agent_dispatched`
+   - Deixe `eval_score` e `eval_dimensions` como `null` — serão preenchidos pelo morph-eval
+   - Se esta for a última tarefa da fase, preencha `completed_at`
+
+8. Verifique o tasks.md por tarefas com status pendente. Se houver próxima tarefa, inicie-a imediatamente aplicando esta skill desde o passo 1 — sem aguardar instrução do usuário. Pause apenas se encontrar ambiguidade bloqueante não coberta pelo mandate.
+
+## Output esperado
+- Código implementado conforme o standard consultado (direto ou via sub-agent)
+- `.morph/features/{feature}/3-implement/recap.md` atualizado com entrada da tarefa concluída
+- `.morph/features/{feature}/2-plan/decisions.md` atualizado se houver decisão não trivial
+
+## Referências
+- `framework/standards/STANDARDS.json` — índice de standards (não carregue todos — filtre por tarefa)
+- `framework/agents.json` — personas dos agentes por domínio
+- `framework/MORPH.md` seção 6 — critérios de dispatch e contrato de retorno do sub-agent
+- `.morph/features/{feature}/2-plan/mandate.md` — contrato da feature