@dewtech/dare-cli 2.16.0 → 2.17.0

package/templates/ide/antigravity/templates/TASK-SPEC-template.md

@@ -85,16 +85,57 @@ Execute **todos** antes de marcar a task como DONE. Se qualquer um falhar, leia
 
 ---
 
-## 7. CRITÉRIOS DE DONE
+## 7. PADRÕES PROIBIDOS (ANTI-STUB / ANTI-MOCK)
 
-- [ ] Todos os 4 validation gates passaram sem erros
-- [ ] Testes cobrem caminho feliz + erros + edge cases da seção 4
+> Esta seção é **inegociável**. O comando `dare review` (v2.17+) escaneia o código modificado por esta task e reprova se encontrar qualquer padrão abaixo.
+
+### Em código de produção (qualquer arquivo **fora** de `*.test.*`, `*.spec.*`, `__tests__/`, `tests/`, `spec/`)
+
+- ❌ **TODO / FIXME / XXX / HACK** — qualquer um desses marcadores em comentário
+- ❌ **Função vazia** — `fn x() {}`, `function x() {}`, `def x(): pass`, `def x(): ...`
+- ❌ **Stub explícito** — `throw new Error('not implemented')`, `unimplemented!()`, `todo!()`, `raise NotImplementedError`
+- ❌ **Retorno-fantasma** — `return null` / `return undefined` / `return {}` / `return []` como **única** statement de função pública declarada nesta task
+- ❌ **Mocks fora de testes** — `jest.fn()`, `sinon.stub()`, `mockReturnValue`, dados hardcoded fingindo ser do banco, fixtures injetadas em controllers/services
+- ❌ **Comentário de placeholder** — `// implement later`, `# placeholder`, `// stub`, `// FIXME implement`
+
+### Mocks são permitidos APENAS em
+
+- Arquivos de teste (`*.test.*`, `*.spec.*`, `__tests__/`, `tests/`, `spec/`)
+- Seeds / fixtures dentro de `database/seeders/`, `tests/fixtures/`
+- Helpers explicitamente marcados como auxiliares de teste
+
+### Verificação automática
+
+Antes de marcar a task como DONE, rode:
+
+```bash
+dare review <task-id>
+```
+
+Output esperado:
+
+```
+✅ task-XYZ: nenhum padrão proibido detectado em N arquivos modificados.
+```
+
+Se a review falhar, a task **não pode** ir para DONE — corrija os achados e re-rode.
+
+---
+
+## 8. CRITÉRIOS DE DONE
+
+- [ ] Todos os 4 validation gates passaram sem erros (build + test + lint + audit)
+- [ ] Testes cobrem caminho feliz + erros enumerados + edge cases da seção 4
 - [ ] Considerações de segurança da seção 5 todas checadas
 - [ ] Arquivos listados na seção 3 criados/modificados conforme spec
+- [ ] **`dare review <task-id>` passou** (seção 7 — sem stubs, mocks, TODOs)
+- [ ] Cada validação declarada na spec tem teste demonstrando o erro real (não placeholder)
+- [ ] Cada edge case enumerado tem teste cobrindo
+- [ ] Endpoints retornam dados reais do banco/service, não hardcoded
 - [ ] `DARE/TASKS.md` atualizado com status `DONE`
 
 ---
 
-## 8. PRÓXIMA TASK SUGERIDA
+## 9. PRÓXIMA TASK SUGERIDA
 
 `[task-id]` — [título] _(desbloqueada após conclusão desta task)_

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

@@ -66,6 +66,62 @@ Siga o template `templates/BLUEPRINT-template.md`. Seções obrigatórias:
 
 **2.11 Checklist de Aprovação** — checkboxes para o usuário revisar antes de prosseguir
 
