@dewtech/dare-cli 3.1.0 → 3.3.0

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

@@ -0,0 +1,26 @@
+# /dare-info
+
+Mostra versão do CLI, caminhos relevantes e a integridade da instalação DARE no projeto atual.
+
+> Este comando expõe o CLI `dare info` na IDE. O agente pode **rodar o comando no terminal** e interpretar a saída.
+
+## Quando usar
+
+- Algo parece errado no setup e você quer um diagnóstico rápido.
+- Para confirmar a versão do CLI e os artefatos DARE presentes.
+
+## Como rodar
+
+```bash
+dare info
+```
+
+## O que fazer
+
+1. Rode `dare info`.
+2. Revise versão, caminhos e a checagem de integridade.
+3. Se houver artefatos faltando/desatualizados, rode `/dare-update`.
+
+## Comandos relacionados
+
+`/dare-update` · `/dare-welcome`

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

@@ -0,0 +1,30 @@
+# /dare-init
+
+Cria um projeto DARE do zero (greenfield) com setup interativo: escolhe stack backend/frontend, knowledge graph, IDE e gera o scaffolder completo + DNA DARE.
+
+> Este comando expõe o CLI `dare init` na IDE. O agente pode **rodar o comando no terminal** e interpretar a saída.
+
+## Quando usar
+
+- O usuário quer começar um projeto **novo** do zero.
+- Não existe código ainda — é greenfield. Para projeto legado, use `/dare-discover`.
+
+## Como rodar
+
+```bash
+dare init                       # fluxo interativo completo
+dare init minha-api --stack node-nestjs
+dare init meu-mcp --mcp node-ts --transport http
+dare init api --stack go-gin --toolchain docker --non-interactive
+```
+
+## O que fazer
+
+1. Rode `dare init` (ou com `--stack`/`--mcp` se o usuário já decidiu a stack).
+2. Responda aos prompts: nome, stack backend, frontend opcional, knowledge graph (json/sqlite/neo4j), IDE(s).
+3. Ao final, o projeto tem scaffolder + os 7 artefatos de DNA + comandos/skills de IDE instalados.
+4. Próximo passo: descreva a ideia com `/dare-design`.
+
+## Comandos relacionados
+
+`/dare-design` · `/dare-discover` · `/dare-bootstrap`

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

@@ -0,0 +1,30 @@
+# /dare-skill
+
+Adiciona, remove, lista, inspeciona, atualiza ou publica skills DARE neste projeto.
+
+> Este comando expõe o CLI `dare skill` na IDE. O agente pode **rodar o comando no terminal** e interpretar a saída.
+
+## Quando usar
+
+- Você quer instalar uma skill extra (ex.: uma skill de stack) no projeto.
+- Quer listar/inspecionar as skills disponíveis ou publicar uma própria.
+
+## Como rodar
+
+```bash
+dare skill list
+dare skill info <nome>
+dare skill add <nome>
+dare skill remove <nome>
+dare skill update
+```
+
+## O que fazer
+
+1. Use `dare skill list` para ver o que está instalado/disponível.
+2. Rode o subcomando desejado (`add`/`remove`/`info`/`update`/`publish`).
+3. Confirme o resultado e, se mudou comandos de IDE, recarregue a IDE.
+
+## Comandos relacionados
+
+`/dare-update` · `/dare-info`

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

@@ -0,0 +1,28 @@
+# /dare-update
+
+Sincroniza os artefatos do projeto (comandos de IDE, skills, templates) com a versão instalada do DARE CLI, preservando customizações.
+
+> Este comando expõe o CLI `dare update` na IDE. O agente pode **rodar o comando no terminal** e interpretar a saída.
+
+## Quando usar
+
+- Depois de atualizar o `@dewtech/dare-cli` para uma versão nova.
+- Quando `dare info` apontar artefatos desatualizados.
+
+## Como rodar
+
+```bash
+dare update --dry-run     # mostra o que mudaria, sem escrever
+dare update -y            # aplica tudo, mantém customizações
+dare update --target 3.2.0
+```
+
+## O que fazer
+
+1. Rode `dare update --dry-run` e revise o diff proposto.
+2. Se estiver ok, rode `dare update -y`.
+3. Evite `--force` salvo se o usuário aceitar sobrescrever arquivos customizados.
+
+## Comandos relacionados
+
+`/dare-info` · `/dare-welcome`

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

