@brunosps00/dev-workflow 2.2.0 → 2.3.0

package/scaffold/pt-br/agent-instructions.md

@@ -1,156 +1,50 @@
 <!-- dev-workflow:start -->
-# dev-workflow — Instruções para Agente de IA
-
-Este projeto usa [`@brunosps00/dev-workflow`](https://www.npmjs.com/package/@brunosps00/dev-workflow) (comandos `dw-*`) para desenvolvimento estruturado guiado por IA. Os comandos compõem um pipeline PRD → TechSpec → Tasks → Implementar → Review → Commit → PR com hard gates de segurança, conformidade com constitution e verificação.
-
-**Objetivo deste arquivo:** quando o usuário expressar uma intenção que casa com a Trigger Map abaixo, rode o comando `dw-*` correspondente **sem pedir permissão** — exceto se a mudança for genuinamente trivial (veja Escape Hatches).
-
-## Matriz de Auto-Sizing
-
-Antes de escolher um comando da Trigger Map, dimensione o escopo real da mudança. A mesma intenção ("conserta isso", "adiciona isso") pode significar quantidades muito diferentes de trabalho; a matriz nomeia quatro tamanhos e roteia cada um para uma entrada diferente. **Escolha o menor que cabe — sub-rotear desperdiça cerimônia, super-rotear esconde o escopo.**
-
-| Tamanho | Como se parece | Rotear para |
-|---------|----------------|-------------|
-| **Pequeno** | ≤3 arquivos, sem migration, sem novo endpoint, descritível em uma frase. Exemplos: typo, log message, config de uma linha, bump de dependência, version pin. | Faça inline. Nenhum comando `dw-*`. |
-| **Médio** | Feature ou bug claro, <10 tasks numeradas esperadas, único componente ou serviço, sem decisões arquiteturais. Exemplos: adicionar campo de form com validação, corrigir regressão em módulo conhecido, ligar novo endpoint num handler existente. | `/dw-bugfix` (bugs) ou `/dw-plan` (features) — direto, não via `/dw-autopilot`. |
-| **Grande** | Feature multi-componente, ≥10 tasks esperadas, toca múltiplos módulos, tem superfície UX user-visible E backend. Exemplos: adicionar nova entidade end-to-end (model + migration + API + UI), introduzir integração de terceiro, redesenhar fluxo. | `/dw-autopilot "<wish>"` — primeira invocação planeja e para; segunda invocação retoma via `/dw-goal` para Run → Review → QA/Fix → Review, depois Commit → PR. |
-| **Complexo** | Domínio novo, requisitos ambíguos, decisão arquitetural exigida, superfície regulatória ou de compliance, ou escopo que cruza múltiplos PRDs. Exemplos: introduzir event sourcing, reconstruir auth, multi-tenancy, nova linha de produto. | `/dw-opportunities` primeiro se a ideia ainda nao existir; caso contrario `/dw-brainstorm "<ideia>"` (auto-dispatch de modos research/council), depois `/dw-plan --council` para a etapa de techspec rodar o debate multi-advisor. |
-
-**Safety valve:** se você começou em Pequeno ou Médio mas o trabalho revela que é Grande de fato (a listagem inline passa de 5 passos, ou `/dw-bugfix` dispara seu `Step 5.0`), PARE e escale. Não existe flag para bypass. Escalar é o desfecho correto.
-
-**Adaptado de** [`tech-leads-club/agent-skills/tlc-spec-driven`](https://github.com/tech-leads-club/agent-skills/tree/main/packages/skills-catalog/skills/(development)/tlc-spec-driven) (CC-BY-4.0). A matriz de quatro tamanhos é de lá; o mapeamento para comandos `dw-*` é específico do dev-workflow.
-
-## Trigger Map
-
-| Intenção do usuário (literal ou parafraseada) | Auto-trigger |
-|------------------------------------------------|--------------|
-| "Implementa X" / "Cria Y" / "Adiciona feature Z" / "Preciso de..." | `/dw-autopilot "X"` |
-| "Autopilota esse PRD" / "Leva esse PRD pra PR" / continua escalação de bugfix autonomamente | `/dw-autopilot --from-prd <slug>` (PRD existente em `.dw/spec/<slug>/`) |
-| "Retoma autopilot" / "continua depois do plan" / `autopilot-state.json` tem `status: plan_complete` | `/dw-autopilot` (ou `/dw-goal --from-autopilot <slug>` se o usuário pedir especificamente a etapa de goal) |
-| Erro colado / "X está quebrado" / "Bug em Y" / screenshot de teste falhando | `/dw-bugfix "X"` |
-| "Planeja essa feature" / "Escreve PRD + techspec + tasks" | `/dw-plan "X"` |
-| "Escreve PRD pra X" / "Especifica Y" | `/dw-plan prd "X"` |
-| "Desenha a arquitetura" / "Faz o techspec" | `/dw-plan techspec` |
-| "Quebra em tasks" | `/dw-plan tasks` |
-| "Roda essa task" (com ID da task) | `/dw-run <ID>` |
-| "Roda todas as tasks pendentes" / "Executa o plano" | `/dw-run` |
-| "Roda isso como goal" / "objetivo durável" / "long-running objective" | `/dw-goal "<objetivo>"` |
-| "Continue de onde parei" | `/dw-run --resume` |
-| "Pausa o trabalho" / "Encerra a sessão" / "Salva onde paramos" | `/dw-pause` |
-| "Report de N em N minutos" / "Me mantém informado enquanto isso roda" / "Quero status periódico" | `/dw-report [--every <N>m]` |
-| "Cria uma worktree pra X" / "Limpa as worktrees" / "Mergeia a worktree X" / "Quantas worktrees sobraram?" | `/dw-worktree create <slug>` / `/dw-worktree clean --apply` / `/dw-worktree merge <slug>` / `/dw-worktree list` |
-| "Retoma" / "Onde paramos?" / "Volta de onde parei" | `/dw-resume` |
-| "QA dessa feature" / "Roda o test plan" | `/dw-qa` |
-| "Corrige os bugs do QA" | `/dw-qa --fix` |
-| "Avalia a feature AI" / "Testa o RAG / classifier" | `/dw-qa --ai` |
-| "Caminha comigo pela feature" / "UAT comigo" / "Vamos fazer um run-through manual" | `/dw-qa --uat` |
-| "Revisa esse bugfix" / "Code-review do fix `<slug>`" | `/dw-review --bugfix <slug>` |
-| "QA desse bugfix" / "Valida o fix `<slug>`" | `/dw-qa --bugfix <slug>` |
-| "Revisa meu PR" / "Checa qualidade" / "Tá pronto pra subir?" | `/dw-review` |
-| "Só checagem de cobertura PRD" | `/dw-review --coverage-only` |
-| "Só code review qualidade" | `/dw-review --code-only` |
-| "Hora de commitar" / mudanças validadas e prontas | `/dw-commit` |
-| "Abre um PR" / "Sobe isso" | `/dw-generate-pr` |
-| "Sugere ideias novas" / "O que devemos construir agora?" / "Encontra oportunidades" / "Ideias de roadmap" | `/dw-opportunities` |
-| "Que melhorias de seguranca devemos considerar?" / "Encontra oportunidades de seguranca" | `/dw-opportunities "security"` |
-| "Brainstorm X" / "Explora essa ideia" / "Research X" | `/dw-brainstorm "X"` (auto-dispatch dos modos grill / prototype / council / research / onepager conforme os sinais) |
-| "Auditoria de saude do codigo" / "Tech debt" / "Oportunidades de refactor" / "Smells em X" | `/dw-refactor "X"` |
-| "Onde está X?" / "O que usa Y?" / "Como Z é estruturado?" | `/dw-intel "<pergunta>"` |
-| "Reconstrói o índice" / "Refresh do intel" | `/dw-intel --build` |
-| "Contexto pesado" / "Audita uso de tokens" / "Por que o agente está lento?" | `/dw-context-budget` |
-| "Checa instalação dev-workflow" / "Agentes/wrappers estão saudáveis?" | `/dw-harness-audit` |
-| "Audita skills" / "Skills parecem duplicadas ou pesadas" | `/dw-skill-health` |
-| "Redesign dessa UI" / "Audita e entrega novo design" | `/dw-redesign-ui "<target>"` |
-| "Audita dependências" / "Estamos atrasados em pacotes?" | `/dw-secure-audit --plan` |
-| "Scan de vulnerabilidades" / "Check de segurança" | `/dw-secure-audit` |
-| "Analisa esse projeto" / "Gera rules" | `/dw-analyze-project` |
-| "Abre um novo projeto" / "Bootstrap de stack" | `/dw-new-project` |
-| "Dockeriza isso" / "Adiciona docker-compose" | `/dw-dockerize` |
-| "Functional doc" / "Mapeia screens e flows" | `/dw-functional-doc` |
-| "Instala skills Azure" / "Configura MCP do Microsoft docs" / "Adiciona expertise Azure" / "Vou trabalhar com Azure" | `/dw-install-azure-skills` |
-| "Instala skills AWS" / "Configura MCP da AWS" / "Adiciona expertise AWS" / "Vou trabalhar com AWS" | `/dw-install-aws-skills` |
+# dev-workflow — Instruções do agente
 
-**Prioridade:** na dúvida entre dois comandos, `/dw-autopilot` é o default mais seguro pra qualquer pedido de feature não-trivial. Se um autopilot planejado já parou com `status: plan_complete`, retome em vez de iniciar novo plano; a fase de execução pertence ao `/dw-goal`.
+Use o menor workflow que atende à intenção e ao risco. Continue o trabalho autorizado até implementar, verificar e corrigir falhas. Instruções do usuário e autorização existente prevalecem sobre padrões do workflow; as permissões da plataforma continuam valendo.
 
-## Hard Gates (os comandos enforçam — não burle)
+## Roteamento
 
-- **`.dw/constitution.md`**: princípios com `severity: high` ou `critical` bloqueiam PRs / techspecs sem um ADR justificando o desvio. Constitution ausente? Os comandos auto-instalam defaults em `severity: info` (não-bloqueante) e seguem — ausência nunca bloqueia.
-- **`.dw/spec/<prd>/tasks-validation.md`**: auto-gerado no fim do `/dw-plan tasks`. Qualquer dimensão FAIL bloqueia approval do usuário até resolver ou override explícito.
-- **Verification**: `/dw-generate-pr` exige `dw-verify` PASS fresco (testes + lint + build) depois do último edit.
-- **Segurança**: projetos TS / Python / C# / Rust precisam passar `/dw-secure-audit` (OWASP + Semgrep + gitleaks + Trivy + lockfile audit) antes do PR abrir.
+| Intenção e escopo | Ação |
+|---|---|
+| Explicação, localização de código ou exploração | Inspecione fontes relevantes e responda diretamente. |
+| Mudança pequena, clara e de baixo risco | Implemente diretamente e verifique proporcionalmente. |
+| Bug que exige investigação | `/dw-bugfix`; correção pequena e conhecida pode ficar inline. |
+| Feature que precisa de especificação | `/dw-plan`; em pedido de implementação completa, continue após aprovar as tasks. |
+| Implementação multicomponente até validação | `/dw-autopilot`; aprove o plano de tasks/execução e continue na mesma invocação. |
+| Decisões pendentes de produto ou arquitetura | `/dw-brainstorm`, depois `/dw-plan` quando alinhado. Council somente quando perspectivas diferentes ajudarem a decisão. |
+| Executar tasks aprovadas | `/dw-run`; `/dw-goal` para execução durável. |
+| Retomar trabalho existente | `/dw-resume` ou `/dw-run --resume`; reutilize decisões e evidências salvas. |
+| Pedido explícito de review / QA / commit / PR | `/dw-review` / `/dw-qa` / `/dw-commit` / `/dw-generate-pr`. |
 
-## Escape Hatches — NÃO auto-trigger
+Não inicie outro pipeline dentro de um workflow ativo. Pedido somente de plano ou investigação termina no artefato solicitado. Mais arquivos ou esforço não exigem parada: reorganize dentro do escopo aprovado e pergunte somente sobre escopo novo material, requisitos conflitantes ou decisões ausentes.
 
-Quando qualquer destes se aplica, responda direto e **não** invoque comando `dw-*`:
+Para comandos especializados consulte `.dw/references/command-routing.md` ou `/dw-help`. Não carregue o catálogo completo em trabalho rotineiro.
 
-- Correção de uma linha: typo, rename, sort de imports, ajuste de comentário.
-- Exploração pura: "como isso funciona?", "me mostra X", "explica Y".
-- Preferência estética: "prefiro esse estilo" — aplica, não roda pipeline.
-- Usuário diz explicitamente "faz direto" / "pula autopilot" / "não precisa de PRD" — honre.
-- A conversa já está dentro de um fluxo `dw-*` (você já está executando tasks; não inicie pipeline novo).
+## Planejamento e delegação
 
-## Padrão zoom-out (para áreas desconhecidas do código)
+Na quebra de tasks, proponha desenvolvimento local ou cruzado e modelo, esforço e agentes por task considerando ambiguidade, dependências, risco e escopo. Leia `.dw/references/execution-contract.md` nessa etapa e ao executar/retomar o plano. A aprovação abrange essas escolhas e fallbacks declarados durante a execução.
 
-Quando você cai numa área do codebase que não conhece e a orientação custa mais que a tarefa em si, **não mergulhe nos arquivos primeiro** — peça ao `dw-code-explorer` que produza um mapa. Passe o glossário de domínio do projeto (`.dw/rules/index.md`) e diga: "zoom out de um nível — me mostra os módulos relevantes, suas superfícies públicas, quem chama, e o fluxo de dados entre eles, usando o vocabulário do glossário de domínio." Pegue a visão geral, e só então mergulhe. Isso evita a armadilha de ler o arquivo mais profundo primeiro e reconstruir a arquitetura das folhas pra cima.
+Claude pode delegar implementação por `/dw-codex-run`; Codex pode usar `/dw-claude-run`. O parent conduz review, correções e continuidade. Agentes locais herdam o modelo da sessão salvo override aprovado na task. Delegue trabalho independente e delimitado quando melhorar qualidade ou tempo; mantenha trabalho pequeno ou acoplado local. Máximo de 3 workers por fluxo e nunca escritores simultâneos no mesmo worktree.
 
-Adaptado de [`mattpocock/skills/zoom-out`](https://github.com/mattpocock/skills/tree/main/zoom-out) (MIT).
+Leia primeiro arquivos relevantes. Use `.dw/intel/` ou code-explorer quando ajudar em fluxos amplos ou desconhecidos, conferindo o índice contra o código atual. Carregue entrypoints de skills somente para tasks correspondentes e referências somente para o modo escolhido. Subagentes recebem um pacote compacto e retornam evidências e decisões, não logs completos.
 
-## Disciplina de Dispatch de Subagentes
+## Conclusão e limites
 
-Agentes de projeto sao instalados em `.claude/agents/`, `.opencode/agent/`, `.agents/agents/` e `.github/agents/` quando suportado. Claude Code e OpenCode podem usar subagentes nativos. Copilot recebe custom agents. Codex deve tratar `.agents/agents/` como perfis delegaveis quando houver suporte a subagentes, ou como prompt pack manual caso contrario.
+Um plano de implementação aprovado continua por implementação, review, QA aplicável e correções. Não pare só porque a primeira implementação ficou pronta ou o runner externo retornou. Reutilize decisões resolvidas na conversa. Preserve trabalho parcial e checkpoints duráveis em interrupções.
 
-Use subagente quando:
+Entrega pronta atende aos critérios de aceitação, não tem achado bloqueante pendente e possui evidência válida de verificação. Evidência continua válida enquanto insumos, ambiente e escopo permanecerem equivalentes; outra mensagem não a invalida. Aplique `dw-verify` nos gates de entrega. Não adicione testes para mudanças de baixo impacto apenas para preencher template.
 
-- A tarefa gerar output volumoso: logs, testes, grep amplo, evidencia de QA, traces de browser ou notas de pesquisa.
-- A tarefa for read-only, paralelizavel e tiver fronteira clara.
-- A tarefa tiver return value compacto: findings, mapa, arquivos alterados, verificacao ou bloqueios.
-- Voce precisar de review independente: seguranca, silent failure, corretude por linguagem ou prontidao de PR.
-
-Nao use subagente quando:
-
-- A tarefa exigir dialogo frequente com o usuario.
-- Planejamento, implementacao e teste compartilharem contexto vivo demais.
-- A mudanca for pequena o bastante para fazer inline.
-- O subagente precisar do transcript completo do parent para nao chutar.
-- A tarefa delegada precisaria spawnar outros subagentes.
-
-Limites:
+Merge, push, publicação e operações destrutivas exigem autorização aplicável; não pergunte novamente quando já autorizado. Prepare e valide o resultado concreto antes de pedir autorização final ausente. Worktree isola mudanças Git, não permissões do sistema operacional.
 
-- Rode no maximo 3 subagentes concorrentes por workstream.
-- Output default deve ficar perto do budget do registry, normalmente 900-1200 palavras.
-- Subagentes resumem logs; retornam linhas falhas, paths, comandos, decisoes e riscos, nao transcripts completos.
-- O parent e o unico sintetizador final.
-- O parent passa um input packet, nao historico bruto da conversa. Use `/dw-subtask-start`, `/dw-subtask-complete` e `/dw-subtask-resume` para handoffs locais.
-
-Claude-only: prefira named subagents para pesquisa, review, build e QA isolados. Use forks so quando a subtarefa realmente precisar do contexto do parent.
-
-Roteamento de agentes:
-
-- Use `dw-code-explorer` antes de planejar ou debugar areas desconhecidas.
-- Use `dw-build-fixer` so depois de uma falha real de build/typecheck/lint.
-- Use `dw-code-reviewer`, `dw-security-reviewer` e `dw-silent-failure-hunter` durante `/dw-review`.
-- Use agentes especificos de linguagem quando o modulo estiver instalado e o diff bater com a linguagem.
+## Contratos do projeto
 
-## Disciplina de Carregamento de Skills
+- Respeite `.dw/constitution.md`; desvios high/critical seguem o processo de ADR definido. Ausência não bloqueia: use defaults não bloqueantes.
+- Planos aprovados precisam de dependências válidas e `tasks-validation.md`; corrija inconsistências internas antes de pedir aprovação.
+- Complete os checks exigidos pelo projeto. Gates de segurança e PR continuam aplicáveis; segredos e achados bloqueantes não podem ser escondidos por nota ou build verde.
+- Execução formal de tasks mantém commits atômicos com escopo e rastreabilidade de requisitos. Edição pequena direta não implica pedido de commit ou PR.
 
-Skills são protocolos compactos primeiro. Leia o `SKILL.md` de entrada e carregue arquivos em `references/`, `assets/`, `rules/` ou `scripts/` só quando o trigger, a tarefa ou o output exigir esse material mais profundo. Se uma skill parecer duplicada, ampla demais ou cara para a tarefa atual, rode `/dw-skill-health`.
+## Personalização
 
-## Referência de Workflow
-
-```
-/dw-autopilot "wish"  ────►  Primeira invocação planeja: PRD → TechSpec → Tasks → STOP
-/dw-autopilot         ────►  Segunda invocação retoma: /dw-goal → Commit → PR
-
-  --- OU passo a passo ---
-
-/dw-brainstorm ─► /dw-plan ─► /dw-goal ─► /dw-commit ─► /dw-generate-pr
-```
-
-Lista completa e ajuda contextual: `/dw-help`.
-
-## Editando esta seção
-
-Este bloco vive entre os marcadores `<!-- dev-workflow:start -->` e `<!-- dev-workflow:end -->`. Qualquer coisa que você escrever **fora** dos marcadores em `CLAUDE.md` / `AGENTS.md` é preservada a cada `dev-workflow update`. Tudo **dentro** é regenerado do pacote — seus edits dentro do bloco serão sobrescritos.
-
-Para customizar a trigger map permanentemente, copie o conteúdo pra fora dos marcadores (ou pra arquivo separado tipo `.dw/agent-instructions-custom.md`) e edite lá.
+Este bloco fica entre os marcadores `<!-- dev-workflow:start -->` e `<!-- dev-workflow:end -->` e é atualizado pelo pacote. Coloque instruções específicas fora dos marcadores; não duplique o bloco inteiro. Configurações e overrides explícitos do projeto prevalecem no seu escopo.
 <!-- dev-workflow:end -->

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

@@ -310,6 +310,8 @@ Documentar os fluxos rastreados com caminhos de arquivo em cada etapa.
 
 ### Passo 5: Detectar Antipatterns (Obrigatório)
 
+Para um módulo frontend, leia `dw-ui-discipline/references/frontend-engineering.md` no local das skills instaladas. Use `.dw/templates/frontend-quality-template.md` para incluir controles observados, lacunas e propostas de adoção no `.dw/rules/<module>.md` do módulo. Inspecione scripts/configurações reais e CI; registre checks não executados explicitamente. Preserve a política existente e separe-a das recomendações. Este comando apenas documental não instala ferramentas, altera código/configurações nem ativa novos gates no CI.
+
 Verificar a presença de:
 
 | Antipattern | Como Detectar |

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

@@ -1,259 +1,36 @@
 <system_instructions>
-Você é o orquestrador de pipeline completo. Este comando recebe um desejo do usuário e conduz o workflow PRD-ao-PR em duas invocações:
+# Orquestrador de implementação contínua
 
-1. **Invocação de planejamento:** pesquisa/brainstorm quando necessário, PRD, TechSpec, Tasks, depois PARA.
-2. **Invocação de execução:** retoma de `autopilot-state.json`, roda `/dw-goal --from-autopilot <prd-slug>`, depois commit e gate de PR.
+`/dw-autopilot "<wish>"` planeja e conduz trabalho aprovado até implementação e validação. `/dw-autopilot --from-prd <slug>` parte de `.dw/spec/<slug>/prd.md`; ausência bloqueia informando o caminho. `/dw-autopilot` sem descrição retoma estado salvo. Não imponha segunda invocação após aprovar tasks. Pedido somente de plano ou modo Plan ativo da plataforma termina no artefato de planejamento.
 
-<critical>A primeira invocação DEVE parar depois que os artefatos de planejamento estiverem completos. Não rode implementação, QA, review, commit ou PR na primeira invocação.</critical>
-<critical>A segunda invocação DEVE retomar do estado salvo e delegar Run → Review → QA/Fix → Review para `/dw-goal --from-autopilot <prd-slug>`.</critical>
-<critical>Cada etapa que invoca um comando `/dw-*` DEVE seguir as instruções completas de `.dw/commands/`. Leia e execute o comando inteiro, não uma versão resumida.</critical>
+## Planejamento
 
-## Quando Usar
-- Use quando quiser ir de uma ideia até um PR com mínima intervenção manual, mas com parada obrigatória após o planejamento.
-- Use para features completas que exigem planejamento, execução, qualidade e prontidão de PR.
-- NÃO use para tasks pequenas e bem-escopadas; use `/dw-run` com um plano existente.
-- NÃO use para bugfix cirúrgico; use `/dw-bugfix`.
-- NÃO use quando o usuário quer controle manual entre cada fase; use comandos individuais.
+1. Inspecione código/regras relevantes e decisões existentes. Use `.dw/intel/` quando útil; pesquise tecnologias/domínios/integrações desconhecidos. Brainstorm só para escolhas pendentes, sem entrevista obrigatória de três opções.
+2. Invoque `/dw-plan` ou estágios relevantes para produzir PRD, TechSpec, tasks e tasks-validation.md. Reutilize respostas e handoffs alinhados. Pergunte lacunas materiais pela ferramenta de entrevista disponível; não repita fatos descobertos.
+3. Na quebra apresente desenvolvimento local/cruzado, modelo/esforço concretos e agentes relevantes por complexidade. Siga `.dw/references/execution-contract.md`, escreva/valide execution-plan.json e obtenha aprovação da mesma matriz de tasks/escolhas. Respeite aprovações de estágios existentes sem repeti-las.
+4. Salve `autopilot-state.json` com `status: plan_complete`, `current_step: goal`, artefatos, caminho das escolhas aprovadas e `next_command: /dw-goal --from-autopilot <slug>`. Em pedido de implementação continue imediatamente. Em pedido somente de plano reporte-o e preserve o ponto de retomada.
 
-## Posição no Pipeline
-**Antecessor:** desejo do usuário | **Sucessor:** `/dw-goal`, `/dw-commit`, `/dw-generate-pr`
+## Execução e entrega
 
-## Skills / Comandos Complementares
+Arme `/dw-report` uma vez (idempotente, pule quando `DW_REPORT_AUTO=off`). Invoque `/dw-goal --from-autopilot <slug>` para conduzir `/dw-run` → `/dw-review` completo → `/dw-qa` aplicável → `/dw-qa --fix` para bugs Open → review pós-QA quando edições ou novos achados invalidarem review anterior. Não substitua review completo por coverage-only. Runners externos retornam ao parent para correções e continuidade, sem encerrar o goal.
 
-| Skill ou comando | Gatilho |
-|------------------|---------|
-| `dw-memory` | SEMPRE — preserva decisões entre planejamento, goal de execução, QA, review e PR. |
-| `dw-verify` | SEMPRE — invocado por gates e comandos downstream antes de claims de aprovação/commit/PR. |
-| `/dw-goal` | SEMPRE na segunda invocação — objetivo durável de execução/qualidade. |
+Use `dw-memory` para decisões duráveis e `dw-verify` para evidência válida. Security Gate continua obrigatório quando aplicável: `/dw-secure-audit` produz `.dw/secure-audit/audit-summary.md`; evidência ausente/inválida é refeita e achados bloqueantes corrigidos. SECRET findings sempre bloqueiam (sem escape por ADR). Reutilize scan válido em outro checkpoint.
 
-## Variáveis de Entrada
+Goal conclui apenas com critérios atendidos, artefatos exigidos de review/QA e checks válidos, sem achado bloqueante pendente. Para `prd-bugfix-*` escalado, localize `.dw/bugfixes/*/escalated.md` original, produza SUMMARY.md ausente com evidências e feche o índice.
 
-| Variável | Descrição | Exemplo |
-|----------|-----------|---------|
-| `{{WISH}}` | Descrição do que o usuário quer construir no modo padrão. | `"preferencias de notificacao push"` |
-| `{{PRD_SLUG}}` | Slug de PRD existente quando `--from-prd` é usado. | `prd-bugfix-stripe-webhook-retry` |
-| `{{MODE}}` | Flag opcional de invocação. | `--from-prd <slug>` |
+Inspecione commits com escopo e bookkeeping restante; `/dw-commit` faz commit final autorizado quando necessário. Não crie commits vazios nem exija commit extra para trabalho já commitado. Prepare branch/worktree validado e resumo de entrega. Merge, push e publicação de PR seguem só autorização existente. Se faltar autorização final, apresente resultado concreto e peça apenas essa ação; não repita permissão já concedida.
 
-## Modos de Invocação
+## Estado durável
 
-| Invocação | Comportamento |
-|-----------|---------------|
-| `/dw-autopilot "<wish>"` | Invocação de planejamento do zero. Roda Inteligência do Codebase → Pesquisa opcional → Brainstorm → PRD → TechSpec → Tasks, salva estado e para. |
-| `/dw-autopilot --from-prd <slug>` | Invocação de planejamento a partir de PRD existente. Começa em aprovação do PRD, depois TechSpec → Tasks, salva estado e para. |
-| `/dw-autopilot` em PRD com `autopilot-state.json status=plan_complete` | Invocação de execução. Roda `/dw-goal --from-autopilot <slug>`, depois commit e gate de PR. |
+Preserve campos de `autopilot-state.json`: mode, wish, prd_path, from_prd_slug, current_step, completed_steps, skipped_steps, skip_reasons, gates_passed, step_artifacts, goal_slug, next_command, started_at, last_updated. Acrescente caminhos `execution_plan` e `execution_state`. Registre evidência, não só existência de arquivo, antes de concluir etapa.
 
-## Pontos de Pausa Obrigatórios
-
-Autopilot pausa em:
-
-1. **Aprovação do PRD** antes do TechSpec.
-2. **Aprovação das Tasks** antes de marcar planejamento completo.
-3. **Parada obrigatória de planejamento** depois que Tasks forem aprovadas e estado salvo.
-4. **Gate de PR** depois que o goal de execução e commit completarem.
-
-Entre estes pontos, execute automaticamente respeitando perguntas bloqueantes exigidas pelo comando chamado.
-
-## Retomada de Sessão
-
-Se este comando for re-invocado no mesmo PRD:
-
-<critical>Leia `.dw/spec/<prd-slug>/autopilot-state.json` primeiro. Se `status` for `plan_complete`, não repita planejamento. Inicie a invocação de execução chamando formalmente `/dw-goal --from-autopilot <prd-slug>`.</critical>
-
-Significados de estado:
-
-| Status | Ação |
-|--------|------|
-| estado ausente | Iniciar invocação de planejamento normal. |
-| `planning` | Retomar de `current_step`, respeitando etapas completas/puladas. |
-| `plan_complete` | Iniciar invocação de execução via `/dw-goal --from-autopilot <prd-slug>`. |
-| `goal_active` | Continuar `/dw-goal resume` ou `/dw-goal --from-autopilot <prd-slug>` conforme `.dw/goals/autopilot-<prd-slug>/status.json`. |
-| `goal_complete` | Continuar para commit e gate de PR. |
-| `completed` | Reportar que já foi concluído e mostrar resumo de PR/commit se disponível. |
-
-## Invocação de Planejamento
-
-### Etapa 0: Resolver modo de invocação
-
-1. Se `--from-prd <slug>` aparece:
-   - Resolva para `.dw/spec/<slug>/`.
-   - Verifique que `prd.md` existe; senão PARE com: `Alvo de --from-prd .dw/spec/<slug>/prd.md nao encontrado. Rode /dw-plan prd ou corrija o slug.`
-   - Crie ou atualize `autopilot-state.json` com `mode: "from-prd"`, `status: "planning"`, `skipped_steps: [1,2,3,4]`, e `skip_reasons["1-4"] = "from-prd-mode"`.
-   - Pule para aprovação do PRD usando o PRD existente.
-2. Caso contrário:
-   - Crie ou atualize `autopilot-state.json` com `mode: "autopilot"`, `status: "planning"`, wish original e `current_step: 1`.
-
-### Etapa 1: Inteligência do Codebase
-
-<critical>Se `.dw/intel/` existir, consulte via `/dw-intel` antes de planejar. Caia para `.dw/rules/` e grep direto se ausente.</critical>
-
-- Identifique stack, padrões existentes, features relacionadas e restrições do projeto.
-- Se `.dw/intel/` estiver ausente, sugira `/dw-intel --build` para contexto futuro mais rico, mas continue com `.dw/rules/` e inspeção direta.
-
-### Etapa 2: Pesquisa (Condicional)
-
-Rode `/dw-brainstorm --research` quando a feature envolver tecnologia nova, domínio desconhecido, APIs externas, regulação ou arquitetura de alto impacto. Caso contrário, pule e registre o motivo em `skip_reasons`.
-
-### Etapa 3: Brainstorm (Interativo)
-
-Rode `/dw-brainstorm` com o contexto acumulado. Apresente três direções e espere o usuário escolher uma antes de continuar.
-
-### Etapa 4: PRD
-
-Rode `/dw-plan prd` usando findings de brainstorm/research.
-
-<critical>O estágio PRD deve usar a ferramenta de entrevista estruturada quando disponível. Se indisponível, faça as perguntas obrigatórias no chat e registre o fallback. O usuário deve responder; não infira respostas.</critical>
-
-Depois que `prd.md` existir, apresente resumo do PRD e aguarde aprovação explícita. Se o usuário pedir edits, atualize e reapresente.
-
-### Etapa 5: TechSpec
-
-Rode `/dw-plan techspec` a partir do PRD aprovado.
-
-<critical>O estágio TechSpec deve usar a ferramenta de entrevista estruturada quando disponível. Se indisponível, faça as perguntas obrigatórias no chat e registre o fallback. O usuário deve responder; não infira respostas.</critical>
-
-Depois que `techspec.md` existir, apresente resumo do TechSpec e aguarde aprovação explícita.
-
-### Etapa 6: Tasks
-
-Rode `/dw-plan tasks` a partir de PRD + TechSpec. Verifique:
-- `tasks.md` existe.
-- arquivos per-task existem.
-- `tasks-validation.md` existe e passou ou tem override explícito do usuário.
-
-### Etapa 7: Aprovação das Tasks e Parada Obrigatória
-
-Apresente resumo das tasks, dependências e esforço total. Aguarde aprovação explícita.
-
-Após aprovação:
-
-1. Salve `.dw/spec/<prd-slug>/autopilot-state.json` com:
-
-```json
-{
-  "status": "plan_complete",
-  "current_step": "goal",
-  "next_command": "/dw-goal --from-autopilot <prd-slug>"
-}
-```
-
-2. Inclua `completed_steps` para todas as etapas de planejamento completas e `step_artifacts` para `prd.md`, `techspec.md`, `tasks.md`, arquivos per-task e `tasks-validation.md`.
-3. PARE e diga ao usuário que a fase de planejamento está completa. Não rode implementação nesta invocação.
-
-## Invocação de Execução
-
-### Etapa 8: Goal Durável de Execução
-
-Primeiro arme o loop de progresso: invoque `/dw-report` (contrato de auto-arme — idempotente, pulado quando `DW_REPORT_AUTO=off`). Ele reporta feito / fazendo / falta a cada 10 minutos ao longo do goal, do Security Gate, do commit e do PR, e se desarma sozinho com um report final no gate de PR.
-
-Quando `autopilot-state.json status=plan_complete`, invoque formalmente:
-
-```text
-/dw-goal --from-autopilot <prd-slug>
-```
-
-O goal é dono desta sequência:
-
-1. `/dw-run <prd-path>`
-2. `/dw-review <prd-path>` (review completo: cobertura, qualidade, convenções, constitution, verify)
-3. `/dw-qa <prd-path>`
-4. `/dw-qa --fix <prd-path>` se QA encontrou bugs Open
-5. `/dw-review <prd-path>` novamente após QA/fixes
-6. **Security Gate** — o `/dw-review` pós-QA (passo 5) aciona o `/dw-secure-audit`, produzindo um `.dw/secure-audit/audit-summary.md` fresco. Este passo **garante** que o verdict é APROVADO: se ausente/desatualizado/REPROVADO, rode `/dw-secure-audit <prd-path>` standalone, depois volte pro `/dw-bugfix` por finding e re-cheque. Findings SECRET sempre bloqueiam (sem escape de ADR). Não force um segundo scan completo quando já existe um summary APROVADO fresco.
-
-<critical>Não substitua os reviews do goal por `/dw-review --coverage-only`. O goal de qualidade do autopilot exige `/dw-review` completo antes do QA e depois dos fixes de QA.</critical>
-
-Depois que `/dw-goal` completar, verifique que `.dw/goals/autopilot-<prd-slug>/status.json` tem `status: "complete"`, então defina `autopilot-state.json status: "goal_complete"`.
-
-### Etapa 9: Fechar Loop de Bugfix (Condicional)
-
-Se `mode == "from-prd"` e o slug do PRD casar com `prd-bugfix-*`, feche o índice de bugfix antes do commit:
-- Encontre `.dw/bugfixes/*/escalated.md` que referência o slug do PRD.
-- Se `SUMMARY.md` estiver ausente, escreva usando evidências disponíveis de PRD, TechSpec, QA e diff com `.dw/templates/bugfix-summary-template.md`.
-- Nunca fabrique evidência de verificação.
-- Registre artefatos em `autopilot-state.json`.
-
-### Etapa 10: Auditoria Pre-Commit
-
-Antes de `/dw-commit`, verifique:
-- `.dw/goals/autopilot-<prd-slug>/status.json` está completo.
-- `<prd-path>/QA/review-consolidated.md` existe a partir do review final pós-QA.
-- `<prd-path>/QA/qa-report.md` e `<prd-path>/QA/bugs.md` existem.
-- **Security Gate passou:** `.dw/secure-audit/audit-summary.md` existe, está fresco (pós-última-edição) e status APROVADO. Se ausente/desatualizado/REPROVADO → PARE (não commite).
-- `autopilot-state.json` registra artefatos de planejamento e o goal completo.
-
-Se algo estiver faltando, PARE e re-execute o comando formal ausente. Não faça commit parcial.
-
-### Etapa 11: Commit
-
-Rode `/dw-commit` automaticamente. Não aguarde aprovação depois que o goal estiver completo.
-
-### Etapa 12: Gate de Pull Request
-
-Pergunte: **"Commits realizados. Deseja gerar o Pull Request?"**
-
-- SIM: rode `/dw-generate-pr`.
-- NÃO: informe que os commits estão prontos e o PR pode ser gerado depois.
-
-Marque `autopilot-state.json status: "completed"` após commit, e inclua link do PR se gerado.
-
-## Persistencia de Estado
-
-`autopilot-state.json` deve incluir:
-
-```json
-{
-  "mode": "autopilot",
-  "status": "planning",
-  "wish": "descricao original do usuario",
-  "prd_path": ".dw/spec/prd-name",
-  "from_prd_slug": null,
-  "current_step": 1,
-  "completed_steps": [],
-  "skipped_steps": [],
-  "skip_reasons": {},
-  "gates_passed": [],
-  "step_artifacts": {},
-  "goal_slug": null,
-  "next_command": null,
-  "started_at": "2026-05-20T00:00:00Z",
-  "last_updated": "2026-05-20T00:00:00Z"
-}
-```
-
-Atualize estado depois de cada etapa completa ou pulada. Uma etapa só está completa depois que artefatos obrigatórios existem.
-
-## Formato de Progresso
-
-Reporte progresso depois de cada etapa:
-
-```text
-=== AUTOPILOT =====================================
-  OK [1] Inteligencia do Codebase
-  OK [2] Pesquisa (pulada — dominio conhecido)
-  OK [3] Brainstorm
-  OK [4] PRD
-  OK [5] TechSpec
-  OK [6] Tasks
-  STOP [PLAN COMPLETE] Proximo: /dw-goal --from-autopilot prd-name
-===================================================
-```
-
-Durante a invocação de execução:
-
-```text
-=== AUTOPILOT =====================================
-  OK [PLAN] Ja completo
-  RUN [GOAL] /dw-goal --from-autopilot prd-name
-  NEXT [COMMIT] apos goal status=complete
-===================================================
-```
-
-## Anti-patterns
-
-- Não continue para implementação durante a primeira invocação.
-- Não pule `/dw-goal` durante a segunda invocação.
-- Não substitua `/dw-review` completo por review mais estreito no goal de execução.
-- Não marque estado completo a partir de validação manual.
-- Não reexecute planejamento quando `status=plan_complete`; retome o goal.
+| status | Ação de retomada |
+|---|---|
+| ausente / planning | Continue apenas planejamento pendente; preserve decisões resolvidas. |
+| plan_complete | Execute plano aprovado por `/dw-goal --from-autopilot <slug>` quando implementação for solicitada. |
+| goal_active | `/dw-goal resume` com estado salvo de task/executor. |
+| goal_complete | Prepare entrega e ações restantes autorizadas de commit/publicação. |
+| completed | Reporte entrega validada e links/branch; publicação pode aguardar autorização. |
 
+Atualize estado após cada checkpoint. Reporte task atual, evidência e restante de forma compacta. Preserve checkpoints em pausa ou bloqueio real; corrija falhas recuperáveis no escopo e continue.
 </system_instructions>

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

@@ -247,51 +247,25 @@
     | Pergunta | Se SIM |
     |----------|--------|
     | Precisa de migration/alteração de schema? | Redirecionar para PRD |
-    | Afeta mais de 5 arquivos? | Redirecionar para PRD |
+    | Escopo de arquivos maior? | Reavalie organização e risco real; sem parada automática |
     | Requer novo endpoint? | Redirecionar para PRD |
     | Muda contrato de API existente? | Redirecionar para PRD |
     | Afeta múltiplos projetos? | Redirecionar para PRD |
-    | Estimativa > 2 horas de implementação? | Redirecionar para PRD |
+    | Estimativa maior de implementação? | Reorganize/checkpoint dentro do escopo aprovado |
 
-    ### 5.0. Safety Valve (OBRIGATÓRIO antes do passo 5)
+    ### 5.0. Safety Valve (antes da implementação)
 
-    <critical>
-    ANTES de desenhar a lista numerada do passo 5, esboce inline os passos que pretende escrever.
-    Se esse esboço revelar **mais de 5 tasks numeradas distintas**, OU **qualquer dependência cross-file que obrigue ordem específica de execução**, OU **uma task que requeira rodar migration / refactor / novo endpoint / alteração de contrato de API**, então o escopo do bugfix foi SUBESTIMADO e você DEVE escalar.
-    </critical>
-
-    **Por que isso existe:** a triagem do passo 0 pega problemas de escopo a partir da descrição do sintoma. O checkpoint 4.1 pega depois da análise de causa raiz. Esta válvula pega o caso que sobra — quando o fix em si, uma vez listado, revela mais complexidade do que triagem e RCA previram. NÃO existe flag de bypass. Escalar é o desfecho correto.
-
-    **Procedimento de escalação:**
-
-    1. Aloque `NNN` para `.dw/bugfixes/NNN-<slug>/`. Escreva `TASK.md` com a triagem, clarificações, causa raiz e plano que seria executado.
-    2. Crie `.dw/spec/prd-bugfix-<slug>/` e escreva `prd.md` lá (use `.dw/templates/bugfix-template.md`). Este é o path que `/dw-plan` espera.
-    3. Escreva `.dw/bugfixes/NNN-<slug>/escalated.md` com: `Escalated to /dw-plan on <YYYY-MM-DD> — reason: <qual critério da válvula disparou> → see .dw/spec/prd-bugfix-<slug>/`.
-    4. Reporte ao usuário:
-
-    ```
-    ## Escopo maior que bugfix
-
-    Listando o fix produziu [N] tasks / [deps cross-file] / [tipo de mudança proibida].
-    Pelo safety valve, isso não é mais um bugfix cirúrgico.
-
-    Índice do bugfix preservado em `.dw/bugfixes/NNN-<slug>/{TASK.md, escalated.md}`.
-    PRD criado em `.dw/spec/prd-bugfix-<slug>/prd.md`.
-
-    Próximo — escolha um:
-      - Cadeia manual: `/dw-plan techspec prd-bugfix-<slug>` → `/dw-plan tasks prd-bugfix-<slug>` → `/dw-run` → `/dw-qa` → `/dw-review` → `/dw-commit` → `/dw-generate-pr`.
-      - Entregar pro autopilot: `/dw-autopilot --from-prd prd-bugfix-<slug>` — roda a fase de planejamento a partir do PRD existente, para depois de Tasks, e uma invocacao posterior retoma via `/dw-goal`.
-    ```
+    Inspecione o fix proposto por mudanças materiais de escopo ou arquitetura. Quantidade de tasks/arquivos, dependências de ordem e estimativas maiores sinalizam organização, não bloqueio automático. Refactor necessário para corrigir comportamento aprovado pode permanecer no escopo. Contrato novo de produto, migration sensível ou decisão arquitetural pendente exige proposta concreta antes de implementar trabalho dependente.
 
-    5. Pare este comando. Não avance para o passo 5. O usuário (ou autopilot) invoca `/dw-plan` ou `/dw-autopilot --from-prd` em seguida.
+    Quando precisar de plano estruturado, preserve `.dw/bugfixes/NNN-<slug>/TASK.md`, crie `.dw/spec/prd-bugfix-<slug>/prd.md` pelo template de bugfix e registre referência em `escalated.md`. Continue por `/dw-plan` ou `/dw-autopilot --from-prd prd-bugfix-<slug>` conforme intenção existente. A quebra propõe executor/modelo/agentes; após aprovação continue na mesma invocação. Não peça autorização novamente para organizar fix já autorizado. Pedido somente de análise termina no relatório.
 
-    **Se a válvula NÃO disparar:** Continue para o passo 5.
+    Sem nova decisão material nem necessidade de plano estruturado, continue no passo 5.
 
     ### 5. Propor Tarefas Numeradas (Obrigatório)
 
     <critical>
     Liste TODAS as tarefas necessárias, numeradas sequencialmente.
-    Aguarde aprovação antes de executar.
+    Use aprovação existente do mesmo escopo; pergunte só decisões materiais novas antes de executar.
     </critical>
 
     **Formato:**
@@ -364,8 +338,8 @@
 
     Opção B (entregar pro autopilot):
     1. Rode: `/dw-autopilot --from-prd prd-bugfix-<slug>`
-    2. Autopilot roda aprovacao do PRD, TechSpec e Tasks, depois para com `status: plan_complete`.
-    3. Uma invocacao posterior do autopilot retoma via `/dw-goal --from-autopilot prd-bugfix-<slug>` para Run, Review completo, QA/Fix e Review completo pos-QA antes de commit/PR.
+    2. Autopilot roda aprovacao do PRD, TechSpec e Tasks, registra `status: plan_complete` e continua após aprovação das tasks/escolhas de execução.
+    3. A mesma invocação do autopilot retoma via `/dw-goal --from-autopilot prd-bugfix-<slug>` para Run, Review completo, QA/Fix e Review completo pos-QA antes de commit/PR.
 
     O índice do bugfix continua queryable via `/dw-intel "bugfix history in <module>"`. Downstream `/dw-review --bugfix <slug>` e `/dw-qa --bugfix <slug>` ainda apontam para `.dw/bugfixes/NNN-<slug>/` quando quiser uma revisão focada apenas no patch cirúrgico final.
     ```