+---
+
+## 🚫 ANTI-STUB CONTRACT (regra inegociável)
+
+> **Por que existe esta seção:** o `/dare-tasks` que vem depois usa este Blueprint como **única fonte de verdade**. Se um endpoint, função ou regra ficar genérico aqui, o agente que implementar a task **será forçado a inventar** — e vai produzir mocks, stubs e esqueletos para "preencher o vazio". Detalhe agora.
+>
+> Tasks que produzem mock/stub/skeleton **falham** no `dare review` (introduzido na v2.17) e bloqueiam o `dare execute --complete`.
+
+Para **cada** endpoint, função pública, evento ou job declarado no Blueprint, especifique de forma **executável**:
+
+### Para endpoints HTTP/RPC
+
+- **Assinatura completa:** método, path, headers obrigatórios, content-type
+- **Request schema:** todos os campos com tipo, restrições (min/max/regex), opcionalidade
+- **Response schema por status code:** estrutura para 2xx, 4xx, 5xx — não apenas "200 OK"
+- **Validações server-side:** lista exaustiva de regras (`email único`, `senha ≥ 8 chars + 1 maiúscula + 1 dígito`, etc.)
+- **Edge cases enumerados:** o que acontece com input vazio, duplicado, expirado, sem permissão, com dados inconsistentes
+- **Side effects:** que tabelas/filas/caches/emails são tocados — em ordem
+- **Exemplo concreto (não placeholder):** payload real, response real
+
+### Para funções de domínio / services
+
+- **Assinatura tipada** (`fn name(args: Types) -> ReturnType` ou equivalente)
+- **Pré-condições** verificáveis (estado obrigatório do banco/cache/etc.)
+- **Pós-condições** verificáveis (o que muda no sistema após retornar OK)
+- **Estados de erro** com tipo de exceção/Result/Either esperado
+- **Comportamento em concorrência** quando relevante (idempotência, locking, retry)
+
+### Para jobs / event handlers / workers
+
+- **Trigger:** evento, cron, fila — incluir o **nome canônico**
+- **Payload schema** com tipos
+- **Retry policy** (backoff, max attempts, DLQ)
+- **Idempotência:** chave + estratégia
+- **SLA / timeout**
+
+### Para modelos de dados
+
+- Cada campo: tipo, nullable, default, constraints (unique, fk, check), índices
+- Triggers ou hooks (soft-delete, audit, encryption-at-rest)
+- Estado inicial / seed obrigatório (se aplicável)
+
+### Critério de "Blueprint detalhado o suficiente"
+
+Antes de salvar, valide internamente — se a resposta a **qualquer** pergunta abaixo for "não", o Blueprint ainda está raso e precisa ser expandido:
+
+- [ ] Para cada endpoint, um humano não-familiarizado consegue escrever request/response sem perguntar nada?
+- [ ] Para cada função pública, está claro **o que retorna** em todos os caminhos (sucesso + erros enumerados)?
+- [ ] Edge cases foram **enumerados** ou só listados como "tratar edge cases"?
+- [ ] Cada validação tem uma regra concreta (não "validar email" — `^[a-z0-9._%+-]+@...`)?
+- [ ] Cada decisão arquitetural tem **justificativa** (não só "escolhemos X")?
+
+**Anti-padrão a evitar:** seções como _"implementar autenticação"_ ou _"validar dados"_ — isso vai virar stub. Especifique **qual** algoritmo, **quais** campos, **quais** regras.
+
+---
+
 ### 3. Salvar e aguardar aprovação humana
 
 Salve `DARE/BLUEPRINT.md` e informe:

package/templates/ide/claude/.claude/commands/dare-dag-build.md

@@ -65,6 +65,47 @@ tasks:
 - Cadeia linear é antipattern
 - `complexity` honesta
 
