@dewtech/dare-cli 2.17.0 → 3.0.0

package/templates/ide/claude/.claude/commands/dare-frontend-design.md

@@ -0,0 +1,149 @@
+# /dare-frontend-design
+
+Arquitetura frontend DARE para projetos React e Vue. Detecta god components, fetch inline em JSX/template, e gera scaffold DARE-compliant.
+
+## Como usar
+
+```
+/dare-frontend-design                    # audita projeto atual
+/dare-frontend-design lint               # roda checks AP-01 a AP-06
+/dare-frontend-design scaffold <página>  # gera Page + Container + Hook + Presentational
+```
+
+## Arquitetura
+
+```
+Page  →  Container (lógica)  →  Presentational (puro)
+           ↑
+        Hook (fetch + cache)
+```
+
+## As 4 regras
+
+### 1. Componente < 300 linhas
+
+Se passar de 300, quebrar em sub-componentes, hooks ou helpers.
+
+### 2. Zero `fetch()` em JSX/template
+
+Use TanStack Query (React/Vue), SWR ou similar. Hook devolve `{ data, isLoading, error }`.
+
+### 3. Error Boundary em cada Page
+
+React: `<ErrorBoundary>` wrapping rotas.
+Vue: `onErrorCaptured` em layout/page-level.
+
+### 4. Bundle size monitorado
+
+`rollup-plugin-visualizer`, `webpack-bundle-analyzer`. Limite por chunk (ex: <300KB inicial).
+
+## Métricas obrigatórias
+
+| ID | Métrica |
+|---|---|
+| M-01 | 100% de componentes < 300 linhas |
+| M-02 | 0 `fetch()` direto em JSX/template |
+| M-03 | 100% de páginas com error boundary |
+| M-04 | Bundle config presente |
+
+## Antipatterns
+
+| AP | Antipattern | Correção |
+|---|---|---|
+| AP-01 | God component (>300 linhas) | Quebrar em sub-componentes + hooks |
+| AP-02 | Fetch em JSX | Mover para hook |
+| AP-03 | Booleanos isLoading espalhados | Discriminated union de estados |
+| AP-04 | Sem error boundary | Wrap em `<ErrorBoundary>` |
+| AP-05 | Estilo inline pesado | CSS module/styled |
+| AP-06 | Props drilling profundo | Context/Zustand/Pinia |
+
+## O que fazer
+
+### Passo 1: Detectar god components
+
+```bash
+find src/ -name "*.tsx" -o -name "*.vue" | xargs wc -l | sort -rn | head -20
+```
+
+### Passo 2: Detectar fetch inline
+
+```bash
+grep -rn "fetch(\|axios\." src/components/ src/pages/
+```
+
+### Passo 3: Migrar para hooks de dados
+
+```tsx
+// Antes
+function UserList() {
+  const [users, setUsers] = useState([]);
+  useEffect(() => { fetch('/api/users').then(r => r.json()).then(setUsers); }, []);
+  return <ul>{users.map(...)}</ul>;
+}
+
+// Depois
+function UserList() {
+  const { data, isLoading, error } = useUsers();
+  if (isLoading) return <Spinner />;
+  if (error) return <ErrorMessage error={error} />;
+  return <ul>{data.map(...)}</ul>;
+}
+
+function useUsers() {
+  return useQuery({ queryKey: ['users'], queryFn: () => api.users.list() });
+}
+```
+
+### Passo 4: Error boundaries
+
+```tsx
+// React
+class ErrorBoundary extends React.Component { ... }
+
+<ErrorBoundary fallback={<ErrorPage />}>
+  <UserList />
+</ErrorBoundary>
+```
+
+```vue
+<!-- Vue -->
+<script setup>
+import { onErrorCaptured } from 'vue';
+onErrorCaptured((err) => { logError(err); return false; });
+</script>
+```
+
+### Passo 5: Bundle analyzer
+
+```typescript
+// vite.config.ts
+import { visualizer } from 'rollup-plugin-visualizer';
+export default {
+  plugins: [visualizer({ open: false, gzipSize: true })],
+  build: { chunkSizeWarningLimit: 300 }
+};
+```
+
+## Stack recomendada
+
+| Camada | React | Vue |
+|---|---|---|
+| Roteamento | React Router / Next | Vue Router / Nuxt |
+| Estado server | TanStack Query | TanStack Vue Query |
+| Estado client | Zustand / Jotai | Pinia |
+| Styling | Tailwind / CSS Modules | Tailwind / SCSS |
+| Testes | Vitest + Testing Library | Vitest + Testing Library |
+
+## Saída esperada
+
+Reporte:
+- Top 10 componentes com mais linhas
+- Lista de `fetch()`/`axios` inline em componentes
+- Páginas sem error boundary
+- Configuração de bundle (presente/ausente)
+
+$ARGUMENTS
+
+---
+
+Skill MIT — parte do DARE Method.

