@brunosps00/dev-workflow 0.15.0 → 1.0.0

package/scaffold/pt-br/commands/dw-help.md

@@ -1,330 +1,127 @@
 <system_instructions>
-Você é um assistente de ajuda do workspace. Quando invocado, apresente ao usuário um guia completo dos comandos disponíveis, seus fluxos de integração e quando usar cada um.
+Você é o guia do dev-workflow. Exibe a surface primária de comandos, o fluxo típico e atalhos contextuais. Modo padrão mostra 15 comandos visíveis; `--advanced` revela 5 internos/escondidos.
 
 ## Quando Usar
-- Use quando precisar de uma visão geral dos comandos disponíveis, seus fluxos de integração ou orientação sobre qual comando usar em seguida
-- NÃO use quando já souber qual comando específico executar
+- Usuário digita `/dw-help` para descobrir comandos.
+- Usuário digita `/dw-help <palavra-chave>` para atalho contextual.
+- Usuário digita `/dw-help --advanced` para ver comandos internos.
 
-## Posição no Pipeline
-**Antecessor:** (qualquer comando ou pergunta do usuário) | **Sucessor:** (qualquer comando)
+## Modo padrão — surface primária
 
-## Comportamento
+```markdown
+# dev-workflow — Comandos Primários
 
-- Se invocado sem argumentos (`/dw-help`): mostre o guia completo abaixo
-- Se invocado com argumento correspondente a um comando (`/dw-help dw-create-prd`): mostre apenas a seção detalhada daquele comando
-- Se invocado com **keyword que não é nome de comando** (`/dw-help bug`, `/dw-help review`, `/dw-help design`): faça lookup contextual — identifique o(s) comando(s) mais relevante(s) pela keyword e apresente cada um com 1-2 linhas de justificativa ("para bug, use `/dw-bugfix` porque..."). Use a tabela de mapeamento abaixo.
+Use `/dw-autopilot "desejo"` como gateway pra maior parte do trabalho. Comandos granulares dão controle quando preciso.
 
-### Mapeamento contextual (keyword → comando sugerido)
+## Tier 1 — Gateway (3)
 
-| Keyword(s) | Comando sugerido | Justificativa |
-|------------|------------------|---------------|
-| bug, erro, falha, problema | `/dw-bugfix` | Triagem automática bug vs feature + correção |
-| review, revisão, qualidade | `/dw-code-review` | Review formal Nível 3 com relatório |
-| qa, teste visual, playwright | `/dw-run-qa` | QA E2E com browser automation |
-| refactor, smell, fowler | `/dw-refactoring-analysis` | Auditoria de code smells priorizada |
-| design, ui, redesign | `/dw-redesign-ui` | Auditoria + propostas + implementação visual |
-| debate, council, stress-test, opiniões | `/dw-brainstorm --council` ou `/dw-create-techspec --council` | Invoca `dw-council` para debate multi-advisor |
-| security, segurança, vulnerabilidade, owasp, trivy, cve | `/dw-security-check` | Check multi-camada rígido (OWASP estático + Trivy SCA/IaC + audit nativo) para TS/Python/C#/Rust |
-| supply chain, outdated, comprometido, pacote malicioso, atualizar deps, npm audit, pip-audit | `/dw-deps-audit` | Detecta + classifica + plano de update por pacote com QA escopada. Vai além do `/dw-security-check` adicionando remediação. |
-| skill, achar skill, instalar skill, ecossistema, capacidade, estender agente | `/dw-find-skills` | Descobre skills no skills.sh / `npx skills` e instala global ou local |
-| projeto novo, scaffold, bootstrap, comecar, iniciar projeto, fullstack, monorepo | `/dw-new-project` | Entrevista de stack + tools create-* + docker-compose para dev. Roda apos `npx dev-workflow init`. |
-| dockerize, docker, dockerfile, compose, container, imagem prod, multi-stage | `/dw-dockerize` | Le projeto existente, brainstorm de base, gera Dockerfile + docker-compose para dev/prod/ambos, ou audita artefatos existentes. |
-| refinamento, refine, idea, one-pager, ideia | `/dw-brainstorm --onepager` | Refinamento de ideia com Product Inventory + classification (IMPROVES/CONSOLIDATES/NEW) + one-pager durável |
-| reverter, rollback de task | `/dw-revert-task` | Revert seguro com check de dependências |
-| pesquisa, research | `/dw-deep-research` | Pesquisa multi-fonte com citações |
-| ideia, brainstorm | `/dw-brainstorm` | Ideação estruturada com trade-offs |
-| atualizar dev-workflow | `/dw-update` | Atualiza para versão npm mais recente |
+| Comando | Quando |
+|---------|--------|
+| `/dw-autopilot "desejo"` | Entry point padrão. PRD → TechSpec → Tasks → Run → QA → Review → Commit → PR. Três gates de aprovação. |
+| `/dw-bugfix "descrição"` | Bug ou error report. Fix cirúrgico ou rota pra PRD. |
+| `/dw-help [palavra-chave]` | Esta tela. Passe palavra-chave pra atalhos. `--advanced` revela comandos internos. |
 
----
+## Tier 2 — Pipeline granular (7)
 
-# Guia de Comandos - Dev Workflow AI
+| Comando | O que |
+|---------|-------|
+| `/dw-brainstorm "ideia"` | Refina ideia antes do PRD. Flags: `--onepager`, `--council`, `--research`, `--refactor`. |
+| `/dw-plan "feature"` | PRD → TechSpec → Tasks sequencial com checkpoints. Stages: `prd`, `techspec`, `tasks`. |
+| `/dw-run [task-id]` | Executa todas tasks pendentes ou uma específica. Flag `--resume`. |
+| `/dw-review` | Level 2 (cobertura PRD) + Level 3 (qualidade). Flags: `--coverage-only`, `--code-only`. |
+| `/dw-qa` | QA mode-aware (UI / API auto-detect). Flags: `--fix`, `--api`, `--ai`. |
+| `/dw-commit` | Commits atômicos Conventional pra trabalho pendente. |
+| `/dw-generate-pr [target]` | Push branch, draft do PR body, abre browser. |
 
-## Visão Geral
+## Tier 3 — Especialidade (5)
 
-Este workspace utiliza um sistema de comandos AI que automatiza o ciclo completo de desenvolvimento: do planejamento (PRD) até o merge (PR). Os comandos estão em `.dw/commands/` e são acessíveis nos CLIs suportados (ex: Claude Code, Codex, OpenCode e GitHub Copilot), usando o prefixo do CLI (`/comando`).
+| Comando | O que |
+|---------|-------|
+| `/dw-analyze-project` | Scan do repo, escreve `.dw/rules/` + oferece gerar `.dw/constitution.md`. |
+| `/dw-redesign-ui "target"` | Audit, propõe 2-3 direções, entrega. Enforça UI grounding + WCAG. |
+| `/dw-functional-doc` | Mapeia screens + flows em doc funcional validado com Playwright. |
+| `/dw-new-project` | Bootstrap por entrevista (stack + infra + docker-compose + CI). |
+| `/dw-dockerize` | Detecta stack, propõe Dockerfile + docker-compose pra dev/prod. |
 
-## Fluxo Principal de Desenvolvimento
+## Workflow em resumo
 
-```
-┌─────────────┐     ┌────────────────┐     ┌──────────────┐
-│ /dw-create-prd  │────>│/dw-create-techspec │────>│ /dw-create-tasks │
-│ (O QUÊ)     │     │ (COMO)         │     │ (QUANDO)     │
-└─────────────┘     └────────────────┘     └──────┬───────┘
-                                                   │
-                                     ┌─────────────┴─────────────┐
-                                     ▼                           ▼
-                            ┌────────────────┐         ┌─────────────────┐
-                            │ /dw-run-task  │         │ /dw-run-plan │
-                            │ (uma por vez)   │         │ (todas auto)    │
-                            └───────┬────────┘         └────────┬────────┘
-                                    │                           │
-                            ┌───────┴───────┐                   │
-                            ▼               │                   │
-                  ┌──────────────────┐      │                   │
-                  │/dw-functional-doc│      │                   │
-                  │ (mapeia telas & │      │                   │
-                  │  fluxos)        │      │                   │
-                  └───────┬──────────┘      │                   │
-                          └───────┬─────────┘                   │
-                                    │                           │
-                                    └─────────┬─────────────────┘
-                                              │
-                                              ▼
-                                    ┌─────────────────┐
-                                    │ Validação Nível 1│ (automática, embutida)
-                                    │ critérios+testes │
-                                    └────────┬────────┘
-                                             │
-                              ┌──────────────┼──────────────┐
-                              ▼              ▼              ▼
-                    ┌──────────────┐ ┌──────────────┐ ┌─────────────────────┐
-                    │/dw-run-qa  │ │/dw-review-impl.│ │ /dw-code-review        │
-                    │(QA visual)   │ │(PRD compliance│ │ (code review formal)│
-                    └──────────────┘ │ Nível 2)     │ │ (Nível 3)           │
-                                     └──────────────┘ └─────────────────────┘
-                                              │
-                              ┌───────────────┴───────────────┐
-                              ▼                               ▼
-                    ┌──────────────┐                 ┌────────────────┐
-                    │ /dw-commit      │                 │ /dw-generate-pr      │
-                    │ (um projeto) │                 │ (push + PR)    │
-                    └──────────────┘                 └────────────────┘
-```
+`/dw-autopilot "desejo"` roda o pipeline completo (PRD → ... → PR) com 3 gates. Passo a passo:
 
-## Tabela de Comandos
-
-### Planejamento
-
-| Comando | O que faz | Input | Output |
-|---------|-----------|-------|--------|
-| `/dw-brainstorm` | Facilita ideação estruturada antes do PRD ou da implementação | Problema, ideia ou contexto | Opções + trade-offs + recomendação |
-| `/dw-create-prd` | Cria PRD com min. 7 perguntas de clarificação | Descrição da feature | `.dw/spec/prd-[nome]/prd.md` |
-| `/dw-create-techspec` | Cria especificação técnica a partir do PRD | Path do PRD | `.dw/spec/prd-[nome]/techspec.md` |
-| `/dw-create-tasks` | Quebra PRD+TechSpec em tasks (max 2 FRs/task) | Path do PRD | `.dw/spec/prd-[nome]/tasks.md` + `*_task.md` |
-
-### Execução
-
-| Comando | O que faz | Input | Output |
-|---------|-----------|-------|--------|
-| `/dw-run-task` | Implementa UMA task + validação Nível 1 + commit | Path do PRD | Código + commit |
-| `/dw-run-plan` | Executa TODAS tasks + revisão final Nível 2 | Path do PRD | Código + commits + relatório |
-| `/dw-bugfix` | Analisa e corrige bugs (triagem bug vs feature) | Target + descrição | Fix + commit OU PRD (se feature) |
-| `/dw-fix-qa` | Corrige bugs documentados no QA e retesta com evidências | Path do PRD | Código + `QA/bugs.md` + `QA/qa-report.md` atualizados |
-| `/dw-redesign-ui` | Audita, propõe e implementa redesign visual de páginas/componentes | Página/componente alvo | Brief de redesign + código |
-| `/dw-autopilot` | Orquestrador completo: de um desejo até o PR com mínima intervenção | Descrição do desejo | PRD + código + commits + PR |
-
-### Análise e Pesquisa
-
-| Comando | O que faz | Input | Output |
-|---------|-----------|-------|--------|
-| `/dw-analyze-project` | Escaneia o repo e gera rules do projeto automaticamente | (nenhum) | `.dw/rules/index.md` + `.dw/rules/[projeto].md` |
-| `/dw-deep-research` | Pesquisa profunda com citações e verificação multi-fonte | Tópico ou pergunta | Relatório com citações em Markdown/HTML |
-| `/dw-functional-doc` | Mapeia telas, fluxos e módulos em dossiê funcional com cobertura E2E | URL/rota alvo + projeto | `.dw/flows/<projeto>/<slug>/` com docs, scripts, evidências |
-
-### Qualidade (3 Níveis)
-
-| Nível | Comando | Quando | Gera Relatório? |
-|-------|---------|--------|-----------------|
-| **1** | *(embutido no /dw-run-task)* | Após cada task | Não (output no terminal) |
-| **2** | `/dw-review-implementation` | Após todas tasks / manual | Sim (output formatado) |
-| **3** | `/dw-code-review` | Antes do PR / manual | Sim (`code-review.md`) |
-
-| Comando | O que faz | Input | Output |
-|---------|-----------|-------|--------|
-| `/dw-run-qa` | QA visual com Playwright MCP + acessibilidade | Path do PRD | `QA/qa-report.md` + `QA/screenshots/` |
-| `/dw-review-implementation` | Compara PRD vs código (FRs, endpoints, tasks) | Path do PRD | Relatório de gaps |
-| `/dw-code-review` | Code review formal (qualidade, rules, testes) | Path do PRD | `code-review.md` |
-| `/dw-refactoring-analysis` | Auditoria de code smells e oportunidades de refatoração (catálogo Fowler) | Path do PRD | `refactoring-analysis.md` |
-| `/dw-security-check` | Check de segurança rígido (OWASP estático + Trivy SCA/IaC + audit nativo) para TS/Python/C#/Rust | Path do PRD ou código | `security-check.md` |
-
-### Versionamento
-
-| Comando | O que faz | Input | Output |
-|---------|-----------|-------|--------|
-| `/dw-commit` | Commit semântico (Conventional Commits) | - | Commit |
-| `/dw-generate-pr` | Push + cria PR + copia body + abre URL | Branch alvo | PR no GitHub |
-| `/dw-revert-task` | Reverte com segurança os commits de uma task específica (check de dependências + confirmação) | Path do PRD + número da task | Commits revertidos + `tasks.md` atualizado |
-
-### Comandos internos (usados por outros dw-* commands; raramente invocados direto)
-
-| Comando | O que faz | Tipicamente invocado por |
-|---------|-----------|--------------------------|
-| `/dw-adr` | Registra Architecture Decision Record durante execução do PRD | `/dw-create-techspec`, `/dw-run-task` quando surge decisão não-trivial |
-| `/dw-intel` | Consulta o índice do codebase em `.dw/intel/` | `/dw-create-prd`, `/dw-create-techspec`, `/dw-code-review` etc. |
-| `/dw-map-codebase` | Constroi/refresca o índice queryable em `.dw/intel/` | `/dw-analyze-project` (auto-roda após geração de rules) |
-
-Esses ficam expostos como slash commands para uso manual ocasional (ex.: registrar ADR rapidamente mid-sessão, consultas ad-hoc no codebase) mas a maioria dos usuários nunca invoca direto — eles são chamados pelos comandos high-level acima.
-
-### Utilitários
-
-| Comando | O que faz | Input | Output |
-|---------|-----------|-------|--------|
-| `/dw-help` | Este guia de comandos (suporta lookup por keyword: `/dw-help bug`) | (opcional) comando ou keyword | Este documento ou seção filtrada |
-| `/dw-update` | Atualiza o dev-workflow para a versão mais recente no npm sem sair do agente (suporta `--rollback`) | (nenhum) ou `--rollback` | Arquivos gerenciados atualizados ou restaurados |
-
-### Bundled Skills (invocadas internamente — não são commands)
-
-Skills em `.agents/skills/` que os commands acima invocam transparentemente. Você não as chama diretamente.
-
-| Skill | Invocada por | Papel |
-|-------|--------------|-------|
-| `dw-verify` | run-task, run-plan, fix-qa, bugfix, code-review, generate-pr, quick | core rule: nenhuma claim de sucesso sem VERIFICATION REPORT PASS |
-| `dw-memory` | run-task, run-plan, autopilot, resume, revert-task | Memory de workflow em dois níveis (shared + task-local) com promotion test |
-| `dw-review-rigor` | code-review, review-implementation, refactoring-analysis | De-duplication, severity ordering, verify-intent-before-flag, signal-over-volume |
-| `dw-council` | brainstorm `--council`, create-techspec `--council` | Debate multi-advisor (3-5 archetypes) com steel-manning, concession tracking e synthesis que preserva dissent. Opt-in. |
-
-Inspiradas em skills do projeto [Compozy](https://github.com/compozy/compozy) (`cy-final-verify`, `cy-workflow-memory`, `cy-review-round`).
-
-## Fluxos Comuns
-
-### Nova Feature (Completo)
-```bash
-/dw-brainstorm "ideia inicial"                    # 0. Explora opções e trade-offs
-/dw-create-prd                                    # 1. Descreve a funcionalidade
-/dw-create-techspec .dw/spec/prd-nome             # 2. Gera spec técnica
-/dw-create-tasks .dw/spec/prd-nome                # 3. Quebra em tasks
-/dw-run-plan .dw/spec/prd-nome             # 4. Executa todas (inclui Nível 1+2)
-/dw-refactoring-analysis .dw/spec/prd-nome        # 5. Auditoria de code smells (opcional)
-/dw-code-review .dw/spec/prd-nome               # 6. Code review formal (Nível 3)
-/dw-generate-pr main                                # 7. Cria PR
 ```
-
-### Nova Feature (Incremental)
-```bash
-/dw-create-prd                                    # 1. PRD
-/dw-create-techspec .dw/spec/prd-nome             # 2. TechSpec
-/dw-create-tasks .dw/spec/prd-nome                # 3. Tasks
-/dw-run-task .dw/spec/prd-nome              # 4. Task 1 (com Nível 1)
-/dw-run-task .dw/spec/prd-nome              # 5. Task 2 (com Nível 1)
-# ... repete para cada task
-/dw-review-implementation .dw/spec/prd-nome      # 6. Revisão PRD (Nível 2)
-/dw-code-review .dw/spec/prd-nome               # 7. Code review (Nível 3)
-/dw-generate-pr main                                # 8. PR
-```
-
-### Bug Simples
-```bash
-/dw-bugfix meu-projeto "descrição do bug"        # Analisa e corrige
-/dw-commit                                       # Commit da correção
-/dw-generate-pr main                                # PR
+/dw-brainstorm → /dw-plan → /dw-run → /dw-qa → /dw-review → /dw-commit → /dw-generate-pr
 ```
 
-### Bug Complexo
-```bash
-/dw-bugfix meu-projeto "descrição" --análise     # Gera documento de análise
-/dw-create-techspec .dw/spec/dw-bugfix-nome          # TechSpec do fix
-/dw-create-tasks .dw/spec/dw-bugfix-nome             # Tasks do fix
-/dw-run-plan .dw/spec/dw-bugfix-nome          # Executa tudo
-/dw-generate-pr main                                # PR
-```
+## Comandos avançados / internos
 
-### QA Visual (Frontend)
-```bash
-/dw-run-qa .dw/spec/prd-nome                # QA com Playwright MCP
-# Se encontrar bugs:
-/dw-fix-qa .dw/spec/prd-nome               # Corrige + retesta ciclo completo
+Passe `--advanced` pra ver internos (`dw-adr`, `dw-intel`, `dw-secure-audit`, `dw-find-skills`, `dw-update`) — usualmente invocados por outros comandos.
 ```
 
-### Redesign de Frontend
-```bash
-/dw-analyze-project                                # 0. Entender padrões do projeto
-/dw-redesign-ui "página ou componente alvo"        # 1. Auditar + propor + implementar
-/dw-run-qa .dw/spec/prd-nome                       # 2. QA visual (opcional)
-/dw-code-review .dw/spec/prd-nome                  # 3. Code review
-/dw-commit                                         # 4. Commit
-/dw-generate-pr main                               # 5. PR
-```
+## Modo advanced — flag `--advanced`
 
-### Autopilot (Pipeline Completo)
-```bash
-/dw-autopilot "descrição do que quer construir"    # Pesquisa → PRD → Tasks → Código → QA → PR
-```
+ALSO show:
 
-### Consultar Codebase
-```bash
-/dw-intel "como funciona X neste projeto?"         # Resposta com fontes
-```
+```markdown
+# dev-workflow — Comandos Avançados / Internos
 