+### 3.1 ANTI-STUB CONTRACT (inegociável)
+
+> Tasks geradas com `subtask_prompt` ou spec genéricos forçam o agente a inventar — e ele vai produzir mock, stub ou esqueleto. **Não é negociável**. O comando `dare review <task-id>` (v2.17+) detecta isso e marca a task como FAILED.
+
+Cada `subtask_prompt` e `EXECUTION/task-<id>.md` deve atender este contrato:
+
+**O `subtask_prompt` deve ser auto-suficiente**
+
+O subagente recebe **apenas** o `subtask_prompt` + snippets de 2000 chars dos pais. Tudo que ele precisa para implementar **sem inventar** deve estar ali ou na `spec_file`. Inclua:
+
+- Caminho exato dos arquivos a criar/modificar
+- Assinaturas exatas das funções/endpoints (`fn name(params: T) -> R`)
+- Schema de request/response com tipos
+- Validações específicas (não "validar input" — `email: regex /^.../`, `senha: ≥ 8 chars + 1 maiúscula + 1 dígito`)
+- Edge cases enumerados (input vazio, duplicado, expirado, sem permissão)
+- Lista de testes esperados com nome + comportamento
+
+**A `spec_file` (`EXECUTION/task-<id>.md`) deve ter Definition of Done anti-stub:**
+
+```markdown
+## Definition of Done (ANTI-STUB)
+
+- [ ] Nenhum `TODO`, `FIXME`, `XXX` ou `HACK` em arquivos modificados
+- [ ] Nenhuma função vazia (`fn x() {}`, `def x(): pass`, `function x() {}`)
+- [ ] Nenhum `throw new Error('not implemented')`, `unimplemented!()`, `todo!()`, `NotImplementedError`
+- [ ] Nenhum `return null` / `return undefined` / `return {}` como única statement de função pública
+- [ ] Mocks **somente** dentro de `*.test.*`, `*.spec.*`, `__tests__/`, `tests/`, `spec/` — NUNCA em código de produção
+- [ ] Todos os endpoints declarados na seção 3 retornam dados reais (não fixos / hardcoded)
+- [ ] Cada validação da spec produz erro real com status code correto (testado)
+- [ ] Cada edge case da spec tem teste unitário ou integração demonstrando comportamento
+```
+
+**Verificação automatizável:** o agente vai rodar `dare review <id>` antes de marcar DONE. Se a review falhar, a task volta para revisão.
+
+**Sinais de spec rasa** (auto-validar antes de salvar):
+
+- ❌ "Implementar X" — sem assinatura, sem retorno, sem validações
+- ❌ "Tratar erros adequadamente" — quais erros? como? que código?
+- ❌ "Adicionar validações" — quais regras?
+- ✅ "Implementar `POST /auth/login` retornando `{ token: string, refresh: string }` com 200 se credenciais válidas, 401 se inválidas, 429 se rate limit"
+
 ### 4. Validar consistência com `EXECUTION/task-*.md`
 
 Se uma spec existe em `DARE/EXECUTION/task-<id>.md`:

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