package/templates/ide/claude/.claude/commands/dare-laravel-api.md

@@ -0,0 +1,211 @@
+# /dare-laravel-api
+
+Padrões DARE para APIs REST em Laravel 11 + PHP 8.3. Strict Types, FormRequests, Services, Resources, Repositories, Eloquent + casts, tratamento global de exceções, testes Pest, PHPStan/Larastan nível 8.
+
+## Como usar
+
+```
+/dare-laravel-api                          # audita projeto Laravel
+/dare-laravel-api scaffold users           # gera CRUD com camadas
+/dare-laravel-api migrate-controllers      # extrai lógica de Controllers para Services
+```
+
+## Stack canônica
+
+- PHP 8.3 com `declare(strict_types=1);` em todo arquivo
+- Laravel 11.x modo API
+- PostgreSQL 16 ou MySQL 8
+- Pest para testes (ou PHPUnit 11)
+- PHPStan + Larastan nível 8
+- Pint para formatação
+- Sanctum para auth
+
+## Layered Design
+
+| Camada | Pasta Laravel |
+|---|---|
+| Handler | `app/Http/Controllers/` |
+| Service | `app/Services/` |
+| Repository | `app/Repositories/` |
+| Model | `app/Models/` |
+| Presenter | `app/Http/Resources/` |
+
+## Controllers (Handler)
+
+```php
+<?php declare(strict_types=1);
+
+namespace App\Http\Controllers;
+
+use App\Http\Requests\StoreUserRequest;
+use App\Http\Resources\UserResource;
+use App\Services\RegisterUser;
+
+final class UserApiController extends Controller
+{
+    public function __construct(private RegisterUser $service) {}
+
+    public function store(StoreUserRequest $request): UserResource
+    {
+        $user = $this->service->execute($request->validated());
+        return new UserResource($user);
+    }
+}
+```
+
+Regras:
+- Apenas: recebe → valida via FormRequest → chama Service → retorna Resource
+- NUNCA: query Eloquent, lógica de negócio, validação inline
+
+## FormRequests
+
+```php
+final class StoreUserRequest extends FormRequest
+{
+    public function authorize(): bool { return $this->user()->can('create', User::class); }
+
+    public function rules(): array {
+        return [
+            'email' => ['required', 'email', 'unique:users,email'],
+            'password' => ['required', 'string', 'min:12'],
+        ];
+    }
+}
+```
+
+## Services
+
+Uma operação por classe:
+
+```php
+final class RegisterUser
+{
+    public function __construct(private UserRepository $users) {}
+
+    public function execute(array $data): User
+    {
+        if ($this->users->existsByEmail($data['email'])) {
+            throw new UserAlreadyExistsException();
+        }
+        return $this->users->create([...$data, 'password' => Hash::make($data['password'])]);
+    }
+}
+```
+
+## Repositories
+
+```php
+final class UserRepository
+{
+    public function existsByEmail(string $email): bool {
+        return User::where('email', $email)->exists();
+    }
+    public function create(array $data): User {
+        return User::create($data);
+    }
+}
+```
+
+## Resources
+
+Nunca retorne Model direto:
+
+```php
+final class UserResource extends JsonResource
+{
+    public function toArray($request): array {
+        return [
+            'id' => $this->id,
+            'email' => $this->email,
+            'createdAt' => $this->created_at?->toIso8601String(),
+        ];
+    }
+}
+```
+
+## Exceções globais (`bootstrap/app.php`)
+
+```php
+->withExceptions(function (Exceptions $exceptions) {
+    $exceptions->render(fn (UserAlreadyExistsException $e) =>
+        response()->json(['error' => 'User exists', 'code' => 'USER_EXISTS'], 409));
+})
+```
+
+## Transações
+
+```php
+DB::transaction(function () use ($data) {
+    $user = User::create($data);
+    UserProfile::create([...]);
+});
+```
+
+## Testes Pest
+
+```php
+it('cria usuário com sucesso', function () {
+    $this->actingAs(User::factory()->admin()->create())
+         ->postJson('/api/users', ['email' => 'jane@example.com', 'name' => 'Jane', 'password' => 'longsecret123'])
+         ->assertCreated();
+});
+
+it('rejeita email duplicado', function () {
+    User::factory()->create(['email' => 'taken@example.com']);
+    $this->actingAs(User::factory()->admin()->create())
+         ->postJson('/api/users', ['email' => 'taken@example.com', ...])
+         ->assertStatus(409);
+});
+```
+
+Cobertura mínima por endpoint: 200/201, 422, 401/403, 404.
+
+## Antipatterns
+
+| AP | Antipattern | Correção |
+|---|---|---|
+| AP-01 | `$request->validate()` no Controller | FormRequest |
+| AP-02 | Query Eloquent no Controller | Repository |
+| AP-03 | Lógica no Controller | Service |
+| AP-04 | Retornar Model direto | JsonResource |
+| AP-05 | `$guarded = []` | `$fillable` explícito |
+| AP-06 | Sem `declare(strict_types=1)` | Adicionar no topo |
+| AP-07 | Múltiplas inserções sem transaction | `DB::transaction()` |
+| AP-08 | `bcrypt()` default cost | `Hash::make($pwd, ['rounds' => 12])` |
+
+## Validação no CI
+
+```bash
+./vendor/bin/phpstan analyse --level=8
+./vendor/bin/pint --test
+./vendor/bin/pest --coverage --min=80
+```
+
+## O que fazer
+
+1. Audit:
+   ```bash
+   grep -rn "request()->validate" app/Http/Controllers/
+   grep -rn "::where\|::find" app/Http/Controllers/
+   ./vendor/bin/phpstan analyse --level=8
+   ```
+2. Para cada `$request->validate(...)` → FormRequest com `php artisan make:request`
+3. Para cada Controller com lógica > 10 linhas → Service
+4. Para cada query Eloquent em Controller → Repository
+5. Substituir `return $user` por `return new UserResource($user)`
+6. Adicionar `declare(strict_types=1);` em todo arquivo
+
+## Segurança (combinar com `/dare-security`)
+
+- Hash com `Hash::make($pwd, ['rounds' => 12])` ou Argon2
+- Sanctum para SPA/mobile
+- `ThrottleRequests` middleware
+- Headers de segurança (HSTS, X-Frame, CSP) em middleware
+- CORS específico, nunca `*` em produção
+- `$fillable` SEMPRE, nunca `$guarded = []`
+
+$ARGUMENTS
+
+---
+
+Skill MIT — parte do DARE Method.