-### Onboarding em Projeto Novo
-```bash
-/dw-analyze-project                             # Escaneia e gera rules automaticamente
-/dw-help                                        # Mostra comandos disponíveis
-```
+Auto-invocados por comandos primários mas disponíveis standalone.
 
-## Estrutura de Arquivos
+## Tier 4 — Hidden (5)
 
+| Comando | O que | Invocado por |
+|---------|-------|--------------|
+| `/dw-adr "decisão"` | Registra um ADR em `.dw/spec/<prd>/adrs/`. | `/dw-plan techspec --council`, desvios de constitution |
+| `/dw-intel "pergunta"` | Query de codebase intel; `--build` (re)indexa `.dw/intel/`. | `/dw-plan`, `/dw-review`, `/dw-bugfix` |
+| `/dw-secure-audit` | OWASP + Trivy + lockfile + supply-chain scan. Hard gate. Flags: `--scan-only`, `--plan`, `--execute`. | `/dw-review`, `/dw-generate-pr` |
+| `/dw-find-skills "query"` | Busca npx skills ecosystem, valida, instala. | manual ao estender bundle |
+| `/dw-update` | Atualiza dev-workflow pro último release npm com snapshot rollback. | manutenção manual |
 ```
-workspace/
-├── .dw/
-│   ├── commands/              # Fonte de verdade dos comandos
-│   │   ├── dw-help.md
-│   │   ├── dw-analyze-project.md
-│   │   ├── dw-autopilot.md
-│   │   ├── dw-brainstorm.md
-│   │   ├── dw-create-prd.md
-│   │   ├── dw-create-techspec.md
-│   │   ├── dw-create-tasks.md
-│   │   ├── dw-run-task.md
-│   │   ├── dw-run-plan.md
-│   │   ├── dw-run-qa.md
-│   │   ├── dw-code-review.md
-│   │   ├── dw-refactoring-analysis.md
-│   │   ├── dw-review-implementation.md
-│   │   ├── dw-deep-research.md
-│   │   ├── dw-intel.md
-│   │   ├── dw-redesign-ui.md
-│   │   ├── dw-bugfix.md
-│   │   ├── dw-fix-qa.md
-│   │   ├── dw-commit.md
-│   │   ├── dw-functional-doc.md
-│   │   └── dw-generate-pr.md
-│   ├── templates/             # Templates de documentos
-│   │   ├── prd-template.md
-│   │   ├── techspec-template.md
-│   │   ├── tasks-template.md
-│   │   ├── task-template.md
-│   │   ├── bugfix-template.md
-│   │   └── functional-doc/    # Templates do dossiê funcional
-│   ├── scripts/               # Scripts utilitários
-│   │   └── functional-doc/    # Geração de dossiê & runner Playwright
-│   ├── references/            # Materiais de referência e documentos externos
-│   ├── rules/                 # Regras por projeto (gerado por /dw-analyze-project)
-│   │   ├── index.md
-│   │   └── [projeto].md
-│   └── tasks/                 # PRDs e tasks em andamento
-│       └── prd-[nome]/
-│           ├── prd.md
-│           ├── techspec.md
-│           ├── tasks.md
-│           └── *_task.md
-```
-
-## Dúvidas Frequentes
-
-**Q: Qual a diferença entre `/dw-run-task` e `/dw-run-plan`?**
-- `/dw-run-task` executa UMA task com controle manual entre cada uma
-- `/dw-run-plan` executa TODAS automaticamente com revisão final
-
-**Q: Preciso rodar `/dw-review-implementation` manualmente?**
-- Não se usar `/dw-run-plan` (já inclui). Sim se usar `/dw-run-task` incremental.
-
-**Q: Quando usar `/dw-code-review` vs `/dw-review-implementation`?**
-- `/dw-review-implementation` (Nível 2): Verifica se os FRs do PRD foram implementados
-- `/dw-code-review` (Nível 3): Além disso, analisa qualidade de código e gera relatório formal
-
-**Q: O `/dw-bugfix` sempre corrige direto?**
-- Não. Ele faz triagem. Se for feature (não bug), redireciona para `/dw-create-prd`. Se for bug complexo, pode gerar documento de análise com `--análise`.
-
-**Q: Preciso rodar `/dw-analyze-project` antes de tudo?**
-- Sim, é recomendado para projetos novos. Ele gera as rules em `.dw/rules/` que todos os outros comandos utilizam.
-
-**Q: O `/dw-redesign-ui` funciona com Angular?**
-- Sim. O comando é framework-agnostic. Para React usa react-doctor e `vercel-react-best-practices`; para Angular usa `ng lint` e Angular DevTools. Disciplina de UI (`dw-ui-discipline`) funciona com qualquer framework — enforça o hard-gate, anti-slop catalog e WCAG floor independente do stack.
-
-**Q: Como obtenho inteligência do codebase e execução paralela?**
-- Os dois são nativos do dev-workflow. Rode `/dw-map-codebase` para construir o índice queryable em `.dw/intel/`, depois `/dw-intel "<pergunta>"` para consultá-lo. Para execução paralela, `/dw-run-plan` invoca os agentes bundled de execução de fase (executor + plan-checker) diretamente para dispatcha tasks em waves com commits atômicos por task. Sem dependência externa.
 