@@ -0,0 +1,145 @@
+# Comando: /dare-refine
+
+## Descrição
+
+Analisa a complexidade de uma task e, quando alta, **quebra em sub-tasks menores** com escopo bem delimitado. Pode ser chamada:
+
+- Automaticamente pela skill `dare-tasks` logo após gerar o DAG (para cada task ≥ MED)
+- Manualmente pelo dev: `/dare-refine task-034`
+- Após mudança de escopo: quando o BLUEPRINT mudou e uma task ficou grande demais
+
+A camada determinística (heurística de complexidade) já é feita pelo CLI: `dare refine <id>`. Este comando adiciona a camada **semântica** — você lê a spec, decide se a quebra é necessária e, se for, produz sub-tasks coerentes.
+
+## Quando rodar
+
+- Logo após `/dare-tasks` para cada task com complexity HIGH no `dare-dag.yaml`
+- Quando o dev pede explicitamente: `/dare-refine task-034`
+- Quando você gerou uma task e ela "te parece grande" mesmo marcada MED — confie no instinto
+
+## Como executar
+
+### 1. Validar argumento
+
+`$ARGUMENTS` deve ter o `task-id`. Se vazio, peça.
+
+### 2. Rodar a camada determinística
+
+```bash
+dare refine $ARGUMENTS --split --format json > .dare/refine-$ARGUMENTS.json
+```
+
+Esse JSON traz:
+- `report.score` e `report.level` (LOW/MED/HIGH/CRITICAL)
+- `report.signals` — explica por que pontuou alto/baixo
+- `report.recommendsSplit` — true se HIGH ou CRITICAL
+- `proposal.subtasks` — quebra inicial baseada em diretórios (chute coarse)
+
+### 3. Decidir se vale quebrar
+
+Critérios para **quebrar**:
+
+- ✅ `recommendsSplit: true` da heurística (HIGH/CRITICAL)
+- ✅ Mais de 6 arquivos a criar/modificar
+- ✅ Mistura responsabilidades fortes (ex.: cria modelo + escreve controller + escreve teste + faz migration — split por camada)
+- ✅ Toca código que outra task ainda não criou (deveria ser depois)
+- ✅ Inclui refactor + feature nova juntos
+- ✅ Tem keyword "pesada" (refactor, migrate, integrate) E score MED+
+
+Critérios para **manter inteira**:
+
+- ✅ Score LOW e até MED
+- ✅ Todos os arquivos pertencem ao mesmo módulo/feature
+- ✅ Cabe em uma conversa única do agente (15–60 min de trabalho efetivo)
+
+### 4. Se decidir quebrar — produzir sub-tasks coerentes
+
+Não use a `proposal.subtasks` da CLI sem revisão — ela agrupa por diretório, o que nem sempre faz sentido semantico. **Reagrupe por responsabilidade**:
+
+| Eixo de split | Quando aplicar |
+|---|---|
+| **Por camada** | Modelo / Controller / Service / Test ficam em tasks separadas se cada um é grande |
+| **Por endpoint** | Task original tinha 4 endpoints REST → 4 sub-tasks de 1 endpoint cada |
+| **Por feature** | Auth tinha "register + login + refresh + logout" → split por verbo |
+| **Refactor + feature** | Quebra em "1. refactor X para preparar terreno" + "2. adiciona feature Y em cima" |
+| **Migration + código** | "1. migration + seeds" + "2. código que usa o novo schema" |
+
+Cada sub-task deve:
+
+- Ter `subtask_prompt` auto-suficiente (assinaturas exatas, validações, edge cases — o Anti-Stub Contract aplica)
+- Ter spec_file própria em `DARE/EXECUTION/<sub-id>.md`
+- Ter `depends_on` mínimo mas correto (sub-tasks da mesma família geralmente dependem em ordem)
+- Ter complexity honesta — se a sub ainda ficar HIGH, quebra de novo
+
+### 5. Emitir verdito + plano
+
+Salve em `.dare/refine-verdict-$ARGUMENTS.json`:
+
+```json
+{
+  "manageable": false,
+  "reasons": [
+    "Score 18 (HIGH) — 7 endpoints + migration + 12 testes no mesmo escopo",
+    "Mistura refactor de service layer com novos endpoints"
+  ],
+  "proposedSubtasks": [
+    {
+      "id": "task-034a",
+      "title": "Refactor UserService para suportar profile_settings",
+      "files": ["src/services/UserService.ts", "tests/services/UserService.test.ts"],
+      "rationale": "Refactor isolado antes da feature — gates passam sem mexer em controllers",
+      "estimatedLevel": "MED"
+    },
+    {
+      "id": "task-034b",
+      "title": "Endpoints GET/PATCH /users/me/profile",
+      "files": ["src/controllers/profile.ts", "tests/controllers/profile.test.ts"],
+      "rationale": "Endpoints novos consumindo o serviço refatorado",
+      "estimatedLevel": "MED"
+    }
+  ]
+}
+```
+
+Se a task **é** manuseável (não precisa quebrar):
+
+```json
+{
+  "manageable": true,
+  "reasons": ["Score 7 (MED), 4 arquivos no mesmo módulo, 6 testes — cabe em uma conversa"]
+}
+```
+
+### 6. Aplicar o split
+
+Se quebrou:
+
+1. **Edite** `DARE/dare-dag.yaml` substituindo a task original pelas sub-tasks
+2. **Crie** as specs novas em `DARE/EXECUTION/<sub-id>.md` (use `templates/TASK-SPEC-template.md` — seguindo o Anti-Stub Contract!)
+3. **Atualize** `DARE/TASKS.md` (visão humana) refletindo a quebra
+4. **Regenere** o Mermaid: `dare dag viz -o DARE/dag-graph.mmd`
+5. **Marque** a task original como SPLIT (não deletar — preservar histórico) ou remover e referenciar no header das sub-tasks
+
+### 7. Mensagem ao usuário
+
+Se manteve inteira:
+> ✅ Task `$ARGUMENTS` está bem-dimensionada (score X, level Y). Sem split necessário.
+
+Se quebrou:
+> 🪓 Task `$ARGUMENTS` quebrada em N sub-task(s):
+> - `<id>a`: <título>
+> - `<id>b`: <título>
+> ...
+>
+> Specs criadas em `DARE/EXECUTION/`. Revise antes de executar:
+> ```bash
+> dare validate                    # verifica DAG
+> dare dag viz                     # confirma grafo
+> dare execute --next              # roda a primeira sub-task pronta
+> ```
+
+## Regras inegociáveis
+
+- **Não quebre tasks LOW** — overhead não vale a pena
+- **Não invente dependências** — sub-tasks da mesma família frequentemente são sequenciais, não falsamente paralelas
+- **Cada sub-task precisa ser independentemente testável** — se você precisa rodar A para testar B, A precisa ser parent de B no DAG
+- **Anti-Stub Contract aplica em cada sub-task** — não relaxa critérios só porque é menor

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