package/templates/ide/claude/.claude/commands/dare-layered-design.md

@@ -0,0 +1,124 @@
+# /dare-layered-design
+
+Enforce arquitetura estrita de 4 camadas (Handlers, Services, Repositories, Models) em projetos DARE — independente de linguagem.
+
+## Como usar
+
+```
+/dare-layered-design                        # audita projeto atual
+/dare-layered-design lint                   # roda checks AP-01 a AP-06
+/dare-layered-design scaffold <recurso>     # gera CRUD com camadas corretas
+```
+
+## As 4 camadas
+
+```
+Handler  →  Service  →  Repository  →  Model
+(HTTP)      (negócio)   (I/O)         (domínio)
+```
+
+### Handler
+- Recebe request, valida input, chama um Service, retorna response
+- **Nunca** acessa Repository direto, **nunca** instancia Service com `new`
+
+### Service
+- Implementa uma operação de negócio (`RegisterUser`, `RefundPayment`)
+- Orquestra Repositories
+- **Nunca** sabe sobre HTTP, **nunca** faz SQL inline
+
+### Repository
+- Abstrai persistência (DB, cache, API externa)
+- Retorna Model ou primitivo
+- **Nunca** retorna HTTP status, **nunca** lança exceção de domínio
+
+### Model
+- Entidade pura do domínio
+- **Nunca** importa Repository/Service/Handler
+
+## Métricas obrigatórias
+
+| ID | Métrica |
+|---|---|
+| M-01 | 100% dos Services têm testes unitários (sem DB/HTTP real) |
+| M-02 | 0% de chamadas Handler→Repository direto |
+| M-03 | 100% dos Handlers usam injeção (sem `new Service()`) |
+| M-04 | 100% dos Repositories são agnósticos das camadas superiores |
+
+## Tabela por linguagem
+
+| Camada | Laravel | NestJS | FastAPI | Rails | Rust | Go |
+|---|---|---|---|---|---|---|
+| Handler | `Http/Controllers/` | `*.controller.ts` | `routers/` | `app/controllers/` | `handlers/` | `handlers/` |
+| Service | `Services/` | `*.service.ts` | `services/` | `app/services/` | `services/` | `services/` |
+| Repository | `Repositories/` | `*.repository.ts` | `repositories/` | `app/repositories/` | `repositories/` | `repositories/` |
+| Model | `Models/` | `entities/` | `models/` | `app/models/` | `domain/` | `models/` |
+
+## Antipatterns
+
+| AP | Antipattern | Sinal |
+|---|---|---|
+| AP-01 | Handler→Repository direto | `controller.repo.find()` |
+| AP-02 | Service com SQL inline | `db.query()` em Service |
+| AP-03 | Repository lança exceção de domínio | `throw UserNotFound` |
+| AP-04 | Model importa Service | acoplamento invertido |
+| AP-05 | God Service (>20 métodos) | `UserService.everything()` |
+| AP-06 | Fat Controller (>100 linhas) | lógica em Handler |
+
+## O que fazer
+
+### Passo 1: Mapear camadas existentes
+
+Liste as pastas atuais e classifique cada uma como Handler, Service, Repository, Model ou "indefinido". Indefinido = candidato a refactor.
+
+### Passo 2: Detectar violações com grep
+
+```bash
+# AP-01: Handler→Repository direto
+grep -rn "Repository" src/controllers/    # Laravel/NestJS
+grep -rn "Repository" app/controllers/    # Rails
+
+# AP-02: SQL inline em Service
+grep -rn "SELECT\\|INSERT\\|UPDATE\\|DELETE" src/services/
+
+# AP-03: Exceção de domínio em Repository
+grep -rn "throw.*NotFound\\|raise.*NotFound" src/repositories/
+```
+
+### Passo 3: Quebrar God Service
+
+Para cada Service com >20 métodos, separe em vários services nomeados por operação:
+- `UserService.register()` → `RegisterUser`
+- `UserService.resetPassword()` → `ResetPassword`
+- `UserService.delete()` → `DeleteUser`
+
+### Passo 4: Cobrir Services com testes unitários
+
+Service não depende de DB nem HTTP real — Repository é mockado:
+
+```typescript
+const repo = { findByEmail: jest.fn().mockResolvedValue({id: 1}) };
+const sut = new RegisterUserService(repo as any);
+await expect(sut.execute(...)).rejects.toThrow();
+```
+
+### Passo 5: Adicionar lint no CI
+
+```yaml
+- name: Layered design lint
+  run: |
+    grep -rn "Repository" src/controllers/ && exit 1 || true
+    grep -rn "new .*Service" src/controllers/ && exit 1 || true
+```
+
+## Saída esperada
+
+Reporte numerado por antipattern (AP-01 a AP-06):
+- Quantas violações por arquivo
+- Sugestão concreta de refactor para cada uma
+- Lista de Services sem cobertura unitária
+
+$ARGUMENTS
+
+---
+
+Skill MIT — parte do DARE Method. Inspirado em "Layered Design for Ruby on Rails Applications" de Vladimir Dementyev (Evil Martians).