-**Q: O `/dw-autopilot` substitui todos os outros comandos?**
-- Não. Ele orquestra os comandos existentes em sequência. Você ainda pode usar cada comando individualmente para controle manual. O autopilot é para quando quer ir do desejo ao PR com mínima intervenção.
+## Modo keyword — `/dw-help <palavra-chave>`
+
+| Keyword | Sugestão |
+|---------|----------|
+| `prd`, `spec`, `plan`, `arquitetura`, `techspec`, `tasks` | `/dw-plan` (stage apropriado) |
+| `bug`, `erro`, `quebrado`, `fix` | `/dw-bugfix` |
+| `run`, `executa`, `implementa` | `/dw-run` |
+| `review`, `qualidade`, `audit code` | `/dw-review` |
+| `qa`, `test plan`, `e2e` | `/dw-qa` |
+| `commit`, `git` | `/dw-commit` |
+| `pr`, `pull request`, `merge` | `/dw-generate-pr` |
+| `ideia`, `brainstorm`, `explora` | `/dw-brainstorm` |
+| `research`, `compara`, `estado da arte` | `/dw-brainstorm --research` |
+| `refactor`, `smell`, `code health` | `/dw-brainstorm --refactor` |
+| `ui`, `design`, `redesign` | `/dw-redesign-ui` |
+| `intel`, `onde está`, `o que usa` | `/dw-intel` (ou `--build`) |
+| `analyze`, `rules`, `convenções` | `/dw-analyze-project` |
+| `constitution`, `princípios` | `/dw-analyze-project` (Step 8) |
+| `security`, `vulnerabilidades`, `cve`, `deps` | `/dw-secure-audit` |
+| `adr`, `decisão` | `/dw-adr` |
+| `docker`, `compose`, `container` | `/dw-dockerize` |
+| `new project`, `bootstrap`, `scaffold` | `/dw-new-project` |
+| `functional doc`, `screen map` | `/dw-functional-doc` |
+| `incident`, `outage`, `postmortem`, `sev-1` | (Skill `dw-incident-response` auto-invocada de `/dw-bugfix`) |
+| `eval`, `llm`, `ai feature`, `rag` | (Skill `dw-llm-eval` invocada de `/dw-plan`, `/dw-review`, `/dw-qa --ai`) |
+
+Sem match: surface padrão + nota.
+
+## FAQ
+
+**P: Onde começo com uma nova feature?**
+- `/dw-autopilot "o que voce quer"`. Roda PRD → ... → PR com três gates.
+
+**P: Tenho que usar `/dw-autopilot`?**
+- Não. Pipeline granular dá controle a cada step.
+
+**P: Só quero corrigir um bug.**
+- `/dw-bugfix "<descrição>"`. Tria, 3 perguntas, fixa ou roteia.
+
+**P: Como verifico padrões do projeto?**
+- `/dw-analyze-project` escreve `.dw/rules/`.
+
+**P: Onde features AI são avaliadas?**
+- Skill `dw-llm-eval` auto-invocada de `/dw-plan tasks`, `/dw-review`, `/dw-qa --ai`.
+
+**P: O que aconteceu com outros comandos?**
+- v1.0.0 consolidou 30 → 20. Mergers: create-prd/techspec/tasks → `/dw-plan`; run-task/run-plan → `/dw-run`; code-review/review-implementation → `/dw-review`; run-qa/fix-qa → `/dw-qa`; security-check/deps-audit → `/dw-secure-audit`; map-codebase → `/dw-intel --build`; deep-research e refactoring-analysis → `/dw-brainstorm --research/--refactor`. Removidos: revert-task (use `git revert` direto).
 
 </system_instructions>

