@polymorphism-tech/morph-spec 4.5.0 → 4.7.0

package/docs/plans/2026-02-23-ddd-nextsteps.md

@@ -0,0 +1,682 @@
+# DDD Next Steps Implementation Plan
+
+> **For Claude:** REQUIRED SUB-SKILL: Use superpowers:executing-plans to implement this plan task-by-task.
+
+**Goal:** Fechar os 5 gaps pós-refactor DDD: instalação nativa do domain-architect, remoção do template legado contracts.cs, phase-tasks DDD-aware, system prompt enriquecido do domain-architect, e exemplo end-to-end de feature Level 2.
+
+**Architecture:** Cada task é independente e toca uma camada diferente: agents-installer (JS), templates (remoção + registry), skills (markdown), agents.json (JSON), e docs/examples (markdown). Nenhuma task depende de outra para executar.
+
+**Tech Stack:** Node.js ESM, `node:test`, Handlebars v2.0, JSON, Markdown.
+
+---
+
+## Contexto Crítico
+
+- Worktree: criar em `.worktrees/feat-ddd-nextsteps` a partir de `main`
+- Test suite baseline: 659 pass, 0 fail, 1 skip
+- `src/utils/agents-installer.js` — filtra tier 1+2, instala `morph-{id}.md` em `.claude/agents/`
+- `framework/agents.json` v3.2.0-hierarchical — `domain-architect` é tier 2, `always_active: true`
+- Arquivos com referência ao template legado `contracts.cs`:
+  - `framework/skills/level-1-workflows/phase-design/SKILL.md` (linha 38)
+  - `framework/skills/level-0-meta/tool-usage-guide/SKILL.md` (linha ~144)
+  - `framework/templates/REGISTRY.json` (entrada `code/dotnet/contracts/contracts.cs`)
+  - `framework/templates/code/dotnet/contracts/contracts.cs` (o próprio arquivo — DELETAR)
+  - `framework/templates/code/dotnet/contracts/contracts.cs.hbs` (se existir — DELETAR)
+
+---
+
+## Task 1: domain-architect como native subagent — verificar + testar
+
+**Files:**
+- Modify: `test/utils/agents-installer.test.js`
+
+**Step 1: Verificar que domain-architect está sendo instalado**
+
+```bash
+node -e "
+import { installAgents } from './src/utils/agents-installer.js';
+import { mkdtempSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+
+const out = mkdtempSync(join(tmpdir(), 'morph-test-'));
+await installAgents(process.cwd(), out);
+const files = require('fs').readdirSync(join(out, '.claude', 'agents'));
+console.log(files.filter(f => f.includes('domain-architect')));
+" --input-type=module
+```
+
+**Forma mais simples — usar o executável:**
+```bash
+node --test test/utils/agents-installer.test.js 2>&1 | grep -i "domain"
+```
+
+**Step 2: Ler `test/utils/agents-installer.test.js` para entender a estrutura atual**
+
+```bash
+# Procurar onde estão os testes de agent names específicos
+grep -n "domain\|tier.*2\|morph-" test/utils/agents-installer.test.js | head -20
+```
+
+**Step 3: Escrever o failing test** — adicionar dentro da suite `installAgents` existente:
+
+```javascript
+test('installs domain-architect as morph-domain-architect.md', async () => {
+  const { agentFiles, agentsDir } = await setupInstall();
+  const file = agentFiles.find(f => f === 'morph-domain-architect.md');
+  assert.ok(file, 'morph-domain-architect.md must be installed');
+
+  const content = readFileSync(join(agentsDir, file), 'utf8');
+  assert.ok(content.includes('domain-architect') || content.includes('Domain Modeling'),
+    'File must reference domain-architect');
+  assert.ok(content.includes('ddd') || content.includes('aggregate') || content.includes('complexity'),
+    'File must mention DDD concepts');
+});
+
+test('domain-architect is installed with tier-2 defaults (no Task tool)', async () => {
+  const { agentFiles, agentsDir } = await setupInstall();
+  const content = readFileSync(join(agentsDir, 'morph-domain-architect.md'), 'utf8');
+  assert.ok(!content.includes('Task'), 'Tier-2 agent must NOT have Task tool');
+  assert.match(content, /maxTurns.*20/, 'Tier-2 agent must have maxTurns: 20');
+});
+```
+
+> **Nota:** `setupInstall` é o helper já existente no test file — leia o arquivo para entender o padrão exato antes de escrever os testes.
+
+**Step 4: Rodar para ver falhar**
+
+```bash
+node --test test/utils/agents-installer.test.js 2>&1 | grep -E "pass|fail"
+```
+
+Esperado: novos testes falham (domain-architect não encontrado) OU já passam (se já instalado).
+
+Se já passam: os testes são válidos como regressão. Commit assim mesmo.
+Se falham: investigar o agente no agents.json — verificar se `tier: 2` está correto.
+
+**Step 5: Rodar suite para confirmar nenhuma regressão**
+
+```bash
+node --test test/utils/agents-installer.test.js 2>&1 | grep -E "# (pass|fail)"
+```
+
+**Step 6: Commit**
+
+```bash
+git add test/utils/agents-installer.test.js
+git commit -m "test(agents): add domain-architect native subagent installation tests"
+```
+
+---
+
+## Task 2: Remover template legado contracts.cs + atualizar referências
+
+**Files:**
+- Delete: `framework/templates/code/dotnet/contracts/contracts.cs`
+- Delete: `framework/templates/code/dotnet/contracts/contracts.cs.hbs` (se existir)
+- Modify: `framework/skills/level-1-workflows/phase-design/SKILL.md`
+- Modify: `framework/skills/level-0-meta/tool-usage-guide/SKILL.md`
+- Modify: `framework/templates/REGISTRY.json`
+- Modify: `test/templates/contracts-levels.test.js` (adicionar teste de ausência)
+
+**Step 1: Confirmar quais arquivos existem e todas as referências**
+
+```bash
+ls framework/templates/code/dotnet/contracts/
+grep -rn "contracts\.cs" framework/skills/ framework/templates/ .claude/skills/ --include="*.md" --include="*.json" | grep -v "level1\|level2\|level3\|contracts-level"
+```
+
+**Step 2: Deletar o template legado**
+
+```bash
+rm framework/templates/code/dotnet/contracts/contracts.cs
+# Se existir:
+rm -f "framework/templates/code/dotnet/contracts/contracts.cs.hbs"
+```
+
+**Step 3: Atualizar `framework/templates/REGISTRY.json`**
+
+Remover a entrada com `"path": "code/dotnet/contracts/contracts.cs"`.
+
+Verificar: `node -e "const r=JSON.parse(require('fs').readFileSync('framework/templates/REGISTRY.json')); console.log(r.templates?.filter(t=>t.path?.includes('contracts.cs')&&!t.path?.includes('level')))"`
+
+Esperado: array vazio.
+
+**Step 4: Atualizar `framework/skills/level-1-workflows/phase-design/SKILL.md`**
+
+Localizar a linha na tabela "Ferramentas Recomendadas" que diz:
+```
+| Renderizar template contracts.cs | **Bash** `npx morph-spec template render code/dotnet/contracts/contracts.cs ...` | — |
+```
+
+Substituir por:
+```
+| Renderizar template contracts (nível detectado) | **Bash** `npx morph-spec template render code/dotnet/contracts/contracts-level{N}.cs ...` onde N = nível detectado no Passo 1.5 | — |
+```
+
+**Step 5: Atualizar `framework/skills/level-0-meta/tool-usage-guide/SKILL.md`**
+
+Localizar a linha que referencia `contracts.cs` genérico (~linha 144) e substituir pela versão com level{N}.
+
+**Step 6: Adicionar teste de ausência em `test/templates/contracts-levels.test.js`**
+
+```javascript
+test('legacy contracts.cs template no longer exists', () => {
+  const legacyPath = join(FRAMEWORK_DIR, 'templates', 'code', 'dotnet', 'contracts', 'contracts.cs');
+  assert.throws(
+    () => readFileSync(legacyPath),
+    { code: 'ENOENT' },
+    'Legacy contracts.cs must not exist — use contracts-level1/2/3.cs instead'
+  );
+});
+```
+
+**Step 7: Rodar testes**
+
+```bash
+node --test test/templates/contracts-levels.test.js 2>&1 | grep -E "# (pass|fail)"
+```
+Esperado: 8 pass (7 anteriores + 1 novo), 0 fail.
+
+**Step 8: Rodar suite completa**
+
+```bash
+node --test 2>&1 | grep -E "# (pass|fail)"
+```
+Esperado: 0 fail.
+
+**Step 9: Commit**
+
+```bash
+git add -A framework/templates/code/dotnet/contracts/ \
+           framework/templates/REGISTRY.json \
+           framework/skills/level-1-workflows/phase-design/SKILL.md \
+           framework/skills/level-0-meta/tool-usage-guide/SKILL.md \
+           test/templates/contracts-levels.test.js
+git commit -m "feat(templates): remove legacy contracts.cs — level1/2/3 are the only contracts templates"
+```
+
+---
+
+## Task 3: phase-tasks DDD-aware
+
+**Files:**
+- Modify: `framework/skills/level-1-workflows/phase-tasks/SKILL.md`
+
+**Step 1: Ler o arquivo atual** para entender onde inserir
+
+```bash
+grep -n "Passo\|Step\|### " framework/skills/level-1-workflows/phase-tasks/SKILL.md | head -20
+```
+
+**Step 2: Inserir "Passo 0" ANTES do Passo 1 atual**
+
+O Passo 0 lê o nível de domínio do spec.md e ajusta a geração de tasks:
+
+```markdown
+### Passo 0: Ler Nível de Domínio
+
+**Ref:** `framework/standards/architecture/ddd/complexity-levels.md`
+
+Antes de quebrar tasks, leia a seção `## Domain Complexity` do spec.md:
+
+```bash
+# Extrair nível do spec.md
+grep -A2 "## Domain Complexity" .morph/features/$ARGUMENTS/1-design/spec.md
+```
+
+Use o nível para ajustar as categorias de tasks:
+
+| Nível | Categorias de Tasks |
+|-------|---------------------|
+| **1 — CRUD** | `domain` (Entity simples) → `infrastructure` (Repository, EF Config) → `application` (Service CRUD) → `presentation` (API/Page) → `tests` |
+| **2 — Business Logic** | `domain` (AggregateRoot, ValueObjects, DomainEvents) → `infrastructure` (Repository, EF Config) → `application` (Commands, Queries, Handlers) → `presentation` (API/Page) → `tests` |
+| **3 — Bounded Context** | `domain-bc` (BC setup, Aggregates, Events) → `infrastructure` (BC repositories, EF) → `application` (Commands, Queries, Integration handlers) → `presentation` → `tests` |
+
+**Tasks adicionais obrigatórias por nível:**
+
+**Nível 2 only:**
+- `T{N}: Implementar AggregateRoot {EntityName} com factory method e invariants` (domain)
+- `T{N}: Implementar ValueObjects: {lista}` (domain)
+- `T{N}: Implementar DomainEvents: {lista}` (domain)
+- `T{N}: Implementar Command Handlers com MediatR` (application)
+- `T{N}: Implementar Query Handlers com read models` (application)
+
+**Nível 3 only (além do Nível 2):**
+- `T{N}: Configurar namespace/pasta do Bounded Context {BC}` (infrastructure)
+- `T{N}: Implementar Integration Events para comunicação cross-BC` (domain-bc)
+- `T{N}: Implementar handlers de Integration Events` (application)
+
+---
+```
+
+**Step 3: Verificar que a inserção está antes do Passo 1**
+
+```bash
+grep -n "Passo 0\|Passo 1\|complexity" framework/skills/level-1-workflows/phase-tasks/SKILL.md | head -10
+```
+Esperado: Passo 0 antes do Passo 1, referência a complexity-levels.md presente.
+
+**Step 4: Commit**
+
+```bash
+git add framework/skills/level-1-workflows/phase-tasks/SKILL.md
+git commit -m "feat(skills): add Passo 0 DDD-aware task generation to phase-tasks — 3 level task templates"
+```
+
+---
+
+## Task 4: Enriquecer system prompt do domain-architect
+
+**Files:**
+- Modify: `framework/agents.json`
+
+**Step 1: Ler o `spawn_prompt` atual do domain-architect**
+
+```bash
+node -e "
+const a = JSON.parse(require('fs').readFileSync('framework/agents.json', 'utf8'));
+const da = a.agents.find(x => x.id === 'domain-architect');
+console.log(JSON.stringify(da.teammate, null, 2));
+"
+```
+
+**Step 2: Atualizar os campos do domain-architect**
+
+Mudanças necessárias no objeto `domain-architect`:
+
+1. `standards` — adicionar os 3 novos standards DDD:
+```json
+"standards": [
+  "core/coding.md",
+  "core/architecture.md",
+  "architecture/ddd/complexity-levels.md",
+  "architecture/ddd/aggregates.md",
+  "architecture/ddd/entities.md",
+  "architecture/ddd/value-objects.md",
+  "architecture/ddd/bounded-contexts.md",
+  "architecture/ddd/ubiquitous-language.md"
+]
+```
+
+2. `teammate.spawn_prompt` — substituir pelo prompt enriquecido:
+```
+You are the Domain Modeling Leader for MORPH-SPEC. Your primary responsibility is detecting the correct domain complexity level and producing the Aggregate Blueprint before any contracts are generated.
+
+ALWAYS start with the 5-question complexity detection:
+1. Does the main entity have state transitions? (Draft → Confirmed → Shipped) → Yes = Level 2+
+2. Are there business invariants? ("can only cancel if Active") → Yes = Level 2+
+3. Are there derived calculations? (Total, Balance, Discount) → Yes = Level 2+
+4. Do other modules need to react to changes? (Domain Events with consumers) → Yes = Level 2+
+5. Did the user explicitly declare a Bounded Context? Or are there 3+ domains with conflicting models? → Yes = Level 3
+If none of the above: Level 1 (CRUD)
+
+For Level 1: Use contracts-level1.cs template. No AggregateRoot, no Domain Events.
+For Level 2: Use contracts-level2.cs template. Design AggregateRoot with factory methods, invariants, Value Objects, Domain Events.
+For Level 3: Use contracts-level3.cs template. Add BOUNDED_CONTEXT namespace, Integration Events, cross-BC ID references only.
+
+Document in spec.md under ## Domain Complexity and ## Aggregate Blueprint (Level 2+).
+Coordinate ef-modeler for persistence design and event-architect for Domain Event patterns.
+Ref: framework/standards/architecture/ddd/complexity-levels.md
+```
+
+**Step 3: Aplicar as mudanças com Edit tool** (não reescrever o JSON todo)
+
+Usar Edit para substituir `"standards": [` block e `"spawn_prompt":` value no domain-architect.
+
+**Step 4: Validar JSON**
+
+```bash
+node -e "
+const a = JSON.parse(require('fs').readFileSync('framework/agents.json', 'utf8'));
+const da = a.agents.find(x => x.id === 'domain-architect');
+console.log('standards count:', da.standards.length);
+console.log('spawn_prompt length:', da.teammate.spawn_prompt.length);
+console.log('mentions complexity-levels:', da.teammate.spawn_prompt.includes('complexity-levels'));
+"
+```
+Esperado: standards count >= 8, spawn_prompt length > 500, mentions complexity-levels: true.
+
+**Step 5: Rodar testes do agents-installer para garantir nenhuma regressão**
+
+```bash
+node --test test/utils/agents-installer.test.js 2>&1 | grep -E "# (pass|fail)"
+```
+Esperado: 0 fail.
+
+**Step 6: Commit**
+
+```bash
+git add framework/agents.json
+git commit -m "feat(agents): enrich domain-architect spawn_prompt with 5-question detection + standards list"
+```
+
+---
+
+## Task 5: Exemplo end-to-end Level 2 (Order Management)
+
+**Files:**
+- Create: `docs/examples/order-management/proposal.md`
+- Create: `docs/examples/order-management/spec.md`
+- Create: `docs/examples/order-management/contracts.cs`
+
+Este exemplo serve como referência viva de como um feature Level 2 deve se parecer após passar pelo pipeline completo. É documentação — sem testes unitários.
+
+**Step 1: Criar `docs/examples/order-management/proposal.md`**
+
+```markdown
+# Proposal: Order Management
+
+**Feature:** order-management
+**Type:** Business Logic (Level 2 candidate)
+**Stack:** .NET 10 / C# 14, Blazor Server, EF Core, Azure SQL
+
+## User Story
+Como usuário autenticado, quero criar e gerenciar pedidos de compra para que eu possa
+acompanhar o status dos meus pedidos e receber notificações de mudanças.
+
+## Acceptance Criteria
+- [ ] Usuário pode criar um pedido com 1+ itens
+- [ ] Pedido começa no status Draft
+- [ ] Pedido só pode ser Confirmado se tiver pelo menos 1 item
+- [ ] Pedido Confirmado não pode receber mais itens
+- [ ] Total do pedido é calculado automaticamente
+- [ ] Sistema notifica quando pedido é Confirmado
+
+## Out of Scope
+- Pagamento (feature separada)
+- Envio/logística
+```
+
+**Step 2: Criar `docs/examples/order-management/spec.md`**
+
+Preencher o template de spec.md para este feature, incluindo as seções DDD obrigatórias:
+
+```markdown
+# Feature Specification: Order Management
+
+| Field | Value |
+|-------|-------|
+| **ID** | order-management |
+| **Status** | Approved |
+| **Created** | 2026-02-23 |
+| **Stack** | .NET 10 / Blazor Server / EF Core |
+| **Complexity** | Medium |
+| **Agents** | Core: All / Specialists: domain-architect, ef-modeler, event-architect |
+
+---
+
+## Overview
+
+**Problem:** Usuários precisam criar e gerenciar pedidos com rastreamento de status.
+
+**Solution:** Aggregate Order com factory method, invariants de estado, e Domain Events para notificações.
+
+**Success Criteria:**
+- [ ] Order CRUD com validações de negócio
+- [ ] Status tracking com transições controladas
+- [ ] Notificação ao confirmar pedido
+
+---
+
+## Requirements
+
+**Functional:**
+FR001: Criar pedido com mínimo 1 item | FR002: Confirmar pedido (Draft → Confirmed) | FR003: Cancelar pedido (Draft/Confirmed → Cancelled) | FR004: Calcular total automaticamente
+
+**Non-Functional:**
+NFR001: Performance - operações < 200ms | NFR002: Consistência - invariants garantidas em toda operação
+
+---
+
+## User Stories
+
+### US001: Criar Pedido
+**As** usuário autenticado **I want** criar um pedido com itens **so that** posso comprar produtos
+
+**Acceptance Criteria:**
+1. Pedido criado com status Draft
+2. Total calculado na criação
+
+**Edge Cases:** Lista de itens vazia → erro 400
+
+---
+
+## Technical Design
+
+### Stack
+| Component | Technology |
+|-----------|------------|
+| Frontend | Blazor Server |
+| Backend | .NET 10 / C# 14 |
+| Database | Azure SQL / EF Core |
+
+### Data Model
+
+#### Order
+| Column | Type | Constraints |
+|--------|------|-------------|
+| Id | Guid | PK |
+| UserId | Guid | FK (reference by ID — cross-aggregate) |
+| Status | OrderStatus | Enum |
+| CreatedAt | datetime2 | Default: GETUTCDATE() |
+| UpdatedAt | datetime2 | Nullable |
+
+#### OrderItem (owned entity)
+| Column | Type | Constraints |
+|--------|------|-------------|
+| Id | Guid | PK |
+| OrderId | Guid | FK |
+| ProductId | Guid | Reference by ID |
+| Quantity | int | > 0 |
+| UnitPrice | decimal(18,2) | > 0 |
+
+### Contracts
+> **Ref:** `framework/templates/code/dotnet/contracts/contracts-level2.cs`
+
+---
+
+## Domain Complexity
+
+**Nível:** 2 — Business Logic
+
+**Justificativa:** Order tem estados com transições controladas (Draft → Confirmed → Cancelled),
+invariants de negócio (não confirmar sem itens, não adicionar itens a pedido confirmado),
+cálculo derivado (Total), e outros módulos precisam reagir (NotificationService ao OrderConfirmed).
+
+**Padrões Aplicados:**
+- AggregateRoot com factory method estático
+- Value Objects: Money (UnitPrice, Total)
+- Domain Events: OrderCreatedEvent, OrderConfirmedEvent, OrderCancelledEvent
+- CQRS com MediatR
+
+**Padrões Omitidos:**
+- Bounded Contexts — sistema single-domain, desnecessário
+
+---
+
+## Aggregate Blueprint (Nível 2+ apenas)
+
+### Aggregate Root: Order
+
+**Invariants:**
+- Order só pode ser Confirmado se Status == Draft E tiver pelo menos 1 item
+- Order Confirmado não pode receber mais itens (AddItem lança DomainException)
+- Order Cancelado não pode ser reativado (estado terminal)
+
+**Estados e Transições:**
+```
+{Draft} → Confirm() → {Confirmed}
+{Draft} → Cancel()  → {Cancelled}
+{Confirmed} → Cancel() → {Cancelled}
+```
+
+**Domain Events:**
+- `OrderCreatedEvent` — publicado ao criar (Create factory method)
+- `OrderConfirmedEvent` — publicado ao confirmar (Confirm method)
+- `OrderCancelledEvent` — publicado ao cancelar (Cancel method)
+
+**Value Objects:**
+- `Money` — UnitPrice e Total não são decimals simples: têm validação (> 0) e operações (Add, Multiply)
+
+**Referências Cross-Aggregate (por ID):**
+- `UserId: Guid` — nunca `User User { get; }`
+- `ProductId: Guid` em OrderItem — nunca `Product Product { get; }`
+
+### Linguagem Ubíqua
+
+| Termo | Definição | Código |
+|-------|-----------|--------|
+| Order | Pedido de compra de um usuário | `Order` (AggregateRoot) |
+| Draft | Pedido criado, ainda editável | `OrderStatus.Draft` |
+| Confirm | Ato de finalizar e submeter um pedido | `Order.Confirm()` |
+| OrderItem | Linha de produto dentro de um pedido | `OrderItem` (Entity owned) |
+| Total | Soma calculada de todos os itens | `Order.Total` (property calculada) |
+
+---
+
+## Flows
+
+### Confirmar Pedido
+**Trigger:** Usuário clica "Confirmar Pedido"
+1. Frontend → `POST /api/orders/{id}/confirm`
+2. API → `ConfirmOrderCommand(OrderId)`
+3. Handler → `repository.GetAsync(id)` → `order.Confirm()` → `repository.UpdateAsync(order)`
+4. `OrderConfirmedEvent` publicado → NotificationService envia email
+**End State:** Order.Status = Confirmed
+
+---
+
+## Definition of Done
+- [ ] Aggregate implementado com todos os invariants
+- [ ] Domain Events publicados e consumidos
+- [ ] Testes unitários do Aggregate (sem EF)
+- [ ] Testes de integração do Handler
+- [ ] API endpoint documentado
+```
+
+**Step 3: Criar `docs/examples/order-management/contracts.cs`**
+
+Exemplo real de contracts-level2.cs preenchido para Order:
+
+```csharp
+// ============================================================
+// CONTRACTS: Order Management — Level 2 (Business Logic)
+// Example of correctly filled contracts-level2.cs template
+// Feature: order-management | Date: 2026-02-23
+// ============================================================
+
+// ===== AGGREGATE ROOT =====
+// Implementado em: Domain/Orders/Aggregates/Order.cs
+//
+// Invariants (do spec.md > Aggregate Blueprint):
+//   - Confirm() só é válido se Status == Draft E Items.Any()
+//   - AddItem() lança DomainException se Status != Draft
+//   - Cancel() é válido de Draft ou Confirmed → Cancelled (terminal)
+
+// Domain/Orders/Events:
+public record OrderCreatedEvent(Guid OrderId, Guid UserId) : DomainEvent;
+public record OrderConfirmedEvent(Guid OrderId, Guid UserId, decimal Total) : DomainEvent;
+public record OrderCancelledEvent(Guid OrderId, string Reason) : DomainEvent;
+
+// Application/Orders/Commands:
+public record CreateOrderCommand(Guid UserId, List<CreateOrderItemRequest> Items)
+    : IRequest<CreateOrderResult>;
+public record CreateOrderResult(Guid OrderId);
+
+public record ConfirmOrderCommand(Guid OrderId) : IRequest;
+public record CancelOrderCommand(Guid OrderId, string Reason) : IRequest;
+
+// Application/Orders/Queries:
+public record GetOrderQuery(Guid OrderId) : IRequest<OrderDto?>;
+public record ListOrdersByUserQuery(Guid UserId, int Page = 1, int PageSize = 20)
+    : IRequest<PagedResult<OrderDto>>;
+
+// Application/Orders — DTOs (read models):
+public record OrderDto(
+    Guid Id,
+    Guid UserId,
+    string Status,
+    decimal Total,
+    List<OrderItemDto> Items,
+    DateTime CreatedAt,
+    DateTime? UpdatedAt
+);
+
+public record OrderItemDto(Guid ProductId, int Quantity, decimal UnitPrice, decimal Subtotal);
+
+public record CreateOrderItemRequest(Guid ProductId, int Quantity, decimal UnitPrice);
+
+// Domain/Orders — Repository:
+public interface IOrderRepository
+{
+    Task<Order?> GetAsync(Guid id, CancellationToken ct = default);
+    Task<List<Order>> GetByUserAsync(Guid userId, CancellationToken ct = default);
+    Task AddAsync(Order order, CancellationToken ct = default);
+    Task UpdateAsync(Order order, CancellationToken ct = default);
+    Task<bool> ExistsAsync(Guid id, CancellationToken ct = default);
+}
+
+// Exceptions:
+public class OrderNotFoundException(Guid id) : DomainException($"Order '{id}' not found.");
+public class OrderInvalidStateException(string message) : DomainException(message);
+```
+
+**Step 4: Verificar que os 3 arquivos foram criados**
+
+```bash
+ls docs/examples/order-management/
+```
+Esperado: `contracts.cs`, `proposal.md`, `spec.md`
+
+**Step 5: Commit**
+
+```bash
+git add docs/examples/order-management/
+git commit -m "docs(examples): add order-management Level 2 reference example — proposal + spec + contracts"
+```
+
+---
+
+## Verificação Final
+
+```bash
+# Testes
+node --test 2>&1 | grep -E "# (pass|fail|skip)"
+
+# Sem referências ao template legado
+grep -rn "contracts\.cs" framework/skills/ framework/templates/ \
+  --include="*.md" --include="*.json" | grep -v "level1\|level2\|level3\|contracts-level\|contracts\.cs\.hbs"
+
+# domain-architect é tier 2 e tem standards DDD
+node -e "
+const a = JSON.parse(require('fs').readFileSync('framework/agents.json', 'utf8'));
+const da = a.agents.find(x => x.id === 'domain-architect');
+console.log('tier:', da.tier);
+console.log('standards:', da.standards.filter(s => s.includes('ddd')));
+"
+
+# Exemplo existe
+ls docs/examples/order-management/
+```
+
+---
+
+## Resumo das Mudanças
+
+| Categoria | Arquivos | Tipo |
+|-----------|---------|------|
+| Tests | `test/utils/agents-installer.test.js` | +2 testes domain-architect |
+| Templates | `contracts.cs`, `contracts.cs.hbs` | DELETE |
+| Templates | `REGISTRY.json` | Remove entrada legada |
+| Skills | `phase-design/SKILL.md`, `tool-usage-guide/SKILL.md` | Atualizar referências |
+| Tests | `test/templates/contracts-levels.test.js` | +1 teste ausência legado |
+| Skills | `phase-tasks/SKILL.md` | +Passo 0 DDD-aware |
+| Agents | `agents.json` | domain-architect standards + spawn_prompt |
+| Docs | `docs/examples/order-management/` | 3 novos arquivos |
+
+**5 tasks — ~1h30 de execução.**
+
+---
+
+*MORPH-SPEC by Polymorphism Tech*