@dewtech/dare-cli 2.2.0 → 2.3.1

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

@@ -1,33 +1,45 @@
 ---
 name: dare-dag-runner
-description: Constrói e executa o grafo DAG de tasks do método DARE com paralelismo via Kahn's algorithm. Use quando o BLUEPRINT.md está aprovado e é hora de gerar dare-dag.yaml ou executar tasks em paralelo. Garante schema correto, dependências mínimas e specs consistentes.
+description: Constrói e executa o grafo DAG do método DARE com paralelismo lógico via Kahn's algorithm. Antigravity é o executor — usa o plano nativo da IDE; sem API key. O CLI dare é orquestrador (--next/--complete/--fail).
 ---
 
 # DARE DAG Runner Skill
 
-Você é o orquestrador da fase de execução paralela do método DARE. Seu papel
-é traduzir o BLUEPRINT em um grafo executável (`DARE/dare-dag.yaml`) e
-operar o `dare execute --parallel` com confiança.
+Você é o executor da fase E (Execute) do método DARE no Antigravity. O CLI
+`dare` é o **orquestrador**: ele indica quais tasks executar agora e registra
+o que você terminou. **Você** é quem efetivamente roda cada task usando o
+runtime nativo do Antigravity — não há API key nem custo extra de tokens.
 
 ## Quando usar esta skill
 
-- BLUEPRINT.md foi aprovado e é hora de gerar tasks
-- Existe `DARE/dare-dag.yaml` e você precisa entender, modificar ou rodar
+- BLUEPRINT.md está aprovado e é hora de gerar tasks
+- Existe `DARE/dare-dag.yaml` e você precisa entender, executar ou modificar
 - Aparece o canvas `DARE/.canvas.md` durante uma execução
-- Usuário pede "executa em paralelo" ou "gera o DAG"
+- Usuário pede "executa o DAG" ou "começa o execute"
+
+## Modelo de execução
+
+> **Antigravity é o executor. O CLI `dare` é orquestrador.**
+
+- A IDE já está autenticada
+- Você lê `dare-dag.yaml` e as specs em `DARE/EXECUTION/task-*.md`
+- Você executa cada task — escreve código, roda testes, faz lint
+- Após cada task, registra o resultado no CLI:
+  - `dare execute --complete <task-id> --output "<resumo>"`
+  - `dare execute --fail <task-id> --reason "<mensagem>"`
+- O CLI atualiza `DARE/.canvas.md` e popula o `dare-graph` automaticamente
 
 ## O que é o DAG do DARE
 
-`DARE/dare-dag.yaml` é o **plano de execução** da fase E (Execute) do método.
-É um grafo direcionado acíclico:
+`DARE/dare-dag.yaml` é o **plano de execução** da fase E. Grafo direcionado
+acíclico:
 
 - **Nó** = uma task atômica
-- **Aresta** = `depends_on` (a task filha precisa do output da pai)
+- **Aresta** = `depends_on` (filha precisa do output da pai)
 