package/scaffold/pt-br/commands/dw-intel.md

@@ -1,20 +1,28 @@
 <system_instructions>
-Voce e um assistente de inteligencia do codebase. Este comando responde perguntas sobre o projeto usando o indice queryable em `.dw/intel/` (construido pelo `/dw-map-codebase`) e as convencoes human-readable em `.dw/rules/` (construidas pelo `/dw-analyze-project`).
+Voce e o assistente de inteligencia do codebase. Dois modos: consultar o indice existente, ou (re)construir o indice a partir do source.
 
-<critical>Este comando e somente leitura. NAO modifique codigo ou arquivos do projeto.</critical>
-<critical>Sempre cite as fontes (caminho do arquivo, numero da linha quando aplicavel).</critical>
-<critical>Se o indice esta defasado (>7 dias) ou ausente, suba o aviso para o usuario — NAO caia em fallback silencioso sem sinalizar.</critical>
+<critical>Modo query e somente leitura. NAO modifique codigo ou arquivos do projeto.</critical>
+<critical>Modo build escreve em `.dw/intel/` apenas — nunca no source.</critical>
+<critical>Em modo query, sempre cite as fontes (caminho do arquivo, numero da linha quando aplicavel).</critical>
+<critical>Se o indice esta defasado (>7 dias) ou ausente, suba o aviso — NAO caia em fallback silencioso sem sinalizar.</critical>
+
+## Modos
+
+| Invocacao | Comportamento |
+|-----------|---------------|
+| `/dw-intel "<pergunta>"` | **Padrao — modo query.** Responde usando `.dw/intel/` (machine-readable) + `.dw/rules/` (human-readable) + grep fallback. |
+| `/dw-intel --build` | **Modo build.** Scan recursivo do projeto e produz `.dw/intel/{stack,files,apis,deps}.json` + `.dw/intel/arch.md`. Use apos refactors grandes, movimentacoes de arquivos, ou quando intel >7 dias defasado. |
+| `/dw-intel --build --incremental` | Build incremental: so re-le arquivos modificados desde `.last-refresh.json`. Mais rapido mas pode perder mudancas estruturais grandes. |
 
 ## Quando Usar
 