package/templates/ide/claude/.claude/commands/dare-llm-integration.md

@@ -0,0 +1,148 @@
+# /dare-llm-integration
+
+Integração segura e eficiente com LLMs (Gemini, Claude, OpenAI, Ollama) em projetos DARE.
+
+## Como usar
+
+```
+/dare-llm-integration                       # audita uso de LLM no projeto
+/dare-llm-integration scaffold              # gera LLMProvider + cache + rate limit
+/dare-llm-integration prompts               # extrai prompts inline para arquivos versionados
+```
+
+## Os 5 pilares
+
+### 1. LLMProvider abstraction
+
+Nunca chame SDK do Gemini/OpenAI direto em Handler ou Service de negócio. Sempre via interface `LLMProvider`.
+
+### 2. Cache TTL
+
+Toda chamada passa por cache. Key = `hash(promptId + input + model)`. TTL default 1h.
+
+### 3. Rate limit via token bucket
+
+Token bucket por provider:
+- Gemini Free: 15 RPM, 1M tokens/dia
+- Claude tier 1: 50 RPM
+- OpenAI tier 1: 500 RPM
+
+### 4. Prompts versionados
+
+Nunca inline em código. Vivem em `prompts/<id>.v<n>.md` com frontmatter (model, temperature, schema).
+
+### 5. Validação via schema
+
+LLM mente — sempre valide output com Zod/Pydantic/serde.
+
+## Métricas obrigatórias
+
+| ID | Métrica |
+|---|---|
+| M-01 | 100% das chamadas LLM via LLMProvider injetado |
+| M-02 | 100% das responses LLM cacheadas |
+| M-03 | 100% das requests com rate limit |
+| M-04 | 100% das respostas validadas contra schema |
+
+## Antipatterns
+
+| AP | Antipattern | Por quê |
+|---|---|---|
+| AP-01 | SDK direto em Handler | impossível mockar/trocar provider |
+| AP-02 | Sem cache | custo explode |
+| AP-03 | Prompt em código | impossível versionar/A-B |
+| AP-04 | User input direto em prompt | prompt injection trivial |
+| AP-05 | Trusting LLM output | LLM mente, schema é defesa |
+
+## Defesa contra prompt injection
+
+```python
+# ❌ Concatenação direta
+system = f"You are an assistant. {user_question}"
+
+# ✅ Separação por delimitador + escape
+messages = [
+    {"role": "system", "content": "You are an assistant. Answer based on the document below."},
+    {"role": "user", "content": f"<document>{escape(doc)}</document>\n<question>{escape(q)}</question>"}
+]
+```
+
+Regras:
+- Use delimitadores (`<document>`, `<question>`)
+- Escape conteúdo do usuário (XML/HTML escape)
+- Detecte "Ignore instructions above"
+- Valide output — fora do schema = sinal de injection
+
+## O que fazer
+
+### Passo 1: Auditar chamadas LLM
+
+```bash
+grep -rn "GoogleGenAI\\|new OpenAI\\|Anthropic(" src/
+```
+
+Toda ocorrência em Handler ou Service de negócio = AP-01.
+
+### Passo 2: Criar `LLMProvider` interface
+
+```typescript
+interface LLMProvider {
+  complete(req: {
+    promptId: string;
+    input: Record<string, unknown>;
+    schema: ZodSchema;
+  }): Promise<unknown>;
+}
+```
+
+### Passo 3: Implementar providers
+
+Comece com o que o projeto usa. Use os exemplos em `packages/skills/dare-llm-integration/providers/`.
+
+### Passo 4: Configurar cache + rate limit
+
+Cache em memória com TTL + token bucket por provider. Implementação pronta em `packages/skills/dare-llm-integration/cache/` e `.../rate_limit/`.
+
+### Passo 5: Extrair prompts inline
+
+Para cada prompt inline encontrado, mova para `prompts/<id>.v1.md` com frontmatter:
+
+```markdown
+---
+id: summarize
+version: 1
+model: gemini-2.0-flash
+temperature: 0.2
+max_tokens: 500
+schema: SummarySchema
+---
+
+# System
+You are a concise summarizer.
+
+# User
+Summarize: <text>{{ text }}</text>
+```
+
+### Passo 6: Adicionar validação no chamador
+
+```typescript
+const raw = await llm.complete({...});
+const parsed = SummarySchema.parse(raw);  // joga LLMOutputInvalidError se falhar
+```
+
+## Saída esperada
+
+Reporte numerado:
+- Quantas chamadas LLM no projeto
+- Quantas via LLMProvider (M-01)
+- Quantas cacheadas (M-02)
+- Quantas com rate limit (M-03)
+- Quantas validadas contra schema (M-04)
+- Lista de prompts inline a extrair
+
+$ARGUMENTS
+
+---
+
+Skill MIT — parte do DARE Method.