-O CLI ordena topologicamente (Kahn's algorithm) e executa tasks do mesmo rank
-em paralelo via `Promise.all`. Tasks sem dependências comuns rodam ao mesmo
-tempo. Outputs dos pais são costurados no contexto dos filhos (snippet de até
-2000 chars cada).
+O CLI ordena topologicamente (Kahn's algorithm). 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       (paralelas)
@@ -42,9 +54,9 @@ title: "<Nome do projeto> - Development Tasks"
 version: "1.0.0"
 
 limits:
-  parent_context_chars: 2000   # snippet de output de cada pai injetado no filho
+  parent_context_chars: 2000   # snippet de output de pai injetado no filho
   task_output_chars: 4000      # cap do output capturado por task
-  timeout_seconds: 600         # AbortController por task
+  timeout_seconds: 600         # apenas referência
 
 models:
   cursor:      { HIGH: gpt-5.3-codex,     MED: composer-2,       LOW: auto-low }
@@ -61,105 +73,96 @@ tasks:
       <prompt completamente self-contained>
 ```
 
-## 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. O id
-aparece no canvas e nos logs.
-
-### 2. `depends_on` mínimo
+## Loop de execução
 
-> Adicione uma dependência **somente** quando a task filha não pode começar
-> sem o output da pai (arquivo, schema, decisão exportada).
-
-| Cenário | Dependência? |
-|---------|--------------|
-| 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 |
-
-Se o seu DAG vira uma cadeia linear `001 → 002 → 003 → ...`, há dependências
-falsas. Reanalise.
-
-### 3. `complexity` mapeia para modelo
-| Nível | Uso típico |
-|-------|------------|
-| `LOW`  | Setup, scaffolding, docs simples, pesquisa |
-| `MED`  | Implementação direta, refactors, testes unitários |
-| `HIGH` | Lógica de negócio crítica, segurança, integrações |
+```
+1. dare execute --next
+   ↓ imprime prompts das tasks ready (rank atual)
+2. Para cada prompt:
+     - leia spec_file se houver
+     - implemente
+     - rode build/test/lint (Ralph Loop)
+3. dare execute --complete <id> --output "<resumo + arquivos tocados>"
+   (ou --fail <id> --reason "..." se falhou)
+4. Volte ao passo 1 até não haver mais tasks ready
+```
 
-Não use `HIGH` em tudo — encarece sem ganho.
+Comandos úteis:
 
-### 4. `subtask_prompt` totalmente self-contained
+```bash
+dare execute --next                                # próximas tasks ready
+dare execute --complete task-001 --output "..."    # marca DONE
+dare execute --fail task-002 --reason "..."        # marca FAILED + cascade
+dare execute --reset task-002                      # volta para PENDING (retry)
+dare execute --status                              # snapshot do canvas
+```
 
-O subagente recebe apenas:
-- O próprio `subtask_prompt`
-- Snippets de até 2000 chars dos outputs de cada pai
-- Acesso ao filesystem do projeto
+## Regras inegociáveis ao construir o DAG
 
-Não vale dizer "use o padrão combinado" ou "como na task-001". Coloque tudo no
-prompt ou faça vir pelos pais.
+### 1. `id` em kebab-case e único
+`task-001`, `auth-jwt`, `db-migrations`.
 
-### 5. Output capado em 4000 chars
+### 2. `depends_on` mínimo
+Só adicione dependência quando a filha **literalmente** precisa do output.
+
+| Cenário | Dep? |
+|---------|------|
+| B precisa do arquivo de A | sim |
+| B precisa de decisão de A | sim |
+| B é independente de A | não |
+| Testes/Docs do módulo X | sim — depende da implementação |
+| Pesquisa sem efeito colateral | não |
+
+Cadeia linear é antipattern. Reanalise.
+
+### 3. `complexity` é sinal de cuidado, não custo
+| Nível | Uso |
+|-------|-----|
+| `LOW`  | Setup, scaffolding, docs simples |
+| `MED`  | Implementação direta, refactors, testes unitários |
+| `HIGH` | Lógica crítica, segurança, integrações |
 
-Se a task gera muito, escreva em arquivo e faça o output ser um resumo curto +
-caminhos dos arquivos criados.
+### 4. `subtask_prompt` self-contained
+Receberá `subtask_prompt` + snippets de até 2000 chars dos outputs dos pais.
+Não vale "como combinamos". Tudo no prompt ou via pais.
 
-### 6. Cada task tem spec em `EXECUTION/task-<id>.md`
+### 5. Output cap 4000 chars
+Se gerar muito, escreva em arquivo e faça o `--output` ser resumo + caminhos.
 
-Spec detalhada com: objetivo, arquivos a criar/modificar, validation gates,
-testes esperados, segurança. O `subtask_prompt` referencia
-`spec_file: EXECUTION/task-001.md` para que o subagente leia a spec.
+### 6. Spec por task em `EXECUTION/task-<id>.md`
+Spec detalhada com objetivo, arquivos, validation gates, testes, segurança.
 
 ## Os 3 artefatos sempre juntos
 
-Quando gerar tasks, produza simultaneamente:
-
-1. **`DARE/TASKS.md`** — tabela master para humanos
-2. **`DARE/dare-dag.yaml`** — grafo executável pelo CLI
-3. **`DARE/EXECUTION/task-<id>.md`** — uma spec detalhada por task
-
-Os três precisam estar consistentes: mesmo `id`, mesmo `depends_on`, mesma
-`complexity`. Inconsistência aqui quebra a execução.
-
-## Como executar
-
-```bash
-dare execute --parallel              # paralelo, runner padrão
-dare execute --parallel --runner antigravity
-dare execute                         # sequencial (debug)
-dare execute --task task-003         # task única
-dare execute --parallel --resume     # só PENDING/FAILED
-```
+| Arquivo | Para quê |
+|---------|----------|
+| `DARE/TASKS.md` | Visão humana com tabela e progresso |
+| `DARE/dare-dag.yaml` | Grafo executável |
+| `DARE/EXECUTION/task-<id>.md` | Spec por task |
 
-Env vars necessárias por runner:
-- `CURSOR_API_KEY` — runner cursor
-- `ANTHROPIC_API_KEY` — runner claude
-- `ANTIGRAVITY_API_KEY` — runner antigravity
+Os três precisam ser consistentes: mesmos `id`s, `depends_on`, `complexity`.
 
 ## Canvas ao vivo (`DARE/.canvas.md`)
 
-O runner reescreve `DARE/.canvas.md` a cada mudança de status. Status:
-- `PENDING` ⏳ — aguardando rank
-- `RUNNING` 🔄 — executando agora
-- `DONE` ✅ — concluído com sucesso
-- `FAILED` ❌ — erro durante execução
-- `SKIPPED` ⏭️ — dependência falhou; runner pulou automaticamente
+O CLI reescreve a cada `--complete`/`--fail`:
 
-Você não precisa intervir em `SKIPPED` — o runner cuida.
+| Status | Significado |
+|--------|-------------|
+| `PENDING` ⏳ | aguardando rank |
+| `RUNNING` 🔄 | você está executando |
+| `DONE` ✅ | concluído |
+| `FAILED` ❌ | erro durante execução |
+| `SKIPPED` ⏭️ | dependência falhou — automático, não toque |
 
 ## Erros comuns
 
-| Erro | Sintoma | Correção |
-|------|---------|----------|
-| Ciclo | `Circular dependency detected: <id>` | Retire a aresta cíclica |
-| `id` duplicado | Resultado indefinido | Renomeie |
-| `depends_on` inexistente | `Task not found: <id>` | Corrija ou adicione |
-| Tudo em rank 0 | Conflito de escrita no mesmo arquivo | Adicione dependências reais |
-| Cadeia linear | Sem paralelismo | Reveja se as deps são necessárias |
+| Erro | Correção |
+|------|----------|
+| Ciclo | Retire a aresta cíclica |
+| `id` duplicado | Renomeie |
+| `depends_on` inexistente | Corrija ou adicione a task |
+| Tudo em rank 0 | Adicione deps reais quando há contenção |
+| Cadeia linear | Reveja se as deps são necessárias |
 
 ## Checklist antes de aprovar
 
@@ -169,4 +172,4 @@ Você não precisa intervir em `SKIPPED` — o runner cuida.
 - [ ] `complexity` reflete o esforço real
 - [ ] `id` em kebab-case e único
 - [ ] Sem ciclos
-- [ ] `TASKS.md` + `dare-dag.yaml` + `EXECUTION/task-*.md` consistentes
+- [ ] Os 3 artefatos consistentes

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

@@ -1,23 +1,24 @@
 # /dare-dag-run
 
-Executa o grafo de tasks definido em `DARE/dare-dag.yaml` em paralelo,
-respeitando dependências (Kahn's algorithm + execução por rank). O canvas
-ao vivo é gravado em `DARE/.canvas.md`.
+Executa o grafo de tasks definido em `DARE/dare-dag.yaml` usando **Claude
+Code como executor** e o CLI `dare` como orquestrador. O canvas ao vivo fica
+em `DARE/.canvas.md`.
+
+> **Sem API keys.** Você (Claude Code) usa o plano da IDE/CLI em que o
+> usuário já está autenticado. O CLI apenas coordena estado, monta prompts
+> e atualiza canvas.
 
 ## Pré-requisitos
 
-- `DARE/dare-dag.yaml` existe e foi aprovado pelo usuário
+- `DARE/dare-dag.yaml` existe e foi aprovado
 - Specs em `DARE/EXECUTION/task-<id>.md` geradas
-- `ANTHROPIC_API_KEY` exportada no ambiente (runner padrão para o Claude)
+- `dare` disponível no PATH (`npm i -g @dewtech/dare-cli`)
 
 ## Como usar
 
 ```
-/dare-dag-run                    # paralelo, runner claude
-/dare-dag-run --resume           # só PENDING/FAILED
-/dare-dag-run --task task-003    # task única
-/dare-dag-run --sequential       # debug
-/dare-dag-run --runner cursor    # trocar de runner
+/dare-dag-run
+/dare-dag-run --task task-003    # executar só uma task específica
 ```
 
 ## O que fazer
@@ -25,86 +26,84 @@ ao vivo é gravado em `DARE/.canvas.md`.
 ### 1. Validar pré-condições
 
 - Confirme que `DARE/dare-dag.yaml` existe. Se não, oriente
-  `/dare-blueprint` ou `/dare-dag-build`.
-- Leia o YAML e verifique:
-  - Sem ciclos
-  - Pelo menos 2 tasks no rank 0
-  - Cada task tem `id` único, `complexity`, `subtask_prompt`
-- Confirme `ANTHROPIC_API_KEY` (ou a env var do runner escolhido).
+  `/dare-blueprint` ou `/dare-dag-build`
+- Leia o YAML e verifique sem ciclos, ids únicos, ranks paralelizáveis
 
-### 2. Escolher modo de execução
+### 2. Pegar próximas tasks
 
-| Modo | Comando |
-|------|---------|
-| Paralelo (recomendado) | `dare execute --parallel --runner claude` |
-| Sequencial (debug) | `dare execute --runner claude` |
-| Task única | `dare execute --task <id> --runner claude` |
-| Resume (PENDING/FAILED) | `dare execute --parallel --runner claude --resume` |
+```bash
+dare execute --next
+```
 
-### 3. Sugerir abrir o canvas ao vivo
+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.
 
-Antes de rodar, peça ao usuário abrir `DARE/.canvas.md` em outra aba do
-editor. O runner reescreve o arquivo a cada transição de status:
+### 3. Sugerir abrir o canvas
 
+Antes de começar, peça ao usuário abrir `DARE/.canvas.md` em outra aba.
+
+### 4. Executar cada task
+
+Para cada task ready:
+
+1. Leia `spec_file` se houver
+2. Implemente conforme o prompt
+3. Rode Ralph Loop: build → test → lint
+4. Registre o resultado:
+
+```bash
+# Sucesso
+dare execute --complete task-001 --output "Resumo + arquivos criados (paths)"
+
+# Falha
+dare execute --fail task-002 --reason "Mensagem clara da falha"
 ```
-| ID       | Title              | Status        | Duration | Tokens |
-|----------|--------------------|---------------|----------|--------|
-| task-001 | Setup structure    | ✅ DONE       | 1240ms   | 850    |
-| task-002 | DB schema          | 🔄 RUNNING    | -        | -      |
-| task-003 | Core endpoints     | ⏳ PENDING    | -        | -      |
-```
 
-### 4. Executar e monitorar
+### 5. Avançar de rank
+
+```bash
+dare execute --next
+```
 
-Rode o comando escolhido. Durante a execução:
+Se aparece `✅ All tasks resolved`, todas terminaram. Caso contrário, continue.
 
-- **Não interrompa por `SKIPPED`** — o runner pula automaticamente quando
-  uma dependência falha. Esse é comportamento esperado.
-- Se uma task falhar, leia o erro no terminal/canvas e corrija a spec em
-  `EXECUTION/task-<id>.md` ou o `subtask_prompt` no `dare-dag.yaml`. Depois
-  re-execute com `--resume`.
-- Use `Ctrl+C` para cancelar — o runner trata SIGINT e finaliza limpamente.
+### 6. Pós-execução
 
-### 5. Pós-execução
+```bash
+dare execute --status
+```
 
-Ao terminar:
+Para retentar tasks FAILED:
 
-- Atualize `DARE/TASKS.md` com os status finais (DONE/FAILED/SKIPPED)
-- Mostre um resumo:
-  - Total DONE / FAILED / SKIPPED
-  - Duração total
-  - Tokens consumidos
-  - Tasks que precisam atenção (FAILED)
-- Se houver FAILED, sugira:
-  1. Ler `EXECUTION/task-<id>.md` da que falhou
-  2. Corrigir spec ou prompt
-  3. Re-executar: `/dare-dag-run --resume`
-- Se tudo DONE, parabenize e oriente próxima feature/blueprint
+```bash
+dare execute --reset task-002
+dare execute --next
+```
 
-## Variáveis de ambiente por runner
+## Comandos do orquestrador
 
-| Runner | Env var |
-|--------|---------|
-| `claude` (default no Claude Code) | `ANTHROPIC_API_KEY` |
-| `cursor` | `CURSOR_API_KEY` |
-| `antigravity` | `ANTIGRAVITY_API_KEY` |
+| 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 do canvas + sumário |
 
 ## Erros comuns
 
 | Sintoma | Causa | Correção |
 |---------|-------|----------|
-| `dare-dag.yaml not found` | Grafo não foi gerado | `/dare-blueprint` ou `/dare-dag-build` |
-| `Circular dependency detected` | Ciclo no grafo | Edite o YAML para remover |
-| `ANTHROPIC_API_KEY not set` | Env var faltando | `export ANTHROPIC_API_KEY=...` |
-| Cascata de SKIPPED | Pai falhou e bloqueou descendentes | Corrija pai, use `--resume` |
-| Output truncado em 4000 chars | Cap de output | Faça a task escrever em arquivo e retornar resumo |
-| Timeout (>600s) | Task longa demais | Quebre em sub-tasks ou aumente `limits.timeout_seconds` |
+| `dare-dag.yaml not found` | Não foi gerado | `/dare-blueprint` ou `/dare-dag-build` |
+| Cascata de SKIPPED | Pai falhou | Corrija pai → `--reset` → `--next` |
+| Output truncado | Cap de 4000 chars | Escreva em arquivo, retorne resumo |
+| Spec inconsistente | TASKS.md ≠ dare-dag.yaml | Re-gere com `/dare-dag-build` |
 
 ## Referências
 
-- Schema do grafo: `DARE/dare-dag.yaml`
-- Canvas ao vivo: `DARE/.canvas.md`
-- Specs por task: `DARE/EXECUTION/task-*.md`
-- Status humano: `DARE/TASKS.md`
+- Schema: `DARE/dare-dag.yaml`
+- Canvas: `DARE/.canvas.md`
+- Specs: `DARE/EXECUTION/task-*.md`
+- Status: `DARE/TASKS.md`
 
 $ARGUMENTS

package/templates/ide/cursor/.cursor/commands/run-dag.md

@@ -1,85 +1,108 @@
 # Comando: /run-dag
 
 ## Descrição
-Executa o grafo de tasks definido em `DARE/dare-dag.yaml` em paralelo
-respeitando dependências (Kahn's algorithm + Promise.all por rank). O canvas
-ao vivo é gravado em `DARE/.canvas.md`.
+
+Executa o grafo de tasks definido em `DARE/dare-dag.yaml` usando o **Cursor
+como executor** e o CLI `dare` como orquestrador. O canvas ao vivo fica em
+`DARE/.canvas.md`.
+
+> **Sem API keys.** Você (Cursor) usa o plano da IDE em que o usuário já está
+> logado. O CLI apenas coordena estado, monta prompts e atualiza canvas.
 
 ## Pré-requisitos
 
 - `DARE/dare-dag.yaml` existe e foi aprovado pelo usuário
 - Specs em `DARE/EXECUTION/task-<id>.md` geradas
-- `CURSOR_API_KEY` exportada no ambiente
+- `dare` disponível no PATH (`npm i -g @dewtech/dare-cli`)
 
 ## Instruções para o Cursor Composer
 
 ### 1. Validar pré-condições
 
 - Confirme que `DARE/dare-dag.yaml` existe. Se não, oriente o usuário a rodar
-  `/generate-tasks` primeiro.
+  `/generate-tasks` primeiro
 - Leia o YAML e verifique:
   - Sem ciclos
-  - Pelo menos 2 tasks no rank 0 (paralelismo real)
-  - Cada `task` tem `id` único, `complexity`, `subtask_prompt`
-- Confira `CURSOR_API_KEY`. Se faltar, peça ao usuário exportar.
+  - Pelo menos 2 tasks no rank 0 (paralelismo lógico)
+  - Cada task tem `id` único, `complexity`, `subtask_prompt`
+
+### 2. Pegar próximas tasks
+
+```bash
+dare execute --next
+```
+
+O CLI imprime as tasks ready do rank atual com o prompt completo (já com
+snippets dos outputs dos pais costurados). Use exatamente esses prompts.
 
-### 2. Escolher o modo de execução
+### 3. Sugerir abrir o canvas
 
-Pergunte ao usuário (ou infira do `$ARGUMENTS`) qual modo:
+Antes de começar, peça ao usuário abrir `DARE/.canvas.md` em uma aba para
+acompanhar o progresso ao vivo.
 
-| Modo | Comando |
-|------|---------|
-| Paralelo (recomendado) | `dare execute --parallel --runner cursor` |
-| Sequencial (debug) | `dare execute --runner cursor` |
-| Task única | `dare execute --task <id> --runner cursor` |
-| Resume (só PENDING/FAILED) | `dare execute --parallel --runner cursor --resume` |
+### 4. Executar cada task
 
-### 3. Abrir o canvas em paralelo à execução
+Para cada task ready:
 
-Antes de rodar, sugira ao usuário abrir `DARE/.canvas.md` em uma aba para
-acompanhar o progresso ao vivo. O runner reescreve o arquivo a cada transição
-de status.
+1. Leia `spec_file` se houver
+2. Implemente conforme o prompt
+3. Rode Ralph Loop: build → test → lint
+4. Registre o resultado:
 
-### 4. Executar e monitorar
+```bash
+# Sucesso
+dare execute --complete task-001 --output "Resumo + arquivos criados/modificados (paths)"
 
-Rode o comando escolhido. Durante a execução:
+# Falha
+dare execute --fail task-002 --reason "Mensagem clara da falha"
+```
 
-- Não interrompa por `SKIPPED` — o runner pula automaticamente quando uma
-  dependência falha
-- Se uma task falhar, leia o erro no terminal/canvas e corrija a spec em
-  `EXECUTION/task-<id>.md` ou o `subtask_prompt` no `dare-dag.yaml`
-- Use `--resume` para retomar sem refazer tasks DONE
+### 5. Avançar de rank
 
-### 5. Pós-execução
+Após registrar todos os `--complete`/`--fail` do rank atual:
+
+```bash
+dare execute --next
+```
+
+Se aparece `✅ All tasks resolved`, todas as tasks terminaram. Caso contrário,
+continue executando o próximo rank.
+
+### 6. Pós-execução
 
 Ao terminar:
 
-- Atualize `DARE/TASKS.md` com os status finais (DONE/FAILED/SKIPPED)
-- Mostre um resumo: total DONE, FAILED, SKIPPED, duração total, tokens
-- Se houver FAILED, sugira diagnóstico e re-execução com `--resume`
-- Se tudo DONE, parabenize e oriente próximo blueprint/feature
+- Rode `dare execute --status` para ver o sumário final
+- Se houver FAILED: leia `DARE/EXECUTION/task-<id>.md` da que falhou,
+  corrija a spec ou o prompt, depois:
+
+  ```bash
+  dare execute --reset task-002    # volta para PENDING
+  dare execute --next              # tente novamente
+  ```
 
-## Variáveis de ambiente por runner
+## Comandos disponíveis
 
-| Runner | Env var |
-|--------|---------|
-| `cursor` (default) | `CURSOR_API_KEY` |
-| `claude` | `ANTHROPIC_API_KEY` |
-| `antigravity` | `ANTIGRAVITY_API_KEY` |
+| Comando | Função |
+|---------|--------|
+| `dare execute --next` | Imprime tasks ready do rank atual com prompts |
+| `dare execute --complete <id> --output "…"` | Marca DONE |
+| `dare execute --fail <id> --reason "…"` | Marca FAILED + cascade-skip |
+| `dare execute --reset <id>` | Volta para PENDING (retry) |
+| `dare execute --status` | Snapshot do canvas + sumário |
 
 ## Erros comuns
 
 | Sintoma | Causa | Correção |
 |---------|-------|----------|
-| `dare-dag.yaml not found` | Arquivo não foi gerado | Rode `/generate-tasks` |
-| `Circular dependency detected` | Ciclo no grafo | Edite `dare-dag.yaml` para remover |
-| `CURSOR_API_KEY not set` | Env var faltando | `export CURSOR_API_KEY=...` |
-| Muitos `SKIPPED` em cascata | Pai falhou e bloqueou descendentes | Corrija o pai e use `--resume` |
-| Output truncado | Cap de 4000 chars | Faça a task escrever em arquivo e retornar resumo |
+| `dare-dag.yaml not found` | Não foi gerado | Rode `/generate-tasks` |
+| Cascata de SKIPPED | Pai falhou | Corrija pai → `--reset` → `--next` |
+| Output truncado em 4000 chars | Cap normal | Faça a task escrever em arquivo, retorne resumo |
+| Tudo no rank 0 disputa o mesmo arquivo | Ausência de deps reais | Edite `dare-dag.yaml` adicionando `depends_on` |
 
 ## Referências
 
-- Skill: `.cursor/rules/skill-dag-runner.mdc` (regras do DAG)
+- Skill: `.cursor/rules/skill-dag-runner.mdc`
 - Schema: `DARE/dare-dag.yaml`
 - Canvas: `DARE/.canvas.md`
 - Specs: `DARE/EXECUTION/task-*.md`