@@ -0,0 +1,28 @@
+# /dare-validate
+
+Valida `DARE/dare-dag.yaml` (ciclos, referências quebradas, campos obrigatórios). Adequado para pre-commit hooks e CI.
+
+> Este comando expõe o CLI `dare validate` na IDE. O agente pode **rodar o comando no terminal** e interpretar a saída.
+
+## Quando usar
+
+- Antes de commitar mudanças no DAG.
+- Em CI, como gate de integridade do plano de execução.
+
+## Como rodar
+
+```bash
+dare validate
+dare validate --strict          # trata warnings como erros (CI-friendly)
+dare validate --dag DARE/dare-dag.yaml
+```
+
+## O que fazer
+
+1. Rode `dare validate` (use `--strict` em CI).
+2. Se houver erros, corrija o `dare-dag.yaml` apontado e rode de novo até passar.
+3. Saída limpa = DAG íntegro e pronto para `/dare-execute`.
+
+## Comandos relacionados
+
+`/dare-dag` · `/dare-execute`

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

@@ -0,0 +1,25 @@
+# /dare-welcome
+
+Mostra o banner do DARE e um guia de início rápido com o fluxo Design → Architecture → Review → Execute.
+
+> Este comando expõe o CLI `dare welcome` na IDE. O agente pode **rodar o comando no terminal** e interpretar a saída.
+
+## Quando usar
+
+- Primeiro contato com o DARE neste projeto.
+- O usuário quer relembrar o fluxo canônico de comandos.
+
+## Como rodar
+
+```bash
+dare welcome
+```
+
+## O que fazer
+
+1. Rode `dare welcome`.
+2. Apresente o fluxo: `/dare-design` → `/dare-blueprint` → `/dare-tasks` → `/dare-execute`.
+
+## Comandos relacionados
+
+`/dare-design` · `/dare-info`

package/templates/ide/cursor/.cursor/commands/dare-bench.md

@@ -0,0 +1,18 @@
+# Comando: /dare-bench
+
+Roda o harness determinístico de fixtures de verificação (`dare bench`) — mede Fix·Rate e solve-rate contra patches versionados.
+
+> Este comando expõe o CLI `dare bench` na IDE.
+
+## Como rodar
+
+```bash
+dare bench --suite fixtures/bench --json
+dare bench --suite fixtures/bench --baseline bench-baseline.json --fail-on-regression 3
+```
+
+## O que fazer
+
+1. Rode `dare bench` com `--json` para relatório estruturado.
+2. Compare com `--baseline` em CI; exit 1 = regressão > limiar pp.
+3. Exit 2 = suite inválida/ausente.

package/templates/ide/cursor/.cursor/commands/{generate-blueprint.md → dare-blueprint.md}

@@ -1,4 +1,4 @@
-# Comando: /generate-blueprint
+# Comando: /dare-blueprint
 
 ## Descrição
 Avança o DARE para a fase Architect: lê `DARE/DESIGN.md` aprovado e gera **somente** `DARE/BLUEPRINT.md`.

package/templates/ide/cursor/.cursor/commands/dare-bootstrap.md

@@ -0,0 +1,27 @@
+# Comando: /dare-bootstrap
+
+Executa o scaffolder oficial da stack registrada em `dare.config.json` para materializar o esqueleto do framework no projeto atual.
+
+> Este comando expõe o CLI `dare bootstrap` na IDE. O agente pode **rodar o comando no terminal** e interpretar a saída.
+
+## Quando usar
+
+- Logo após `dare init`, para gerar o esqueleto real do framework.
+- Quando `dare.config.json` existe mas os artefatos do framework ainda não foram gerados.
+
+## Como rodar
+
+```bash
+dare bootstrap
+dare bootstrap --force   # roda mesmo se já houver artefatos (pode sobrescrever)
+```
+
+## O que fazer
+
+1. Confirme que existe `dare.config.json` com a stack definida.
+2. Rode `dare bootstrap` (use `--force` apenas se o usuário aceitar sobrescrever arquivos existentes).
+3. Verifique a saída: arquivos gerados e próximos passos sugeridos pelo CLI.
+
+## Comandos relacionados
+
+`/dare-init` · `/dare-design`