@@ -0,0 +1,113 @@
+# Comando: /dare-review
+
+## Descrição
+
+Audita uma task **implementada** cruzando a spec (`DARE/EXECUTION/<id>.md`) com os arquivos reais que ela tocou. Detecta stubs, mocks fora de testes, funções vazias, TODOs, retorno-fantasma — **e** valida critério-a-critério se a implementação satisfaz o que a spec prometeu.
+
+Esta é a camada **semântica** do review. A camada estática (regex / patterns) já é feita automaticamente pelo CLI quando você roda `dare review <task-id>`. Este comando combina as duas: rode a estática via CLI, gere um verdito semântico aqui, e produza um relatório fundido.
+
+## Quando rodar
+
+- Antes de marcar uma task como DONE (gate obrigatório no Definition of Done do TASK-SPEC)
+- Quando o `dare review <id>` estático passa mas você quer validação adicional contra a spec
+- Quando o dev pede revisão manual: `/dare-review task-034`
+
+## Como executar
+
+### 1. Validar argumento
+
+`$ARGUMENTS` deve conter o `task-id` (ex.: `task-034`). Se vazio, peça.
+
+### 2. Rodar a camada estática primeiro
+
+```bash
+dare review $ARGUMENTS --format json > .dare/review-static-$ARGUMENTS.json
+```
+
+Leia esse JSON. Se já houver erros estáticos, **reporte-os primeiro** e pergunte se quer prosseguir com a análise semântica mesmo assim (geralmente não vale — corrige os erros estáticos antes).
+
+### 3. Carregar contexto
+
+- `DARE/EXECUTION/$ARGUMENTS.md` — spec da task
+- Cada arquivo listado na seção 3 da spec ("ARQUIVOS A CRIAR / MODIFICAR")
+- `DARE/BLUEPRINT.md` — contratos de API / modelos referenciados
+
+### 4. Auditoria critério-a-critério
+
+Para **cada** item nas seções abaixo da spec, marque ✅ / ❌:
+
+#### 4.1 Objetivo (seção 1)
+A implementação atinge o estado observável que a seção 1 promete? Encontre **evidência concreta** (arquivo + linha) ou marque como não atendido.
+
+#### 4.2 Arquivos a criar / modificar (seção 3)
+- Todos os arquivos da tabela existem com o conteúdo descrito?
+- Há arquivos não listados que deveriam estar lá?
+
+#### 4.3 Implementação (seção 4)
+- Cada passo numerado foi executado?
+- Assinaturas exatas correspondem ao que a spec pede?
+- Validações implementadas correspondem às regras descritas (não "valida email" — a regex específica)?
+
+#### 4.4 Testes (seção 4, subitem)
+Para cada teste listado:
+- Existe um teste com nome correspondente?
+- O teste tem **assertions reais** que validariam o comportamento (não `expect(true).toBe(true)`)?
+- Edge cases enumerados têm cobertura?
+
+#### 4.5 Segurança (seção 5)
+- Input validation cobre o que a spec lista?
+- Não há secrets/tokens hardcoded?
+- SQL/Command injection mitigado via ORM / prepared statements?
+
+#### 4.6 Padrões Proibidos (seção 7 — ANTI-STUB)
+A camada estática já checou. **Não duplique** — só anote se você encontrar algo que o regex não pegaria (ex.: dados hardcoded que parecem reais mas vêm de uma constante embutida no controller).
+
+### 5. Emitir o verdito semântico
+
+Salve em `.dare/review-semantic-$ARGUMENTS.json`:
+
+```json
+{
+  "passed": true,
+  "unmetCriteria": [],
+  "notes": "Resumo de 1-3 frases do que foi verificado"
+}
+```
+
+Se algo falhou:
+
+```json
+{
+  "passed": false,
+  "unmetCriteria": [
+    "Seção 4.3: validação de senha não implementa regex de força (≥8 chars + maiúscula + dígito)",
+    "Seção 4.4: teste de edge case 'email duplicado' não existe"
+  ],
+  "notes": "2 critérios não atendidos em src/auth/register.ts e tests/auth.test.ts"
+}
+```
+
+### 6. Rodar o review fundido
+
+```bash
+dare review $ARGUMENTS --from-agent .dare/review-semantic-$ARGUMENTS.json
+```
+
+O CLI vai fundir estática + semântica e exibir o relatório final. Exit code 0 = task pode ir para DONE; exit code 1 = não pode.
+
+### 7. Mensagem final ao usuário
+
+Se passou:
+> ✅ Task `$ARGUMENTS` aprovada na review. Pode marcar como DONE: `dare execute --complete $ARGUMENTS`
+
+Se falhou:
+> ❌ Task `$ARGUMENTS` não passou na review. Itens a corrigir:
+> [lista de unmetCriteria + violations estáticas]
+>
+> Após corrigir, rode `/dare-review $ARGUMENTS` novamente.
+
+## Regras inegociáveis
+
+- **Não invente** que algo está implementado se você não viu o código. Se um arquivo não existe, isso é `unmetCriteria`.
+- **Não aceite** mocks/stubs em código de produção mesmo que "façam o teste passar". Eles violam o Anti-Stub Contract.
+- **Mocks são OK** dentro de `*.test.*`, `*.spec.*`, `__tests__/`, `tests/`, `spec/` — a camada estática já distingue.