-- Use para entender como algo funciona no projeto (fluxo de auth, modelo de dados, superficie de rotas)
-- Use para encontrar padroes, convencoes ou decisoes arquiteturais
-- Use para verificar se algo ja existe antes de implementar
-- NAO use para implementar mudancas (use `/dw-run-task`)
+- **Modo query**: entender como algo funciona no projeto (fluxo de auth, modelo de dados, superficie de rotas). Encontrar padroes, convencoes ou decisoes arquiteturais. Verificar se algo ja existe antes de implementar.
+- **Modo build**: apos refactors grandes, updates massivos de dependencias, ou quando `.dw/intel/` esta vazio/defasado.
+- NAO use para implementar mudancas (use `/dw-run`).
 
 ## Posicao no Pipeline
 
-**Antecessor:** `/dw-map-codebase` (gera `.dw/intel/`) e/ou `/dw-analyze-project` (gera `.dw/rules/`) | **Sucessor:** qualquer comando `dw-*` que precisa agir sobre o intel
+**Antecessor (modo build):** qualquer mudanca grande do projeto | **Sucessor:** qualquer comando `dw-*` que precisa do intel
 
 ## Skills Complementares
 
@@ -41,9 +49,9 @@ Voce e um assistente de inteligencia do codebase. Este comando responde pergunta
 
 Antes de responder, leia `.dw/intel/.last-refresh.json` se existir:
 