package/templates/ide/cursor/.cursor/commands/{run-dag.md → dare-dag-run.md}

@@ -1,4 +1,4 @@
-# Comando: /run-dag
+# Comando: /dare-dag-run
 
 ## Descrição
 

package/templates/ide/cursor/.cursor/commands/{dag-viz.md → dare-dag-viz.md}

@@ -1,4 +1,4 @@
-# Comando: /dag-viz
+# Comando: /dare-dag-viz
 
 ## Descrição
 

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

@@ -0,0 +1,27 @@
+# Comando: /dare-dag
+
+Mostra o DAG estático de tasks (`DARE/dare-dag.yaml`): ranks, dependências e caminho crítico. Use `dare dag viz` para exportar o diagrama.
+
+> Este comando expõe o CLI `dare dag` na IDE. O agente pode **rodar o comando no terminal** e interpretar a saída.
+
+## Quando usar
+
+- Você quer ver a ordem de execução, os ranks e o caminho crítico das tasks.
+- Antes de começar a execução, para conferir a topologia do plano.
+
+## Como rodar
+
+```bash
+dare dag viz
+dare dag viz --dag DARE/dare-dag.yaml
+```
+
+## O que fazer
+
+1. Rode `dare dag viz` para renderizar o grafo de tasks.
+2. Confira ranks e dependências; tasks de mesmo rank podem rodar em paralelo.
+3. Para validar a integridade do arquivo, use `/dare-validate`. Para executar, `/dare-execute`.
+
+## Comandos relacionados
+
+`/dare-validate` · `/dare-execute` · `/dare-graph`

package/templates/ide/cursor/.cursor/commands/{generate-design.md → dare-design.md}

@@ -1,4 +1,4 @@
-# Comando: /generate-design
+# Comando: /dare-design
 
 ## Descrição
 Inicia o Método DARE (fase Design) gerando `DARE/DESIGN.md` a partir de uma ideia inicial.

package/templates/ide/cursor/.cursor/commands/dare-discover.md

@@ -0,0 +1,28 @@
+# Comando: /dare-discover
+
+Detecta a stack de um projeto já existente (brownfield) e instala os arquivos da metodologia DARE — incluindo os comandos/skills de IDE — sem tocar no código.
+
+> Este comando expõe o CLI `dare discover` na IDE. O agente pode **rodar o comando no terminal** e interpretar a saída.
+
+## Quando usar
+
+- O usuário quer adotar o DARE em um repositório que **já existe**.
+- Para entender/documentar o legado em profundidade depois, encadeie com `/dare-reverse` e `/dare-dna`.
+
+## Como rodar
+
+```bash
+dare discover
+dare discover --dir ./caminho/do/projeto
+dare discover --check    # só mostra a detecção, sem instalar nada
+```
+
+## O que fazer
+
+1. Rode `dare discover --check` primeiro para revisar a stack detectada.
+2. Se a detecção estiver correta, rode `dare discover` para instalar os artefatos DARE + comandos de IDE.
+3. Próximo passo: `/dare-reverse` (Fase 0 — coleta) e `/dare-dna` (convenções).
+
+## Comandos relacionados
+
+`/dare-reverse` · `/dare-dna` · `/dare-migrate`

package/templates/ide/cursor/.cursor/commands/dare-dna.md