package/templates/ide/claude/templates/TASK-SPEC-template.md

@@ -85,16 +85,57 @@ Execute **todos** antes de marcar a task como DONE. Se qualquer um falhar, leia
 
 ---
 
-## 7. CRITÉRIOS DE DONE
+## 7. PADRÕES PROIBIDOS (ANTI-STUB / ANTI-MOCK)
 
-- [ ] Todos os 4 validation gates passaram sem erros
-- [ ] Testes cobrem caminho feliz + erros + edge cases da seção 4
+> Esta seção é **inegociável**. O comando `dare review` (v2.17+) escaneia o código modificado por esta task e reprova se encontrar qualquer padrão abaixo.
+
+### Em código de produção (qualquer arquivo **fora** de `*.test.*`, `*.spec.*`, `__tests__/`, `tests/`, `spec/`)
+
+- ❌ **TODO / FIXME / XXX / HACK** — qualquer um desses marcadores em comentário
+- ❌ **Função vazia** — `fn x() {}`, `function x() {}`, `def x(): pass`, `def x(): ...`
+- ❌ **Stub explícito** — `throw new Error('not implemented')`, `unimplemented!()`, `todo!()`, `raise NotImplementedError`
+- ❌ **Retorno-fantasma** — `return null` / `return undefined` / `return {}` / `return []` como **única** statement de função pública declarada nesta task
+- ❌ **Mocks fora de testes** — `jest.fn()`, `sinon.stub()`, `mockReturnValue`, dados hardcoded fingindo ser do banco, fixtures injetadas em controllers/services
+- ❌ **Comentário de placeholder** — `// implement later`, `# placeholder`, `// stub`, `// FIXME implement`
+
+### Mocks são permitidos APENAS em
+
+- Arquivos de teste (`*.test.*`, `*.spec.*`, `__tests__/`, `tests/`, `spec/`)
+- Seeds / fixtures dentro de `database/seeders/`, `tests/fixtures/`
+- Helpers explicitamente marcados como auxiliares de teste
+
+### Verificação automática
+
+Antes de marcar a task como DONE, rode:
+
+```bash
+dare review <task-id>
+```
+
+Output esperado:
+
+```
+✅ task-XYZ: nenhum padrão proibido detectado em N arquivos modificados.
+```
+
+Se a review falhar, a task **não pode** ir para DONE — corrija os achados e re-rode.
+
+---
+
+## 8. CRITÉRIOS DE DONE
+
+- [ ] Todos os 4 validation gates passaram sem erros (build + test + lint + audit)
+- [ ] Testes cobrem caminho feliz + erros enumerados + edge cases da seção 4
 - [ ] Considerações de segurança da seção 5 todas checadas
 - [ ] Arquivos listados na seção 3 criados/modificados conforme spec