-- Se `updated_at` e mais de 7 dias atras → prefixe a resposta com: `⚠ Indice atualizado em YYYY-MM-DD (X dias atras). Considere rodar /dw-map-codebase para refresh.`
+- Se `updated_at` e mais de 7 dias atras → prefixe a resposta com: `⚠ Indice atualizado em YYYY-MM-DD (X dias atras). Considere rodar /dw-intel --build para refresh.`
 - Se `.dw/intel/` existe mas `.last-refresh.json` falta → prefixe com: `⚠ Sem metadado de refresh; o indice pode estar defasado.`
-- Se `.dw/intel/` nao existe → diga ao usuario: `Sem .dw/intel/. Caindo para .dw/rules/ + grep. Para respostas mais ricas, rode /dw-map-codebase.`
+- Se `.dw/intel/` nao existe → diga ao usuario: `Sem .dw/intel/. Caindo para .dw/rules/ + grep. Para respostas mais ricas, rode /dw-intel --build.`
 
 Nao recuse responder — devolva a melhor info disponivel.
 
@@ -112,7 +120,7 @@ Nao despeje JSON. Escreva resposta de 3-8 linhas que:
 
 - **Prefira `.dw/intel/` ao grep.** E curado e mais rapido. Grep so quando intel esta ausente ou defasado.
 - **Cite caminhos, nao conteudos.** O usuario pode `Read` se precisar do source.