@@ -0,0 +1,75 @@
+# Comando: /dare-dna
+
+Camada semântica da extração de DNA do projeto. 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.
+
+## Como usar
+
+```
+/dare-dna                 # preenche o PROJECT-DNA.md gerado por `dare dna`
+```
+
+> Pré-requisito: rodar `dare dna` antes (gera `DARE/PROJECT-DNA.md` e `DARE/dna-facts.json`).
+> Se não existirem, instrua o usuário a 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 objetivo é um **ruleset** que faça o agente seguir o padrão da casa, não o default genérico.
+
+## 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** (um controller, um service, um model, um teste) para
+  inferir os padrões que o CLI não detecta (tratamento de erro, validação, estilo de teste).
+
+### 2. Preencher `DARE/PROJECT-DNA.md`
+
+Substitua cada bloco `<!-- AGENT: ... -->`:
+
+- **Convenções de Nomenclatura** — confirme o estilo detectado e documente exceções (ex.: componentes
+  em PascalCase, utilitários em kebab).
+- **Arquitetura & Camadas** — nomeie o padrão com confiança (MVC / Layered / Hexagonal) e escreva as
+  **regras de onde cada coisa mora** (ex.: "controllers só orquestram; regra de negócio vai em services;
+  acesso a dados só em repositories").
+- **Padrões de Teste** — onde os testes ficam, naming, assertions reais (não `expect(true)`), uso de
+  mocks/fixtures.
+- **Tratamento de Erros & Validação** — como o projeto trata erros (exceptions, Result/Either, try/catch)
+  e valida inputs. Dê **exemplos concretos** do código real.
+- **Regras de Ouro do Projeto** — liste o que **SEMPRE** e o que **NUNCA** fazer neste codebase.
+- **⚠️ Incertezas / Inconsistências** — convenções ambíguas/misturadas que o humano precisa decidir.
+
+**Não toque** nos fatos determinísticos já preenchidos pelo CLI (tooling, tabela de naming, libs).
+
+### 3. Apresentar ao usuário
+
+Resumo: arquitetura nomeada, principais regras de ouro, inconsistências encontradas. Reforce que o
+`PROJECT-DNA.md` vira referência para `/dare-feature-design` e `/dare-execute` respeitarem o legado.
+
+## Regras de ouro
+
+1. **Descritivo, não aspiracional** — documente como o código É, não como deveria ser.
+2. **Exemplos reais** — cite arquivos/trechos do próprio projeto nas regras.
+3. **Sinalize inconsistência** — se o legado mistura padrões, diga isso em "⚠️ Incertezas", não invente um padrão único.
+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 gerados pelo CLI.
+
+## Antipatterns
+
+| AP | Antipattern | Por quê |
+|---|---|---|
+| AP-01 | Documentar o padrão "ideal" em vez do real | O agente vai gerar código fora do estilo do legado |
+| AP-02 | Forçar um padrão único onde o legado é inconsistente | Esconde a realidade; melhor sinalizar a incerteza |
+| 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á na regra específica do projeto |
+| AP-05 | Ignorar os testes existentes ao descrever o estilo de teste | Nova feature nasce inconsistente |
+
+$ARGUMENTS
+
+---
+
+Skill MIT — parte do DARE Method. DNA do projeto (brownfield). Pareia com o comando `dare dna`.

package/templates/ide/cursor/.cursor/commands/{generate-docker-compose.md → dare-docker-compose.md}

@@ -1,4 +1,4 @@
-# Comando: /generate-docker-compose
+# Comando: /dare-docker-compose
 
 ## Descrição
 Este comando analisa a arquitetura definida no BLUEPRINT.md e gera um `docker-compose.yml` completo com todos os serviços necessários (App, DB, Cache, etc).

package/templates/ide/cursor/.cursor/commands/{generate-dockerfile.md → dare-dockerfile.md}

@@ -1,4 +1,4 @@
-# Comando: /generate-dockerfile
+# Comando: /dare-dockerfile
 
 ## Descrição
 Este comando analisa a stack do projeto (definida no DESIGN.md ou .cursorrules) e gera um `Dockerfile` otimizado para produção e desenvolvimento.

package/templates/ide/cursor/.cursor/commands/{execute-task.md → dare-execute.md}

@@ -1,4 +1,4 @@
-# Comando: /execute-task
+# Comando: /dare-execute
 
 ## Descrição
 Este comando finaliza o Método DARE (Execute) implementando o código e validando os testes de uma tarefa específica isolada.

package/templates/ide/cursor/.cursor/commands/dare-graph.md

@@ -0,0 +1,30 @@
+# Comando: /dare-graph
+
+Consulta e visualiza o grafo de conhecimento do projeto (tasks, arquivos, schemas, endpoints, componentes, entidades e suas relações).
+
+> Este comando expõe o CLI `dare graph` na IDE. O agente pode **rodar o comando no terminal** e interpretar a saída.
+
+## Quando usar
+
+- Você quer entender dependências entre tasks/arquivos/entidades.
+- Precisa achar nós relacionados a um termo, ou exportar um diagrama do grafo.
+
+## Como rodar
+
+```bash
+dare graph stats                       # contagem de nós/arestas por tipo
+dare graph query <termo> --limit 10    # busca nós por label/descrição
+dare graph query auth --type endpoint
+dare graph viz --format mermaid -o graph.mmd
+dare graph ingest                      # re-sincroniza o grafo do dare-dag.yaml
+```
+
+## O que fazer
+
+1. Escolha o subcomando conforme a intenção: `stats`, `query <termo>`, `viz`, `ingest`.
+2. Rode o comando e interprete a saída (para `viz`, abra/renderize o diagrama gerado).
+3. Se o grafo parecer desatualizado, rode `dare graph ingest` para re-sincronizar.
+
+## Comandos relacionados
+
+`/dare-dag` · `/dare-execute`

package/templates/ide/cursor/.cursor/commands/dare-info.md

@@ -0,0 +1,26 @@
+# Comando: /dare-info
+
+Mostra versão do CLI, caminhos relevantes e a integridade da instalação DARE no projeto atual.
+
+> Este comando expõe o CLI `dare info` na IDE. O agente pode **rodar o comando no terminal** e interpretar a saída.
+
+## Quando usar
+
+- Algo parece errado no setup e você quer um diagnóstico rápido.
+- Para confirmar a versão do CLI e os artefatos DARE presentes.
+
+## Como rodar
+
+```bash
+dare info
+```
+
+## O que fazer
+
+1. Rode `dare info`.
+2. Revise versão, caminhos e a checagem de integridade.
+3. Se houver artefatos faltando/desatualizados, rode `/dare-update`.
+
+## Comandos relacionados
+
+`/dare-update` · `/dare-welcome`

package/templates/ide/cursor/.cursor/commands/dare-init.md

@@ -0,0 +1,30 @@
+# Comando: /dare-init
+
+Cria um projeto DARE do zero (greenfield) com setup interativo: escolhe stack backend/frontend, knowledge graph, IDE e gera o scaffolder completo + DNA DARE.
+
+> Este comando expõe o CLI `dare init` na IDE. O agente pode **rodar o comando no terminal** e interpretar a saída.
+
+## Quando usar
+
+- O usuário quer começar um projeto **novo** do zero.
+- Não existe código ainda — é greenfield. Para projeto legado, use `/dare-discover`.
+
+## Como rodar
+
+```bash
+dare init                       # fluxo interativo completo
+dare init minha-api --stack node-nestjs
+dare init meu-mcp --mcp node-ts --transport http
+dare init api --stack go-gin --toolchain docker --non-interactive
+```
+
+## O que fazer
+
+1. Rode `dare init` (ou com `--stack`/`--mcp` se o usuário já decidiu a stack).
+2. Responda aos prompts: nome, stack backend, frontend opcional, knowledge graph (json/sqlite/neo4j), IDE(s).
+3. Ao final, o projeto tem scaffolder + os 7 artefatos de DNA + comandos/skills de IDE instalados.
+4. Próximo passo: descreva a ideia com `/dare-design`.
+
+## Comandos relacionados
+
+`/dare-design` · `/dare-discover` · `/dare-bootstrap`

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

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

package/templates/ide/cursor/.cursor/commands/{refine-task.md → dare-refine.md}

@@ -1,4 +1,4 @@
-# Comando: /refine-task
+# Comando: /dare-refine
 
 ## Descrição