+- [ ] **`dare review <task-id>` passou** (seção 7 — sem stubs, mocks, TODOs)
+- [ ] Cada validação declarada na spec tem teste demonstrando o erro real (não placeholder)
+- [ ] Cada edge case enumerado tem teste cobrindo
+- [ ] Endpoints retornam dados reais do banco/service, não hardcoded
 - [ ] `DARE/TASKS.md` atualizado com status `DONE`
 
 ---
 
-## 8. PRÓXIMA TASK SUGERIDA
+## 9. PRÓXIMA TASK SUGERIDA
 
 `[task-id]` — [título] _(desbloqueada após conclusão desta task)_

package/templates/ide/cursor/.cursor/commands/generate-blueprint.md

@@ -34,6 +34,51 @@ Avança o DARE para a fase Architect: lê `DARE/DESIGN.md` aprovado e gera **som
    - **Estratégia de Deploy** — por ambiente
    - **Checklist de Aprovação** — checkboxes para revisão humana
 
+   ---
+
+   ### 🚫 ANTI-STUB CONTRACT (regra inegociável)
+
+   > **Por que existe esta seção:** o `/generate-tasks` que vem depois usa este Blueprint como **única fonte de verdade**. Se um endpoint, função ou regra ficar genérico aqui, o agente que implementar a task **será forçado a inventar** — e vai produzir mocks, stubs e esqueletos para "preencher o vazio". Detalhe agora.
+   >
+   > Tasks que produzem mock/stub/skeleton **falham** no `dare review` (v2.17+) e bloqueiam o `dare execute --complete`.
+
+   Para **cada** endpoint, função pública, evento ou job declarado no Blueprint, especifique de forma **executável**:
+
+   **Endpoints HTTP/RPC:**
+   - Assinatura completa (método, path, headers, content-type)
+   - Request schema (campos, tipos, restrições, opcionalidade)
+   - Response schema **por status code** (2xx, 4xx, 5xx)
+   - Validações server-side (lista exaustiva — `email único`, `senha ≥ 8 chars + maiúscula + dígito`)
+   - Edge cases enumerados (input vazio, duplicado, expirado, sem permissão)
+   - Side effects (tabelas/filas/caches/emails tocados — em ordem)
+   - Exemplo concreto (payload real, response real — não placeholder)
+
+   **Funções de domínio / services:**
+   - Assinatura tipada (`fn name(args: Types) -> ReturnType`)
+   - Pré-condições e pós-condições verificáveis
+   - Estados de erro com tipo de exceção esperado
+   - Comportamento em concorrência (idempotência, locking, retry)
+
+   **Jobs / event handlers / workers:**
+   - Trigger (evento, cron, fila — nome canônico)
+   - Payload schema tipado
+   - Retry policy (backoff, max attempts, DLQ)
+   - Idempotência (chave + estratégia)
+
+   **Modelos de dados:**
+   - Cada campo: tipo, nullable, default, constraints (unique, fk, check), índices
+   - Triggers / hooks (soft-delete, audit, encryption-at-rest)
+
+   **Critério de "Blueprint detalhado o suficiente"** (auto-validação antes de salvar):
+
+   - [ ] Para cada endpoint, um humano consegue escrever request/response sem perguntar?
+   - [ ] Para cada função pública, está claro o que retorna em todos os caminhos (sucesso + erros enumerados)?
+   - [ ] Edge cases enumerados explicitamente — não "tratar edge cases"?
+   - [ ] Cada validação tem regra concreta — não só "validar email"?
+   - [ ] Cada decisão arquitetural tem **justificativa**?
+
+   **Anti-padrão a evitar:** seções como _"implementar autenticação"_ ou _"validar dados"_ — isso vira stub. Especifique algoritmo, campos, regras.
+
 4. **Salve `DARE/BLUEPRINT.md`** e informe:
 
    _"Blueprint gerado. Revise a arquitetura, os contratos de API e os critérios de DONE de cada fase. Quando aprovado, execute `/generate-tasks` para gerar o DAG e as specs de execução."_

