@dewtech/dare-cli 2.16.0 → 3.0.0

package/templates/ide/cursor/.cursor/rules/skill-dag-run.mdc

@@ -0,0 +1,134 @@
+---
+description: Executa o grafo de tasks definido em DARE/dare-dag.yaml usando Cursor como executor e o CLI dare como orquestrador. Sem API keys — usa o plano nativo da IDE. O canvas ao vivo fica em DARE/.canvas.md.
+globs: DARE/dare-dag.yaml,DARE/EXECUTION/**,DARE/.canvas.md
+alwaysApply: false
+---
+
+# Skill: DAG Run — Executar o grafo
+
+Esta skill **executa** o grafo que já foi construído — não regenera o
+`dare-dag.yaml`, não modifica o BLUEPRINT, não cria specs novas. Apenas
+roda as tasks na ordem topológica correta.
+
+> Para **(re)construir** o grafo, use `skill-dag-build`.
+> Para **visualizar** o grafo, use o comando `/dag-viz`.
+> Para **build + run num único passo**, use `skill-dag-runner`.
+
+> **Sem API keys.** Você (Cursor) usa o plano nativo da IDE. O CLI `dare`
+> apenas coordena estado, monta prompts e atualiza o canvas.
+
+## Quando usar
+
+- `DARE/dare-dag.yaml` está aprovado e pronto
+- As specs em `DARE/EXECUTION/task-<id>.md` estão geradas
+- É hora de implementar as tasks na ordem do grafo
+- O usuário aprovou os ANTI-STUB contracts
+
+## Pré-requisitos
+
+- `DARE/dare-dag.yaml` existe e foi aprovado pelo usuário
+- Specs em `DARE/EXECUTION/task-<id>.md` geradas (se não, use `skill-dag-build`)
+- `dare` disponível no PATH (`npm i -g @dewtech/dare-cli`)
+
+## Procedimento
+
+### 1. Validar pré-condições
+
+- Confirme que `DARE/dare-dag.yaml` existe. Se não, oriente
+  `/generate-blueprint` ou `skill-dag-build`
+- Leia o YAML e verifique: sem ciclos, ids únicos, ranks paralelizáveis
+- Liste para o usuário: total de tasks, ranks, próximas ready
+
+### 2. Pegar próximas tasks
+
+```bash
+dare execute --next
+```
+
+O CLI imprime as tasks **ready** do rank atual com o prompt completo
+(snippets de até 2000 chars dos outputs dos pais já costurados). Use esses
+prompts diretamente.
+
+### 3. Sugerir abrir o canvas
+
+Antes de começar, peça ao usuário abrir `DARE/.canvas.md` em outra aba do
+Cursor. Esse é o feedback visual ao vivo da execução.
+
+### 4. Executar cada task
+
+Para cada task ready:
+
+1. Leia `spec_file` se houver (`DARE/EXECUTION/task-<id>.md`)
+2. Implemente conforme o `subtask_prompt` — **não invente, não use mock fora de tests, sem TODOs**
+3. Rode o Ralph Loop completo: build → test → lint
+4. Registre o resultado no CLI:
+
+```bash
+# Sucesso
+dare execute --complete task-001 --output "Resumo curto + paths dos arquivos criados/modificados"
+
+# Falha
+dare execute --fail task-002 --reason "Mensagem clara da falha"
+```
+
+### 5. Avançar de rank
+
+```bash
+dare execute --next
+```
+
+Se aparecer `✅ All tasks resolved`, todas terminaram. Reporte o resumo.
+Caso contrário, continue executando o próximo rank.
+
+### 6. Pós-execução
+
+```bash
+dare execute --status
+```
+
+Snapshot do canvas + sumário (X DONE, Y FAILED, Z SKIPPED).
+
+Para retentar tasks FAILED:
+
+```bash
+dare execute --reset task-002
+dare execute --next
+```
+
+## Comandos do orquestrador `dare`
+
+| Comando | Função |
+|---------|--------|
+| `dare execute --next` | Próximas tasks ready com prompts compostos |
+| `dare execute --complete <id> --output "..."` | Marca DONE |
+| `dare execute --fail <id> --reason "..."` | Marca FAILED + cascade-skip |
+| `dare execute --reset <id>` | Volta para PENDING |
+| `dare execute --status` | Snapshot + sumário |
+
+## Erros comuns
+
+| Sintoma | Causa | Correção |
+|---------|-------|----------|
+| `dare-dag.yaml not found` | Não foi gerado | `/generate-blueprint` ou `skill-dag-build` |
+| Cascata de SKIPPED | Pai falhou | Corrija pai → `dare execute --reset` → `--next` |
+| Output truncado | Cap de 4000 chars | Escreva em arquivo, retorne resumo |
+| Spec inconsistente | TASKS.md ≠ dare-dag.yaml | Re-gere com `skill-dag-build` |
+
+## Quando NÃO usar
+
+- Se `dare-dag.yaml` não existe — use `/generate-blueprint` ou `skill-dag-build`
+- Se você quer só visualizar — use `/dag-viz`
+- Se você quer build + run num único passo — `skill-dag-runner`
+
+## Referências
+
+- Schema: `DARE/dare-dag.yaml`
+- Canvas: `DARE/.canvas.md`
+- Specs: `DARE/EXECUTION/task-*.md`
+- Status: `DARE/TASKS.md`
+
+---
+
+## Licença
+
+Esta skill é parte do DARE Method e está sob licença MIT (D-001).

package/templates/ide/cursor/.cursor/rules/skill-dag-runner.mdc

@@ -1,221 +1,221 @@
----
-description: Como construir e executar grafos de tasks (DAG) do método DARE com paralelismo lógico via dare-dag.yaml. O Cursor é o executor; o CLI dare é orquestrador.
-globs: DARE/dare-dag.yaml,DARE/EXECUTION/**,DARE/.canvas.md
-alwaysApply: false
----
-
-# Skill: DAG Task Runner
-
-## Quando usar
-
-- O `BLUEPRINT.md` foi aprovado e você precisa decompor em tasks executáveis
-- O usuário pediu para começar a execução do DAG
-- Existe `DARE/dare-dag.yaml` e você precisa entender, executar ou modificar
-- Aparece o canvas `DARE/.canvas.md` durante uma execução
-
-## Quem executa o quê
-
-> **Você (Cursor) é o executor. O CLI `dare` é orquestrador.**
-
-- A IDE em que você roda já está autenticada na conta do usuário
-- Você lê o `dare-dag.yaml` e as specs em `DARE/EXECUTION/task-*.md`
-- Você executa cada task — escreve código, roda testes, faz lint
-- Depois de cada task, você chama o CLI para registrar o resultado:
-  - `dare execute --complete <task-id> --output "<resumo>"`
-  - `dare execute --fail <task-id> --reason "<mensagem>"`
-- O CLI atualiza o canvas e popula o `dare-graph` automaticamente
-
-**Não há API key. Não há custo extra de tokens. Você usa o plano da IDE.**
-
-## O que é o DAG do DARE
-
-`DARE/dare-dag.yaml` é o **plano de execução**: um grafo direcionado acíclico
-em que cada nó é uma task atômica e as arestas são `depends_on`. O CLI ordena
-topologicamente (Kahn's algorithm) e indica em que ordem você deve executar.
-Tasks no mesmo rank podem rodar em paralelo (logicamente — você decide se
-literalmente fan-out ou roda uma após a outra).
-
-```
-rank 0:  task-001    task-002      ←  podem rodar juntas (sem depends_on)
-rank 1:  task-003 (deps: 001, 002) ←  só após rank 0
-rank 2:  task-004 (deps: 003)
-```
-
-## Schema canônico do `dare-dag.yaml`
-
-```yaml
-title: "<Nome do projeto> - Development Tasks"
-version: "1.0.0"
-
-limits:
-  parent_context_chars: 2000   # snippet de cada output de pai injetado no filho
-  task_output_chars: 4000      # cap do output capturado por task
-  timeout_seconds: 600         # apenas referência; quem aborta é você
-
-# Mapeamento complexity → modelo (referencial — você usa o modelo da sua IDE)
-models:
-  cursor:      { HIGH: gpt-5.3-codex,     MED: composer-2,       LOW: auto-low }
-  claude:      { HIGH: claude-sonnet-4-5, MED: claude-haiku-4,   LOW: claude-haiku-4 }
-  antigravity: { HIGH: gemini-2.5-pro,    MED: gemini-2.5-flash, LOW: gemini-2.5-flash }
-
-tasks:
-  - id: task-001
-    title: "Setup project structure"
-    depends_on: []
-    complexity: LOW
-    spec_file: EXECUTION/task-001.md
-    subtask_prompt: |
-      <prompt completamente self-contained>
-```
-
-## Loop de execução
-
-```
-1. dare execute --next
-   ↓ imprime prompts das tasks ready (rank atual)
-2. Para cada prompt:
-     - leia spec_file se houver
-     - implemente
-3. dare execute --complete <id> --output "<resumo + arquivos tocados>"
-     ↓ o CLI roda o RALPH LOOP automático (build → test → lint)
-     ↓ se passar: task vira DONE
-     ↓ se falhar: task vira FAILED com stderr capturado; corrija e retente
-4. Volte ao passo 1 até não haver mais tasks ready
-```
-
-> **Ralph Loop é AUTOMÁTICO e OBRIGATÓRIO.** Você NÃO roda build/test/lint
-> manualmente — o `dare execute --complete` faz isso. Se algum gate falhar,
-> a task NÃO vai para DONE; vai para FAILED. Você corrige o código e tenta
-> de novo (`dare execute --complete <id>` outra vez, ou `--reset` antes se
-> precisar zerar histórico).
->
-> **Não existe flag para pular o Ralph Loop.** Toda task passa pelos 3 gates
-> da stack do projeto.
-
-Comandos úteis:
-
-```bash
-dare execute --next                                # próximas tasks ready (rank atual)
-dare execute --complete task-001 --output "..."    # marca DONE
-dare execute --fail task-002 --reason "..."        # marca FAILED + cascade-skip
-dare execute --reset task-002                      # volta para PENDING (retry)
-dare execute --status                              # snapshot do canvas
-```
-
-## Regras inegociáveis ao construir o DAG
-
-### 1. `id` em kebab-case e único
-`task-001`, `auth-jwt`, `db-migrations`. Sem espaços nem maiúsculas.
-
-### 2. `depends_on` mínimo — maximize paralelismo
-Só adicione dependência quando a task filha **literalmente não pode começar**
-sem o output da pai (arquivo, schema, decisão exportada).
-
-| Cenário | Dep? |
-|---------|------|
-| B precisa do arquivo que A criou | sim |
-| B precisa de uma decisão tomada em A | sim |
-| B faz coisa similar a A mas independente | não |
-| Pesquisa/leitura sem efeito colateral | não — fan out wide |
-| Testes do módulo X | sim — depende da implementação |
-| Docs do módulo X | sim — depende da implementação |
-
-Cadeia linear `001 → 002 → 003 → ...` é antipattern. Reanalise.
-
-### 3. `complexity` é referência (não custo real para você)
-| Nível | Quando usar |
-|-------|-------------|
-| `LOW`  | Setup, scaffolding, docs simples, leitura/pesquisa |
-| `MED`  | Implementação direta, refactors, testes unitários |
-| `HIGH` | Lógica de negócio crítica, segurança, integrações |
-
-Como você usa o plano da IDE, `complexity` virou principalmente um sinal para
-você priorizar atenção/cuidado, não para escolher modelo.
-
-### 4. `subtask_prompt` totalmente self-contained
-Sua sessão futura recebe o prompt + snippets de até 2000 chars dos outputs
-dos pais (via `dare execute --next`). Não vale "como combinamos antes".
-Tudo o que precisa estar no prompt ou virá pelos pais.
-
-### 5. Output cap de 4000 chars
-Se uma task gera muito, escreva em arquivo (permanece no FS) e faça o
-`--output` do `dare execute --complete` ser um resumo curto + caminhos dos
-arquivos criados.
-
-### 6. Cada task tem spec em `EXECUTION/task-<id>.md`
-Spec detalhada com: objetivo, arquivos a criar/modificar, validation gates,
-testes esperados. O `subtask_prompt` referencia `spec_file` para você ler na
-hora de executar.
-
-## Geração: o que o `/generate-tasks` deve produzir
-
-Sempre os **três artefatos juntos**:
-
-1. **`DARE/TASKS.md`** — tabela master para humanos
-2. **`DARE/dare-dag.yaml`** — grafo executável
-3. **`DARE/EXECUTION/task-<id>.md`** — uma spec por task
-
-Os três precisam estar consistentes (mesmos `id`s, mesmos `depends_on`,
-mesma `complexity`). Inconsistência aqui quebra a execução.
-
-## Canvas ao vivo (`DARE/.canvas.md`)
-
-O CLI reescreve `DARE/.canvas.md` a cada `dare execute --complete/--fail`:
-
-```
-| ID       | Title              | Status        | Duration | Tokens |
-|----------|--------------------|---------------|----------|--------|
-| task-001 | Setup structure    | ✅ DONE       | 1240ms   | 850    |
-| task-002 | DB schema          | 🔄 RUNNING    | -        | -      |
-| task-003 | Core endpoints     | ⏳ PENDING    | -        | -      |
-```
-
-Status: `PENDING` ⏳ · `RUNNING` 🔄 · `DONE` ✅ · `FAILED` ❌ · `SKIPPED` ⏭️
-
-`SKIPPED` é automático quando uma dependência falha — você não precisa fazer
-nada; o CLI cuida do cascade.
-
-## Erros comuns ao construir DAG
-
-| Erro | Sintoma | Como corrigir |
-|------|---------|---------------|
-| Ciclo em `depends_on` | `Circular dependency detected: <id>` | Reveja, retire a aresta cíclica |
-| `id` duplicado | Comportamento indefinido | Renomeie |
-| `depends_on` aponta para `id` inexistente | `Task not found: <id>` | Corrija nome |
-| Tudo em rank 0 | Conflito de escrita no mesmo arquivo | Adicione `depends_on` quando há contenção |
-| Cadeia linear longa | Sem ganho de paralelismo | Reveja se as deps são reais |
-
-## Antipatterns que você NÃO deve criar
-
-- ❌ Task chamada **"Ralph Loop final"**, **"Hardening final"**, **"QA final"**
-  — Ralph Loop roda automaticamente em cada `--complete`. Não é uma task.
-- ❌ Tests com `assertTrue(true)` ou equivalentes — o gate `test` vai rodar
-  de verdade. Placeholder não engana o CLI; só atrasa o ciclo.
-- ❌ "Setup project structure" como primeira task quando o ambiente ainda
-  não foi containerizado — sem container/runtime, o Ralph Loop não roda.
-
-## Ordem recomendada das primeiras tasks
-
-1. **Containerize app** (Dockerfile + docker-compose + healthcheck) — sem
-   isso o Ralph Loop não tem onde rodar
-2. **Database schema** (migrations + factories)
-3. **Core endpoints / componentes**
-4. **Auth / autorização**
-5. **Test suite real** (com assertions de verdade)
-
-A task de container/compose pode estar em **outra ordem** se o projeto já
-vive em um container do monorepo, ou se a stack não precisa de DB. Mas
-quase sempre é uma das primeiras — nunca a última.
-
-## Checklist antes de aprovar um DAG
-
-- [ ] Pelo menos 2 tasks no rank 0
-- [ ] Cada `subtask_prompt` é executável sem contexto adicional
-- [ ] Tasks de teste/doc dependem da implementação correspondente
-- [ ] `complexity` reflete o esforço real (não tudo HIGH)
-- [ ] `id` em kebab-case e único
-- [ ] Sem ciclos
-- [ ] **Sem task de "Ralph Loop final"** — Ralph Loop é gate por task
-- [ ] **Tests com assertions reais** — placeholder quebra o gate `test`
-- [ ] Container/runtime resolvido cedo, não na última task
-- [ ] `TASKS.md` + `dare-dag.yaml` + `EXECUTION/task-*.md` consistentes
+---
+description: Como construir e executar grafos de tasks (DAG) do método DARE com paralelismo lógico via dare-dag.yaml. O Cursor é o executor; o CLI dare é orquestrador.
+globs: DARE/dare-dag.yaml,DARE/EXECUTION/**,DARE/.canvas.md
+alwaysApply: false
+---
+
+# Skill: DAG Task Runner
+
+## Quando usar
+
+- O `BLUEPRINT.md` foi aprovado e você precisa decompor em tasks executáveis
+- O usuário pediu para começar a execução do DAG
+- Existe `DARE/dare-dag.yaml` e você precisa entender, executar ou modificar
+- Aparece o canvas `DARE/.canvas.md` durante uma execução
+
+## Quem executa o quê
+
+> **Você (Cursor) é o executor. O CLI `dare` é orquestrador.**
+
+- A IDE em que você roda já está autenticada na conta do usuário
+- Você lê o `dare-dag.yaml` e as specs em `DARE/EXECUTION/task-*.md`
+- Você executa cada task — escreve código, roda testes, faz lint
+- Depois de cada task, você chama o CLI para registrar o resultado:
+  - `dare execute --complete <task-id> --output "<resumo>"`
+  - `dare execute --fail <task-id> --reason "<mensagem>"`
+- O CLI atualiza o canvas e popula o `dare-graph` automaticamente
+
+**Não há API key. Não há custo extra de tokens. Você usa o plano da IDE.**
+
+## O que é o DAG do DARE
+
+`DARE/dare-dag.yaml` é o **plano de execução**: um grafo direcionado acíclico
+em que cada nó é uma task atômica e as arestas são `depends_on`. O CLI ordena
+topologicamente (Kahn's algorithm) e indica em que ordem você deve executar.
+Tasks no mesmo rank podem rodar em paralelo (logicamente — você decide se
+literalmente fan-out ou roda uma após a outra).
+
+```
+rank 0:  task-001    task-002      ←  podem rodar juntas (sem depends_on)
+rank 1:  task-003 (deps: 001, 002) ←  só após rank 0
+rank 2:  task-004 (deps: 003)
+```
+
+## Schema canônico do `dare-dag.yaml`
+
+```yaml
+title: "<Nome do projeto> - Development Tasks"
+version: "1.0.0"
+
+limits:
+  parent_context_chars: 2000   # snippet de cada output de pai injetado no filho
+  task_output_chars: 4000      # cap do output capturado por task
+  timeout_seconds: 600         # apenas referência; quem aborta é você
+
+# Mapeamento complexity → modelo (referencial — você usa o modelo da sua IDE)
+models:
+  cursor:      { HIGH: gpt-5.3-codex,     MED: composer-2,       LOW: auto-low }
+  claude:      { HIGH: claude-sonnet-4-5, MED: claude-haiku-4,   LOW: claude-haiku-4 }
+  antigravity: { HIGH: gemini-2.5-pro,    MED: gemini-2.5-flash, LOW: gemini-2.5-flash }
+
+tasks:
+  - id: task-001
+    title: "Setup project structure"
+    depends_on: []
+    complexity: LOW
+    spec_file: EXECUTION/task-001.md
+    subtask_prompt: |
+      <prompt completamente self-contained>
+```
+
+## Loop de execução
+
+```
+1. dare execute --next
+   ↓ imprime prompts das tasks ready (rank atual)
+2. Para cada prompt:
+     - leia spec_file se houver
+     - implemente
+3. dare execute --complete <id> --output "<resumo + arquivos tocados>"
+     ↓ o CLI roda o RALPH LOOP automático (build → test → lint)
+     ↓ se passar: task vira DONE
+     ↓ se falhar: task vira FAILED com stderr capturado; corrija e retente
+4. Volte ao passo 1 até não haver mais tasks ready
+```
+
+> **Ralph Loop é AUTOMÁTICO e OBRIGATÓRIO.** Você NÃO roda build/test/lint
+> manualmente — o `dare execute --complete` faz isso. Se algum gate falhar,
+> a task NÃO vai para DONE; vai para FAILED. Você corrige o código e tenta
+> de novo (`dare execute --complete <id>` outra vez, ou `--reset` antes se
+> precisar zerar histórico).
+>
+> **Não existe flag para pular o Ralph Loop.** Toda task passa pelos 3 gates
+> da stack do projeto.
+
+Comandos úteis:
+
+```bash
+dare execute --next                                # próximas tasks ready (rank atual)
+dare execute --complete task-001 --output "..."    # marca DONE
+dare execute --fail task-002 --reason "..."        # marca FAILED + cascade-skip
+dare execute --reset task-002                      # volta para PENDING (retry)
+dare execute --status                              # snapshot do canvas
+```
+
+## Regras inegociáveis ao construir o DAG
+
+### 1. `id` em kebab-case e único
+`task-001`, `auth-jwt`, `db-migrations`. Sem espaços nem maiúsculas.
+
+### 2. `depends_on` mínimo — maximize paralelismo
+Só adicione dependência quando a task filha **literalmente não pode começar**
+sem o output da pai (arquivo, schema, decisão exportada).
+
+| Cenário | Dep? |
+|---------|------|
+| B precisa do arquivo que A criou | sim |
+| B precisa de uma decisão tomada em A | sim |
+| B faz coisa similar a A mas independente | não |
+| Pesquisa/leitura sem efeito colateral | não — fan out wide |
+| Testes do módulo X | sim — depende da implementação |
+| Docs do módulo X | sim — depende da implementação |
+
+Cadeia linear `001 → 002 → 003 → ...` é antipattern. Reanalise.
+
+### 3. `complexity` é referência (não custo real para você)
+| Nível | Quando usar |
+|-------|-------------|
+| `LOW`  | Setup, scaffolding, docs simples, leitura/pesquisa |
+| `MED`  | Implementação direta, refactors, testes unitários |
+| `HIGH` | Lógica de negócio crítica, segurança, integrações |
+
+Como você usa o plano da IDE, `complexity` virou principalmente um sinal para
+você priorizar atenção/cuidado, não para escolher modelo.
+
+### 4. `subtask_prompt` totalmente self-contained
+Sua sessão futura recebe o prompt + snippets de até 2000 chars dos outputs
+dos pais (via `dare execute --next`). Não vale "como combinamos antes".
+Tudo o que precisa estar no prompt ou virá pelos pais.
+
+### 5. Output cap de 4000 chars
+Se uma task gera muito, escreva em arquivo (permanece no FS) e faça o
+`--output` do `dare execute --complete` ser um resumo curto + caminhos dos
+arquivos criados.
+
+### 6. Cada task tem spec em `EXECUTION/task-<id>.md`
+Spec detalhada com: objetivo, arquivos a criar/modificar, validation gates,
+testes esperados. O `subtask_prompt` referencia `spec_file` para você ler na
+hora de executar.
+
+## Geração: o que o `/generate-tasks` deve produzir
+
+Sempre os **três artefatos juntos**:
+
+1. **`DARE/TASKS.md`** — tabela master para humanos
+2. **`DARE/dare-dag.yaml`** — grafo executável
+3. **`DARE/EXECUTION/task-<id>.md`** — uma spec por task
+
+Os três precisam estar consistentes (mesmos `id`s, mesmos `depends_on`,
+mesma `complexity`). Inconsistência aqui quebra a execução.
+
+## Canvas ao vivo (`DARE/.canvas.md`)
+
+O CLI reescreve `DARE/.canvas.md` a cada `dare execute --complete/--fail`:
+
+```
+| ID       | Title              | Status        | Duration | Tokens |
+|----------|--------------------|---------------|----------|--------|
+| task-001 | Setup structure    | ✅ DONE       | 1240ms   | 850    |
+| task-002 | DB schema          | 🔄 RUNNING    | -        | -      |
+| task-003 | Core endpoints     | ⏳ PENDING    | -        | -      |
+```
+
+Status: `PENDING` ⏳ · `RUNNING` 🔄 · `DONE` ✅ · `FAILED` ❌ · `SKIPPED` ⏭️
+
+`SKIPPED` é automático quando uma dependência falha — você não precisa fazer
+nada; o CLI cuida do cascade.
+
+## Erros comuns ao construir DAG
+
+| Erro | Sintoma | Como corrigir |
+|------|---------|---------------|
+| Ciclo em `depends_on` | `Circular dependency detected: <id>` | Reveja, retire a aresta cíclica |
+| `id` duplicado | Comportamento indefinido | Renomeie |
+| `depends_on` aponta para `id` inexistente | `Task not found: <id>` | Corrija nome |
+| Tudo em rank 0 | Conflito de escrita no mesmo arquivo | Adicione `depends_on` quando há contenção |
+| Cadeia linear longa | Sem ganho de paralelismo | Reveja se as deps são reais |
+
+## Antipatterns que você NÃO deve criar
+
+- ❌ Task chamada **"Ralph Loop final"**, **"Hardening final"**, **"QA final"**
+  — Ralph Loop roda automaticamente em cada `--complete`. Não é uma task.
+- ❌ Tests com `assertTrue(true)` ou equivalentes — o gate `test` vai rodar
+  de verdade. Placeholder não engana o CLI; só atrasa o ciclo.
+- ❌ "Setup project structure" como primeira task quando o ambiente ainda
+  não foi containerizado — sem container/runtime, o Ralph Loop não roda.
+
+## Ordem recomendada das primeiras tasks
+
+1. **Containerize app** (Dockerfile + docker-compose + healthcheck) — sem
+   isso o Ralph Loop não tem onde rodar
+2. **Database schema** (migrations + factories)
+3. **Core endpoints / componentes**
+4. **Auth / autorização**
+5. **Test suite real** (com assertions de verdade)
+
+A task de container/compose pode estar em **outra ordem** se o projeto já
+vive em um container do monorepo, ou se a stack não precisa de DB. Mas
+quase sempre é uma das primeiras — nunca a última.
+
+## Checklist antes de aprovar um DAG
+
+- [ ] Pelo menos 2 tasks no rank 0
+- [ ] Cada `subtask_prompt` é executável sem contexto adicional
+- [ ] Tasks de teste/doc dependem da implementação correspondente
+- [ ] `complexity` reflete o esforço real (não tudo HIGH)
+- [ ] `id` em kebab-case e único
+- [ ] Sem ciclos
+- [ ] **Sem task de "Ralph Loop final"** — Ralph Loop é gate por task
+- [ ] **Tests com assertions reais** — placeholder quebra o gate `test`
+- [ ] Container/runtime resolvido cedo, não na última task
+- [ ] `TASKS.md` + `dare-dag.yaml` + `EXECUTION/task-*.md` consistentes

package/templates/ide/cursor/.cursor/rules/skill-dna.mdc

@@ -0,0 +1,63 @@
+---
+description: Camada semântica da extração de DNA do projeto. Roda depois do comando `dare dna` e transforma os fatos de convenção em regras acionáveis no DARE/PROJECT-DNA.md, para o agente seguir o padrão da casa em projetos legados.
+globs: DARE/PROJECT-DNA.md,DARE/dna-facts.json
+alwaysApply: false
+---
+
+# Skill: DNA — Convenções do Projeto (brownfield)
+
+Camada **semântica** da extração de DNA. Roda **depois** do comando `dare dna`, que já varreu o código
+e extraiu os fatos de convenção. Sua função é **transformar fatos em regras acionáveis** — o "como esse
+codebase faz as coisas" que uma nova feature deve respeitar.
+
+> Pré-requisito: rodar `dare dna` antes (gera `DARE/PROJECT-DNA.md` e `DARE/dna-facts.json`).
+> Se não existirem, peça para rodar `dare dna` primeiro.
+
+## Quando usar
+
+- Projeto **legado** que vai adotar o DARE para novas features, sem reescrever o existente.
+- Acabou de rodar `dare dna` e o `PROJECT-DNA.md` tem seções `<!-- AGENT -->` em aberto.
+
+## O que fazer
+
+### 1. Carregar os fatos (não re-varrer tudo)
+- Leia `DARE/dna-facts.json` — fonte determinística (tooling, naming, camadas, testes, libs, commits).
+- Abra **2-5 arquivos representativos por camada** (controller, service, model, teste) para inferir o
+  que o CLI não detecta (tratamento de erro, validação, estilo de teste).
+
+### 2. Preencher `DARE/PROJECT-DNA.md`
+Substitua cada `<!-- AGENT: ... -->`:
+- **Convenções de Nomenclatura** — confirme o estilo + exceções.
+- **Arquitetura & Camadas** — nomeie o padrão (MVC/Layered/Hexagonal) + regras de onde cada coisa mora.
+- **Padrões de Teste** — onde ficam, naming, assertions reais, mocks/fixtures.
+- **Tratamento de Erros & Validação** — como erros são tratados e inputs validados (exemplos reais).
+- **Regras de Ouro** — o que SEMPRE e NUNCA fazer neste codebase.
+- **⚠️ Incertezas** — convenções ambíguas que o humano precisa decidir.
+
+**Não toque** nos fatos determinísticos do CLI (tooling, tabela de naming, libs).
+
+### 3. Apresentar ao usuário
+Resumo: arquitetura nomeada, regras de ouro, inconsistências. O `PROJECT-DNA.md` vira referência para
+`skill-feature-design` e `skill-execute` respeitarem o legado.
+
+## Regras de ouro
+
+1. **Descritivo, não aspiracional** — como o código É, não como deveria ser.
+2. **Exemplos reais** — cite arquivos/trechos do projeto.
+3. **Sinalize inconsistência** — não invente um padrão único onde o legado mistura.
+4. **Não re-varra** — os fatos já estão em `dna-facts.json`.
+5. **Preserve o determinístico** — não reescreva tooling/naming/libs do CLI.
+
+## Antipatterns
+
+| AP | Antipattern | Por quê |
+|---|---|---|
+| AP-01 | Documentar o padrão "ideal" em vez do real | Código gerado sai fora do estilo do legado |
+| AP-02 | Forçar padrão único onde o legado é inconsistente | Esconde a realidade |
+| AP-03 | Reescrever os fatos determinísticos do CLI | Quebra a fonte de verdade |
+| AP-04 | Regras vagas ("siga boas práticas") | Inúteis — o valor está no específico |
+| AP-05 | Ignorar os testes existentes | Nova feature nasce inconsistente |
+
+---
+
+Skill MIT — parte do DARE Method. DNA do projeto (brownfield). Pareia com o comando `dare dna`.