-- **Nao invente.** Se `.dw/intel/` nao tem a resposta e grep retorna nada, diga. Sugira `/dw-map-codebase` se `.dw/intel/` esta faltando.
+- **Nao invente.** Se `.dw/intel/` nao tem a resposta e grep retorna nada, diga. Sugira `/dw-intel --build` se `.dw/intel/` esta faltando.
 - **Combine intel + rules.** Uma query sobre "como nomeamos arquivos de service?" deve puxar de `arch.md` (intel) E `.dw/rules/<modulo>.md` (convencoes do projeto). Os dois se complementam.
 
 ## Regras Criticas
@@ -122,8 +130,64 @@ Nao despeje JSON. Escreva resposta de 3-8 linhas que:
 - <critical>Suba avisos de indice defasado de forma visivel — nao enterre no rodape.</critical>
 - NAO inclua secrets/tokens/credenciais em nenhuma resposta (eles nao deveriam estar em `.dw/intel/` em primeiro lugar, mas defesa em profundidade).
 
+## Modo build (`--build`)
+
+Quando invocado com `--build`, o comando produz ou atualiza o indice queryable de intel. Anteriormente era `/dw-intel --build`, agora consolidado.
+
+### Comportamento
+
+1. **Detectar estrutura do projeto.** Scan recursivo por entry points: package.json, requirements.txt, pyproject.toml, Cargo.toml, *.csproj, etc.
+2. **Detectar orquestradores de monorepo.** pnpm/nx/turborepo workspaces, lerna config, git submodules.
+3. **Identificar stack.** Para cada modulo detectado, identificar linguagem, framework, package manager, build tool. Output em `.dw/intel/stack.json`.
+4. **Inventario de arquivos.** Para arquivos source (pular `node_modules/`, `.git/`, `dist/`, `build/`, `.dw/`): catalogar com path, exports, proposito. Output em `.dw/intel/files.json`. Budget ≤2K tokens (priorizar cobertura de arquivos-chave sobre listagem exaustiva em repos grandes).
+5. **Extracao de API.** Routes, RPC handlers, GraphQL resolvers, superficie de CLI publica. Output em `.dw/intel/apis.json`. Budget ≤1.5K tokens.
+6. **Mapa de dependencias.** Imports internos cross-module + pacotes externos com arrays `used_by`. Output em `.dw/intel/deps.json`. Budget ≤1K tokens.
+7. **Sumario de arquitetura.** Documento em prosa descrevendo a forma do projeto, padroes-chave, request flows, topologia de deployment. Output em `.dw/intel/arch.md`. Budget ≤1.5K tokens.
+8. **Metadata de refresh.** Escrever `.dw/intel/.last-refresh.json` com `updated_at`, `version`, `mode` (full ou incremental), contagem de arquivos scanned.
+
+### Skill complementar para build mode
+
+| Skill | Gatilho |
+|-------|---------|
+| `dw-codebase-intel` | **SEMPRE em modo build** — provê schema `.dw/intel/`, protocolo de incremental-update (quais arquivos re-ler, como mergear com entradas existentes), regras de budget por arquivo. |
+
+### Proibido em modo build
+
+- Nunca ler `.env*` (exceto `.env.example` / `.env.template`), `*.key`, `*.pem`, `*.pfx`, `*.p12`, `*.keystore`, `*.jks`, `id_rsa`, `id_ed25519`, ou arquivos com `*credential*`/`*secret*` no nome. Pular silenciosamente.
+- Nunca incluir secrets/tokens/credenciais em nenhum arquivo de intel.
+- Nunca usar Bash `ls`/`find`/`cat` (sensibilidade cross-platform); usar Glob/Read/Grep.
+
+### Modo incremental (`--build --incremental`)
+
+Le `.dw/intel/.last-refresh.json` pra achar timestamp do ultimo build. So re-le arquivos modificados desde entao. Mais rapido mas pode perder:
+- Diretorios novos nao previamente catalogados.
+- Arquivos removidos (permanecem em `files.json` ate full build).
+
+Use full `--build` trimestralmente ou apos mudancas estruturais; incremental pra refresh rotineiro.
+
+### Estrutura de output
+
+```
+.dw/intel/
+├── stack.json            # Stack detectado por modulo
+├── files.json            # Inventario de arquivos source com exports + propositos
+├── apis.json             # Superficie publica de API
+├── deps.json             # Grafo de dependencias (internas + externas)
+├── arch.md               # Sumario de arquitetura (prosa)
+└── .last-refresh.json    # Metadata: updated_at, version, mode
+```
+
+### Por que este skill existe
+
+Anteriormente dois comandos: `/dw-intel` (query) e `/dw-intel --build` (build). O split era historico — um escrevia, outro lia, mas ambos compartilham schema e mesmo `.dw/intel/`. Consolidar reduz:
+- Confusao ("qual rodar?").
+- Burden de manutencao de dois arquivos de command.
+- Docs duplicados.
+
+Mesmas operacoes, um unico mental entry point.
+
 ## Inspirado em
 