package/templates/ide/claude/.claude/commands/dare-migrate.md

@@ -0,0 +1,72 @@
+# /dare-migrate
+
+Camada semântica da migração (Fase 2 brownfield). Roda **depois** de `dare migrate`, que já leu os
+artefatos do `reverse`/`dna` e gerou os esqueletos. Sua função é **escrever a estratégia de migração
+e os cenários Gherkin de paridade reais** — o contrato comportamental que garante uma reimplementação
+fiel ao legado.
+
+## Como usar
+
+```
+/dare-migrate
+```
+
+> Pré-requisito: rodar `dare migrate --to <stack>` antes (gera `DARE/MIGRATION/MIGRATION.md`,
+> `migration-facts.json` e `parity/*.feature`). Isso por sua vez exige `dare reverse` já executado.
+
+## Quando usar
+
+- Projeto legado entendido (`reverse` + `dna` feitos) que será **reimplementado** em outra stack.
+- Acabou de rodar `dare migrate` e o `MIGRATION.md`/`.feature` têm seções `<!-- AGENT -->`/`# AGENT`.
+
+## O que fazer
+
+### 1. Carregar contexto (não re-varrer)
+- Leia `DARE/MIGRATION/migration-facts.json` (origem, alvo, módulos, blocking gaps).
+- Leia `DARE/IDEIA.md` + `DARE/REVERSE/module-*.md` (o que cada módulo faz) e `DARE/PROJECT-DNA.md`
+  (convenções). Abra arquivos-chave do legado só o necessário para inferir comportamento.
+
+### 2. Preencher `DARE/MIGRATION/MIGRATION.md`
+- **Decisão de Paradigma** — origem e alvo mudam de paradigma (procedural→OO, monólito→serviços)?
+  Registre decisão + justificativa; se preservado, diga.
+- **Estratégia de Migração** — big-bang vs. **strangler/parallel-run**; ordem dos módulos; feature flags.
+- **Registro de Risco** — para cada **blocking gap** (🔴) pré-listado, escreva o tratamento; some os
+  riscos de regressão/dados/performance + mitigações.
+- **Arquitetura-alvo** — desenhe na stack-alvo, **alinhada ao DNA** (camadas/convenções) quando o
+  paradigma for preservado; senão justifique a nova organização.
+- **Plano de Cutover & Rollback** — passos de corte, validação de paridade (rodar os `.feature`),
+  critério de go/no-go e rollback.
+
+### 3. Escrever os Gherkin de paridade (`parity/<módulo>.feature`)
+- Um `Scenario` por **fluxo observável** do módulo, derivado do **comportamento legado real**
+  (não invente). `Given` estado inicial → `When` ação → `Then` resultado **idêntico ao legado**.
+- Inclua casos de borda e formatação que o legado garante (ex.: arredondamento monetário, máscaras).
+- Esses `.feature` são o **contrato de aceite** da reimplementação na stack-alvo.
+
+### 4. Apresentar ao usuário
+Resumo: decisão de paradigma, estratégia, nº de cenários de paridade, blocking gaps a resolver.
+Reforce que cenários de paridade só valem se vierem do comportamento legado observado.
+
+## Regras de ouro
+
+1. **Paridade primeiro** — o objetivo é não quebrar comportamento; todo fluxo crítico vira `Scenario`.
+2. **Blocking gaps são bloqueantes** — um 🔴 não resolvido é risco de reimplementação; trate ou registre.
+3. **Respeite o DNA** — a arquitetura-alvo segue as convenções da casa quando faz sentido.
+4. **Não invente comportamento** — cenário sem base no legado é fonte de regressão silenciosa.
+5. **Strangler quando possível** — migração incremental com parallel-run reduz risco vs. big-bang.
+
+## Antipatterns
+
+| AP | Antipattern | Por quê |
+|---|---|---|
+| AP-01 | Gherkin genérico sem base no legado | Não garante paridade — vira regressão |
+| AP-02 | Ignorar blocking gaps (🔴) | Reimplementa em cima de incerteza |
+| AP-03 | Big-bang sem necessidade | Maximiza risco e dificulta rollback |
+| AP-04 | Arquitetura-alvo desalinhada do DNA | Código novo vira ilha inconsistente |
+| AP-05 | Reescrever os fatos determinísticos do CLI | Quebra a fonte de verdade |
+
+$ARGUMENTS
+
+---
+
+Skill MIT — parte do DARE Method. Fase 2 (brownfield). Pareia com o comando `dare migrate`.