@dewtech/dare-cli 2.0.1 → 2.1.0

package/templates/ide/antigravity/.agents/skills/dare-tasks/SKILL.md

@@ -1,229 +1,210 @@
----
-name: dare-tasks
-description: Gera Task Groups estruturados a partir do Blueprint aprovado. Use quando o usuário aprovar o BLUEPRINT.md. Cria um documento TASKS.md com tarefas atômicas e especificações isoladas para cada uma.
----
-
-# DARE Tasks Skill
-
-Você é um especialista em decomposição de projetos e planejamento de tarefas. Seu objetivo é quebrar o Blueprint em tarefas atômicas, executáveis e testáveis.
-
-## Quando usar esta skill
-
-- Blueprint.md foi aprovado pelo usuário
-- Precisa-se quebrar a arquitetura em tarefas
-- Necessário criar especificações isoladas
-- Terceira fase do Método DARE
-
-## Como usar
-
-### Passo 1: Ler o Blueprint Aprovado
-Leia o arquivo `DARE/BLUEPRINT.md` que foi aprovado. Extraia:
-- Fases do plano de execução
-- Endpoints a implementar
-- Modelos de dados
-- Estrutura de diretórios
-
-### Passo 2: Quebrar em Tarefas Atômicas
-Cada tarefa deve:
-- Ser pequena o suficiente para uma conversa
-- Ter dependências claras
-- Ser testável isoladamente
-- Incluir validações de segurança
-
-### Passo 3: Integrar Segurança
-Para cada tarefa, inclua:
-- Validações de entrada
-- Autenticação/Autorização
-- Testes de segurança
-- Proteção contra vulnerabilidades
-
-### Passo 4: Gerar TASKS.md
-Crie um documento `DARE/TASKS.md` com visão geral:
-
-```markdown
-# Tasks: [Nome do Projeto]
-
-## Visão Geral
-Total de Tasks: [N]
-Fases: [Número]
-Tempo Estimado: [Tempo]
-
-## Dependências
-
-```
-Phase 1: Setup
-  └─ Task 001: Migrations
-  └─ Task 002: JWT Setup
-
-Phase 2: Auth
-  ├─ Task 003: RegisterController (depende de Task 001)
-  ├─ Task 004: LoginController (depende de Task 001)
-  └─ Task 005: RefreshController (depende de Task 001)
-
-Phase 3: Protection
-  ├─ Task 006: JWT Middleware (depende de Task 002)
-  ├─ Task 007: Rate Limiting (depende de Task 006)
-  └─ Task 008: Logout (depende de Task 006)
-
-Phase 4: Testing
-  ├─ Task 009: Unit Tests (depende de Task 003-008)
-  ├─ Task 010: Integration Tests (depende de Task 009)
-  └─ Task 011: Docker Setup (depende de Task 010)
-```
-
-## Tarefas por Fase
-
-### Phase 1: Setup Inicial
-
-#### Task 001: Criar Migrations de Users
-- Arquivo: `DARE/EXECUTION/task-001.md`
-- Tempo: 15 min
-- Dependências: Nenhuma
-
-#### Task 002: Configurar JWT
-- Arquivo: `DARE/EXECUTION/task-002.md`
-- Tempo: 20 min
-- Dependências: Nenhuma
-
-### Phase 2: Autenticação
-
-#### Task 003: Implementar RegisterController
-- Arquivo: `DARE/EXECUTION/task-003.md`
-- Tempo: 30 min
-- Dependências: Task 001
-
-#### Task 004: Implementar LoginController
-- Arquivo: `DARE/EXECUTION/task-004.md`
-- Tempo: 30 min
-- Dependências: Task 001, Task 002
-
-#### Task 005: Implementar RefreshController
-- Arquivo: `DARE/EXECUTION/task-005.md`
-- Tempo: 25 min
-- Dependências: Task 001, Task 002
-
-### Phase 3: Proteção
-
-#### Task 006: Implementar JWT Middleware
-- Arquivo: `DARE/EXECUTION/task-006.md`
-- Tempo: 20 min
-- Dependências: Task 002
-
-#### Task 007: Implementar Rate Limiting
-- Arquivo: `DARE/EXECUTION/task-007.md`
-- Tempo: 25 min
-- Dependências: Task 006
-
-#### Task 008: Implementar Logout
-- Arquivo: `DARE/EXECUTION/task-008.md`
-- Tempo: 20 min
-- Dependências: Task 006
-
-### Phase 4: Testing
-
-#### Task 009: Testes Unitários
-- Arquivo: `DARE/EXECUTION/task-009.md`
-- Tempo: 40 min
-- Dependências: Task 003-008
-
-#### Task 010: Testes de Integração
-- Arquivo: `DARE/EXECUTION/task-010.md`
-- Tempo: 50 min
-- Dependências: Task 009
-
-#### Task 011: Docker Setup
-- Arquivo: `DARE/EXECUTION/task-011.md`
-- Tempo: 30 min
-- Dependências: Task 010
-
-## Próximas Etapas
-1. Revisar e aprovar este TASKS.md
-2. Executar `/execute-task task-001` para começar
-3. Continuar com o Método DARE
-```
-
-### Passo 5: Gerar Especificações Isoladas
-Para CADA tarefa, crie um arquivo `DARE/EXECUTION/task-[id].md`:
-
-```markdown
-# Task 001: Criar Migrations de Users
-
-## Objetivo
-Criar as migrations para tabelas de users e refresh_tokens.
-
-## Descrição
-Implementar duas migrations Laravel:
-1. create_users_table.php
-2. create_refresh_tokens_table.php
-
-## Especificações
-
-### Tabela: users
-- id: UUID (PK)
-- email: VARCHAR(255) UNIQUE NOT NULL
-- password_hash: VARCHAR(255) NOT NULL
-- name: VARCHAR(255) NOT NULL
-- is_active: BOOLEAN DEFAULT true
-- created_at: TIMESTAMP
-- updated_at: TIMESTAMP
-
-### Tabela: refresh_tokens
-- id: UUID (PK)
-- user_id: UUID (FK → users.id)
-- token: VARCHAR(500) UNIQUE
-- expires_at: TIMESTAMP NOT NULL
-- revoked_at: TIMESTAMP NULL
-- created_at: TIMESTAMP
-
-## Arquivos a Criar
-- `database/migrations/YYYY_MM_DD_HHMMSS_create_users_table.php`
-- `database/migrations/YYYY_MM_DD_HHMMSS_create_refresh_tokens_table.php`
-
-## Validações (Validation Gates)
-- [ ] Migrations criadas sem erros
-- [ ] Tabelas têm índices apropriados
-- [ ] Foreign keys estão corretas
-- [ ] Timestamps são automáticos
-- [ ] `php artisan migrate` executa sem erros
-
-## Testes
-```bash
-php artisan migrate
-php artisan migrate:rollback
-php artisan migrate
-```
-
-## Segurança
-- Senhas nunca são armazenadas em texto plano
-- Tokens têm expiração
-- Soft deletes para dados históricos
-
-## Próxima Task
-Task 002: Configurar JWT
-
-## Notas
-- Use UUID em vez de auto-increment
-- Considere índices em email e user_id
-```
-
-### Passo 6: Pedir Aprovação
-Após gerar todas as tasks:
-- Peça ao usuário revisar
-- Confirme dependências
-- Aprove antes de executar
-
-## Boas Práticas
-
-1. **Atômicas:** Cada task é independente
-2. **Testáveis:** Inclua validation gates
-3. **Documentadas:** Especificações claras
-4. **Seguras:** Integre requisitos OWASP
-5. **Sequenciadas:** Respeite dependências
-
-## Dicas para Melhor Resultado
-
-- **Tamanho:** Tasks devem levar 15-60 minutos
-- **Testes:** Sempre inclua validation gates
-- **Segurança:** Consulte `skill-security` para cada task
-- **Exemplos:** Use `examples/` como referência
-- **Templates:** Use `templates/TASK-SPEC-template.md`
+---
+name: dare-tasks
+description: Decompõe o BLUEPRINT aprovado em tasks atômicas e gera os 3 artefatos da fase de execução do DARE (TASKS.md, dare-dag.yaml, EXECUTION/task-*.md). Use quando o usuário aprovar o BLUEPRINT.md. A construção do grafo segue rigorosamente a skill dare-dag-runner.
+---
+
+# DARE Tasks Skill
+
+Você é o especialista em decomposição de projetos do método DARE. Seu papel é
+quebrar o BLUEPRINT aprovado em tasks atômicas e gerar simultaneamente os
+**três artefatos** da fase de execução, garantindo consistência entre eles.
+
+## Quando usar esta skill
+
+- BLUEPRINT.md foi aprovado pelo usuário
+- Necessário criar o plano de execução (tasks + grafo + specs)
+- Terceira fase do Método DARE (transição A → E)
+
+## Pré-requisitos
+
+Antes de gerar, leia também a skill `dare-dag-runner` — ela contém as regras
+inegociáveis do grafo (`depends_on` mínimo, complexity, prompt self-contained,
+limites de 2000/4000 chars, ranks paralelos).
+
+## Os 3 artefatos sempre juntos
+
+| Arquivo | Para quê | Lido por |
+|---------|----------|----------|
+| `DARE/TASKS.md` | Visão humana com tabela e progresso | Humano |
+| `DARE/dare-dag.yaml` | Grafo executável | CLI `dare execute` |
+| `DARE/EXECUTION/task-<id>.md` | Spec detalhada por task | Subagente ao executar |
+
+Os três precisam estar **consistentes**: mesmos `id`s, mesmas `depends_on`,
+mesmas `complexity`. Inconsistência aqui quebra a execução.
+
+## Como usar
+
+### Passo 1: Ler o BLUEPRINT aprovado
+
+Leia `DARE/BLUEPRINT.md`. Extraia:
+- Fases do plano de execução
+- Endpoints, modelos de dados, schemas
+- Estrutura de diretórios
+- Decisões arquiteturais
+- Estratégia de testes
+
+### Passo 2: Decompor em tasks atômicas
+
+Cada task deve:
+- Ser pequena o suficiente para uma conversa única (15–60 min de trabalho)
+- Ter dependências reais e mínimas (não falsas)
+- Ser testável isoladamente
+- Incluir validações de segurança apropriadas
+- Ter `complexity` honesta (LOW/MED/HIGH)
+
+### Passo 3: Gerar `DARE/TASKS.md` (visão humana)
+
+```markdown
+# Tasks: [Nome do Projeto]
+
+## Visão Geral
+- Total de Tasks: [N]
+- Ranks paralelos: [N]
+- Tempo estimado: [horas]
+
+## Tabela de Status
+
+| ID       | Título                      | Status      | Depends On       | Complexity |
+|----------|-----------------------------|-------------|------------------|------------|
+| task-001 | Setup project structure     | ⏳ PENDING  | —                | LOW        |
+| task-002 | DB migrations               | ⏳ PENDING  | —                | MED        |
+| task-003 | Auth controllers            | ⏳ PENDING  | task-001, 002    | HIGH       |
+| ...      | ...                         | ...         | ...              | ...        |
+
+## Tarefas por Fase
+
+### Phase 1: Setup
+- task-001: Setup project structure
+- task-002: DB migrations
+
+### Phase 2: Auth
+- task-003: Auth controllers (deps: 001, 002)
+- ...
+
+## Próximas Etapas
+1. Revisar e aprovar este TASKS.md
+2. Executar paralelo: `dare execute --parallel`
+3. Ou task isolada: `/dare-execute task-001`
+```
+
+### Passo 4: Gerar `DARE/dare-dag.yaml` (grafo executável)
+
+Schema canônico:
+
+```yaml
+title: "[Nome do Projeto] - Development Tasks"
+version: "1.0.0"
+
+limits:
+  parent_context_chars: 2000
+  task_output_chars: 4000
+  timeout_seconds: 600
+
+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: |
+      Setup base project structure following DARE/BLUEPRINT.md.
+      Create directories, initialize package files. No business logic yet.
+      Validation gate: project builds.
+
+  - id: task-002
+    title: "DB migrations"
+    depends_on: []
+    complexity: MED
+    spec_file: EXECUTION/task-002.md
+    subtask_prompt: |
+      Create migrations for users and refresh_tokens tables per BLUEPRINT.
+      Include indexes and FKs. Validation gate: migrate runs cleanly.
+```
+
+**Regras inegociáveis (da skill dare-dag-runner):**
+- `id` em kebab-case e único
+- `depends_on` mínimo — só quando filha **literalmente** precisa do output
+- `subtask_prompt` self-contained (subagente recebe só ele + 2000 chars de pais)
+- Pelo menos 2 tasks no rank 0 (`depends_on: []`)
+- Cadeia linear é antipattern — reveja
+
+### Passo 5: Gerar `DARE/EXECUTION/task-<id>.md` (specs detalhadas)
+
+Para CADA task no YAML, crie a spec usando `templates/TASK-SPEC-template.md`:
+
+```markdown
+# Task 001: Setup project structure
+
+## Objetivo
+Criar a estrutura base do projeto seguindo o BLUEPRINT.
+
+## Descrição
+Inicializar diretórios, package files e configuração mínima.
+Sem lógica de negócio — apenas scaffolding.
+
+## Arquivos a Criar
+- `src/` (diretório)
+- `tests/` (diretório)
+- `package.json` (ou equivalente da stack)
+- `.gitignore`
+
+## Validation Gates
+- [ ] Estrutura criada
+- [ ] Build passa sem erros
+- [ ] Lint sem warnings
+- [ ] `package.json` (ou Cargo.toml, composer.json) válido
+
+## Testes
+```bash
+npm run build    # ou cargo build, composer install, etc.
+```
+
+## Segurança
+- `.env` no `.gitignore`
+- Nenhum secret commitado
+
+## Próxima Task
+Task 002: DB migrations
+```
+
+### Passo 6: Validar consistência
+
+Antes de entregar, confirme:
+- [ ] Mesmos `id`s em `TASKS.md`, `dare-dag.yaml` e `EXECUTION/task-*.md`
+- [ ] Mesmas `depends_on` nos três
+- [ ] Mesmas `complexity`
+- [ ] Sem ciclos no grafo
+- [ ] Pelo menos 2 tasks no rank 0
+- [ ] Cada `subtask_prompt` é executável sem contexto adicional
+
+### Passo 7: Pedir aprovação
+
+> Gerados os 3 artefatos da fase de execução:
+> - `DARE/TASKS.md` ([N] tasks)
+> - `DARE/dare-dag.yaml` ([N] ranks paralelos)
+> - `DARE/EXECUTION/task-*.md` ([N] specs)
+>
+> Revise. Quando aprovar, execute: `dare execute --parallel --runner antigravity`.
+
+## Boas práticas
+
+1. **Atômicas:** cada task é independente o suficiente para uma conversa
+2. **Testáveis:** validation gates específicos da stack
+3. **Documentadas:** specs claras e auto-contidas
+4. **Seguras:** integre OWASP nos pontos sensíveis
+5. **Paralelizáveis:** maximize rank 0; minimize cadeias lineares
+
+## Erros comuns a evitar
+
+| Erro | Como corrigir |
+|------|---------------|
+| Cadeia linear `001→002→003→...` | Adicione paralelismo onde a dependência é falsa |
+| `subtask_prompt` referenciando "como combinamos" | Coloque tudo no prompt explicitamente |
+| Tudo em `complexity: HIGH` | Avalie honestamente — HIGH só para lógica crítica |
+| `id` duplicado ou com espaços | Use kebab-case e únicos |
+| Inconsistência entre os 3 artefatos | Revise antes de aprovar |

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