-O mapeamento de query-patterns (where-is / what-uses / architecture-of / etc.) e o schema JSON do intel sao adaptados do projeto [`get-shit-done-cc`](https://github.com/gsd-build/get-shit-done) (licenca MIT). Convencoes de path mudaram de `.planning/intel/` para `.dw/intel/`.
+O mapeamento de query-patterns (where-is / what-uses / architecture-of / etc.) e o schema JSON do intel sao adaptados do projeto [`get-shit-done-cc`](https://github.com/gsd-build/get-shit-done) (licenca MIT). Convencoes de path mudaram de `.planning/intel/` para `.dw/intel/`. Comportamento de modo build anteriormente vivia em `/dw-intel --build` (mesmo upstream).
 
 </system_instructions>

package/scaffold/pt-br/commands/dw-new-project.md

@@ -13,11 +13,11 @@ Voce e o lider de bootstrap de workspace do dev-workflow. Sua funcao e pegar um
 - Subindo uma sandbox de aprendizado onde voce quer um stack realista (db + cache + email + observability) sem 30 minutos de YAML
 - NAO use para adicionar servicos a um projeto existente — use `/dw-dockerize --audit`
 - NAO use para adicionar app novo dentro de um monorepo existente — outra release vai cobrir isso
-- NAO substitui `/dw-create-prd` — este aqui gera o workspace, nao a spec do produto
+- NAO substitui `/dw-plan prd` — este aqui gera o workspace, nao a spec do produto
 
 ## Posicao no Pipeline
 
-**Predecessor:** `npx dev-workflow init` (rodado de dentro do diretorio alvo) | **Sucessor:** `/dw-create-prd` para a primeira feature, ou `/dw-analyze-project` apos o primeiro commit substancial para enriquecer o `.dw/rules/`
+**Predecessor:** `npx dev-workflow init` (rodado de dentro do diretorio alvo) | **Sucessor:** `/dw-plan prd` para a primeira feature, ou `/dw-analyze-project` apos o primeiro commit substancial para enriquecer o `.dw/rules/`
 
 ## Skills Complementares
 
@@ -242,7 +242,7 @@ Gere um README inicial:
 - Local Dev (tabela de portas dos servicos selecionados + URLs das UIs + credenciais default)
 - Diagrama da arquitetura (ASCII do one-pager)
 - Layout do projeto (arvore dos diretorios top-level)
-- Integracao com dev-workflow (mencione `/dw-create-prd`, `/dw-run-task`, `/dw-run-qa`, `/dw-deps-audit`, `/dw-security-check`)
+- Integracao com dev-workflow (mencione `/dw-plan prd`, `/dw-run`, `/dw-qa`, `/dw-secure-audit --plan`, `/dw-secure-audit`)
 
 Se `create-*` ja gerou README, **anexe** sob "## Local Dev"; nao sobrescreva.
 
@@ -303,7 +303,7 @@ monorepo: <pnpm-workspaces|turborepo|nx|none>
 2. `pnpm install` (ou seu package manager).
 3. `pnpm dev:up` para subir todos os servicos. Aguarde os healthchecks.
 4. Abra a UI do MailHog em http://localhost:8025 para confirmar a captura de email.
-5. `/dw-create-prd` para a primeira feature.
+5. `/dw-plan prd` para a primeira feature.
 6. Apos o primeiro commit substancial, rode `/dw-analyze-project` para enriquecer `.dw/rules/`.
 ```
 
@@ -336,15 +336,15 @@ monorepo: <pnpm-workspaces|turborepo|nx|none>
 
 ## Integracao com Outros dw-* Commands
 
-- **`npx dev-workflow init`** e predecessor obrigatorio. Ordem: `init` → `/dw-new-project` → `/dw-create-prd`.
-- **`/dw-create-prd`** e o proximo passo sugerido apos bootstrap bem-sucedido.
+- **`npx dev-workflow init`** e predecessor obrigatorio. Ordem: `init` → `/dw-new-project` → `/dw-plan prd`.
+- **`/dw-plan prd`** e o proximo passo sugerido apos bootstrap bem-sucedido.
 - **`/dw-analyze-project`** deve rodar apos primeiro commit substancial para enriquecer `.dw/rules/` — o bootstrap deixa um seed minimo.
-- **`/dw-deps-audit --scan-only`** pode rodar logo apos o bootstrap para confirmar que nenhum dep vulneravel veio dos templates `create-*`.
-- **`/dw-security-check`** roda como parte do pipeline de PRD apos a primeira feature aterrissar.
+- **`/dw-secure-audit --plan --scan-only`** pode rodar logo apos o bootstrap para confirmar que nenhum dep vulneravel veio dos templates `create-*`.
+- **`/dw-secure-audit`** roda como parte do pipeline de PRD apos a primeira feature aterrissar.
 - **`/dw-dockerize`** e o comando irmao para retrofit de Docker em projeto existente que nao comecou com este aqui.
 
 ## Inspirado em
 
-`dw-new-project` e dev-workflow-native. O padrao de entrevista herda do `/dw-create-prd` (clarificacao socratica, branching condicional por artefato anterior). A disciplina de execucao (verification por fase, gate atomico antes de mutar) herda do `/dw-deps-audit` e `/dw-security-check`. A logica de composicao do compose esta delegada para a skill bundled `docker-compose-recipes`. A filosofia de "wrap a tool oficial" foi confirmada via `/dw-find-skills` contra o ecossistema `npx skills` em 2026-04-28 — nada la matchava "entrevista + scaffold multi-stack + compose dev" em qualidade suficiente.
+`dw-new-project` e dev-workflow-native. O padrao de entrevista herda do `/dw-plan prd` (clarificacao socratica, branching condicional por artefato anterior). A disciplina de execucao (verification por fase, gate atomico antes de mutar) herda do `/dw-secure-audit --plan` e `/dw-secure-audit`. A logica de composicao do compose esta delegada para a skill bundled `docker-compose-recipes`. A filosofia de "wrap a tool oficial" foi confirmada via `/dw-find-skills` contra o ecossistema `npx skills` em 2026-04-28 — nada la matchava "entrevista + scaffold multi-stack + compose dev" em qualidade suficiente.
 
 </system_instructions>