package/templates/ide/cursor/.cursor/commands/generate-tasks.md

@@ -112,6 +112,48 @@ O `subtask_prompt` no YAML pode referenciar a spec via
 `spec_file: EXECUTION/task-<id>.md` para que o subagente leia a spec na hora
 de executar.
 
+### 5.1 ANTI-STUB CONTRACT (inegociável)
+
+> Tasks geradas com `subtask_prompt` ou spec genéricos forçam o agente a inventar — e ele vai produzir mock, stub ou esqueleto. **Não é negociável**. O comando `dare review <task-id>` (v2.17+) detecta isso e marca a task como FAILED.
+
+Cada `subtask_prompt` e `EXECUTION/task-<id>.md` deve atender este contrato:
+
+**O `subtask_prompt` deve ser auto-suficiente**
+
+O subagente recebe **apenas** o `subtask_prompt` + snippets de 2000 chars dos pais. Tudo que ele precisa para implementar **sem inventar** deve estar ali ou na `spec_file`. Inclua:
+
+- Caminho exato dos arquivos a criar/modificar
+- Assinaturas exatas das funções/endpoints (`fn name(params: T) -> R`)
+- Schema de request/response com tipos
+- Validações específicas (não "validar input" — `email: regex /^.../`, `senha: ≥ 8 chars + 1 maiúscula + 1 dígito`)
+- Edge cases enumerados (input vazio, duplicado, expirado, sem permissão)
+- Lista de testes esperados com nome + comportamento (`should_reject_duplicate_email_with_409`)
+
+**A `spec_file` (`EXECUTION/task-<id>.md`) deve ter Definition of Done anti-stub:**
+
+```markdown
+## Definition of Done (ANTI-STUB)
+
+- [ ] Nenhum `TODO`, `FIXME`, `XXX` ou `HACK` em arquivos modificados
+- [ ] Nenhuma função vazia (`fn x() {}`, `def x(): pass`, `function x() {}`)
+- [ ] Nenhum `throw new Error('not implemented')`, `unimplemented!()`, `todo!()`, `NotImplementedError`
+- [ ] Nenhum `return null` / `return undefined` / `return {}` como única statement de função pública
+- [ ] Mocks **somente** dentro de `*.test.*`, `*.spec.*`, `__tests__/`, `tests/`, `spec/` — NUNCA em código de produção
+- [ ] Todos os endpoints declarados na seção 3 retornam dados reais (não fixos / hardcoded)
+- [ ] Cada validação da spec produz erro real com status code correto (testado)
+- [ ] Cada edge case da spec tem teste unitário ou integração demonstrando comportamento
+```
+
+**Verificação automatizável:** o agente que executar a task vai rodar `dare review <id>` antes de marcar DONE. Se a review falhar, a task volta para revisão.
+
+**Sinais de spec rasa** (auto-validar antes de salvar):
+
+- ❌ "Implementar X" — sem assinatura, sem retorno, sem validações
+- ❌ "Tratar erros adequadamente" — quais erros? como? que código?
+- ❌ "Adicionar validações" — quais regras?
+- ❌ Arquivos listados sem dizer **o que cada um contém**
+- ✅ "Implementar `POST /auth/login` retornando `{ token: string, refresh: string }` com 200 se credenciais válidas, 401 se inválidas, 429 se rate limit"
+
 ### 6. Validar consistência dos 3 artefatos
 
 - Mesmos `id`s em `TASKS.md`, `dare-dag.yaml` e `EXECUTION/task-*.md`.