@polymorphism-tech/morph-spec 4.9.0 → 4.10.0

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": [] }`

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

@@ -0,0 +1,254 @@
+---
+name: morph:phase-plan
+description: MORPH-SPEC Phase 4 (Plan). Generates a detailed implementation plan with exact file paths, TDD code blocks, and execution strategy analysis. Produces plan.md in 3-plan/. Use after clarify phase to create an actionable implementation plan before task breakdown.
+argument-hint: "[feature-name]"
+disable-model-invocation: true
+user-invocable: false
+allowed-tools: Read, Write, Edit, Bash, Glob, Grep
+cliVersion: "4.10.0"
+---
+
+# MORPH Plan - FASE 4
+
+> INTERNAL: Workflow skill used by /morph-proposal during automated phase orchestration. Not a user command.
+
+Gere um plano de implementacao detalhado com paths exatos, codigo TDD e estrategia de execucao.
+
+## Pre-requisitos
+
+- [ ] FASE 3 (Clarify) concluida
+- [ ] `spec.md` atualizado com clarificacoes
+- [ ] `contracts.cs` ou `contracts.ts` definidos
+
+## Ferramentas Recomendadas
+
+> **Ref:** `framework/skills/level-0-meta/morph-tool-usage-guide/SKILL.md` para guia completo.
+
+| Acao | Ferramenta | Alternativa |
+|------|------------|-------------|
+| Ler spec + contracts + decisions | **Read** todos os outputs | --- |
+| Analisar codebase existente | **Glob** + **Grep** padroes | --- |
+| Consultar docs de libs | **Context7 MCP** `query_docs()` | **WebSearch** |
+| Dispatch agents para analise | **Bash** `npx morph-spec dispatch-agents $ARGUMENTS plan` | --- |
+| Atualizar state | **Bash** `npx morph-spec state mark-output $ARGUMENTS plan` | --- |
+
+**Anti-padroes:**
+- :x: Gerar plano sem ler contracts.cs (contracts sao a fonte de verdade!)
+- :x: Paths genericos ("adicione o arquivo") -- sempre paths exatos
+- :x: Codigo incompleto no plano ("adicione validacao") -- sempre codigo completo
+- :x: Pular analise de codebase existente (padroes existentes guiam o plano)
+- :x: Ignorar `config.architecture.style` -- VSA e DDD tem estruturas diferentes
+
+---
+
+## PRE-VOO OBRIGATORIO
+
+### 0. Garantir fase plan
+
+```bash
+npx morph-spec state get $ARGUMENTS
+```
+
+Verifique o campo `"phase"` no output:
+- `"phase": "plan"` -> fase correta, prossiga
+- qualquer outro valor -> execute `npx morph-spec phase advance $ARGUMENTS` e volte a verificar
+
+> **Regra:** Nunca escreva em `3-plan/` enquanto a fase nao for `plan`.
+
+### 1. Ler todos os prerequisitos em PARALELO
+
+```
+Read: .morph/features/{feature}/1-design/spec.md
+    + Read: .morph/features/{feature}/1-design/contracts.cs
+    + Read: .morph/features/{feature}/1-design/decisions.md
+    + Read: .morph/features/{feature}/1-design/clarifications.md
+    + Read: .morph/features/{feature}/1-design/schema-analysis.md  (se existir)
+    + Read: .morph/config/config.json
+```
+
+### 2. Criar tasks de sessao
+
+```
+TaskCreate: "Analisar spec e planejar"        -> activeForm: "Analisando spec"
+TaskCreate: "Gerar plan.md"                   -> activeForm: "Gerando plano"
+TaskCreate: "Avanco de fase"                  -> activeForm: "Avancando fase"
+```
+
+---
+
+## Workflow
+
+### Passo 1: Analisar Feature para Contexto
+
+1. **Ler codebase existente** -- Glob para encontrar arquivos que serao modificados/criados
+2. **Identificar padroes** -- Grep por padroes similares ao que sera implementado
+3. **Verificar libs/frameworks** -- Context7 para docs das dependencias
+4. **Detectar arquitetura:**
+
+```bash
+cat .morph/config/config.json | grep -A3 '"architecture"'
+```
+
+| Valor de `config.architecture.style` | Caminho |
+|--------------------------------------|---------|
+| `"vertical-slice"` | -> Estrutura VSA: `Features/{Entity}Feature/{Op}/` |
+| qualquer outro valor | -> Estrutura DDD por layer |
+
+### Passo 2: Determinar Estrategia de Execucao
+
+Execute a analise:
+
+```bash
+npx morph-spec dispatch-agents $ARGUMENTS plan
+```
+
+**Fatores para recomendacao:**
+
+| Fator | Calculo |
+|-------|---------|
+| `taskCount` | Numero de requisitos funcionais + componentes tecnicos no spec |
+| `domainCount` | Dominios distintos nos activeAgents (backend, frontend, infra) |
+| `agentCount` | Total de activeAgents |
+| `independence` | % de tasks sem dependencias cross-domain |
+
+**Decisao:**
+
+| Cenario | Recomendacao |
+|---------|--------------|
+| `taskCount < 8` AND `domainCount <= 2` | **Single session** -- implementacao direta |
+| `taskCount 8-20` AND `domainCount 2-3` | **Subagent-Driven** -- um subagent morph por grupo |
+| `taskCount > 20` OR `domainCount > 3` | **Agent Teams** -- coordenacao multi-dominio |
+
+### Passo 3: Gerar `plan.md`
+
+Crie `.morph/features/$ARGUMENTS/3-plan/plan.md` com a estrutura:
+
+```markdown
+# {Feature Name} Implementation Plan
+
+> **For Claude:** Use morph:phase-implement to execute this plan.
+
+**Goal:** {Uma frase descrevendo o que sera construido}
+
+**Architecture:** {2-3 frases sobre a abordagem}
+
+**Tech Stack:** {Tecnologias chave}
+
+**Execution Strategy:** {single | subagents | agent-teams} (Recommended)
+
+---
+
+## GROUP {A} --- {Nome do Grupo}
+
+{Padrao e contexto do grupo}
+
+### {A1} --- {Nome da task}
+
+**Files:**
+- Create: `exact/path/to/file.cs`
+- Modify: `exact/path/to/existing.cs:123-145`
+- Test: `tests/exact/path/to/test.cs`
+
+**Step 1: Write the failing test**
+
+(Codigo completo do teste)
+
+**Step 2: Run test to verify it fails**
+
+Run: `{comando exato}`
+Expected: FAIL with "{mensagem}"
+
+**Step 3: Write minimal implementation**
+
+(Codigo completo da implementacao)
+
+**Step 4: Run test to verify it passes**
+
+Run: `{comando exato}`
+Expected: PASS
+
+**Step 5: Commit**
+
+git add {files}
+git commit -m "{mensagem}"
+```
+
+**Regras obrigatorias:**
+- Paths exatos SEMPRE (nunca genericos)
+- Codigo COMPLETO no plano (nunca "adicione validacao")
+- Comandos exatos com output esperado
+- DRY, YAGNI, TDD, commits frequentes
+- Cada step e uma acao de 2-5 minutos
+
+### Passo 4: Atualizar State
+
+```bash
+npx morph-spec state mark-output $ARGUMENTS plan
+```
+
+---
+
+## PAUSA OBRIGATORIA
+
+Use `AskUserQuestion` para capturar aprovacao:
+
+```json
+{
+  "questions": [
+    {
+      "header": "Aprovacao",
+      "question": "Plano de implementacao gerado. Aprovar para iniciar task breakdown?",
+      "multiSelect": false,
+      "options": [
+        { "label": "Aprovar plano", "description": "Avancar para fase de task breakdown" },
+        { "label": "Tenho feedback", "description": "Digite o que deseja mudar no campo abaixo (Other)" }
+      ]
+    },
+    {
+      "header": "Execucao",
+      "question": "Qual estrategia de execucao para implementacao?",
+      "multiSelect": false,
+      "options": [
+        { "label": "{Recomendacao} (Recommended)", "description": "{Justificativa baseada na analise do Passo 2}" },
+        { "label": "{Alternativa 1}", "description": "{Descricao}" },
+        { "label": "{Alternativa 2}", "description": "{Descricao}" }
+      ]
+    }
+  ]
+}
+```
+
+> A primeira opcao de "Execucao" deve ser a recomendacao context-aware calculada no Passo 2. As alternativas sao as outras estrategias.
+
+- **"Aprovar plano"** -> execute:
+```bash
+npx morph-spec approve $ARGUMENTS plan
+npx morph-spec phase advance $ARGUMENTS
+```
+- **"Tenho feedback" ou "Other"** -> aplique o feedback recebido e repita esta PAUSA
+
+---
+
+## Outputs desta Fase
+
+<!-- morph:outputs:plan -->
+| Output | Caminho |
+|--------|---------|
+| `plan` | `.morph/features/{feature}/3-plan/plan.md` |
+<!-- /morph:outputs -->
+
+---
+
+## Criterios de Avanco
+
+- [x] `plan.md` criado com todos os grupos e tasks
+- [x] Paths exatos para todos os arquivos
+- [x] Codigo completo em cada step
+- [x] Comandos de teste com output esperado
+- [x] Estrategia de execucao definida e aprovada
+- [x] State atualizado (`mark-output plan`)
+- [x] Usuario aprovou plano
+
+---
+
+Apos aprovacao: prosseguir automaticamente para FASE 5 (Tasks).