@@ -1,6 +1,11 @@
 # /dare-blueprint
 
-Gera o `DARE/BLUEPRINT.md`, `DARE/dare-dag.yaml` e `DARE/TASKS.md` a partir do DESIGN.md.
+Gera os 4 artefatos a partir do `DARE/DESIGN.md`:
+
+1. `DARE/BLUEPRINT.md` — arquitetura técnica
+2. `DARE/TASKS.md` — visão humana das tasks
+3. `DARE/dare-dag.yaml` — grafo executável pelo CLI
+4. `DARE/EXECUTION/task-<id>.md` — uma spec detalhada por task
 
 ## Como usar
 
@@ -11,55 +16,134 @@ Gera o `DARE/BLUEPRINT.md`, `DARE/dare-dag.yaml` e `DARE/TASKS.md` a partir do D
 
 ## O que fazer
 
-1. **Leia `DARE/DESIGN.md`** — obrigatório. Se não existir, peça para rodar `/dare-design` primeiro.
-
-2. **Gere `DARE/BLUEPRINT.md`** com:
-   - Stack tecnológico detalhado (versões, libs)
-   - Módulos e responsabilidades
-   - Contratos de API (endpoints, schemas em OpenAPI)
-   - Modelo de dados (tabelas, índices, relações)
-   - Decisões arquiteturais com justificativa
-   - Estratégia de testes
-   - Estratégia de deploy
-
-3. **Gere `DARE/dare-dag.yaml`** com tasks em grafo de dependências:
-   ```yaml
-   title: "Projeto X - Development Tasks"
-   version: "1.0.0"
-   models:
-     HIGH: "claude-sonnet-4"
-     MED: "claude-haiku-4"
-     LOW: "claude-haiku-4"
-   tasks:
-     - id: task-001
-       title: "Setup project structure"
-       depends_on: []
-       complexity: LOW
-       subtask_prompt: |
-         Setup base project structure following BLUEPRINT.md.
-   ```
-
-4. **Gere `DARE/TASKS.md`** com tabela de status:
-   ```markdown
-   | ID | Título | Status | Depends On | Complexity |
-   |----|--------|--------|------------|------------|
-   | task-001 | Setup | ⏳ PENDING | - | LOW |
-   ```
-
-5. **Maximize paralelismo:** só adicione `depends_on` quando a task filha REALMENTE não pode começar sem o output da pai.
-
-6. **Aguarde aprovação humana** antes de executar qualquer task.
+### 1. Ler `DARE/DESIGN.md`
+
+Obrigatório. Se não existir, peça para rodar `/dare-design` primeiro.
+
+### 2. Gerar `DARE/BLUEPRINT.md`
+
+- Stack tecnológico detalhado (versões, libs)
+- Módulos e responsabilidades
+- Contratos de API (endpoints, schemas em OpenAPI)
+- Modelo de dados (tabelas, índices, relações)
+- Decisões arquiteturais com justificativa
+- Estratégia de testes
+- Estratégia de deploy
+
+### 3. Gerar `DARE/dare-dag.yaml` (grafo executável)
+
+Schema canônico:
+
+```yaml
+title: "<Nome do Projeto> - Development Tasks"
+version: "1.0.0"
+
+limits:
+  parent_context_chars: 2000   # snippet de output de cada pai injetado no filho
+  task_output_chars: 4000      # cap do output capturado por task
+  timeout_seconds: 600         # AbortController por task
+
+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 — o subagente vê só este texto
+      mais snippets de até 2000 chars de cada pai>
+```
+
+**Regras inegociáveis ao construir o DAG:**
+
+- `id` em kebab-case e único
+- `depends_on` **mínimo** — só adicione quando a task filha *literalmente*
+  não pode começar sem o output da pai (arquivo, schema, decisão exportada)
+- `subtask_prompt` totalmente self-contained — não vale "use o padrão da
+  task-001"
+- Pelo menos 2 tasks no rank 0 (`depends_on: []`) para haver paralelismo
+- Cadeia linear (`001→002→003→...`) é antipattern — reanalise
+- `complexity` honesta: `HIGH` só para lógica crítica/segurança
+- Output cap de 4000 chars: se a task gera muito, escreva em arquivo e
+  retorne só resumo + caminhos
+
+### 4. Gerar `DARE/TASKS.md` (visão humana)
+
+```markdown
+# Tasks: <Nome do Projeto>
+
+## Visão Geral
+- Total de Tasks: N
+- Ranks paralelos: N
+
+## Tabela de Status
+
+| ID       | Título                    | Status      | Depends On       | Complexity |
+|----------|---------------------------|-------------|------------------|------------|
+| task-001 | Setup project structure   | ⏳ PENDING  | —                | LOW        |
+| task-002 | DB migrations             | ⏳ PENDING  | —                | MED        |
+| task-003 | Auth controllers          | ⏳ PENDING  | task-001, 002    | HIGH       |
+```
+
+### 5. Gerar `DARE/EXECUTION/task-<id>.md` (uma por task)
+
+Para CADA task em `dare-dag.yaml`, crie a spec correspondente seguindo
+`templates/TASK-SPEC-template.md`:
+
+- **Objetivo** claro
+- **Arquivos a criar/modificar**
+- **Validation Gates** específicos da stack (PHPUnit, Pytest, Vitest, cargo test)
+- **Testes esperados**
+- **Considerações de segurança**
+- **Próxima task** sugerida
+
+O `subtask_prompt` no YAML pode referenciar `spec_file: EXECUTION/task-001.md`
+para que o subagente leia a spec na hora de executar.
+
+### 6. Validar consistência dos 4 artefatos
+
+Antes de entregar:
+- [ ] Mesmos `id`s em `TASKS.md`, `dare-dag.yaml` e `EXECUTION/task-*.md`
+- [ ] Mesmas `depends_on` nos três
+- [ ] Mesmas `complexity`
+- [ ] Sem ciclos
+- [ ] Pelo menos 2 tasks no rank 0
+- [ ] Cada `subtask_prompt` executável sem contexto adicional
+
+### 7. Aguardar aprovação humana
+
+**Não execute nenhuma task** até o usuário revisar e aprovar os 4 artefatos.
 
 ## Templates disponíveis
 
 - `templates/BLUEPRINT-template.md`
 - `templates/TASKS-template.md`
+- `templates/TASK-SPEC-template.md`
+
+## Próximos passos
 
-## Próximo passo
+Após aprovação humana:
 
-Após aprovação humana, rodar:
 ```bash
-dare execute --parallel
+# Paralelo (recomendado)
+dare execute --parallel --runner claude
+
+# Sequencial (debug)
+dare execute --runner claude
+
+# Task única
+dare execute --task task-003 --runner claude
 ```
 
+Ou pelos slash commands:
+
+- `/dare-dag-run` — executa o DAG completo em paralelo
+- `/dare-execute task-001` — executa uma task específica
+- `/dare-tasks` — mostra status atual das tasks
+
 $ARGUMENTS