@brunosps00/dev-workflow 0.3.0 → 0.4.0

package/README.md

@@ -10,7 +10,7 @@ npx @brunosps00/dev-workflow init
 
 This will:
 1. Ask you to select a language (English or Portuguese)
-2. Create `.dw/commands/` with 22 workflow commands
+2. Create `.dw/commands/` with 23 workflow commands
 3. Create `.dw/templates/` with document templates
 4. Create `.dw/rules/` (populated by `/dw-analyze-project`)
 5. Install bundled skills (ui-ux-pro-max, security-review, etc.) to `.agents/skills/`
@@ -29,6 +29,9 @@ npx @brunosps00/dev-workflow install-deps
 #### `/dw-brainstorm`
 Facilitates structured ideation before opening a PRD or implementation. Explores multiple directions — conservative, balanced, and bold — with trade-offs for each, then converges on concrete next steps. No code is written or files modified.
 
+#### `/dw-autopilot`
+Full pipeline orchestrator that takes a wish and automatically runs the entire development flow: codebase intelligence, research (conditional), brainstorm, PRD, techspec, tasks, execution, QA, review, and commit. Stops at 3 gates: PRD approval, tasks approval, and PR confirmation. With GSD installed, leverages plan verification and parallel execution.
+
 #### `/dw-create-prd`
 Creates a Product Requirements Document by first asking at least 7 clarification questions to fully understand the feature. Generates a structured PRD with numbered functional requirements focused on what and why, saved to `.dw/spec/prd-[feature-name]/prd.md`.
 
@@ -105,6 +108,10 @@ Displays the complete guide of available commands, integration flows, and when t
 ```
                         /dw-resume (pick up where you left off)
                             |
+/dw-autopilot "wish"  ------>  Runs entire pipeline automatically
+                                (gates: PRD approval, Tasks approval, PR confirmation)
+    --- OR ---
+
 /dw-brainstorm  ------>  /dw-create-prd  -->  .dw/spec/prd-{name}/prd.md
                             |
                         /dw-create-techspec  -->  .dw/spec/prd-{name}/techspec.md
@@ -147,7 +154,7 @@ All wrappers point to `.dw/commands/` as the single source of truth.
 ```
 your-project/
 ├── .dw/
-│   ├── commands/          # 22 workflow command files
+│   ├── commands/          # 23 workflow command files
 │   ├── templates/         # Document templates (PRD, TechSpec, etc.)
 │   ├── rules/             # Project-specific rules (run /dw-analyze-project)
 │   ├── references/        # Reference documentation

package/lib/constants.js

@@ -1,6 +1,7 @@
 const COMMANDS = {
   en: [
     { name: 'dw-analyze-project', description: 'Analyze repository stack, patterns, and conventions to generate project rules' },
+    { name: 'dw-autopilot', description: 'Full pipeline orchestrator: from a wish to a PR with minimal intervention (research, PRD, tasks, execution, QA, review, commit)' },
     { name: 'dw-brainstorm', description: 'Explore ideas and directions before starting implementation' },
     { name: 'dw-bugfix', description: 'Analyze and fix bugs with automatic triage (bug vs feature vs scope)' },
     { name: 'dw-code-review', description: 'Formal code review (Level 3) with persisted report' },
@@ -25,6 +26,7 @@ const COMMANDS = {
   ],
   'pt-br': [
     { name: 'dw-analyze-project', description: 'Analisa stack, patterns e convencoes do repositorio para gerar regras do projeto' },
+    { name: 'dw-autopilot', description: 'Orquestrador completo: de um desejo ate o PR com minima intervencao (pesquisa, PRD, tasks, execucao, QA, review, commit)' },
     { name: 'dw-brainstorm', description: 'Explorar ideias e direcoes antes de comecar a implementacao' },
     { name: 'dw-bugfix', description: 'Analisar e corrigir bugs com triagem automatica (bug vs feature vs escopo)' },
     { name: 'dw-code-review', description: 'Code review formal (Nivel 3) com relatorio persistido' },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brunosps00/dev-workflow",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "AI-driven development workflow commands for any project. Scaffolds a complete PRD-to-PR pipeline with multi-platform AI assistant support.",
   "bin": {
     "dev-workflow": "./bin/dev-workflow.js"

package/scaffold/en/commands/dw-analyze-project.md

@@ -230,6 +230,8 @@ For each module/project detected, identify:
 When React is detected, run `npx react-doctor@latest --verbose` and include the health score in the generated rules as a baseline metric.
 For Angular projects, run `ng lint` and document any warnings as baseline.
 
+<critical>If GSD is installed, running /gsd-map-codebase is MANDATORY. The command CANNOT be considered complete without executing ALL applicable steps, including generating the index in .planning/intel/.</critical>
+
 #### Codebase Intelligence (GSD)
 
 If GSD (get-shit-done-cc) is installed in the project:

package/scaffold/en/commands/dw-autopilot.md

@@ -0,0 +1,216 @@
+<system_instructions>
+You are a full pipeline orchestrator. This command receives a user's wish and automatically executes the entire development flow, from research to commit, stopping only at critical gates.
+
+<critical>This command MUST execute ALL applicable pipeline steps. Do NOT skip any step. If a step is conditional, evaluate the condition and execute if applicable.</critical>
+<critical>The ONLY pause moments are the 3 gates defined below. Between gates, execute everything automatically without asking for confirmation.</critical>
+<critical>Each step MUST follow the complete instructions from the corresponding command in `.dw/commands/`. Read and execute the full command, not a summarized version.</critical>
+
+## When to Use
+- Use when you want to go from an idea to a PR with minimal manual intervention
+- Use for complete features that go through the entire pipeline (research, planning, execution, quality)
+- Do NOT use for one-off changes (use `/dw-quick`)
+- Do NOT use to fix bugs (use `/dw-bugfix`)
+- Do NOT use when you want manual control between each phase (use individual commands)
+
+## Pipeline Position
+**Predecessor:** (user's wish) | **Successor:** (PR merge)
+
+## Input Variables
+
+| Variable | Description | Example |
+|----------|-------------|---------|
+| `{{WISH}}` | Description of what the user wants to build | "push notification system with per-channel preferences" |
+
+## Approval Gates
+
+The autopilot stops ONLY at these 3 moments:
+
+1. **GATE 1 — PRD**: Presents the generated PRD and awaits user approval before generating techspec/tasks
+2. **GATE 2 — Tasks**: Presents the task list and awaits approval before starting execution
+3. **GATE 3 — PR**: After automatic commit, asks if the user wants to generate the Pull Request
+
+## Session Resumption
+
+If this command is invoked to resume an interrupted autopilot (via `/dw-resume`):
+
+<critical>Read the `autopilot-state.json` file in the PRD directory. Skip ALL steps listed in `completed_steps`. Resume execution from `current_step`. Gates already passed (listed in `gates_passed`) MUST NOT be re-presented.</critical>
+
+1. Read `.dw/spec/prd-[name]/autopilot-state.json`
+2. Report: "Resuming autopilot from step [N] ([name]). Steps 1-[N-1] already completed."
+3. Continue execution normally from the indicated step
+
+## Full Pipeline
+
+### Step 1: Codebase Intelligence
+
+<critical>If `.planning/intel/` exists, querying it is MANDATORY before starting.</critical>
+
+- Query `.planning/intel/` via `/gsd-intel` (if available) or `.dw/rules/` to understand project context
+- Identify: tech stack, existing patterns, related features
+
+### Step 2: Research (Conditional)
+
+Evaluate whether the topic requires deep research:
+- **YES** (run `/dw-deep-research`): new technology for the project, unknown domain, external API integrations, critical architectural decisions
+- **NO** (skip to step 3): simple feature in an already mapped domain, refactoring existing code, basic CRUD
+
+If executed, use `standard` mode by default. Incorporate findings into subsequent steps.
+
+### Step 3: Brainstorm
+
+Run `/dw-brainstorm` with accumulated context (intel + research).
+- Generate 3 directions
+- Automatically converge on the most pragmatic option for the project context
+- Do NOT wait for user approval (brainstorm is automatic in autopilot)
+
+### Step 4: PRD
+
+Run `/dw-create-prd` using brainstorm findings.
+- Follow all command instructions (clarification questions answered based on accumulated context)
+- Generate the complete PRD in `.dw/spec/prd-[name]/prd.md`
+
+### === GATE 1: PRD Approval ===
+
+Present to the user:
+- Summary of functional requirements
+- Decisions made automatically
+- Open questions (if any)
+
+**Wait for explicit approval.** If the user requests changes, adjust and re-present.
+
+### Step 5: TechSpec
+
+Run `/dw-create-techspec` from the approved PRD.
+- Follow all command instructions
+- Generate in `.dw/spec/prd-[name]/techspec.md`
+
+### Step 6: Tasks
+
+Run `/dw-create-tasks` from PRD + TechSpec.
+- Follow all command instructions
+- Generate individual tasks in `.dw/spec/prd-[name]/`
+
+### === GATE 2: Tasks Approval ===
+
+Present to the user:
+- Task list with brief descriptions
+- Dependencies between tasks
+- Total effort estimate
+
+**Wait for explicit approval.** If the user requests changes, adjust and re-present.
+
+### Step 7: Design Contract (Conditional)
+
+Evaluate whether tasks involve frontend:
+- **YES** (run `/dw-redesign-ui`): if there are tasks with visual components AND the `ui-ux-pro-max` skill is available
+  - Generate the design contract in `.dw/spec/prd-[name]/design-contract.md`
+  - Do NOT wait for approval (contract is automatic in autopilot, based on PRD requirements)
+- **NO** (skip to step 8): purely backend/infra tasks
+
+### Step 8: Execution
+
+Run `/dw-run-plan` with the PRD path.
+- Follow ALL command instructions, including GSD integration (plan verification, parallel execution)
+- Each task follows `/dw-run-task` with Level 1 validation
+
+### Step 9: Implementation Review (Loop)
+
+Run `/dw-review-implementation` to verify PRD compliance (Level 2).
+- If gaps found: fix automatically and re-run the review
+- Maximum 3 correction cycles
+- Do NOT advance to QA until the review passes
+
+### Step 10: Visual QA
+
+Run `/dw-run-qa` with Playwright MCP.
+- Test happy paths, edge cases, negative flows, accessibility
+- Document bugs with screenshots
+
+### Step 11: Fix QA (Conditional)
+
+If QA found bugs:
+- Run `/dw-fix-qa` to fix and retest
+- Loop until stable
+
+### Step 12: Implementation Review (Post-QA)
+
+Run `/dw-review-implementation` again to confirm QA fixes did not break PRD compliance.
+- If gaps found: fix and re-run
+- Maximum 3 cycles
+
+### Step 13: Code Review
+
+Run `/dw-code-review` (Level 3) for formal review.
+- Generate persisted report
+
+### Step 14: Commit
+
+Run `/dw-commit` automatically.
+- Semantic commits following Conventional Commits
+- Do NOT wait for approval
+
+### === GATE 3: Pull Request ===
+
+Ask the user: **"Commits completed. Do you want to generate the Pull Request?"**
+
+- **YES**: run `/dw-generate-pr` with the target branch
+- **NO**: inform that commits are ready and the user can generate the PR manually later
+
+## GSD Integration
+
+<critical>When GSD is installed, ALL GSD integrations from each individual command MUST be executed. The autopilot is not an excuse to skip GSD steps.</critical>
+
+If GSD (get-shit-done-cc) is installed:
+- Step 1: use `/gsd-intel` for querying
+- Step 8: use plan verification + parallel execution
+- All commands: follow their individual GSD sections
+
+If GSD is NOT installed:
+- All commands work normally without GSD
+
+## State Persistence
+
+<critical>The autopilot MUST save its state after each completed step to allow resumption via `/dw-resume` in case of interruption.</critical>
+
+Save the file `.dw/spec/prd-[name]/autopilot-state.json` with the following format:
+
+```json
+{
+  "mode": "autopilot",
+  "wish": "original user description",
+  "prd_path": ".dw/spec/prd-[name]",
+  "current_step": 8,
+  "completed_steps": [1, 2, 3, 4, 5, 6, 7],
+  "skipped_steps": [2],
+  "gates_passed": ["prd", "tasks"],
+  "started_at": "2026-04-10T14:30:00Z",
+  "last_updated": "2026-04-10T15:45:00Z"
+}
+```
+
+- Update `current_step` and `completed_steps` BEFORE starting each step
+- If the session drops, `/dw-resume` will read this file and continue from the correct step
+- When the pipeline finishes (after commit or PR), remove the file or mark `"status": "completed"`
+
+## Progress Format
+
+During execution, report progress in this format:
+
+```
+=== AUTOPILOT =====================================
+  OK [1/14] Codebase Intelligence
+  OK [2/14] Research (skipped — known domain)
+  OK [3/14] Brainstorm
+  OK [4/14] PRD
+  PAUSE [GATE 1] Awaiting PRD approval...
+===================================================
+```
+
+## Closing
+
+At the end, present:
+- PR link (if generated)
+- Summary: steps executed, steps skipped, estimated time saved
+- Suggested next steps (merge, deploy, etc.)
+
+</system_instructions>

package/scaffold/en/commands/dw-code-review.md

@@ -26,7 +26,7 @@ When available in the project under `./.agents/skills/`, use these skills as ana
 
 ## Codebase Intelligence
 
-If `.planning/intel/` exists, query before analysis:
+<critical>If `.planning/intel/` exists, querying it is MANDATORY before writing requirements. Do NOT skip this step.</critical>
 - Internally run: `/gsd-intel "documented conventions, anti-patterns, and decision spaces"`
 - Prioritize findings that violate documented conventions
 - Check if questionable architectural decisions are intentional (documented as decision spaces)

package/scaffold/en/commands/dw-create-prd.md

@@ -34,7 +34,7 @@
 
     ## Codebase Intelligence
 
-    If `.planning/intel/` exists, query before writing requirements:
+    <critical>If `.planning/intel/` exists, querying it is MANDATORY before writing requirements. Do NOT skip this step.</critical>
     - Internally run: `/gsd-intel "existing features in the [PRD topic] domain"`
     - Use findings to avoid duplicating existing functionality and reference established patterns
 

package/scaffold/en/commands/dw-create-techspec.md

@@ -23,7 +23,7 @@
 
     ## Codebase Intelligence
 
-    If `.planning/intel/` exists, query before proposing architecture:
+    <critical>If `.planning/intel/` exists, querying it is MANDATORY before writing requirements. Do NOT skip this step.</critical>
     - Internally run: `/gsd-intel "architectural patterns and technical decisions in the project"`
     - Align proposals with existing patterns; flag deviations explicitly
 

package/scaffold/en/commands/dw-help.md

@@ -105,6 +105,7 @@ This workspace uses an AI command system that automates the full development cyc
 | `/dw-quick` | Execute a one-off task with workflow guarantees without PRD | Change description | Code + commit |
 | `/dw-resume` | Restore session context and suggest next step | (none) | Summary + suggestion |
 | `/dw-intel` | Query codebase intelligence about patterns and architecture | Question | Answer with sources |
+| `/dw-autopilot` | Full pipeline orchestrator: from a wish to a PR with minimal intervention | Wish description | PRD + code + commits + PR |
 
 ### Research
 
@@ -237,6 +238,11 @@ LEVEL 3 - Formal Code Review (/dw-code-review)
 /dw-generate-pr main                               # 5. PR
 ```
 
+### Autopilot (Full Pipeline)
+```bash
+/dw-autopilot "description of what you want to build"  # Research → PRD → Tasks → Code → QA → PR
+```
+
 ### Quick Task
 ```bash
 /dw-quick "change description"                     # Implement + validate + commit
@@ -275,6 +281,7 @@ your-project/
 │   │   ├── dw-refactoring-analysis.md
 │   │   ├── dw-review-implementation.md
 │   │   ├── dw-analyze-project.md
+│   │   ├── dw-autopilot.md
 │   │   ├── dw-deep-research.md
 │   │   ├── dw-intel.md
 │   │   ├── dw-quick.md
@@ -348,4 +355,7 @@ Commands work across multiple AI tools, all pointing to the same source `.dw/com
 **Q: Does `/dw-quick` replace `/dw-run-task`?**
 - No. `/dw-quick` is for one-off changes without a PRD. `/dw-run-task` executes tasks from a structured plan with PRD and TechSpec.
 
+**Q: Does `/dw-autopilot` replace all other commands?**
+- No. It orchestrates existing commands in sequence. You can still use each command individually for manual control. Autopilot is for when you want to go from a wish to a PR with minimal intervention.
+
 </system_instructions>

package/scaffold/en/commands/dw-intel.md

@@ -31,6 +31,8 @@ You are a codebase intelligence assistant. This command exists to answer questio
 
 ## GSD Integration
 
+<critical>When .planning/intel/ exists, querying via /gsd-intel is MANDATORY as the primary source. Do NOT skip this query.</critical>
+
 If GSD (get-shit-done-cc) is installed and `.planning/intel/` exists:
 - Delegate to `/gsd-intel "{{QUERY}}"` for indexed lookup
 - GSD returns information from: architectural assumptions, decision spaces, behavioral references, UI patterns

package/scaffold/en/commands/dw-quick.md

@@ -31,6 +31,8 @@ You are a quick task executor. This command exists to implement one-off changes
 
 ## GSD Integration
 
+<critical>When GSD is installed, delegation to /gsd-quick is MANDATORY for tracking.</critical>
+
 If GSD (get-shit-done-cc) is installed in the project:
 - Delegate to `/gsd-quick` for tracking in `.planning/quick/`
 - The task is registered in history for future lookup via `/dw-intel`

package/scaffold/en/commands/dw-redesign-ui.md

@@ -65,6 +65,8 @@ Use diagnostic tools based on the project's framework:
 
 ## GSD Integration
 
+<critical>When GSD is installed, registering the design contract in .planning/ and querying .planning/intel/ are MANDATORY.</critical>
+
 If GSD (get-shit-done-cc) is installed in the project:
 - After generating the design contract, register in `.planning/` for cross-session persistence
 - Query `.planning/intel/` in the audit phase for existing UI patterns

package/scaffold/en/commands/dw-refactoring-analysis.md

@@ -30,7 +30,7 @@ For Angular projects, use `ng lint` as an analytical complement.
 
 ## Codebase Intelligence
 
-If `.planning/intel/` exists, query before the audit:
+<critical>If `.planning/intel/` exists, querying it is MANDATORY before writing requirements. Do NOT skip this step.</critical>
 - Internally run: `/gsd-intel "tech debt, decision spaces, and known technical debt"`
 - Contextualize findings with already documented decisions
 - Avoid flagging as a smell something that is an intentional recorded decision

package/scaffold/en/commands/dw-resume.md

@@ -13,6 +13,19 @@ You are a session continuity assistant. This command exists to restore context f
 
 ## Required Behavior
 
+<critical>BEFORE any analysis, check for an interrupted autopilot. Look for `autopilot-state.json` in ALL directories inside `.dw/spec/`. If you find one without `"status": "completed"`, autopilot resumption takes PRIORITY over any other suggestion.</critical>
+
+### Interrupted Autopilot Detection
+
+1. Search for `.dw/spec/*/autopilot-state.json`
+2. If you find a file with `"mode": "autopilot"` and no `"status": "completed"`:
+   - Present: original wish, step where it stopped, steps already completed
+   - Ask: **"Found an interrupted autopilot at step [N] ([step name]). Do you want to continue where you left off?"**
+   - If **YES**: run `/dw-autopilot` instructing it to resume from `current_step` using the state file. The autopilot must read the state and skip already completed steps.
+   - If **NO**: continue with the normal resume flow below
+
+### Normal Flow (no pending autopilot)
+
 1. Read `.dw/spec/` and identify PRDs with pending tasks (`- [ ]` checkboxes in tasks.md)
 2. Read `git log --oneline -10` to identify the last work performed
 3. Identify the active branch and whether there are uncommitted changes
@@ -22,6 +35,8 @@ You are a session continuity assistant. This command exists to restore context f
 
 ## GSD Integration
 
+<critical>When GSD is installed, delegation to /gsd-resume-work is MANDATORY, not optional.</critical>
+
 If GSD (get-shit-done-cc) is installed in the project:
 - Delegate to `/gsd-resume-work` for cross-session state restoration from `.planning/STATE.md`
 - Incorporate additional context: persistent threads, backlog, notes

package/scaffold/en/commands/dw-run-plan.md

@@ -143,6 +143,8 @@ If a task FAILS during execution:
 
 ## GSD Integration
 
+<critical>When GSD is installed, plan verification and parallel execution are MANDATORY, not optional. The command MUST NOT skip these steps.</critical>
+
 ### Plan Verification (Pre-Execution)
 
 If GSD (get-shit-done-cc) is installed in the project:

package/scaffold/en/commands/dw-run-task.md

@@ -23,7 +23,7 @@ When available in the project at `./.agents/skills/`, use these skills as specia
 
 ## Codebase Intelligence
 
-If `.planning/intel/` exists, query before implementing:
+<critical>If `.planning/intel/` exists, querying it is MANDATORY before writing requirements. Do NOT skip this step.</critical>
 - Internally run: `/gsd-intel "implementation patterns in [task target area]"`
 - Follow conventions found for file structure, naming, and error handling
 

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

@@ -218,6 +218,8 @@ Para cada projeto/módulo detectado, identificar:
 Quando React for detectado, execute `npx react-doctor@latest --verbose` e inclua o health score nas rules geradas como métrica baseline.
 Para projetos Angular, execute `ng lint` e documente warnings como baseline.
 
+<critical>Se o GSD estiver instalado, a execução do /gsd-map-codebase é OBRIGATÓRIA. O comando NÃO pode ser considerado completo sem executar TODOS os passos aplicáveis, incluindo a geração do índice em .planning/intel/.</critical>
+
 #### Inteligência do Codebase (GSD)
 
 Se o GSD (get-shit-done-cc) estiver instalado no projeto:

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

@@ -0,0 +1,216 @@
+<system_instructions>
+Voce e um orquestrador de pipeline completo. Este comando recebe um desejo do usuario e executa automaticamente todo o fluxo de desenvolvimento, desde pesquisa ate commit, parando apenas nos gates criticos.
+
+<critical>Este comando DEVE executar TODAS as etapas aplicaveis do pipeline. NAO pule nenhuma etapa. Se uma etapa e condicional, avalie a condicao e execute se aplicavel.</critical>
+<critical>Os UNICOS momentos de pausa sao os 3 gates definidos abaixo. Entre os gates, execute tudo automaticamente sem pedir confirmacao.</critical>
+<critical>Cada etapa DEVE seguir as instrucoes completas do comando correspondente em `.dw/commands/`. Leia e execute o comando inteiro, nao uma versao resumida.</critical>
+
+## Quando Usar
+- Use quando quiser ir de uma ideia ate um PR com minima intervencao manual
+- Use para features completas que passam por todo o pipeline (pesquisa, planejamento, execucao, qualidade)
+- NAO use para mudancas pontuais (use `/dw-quick`)
+- NAO use para corrigir bugs (use `/dw-bugfix`)
+- NAO use quando quiser controle manual entre cada fase (use os comandos individuais)
+
+## Posicao no Pipeline
+**Antecessor:** (desejo do usuario) | **Sucessor:** (merge do PR)
+
+## Variaveis de Entrada
+
+| Variavel | Descricao | Exemplo |
+|----------|-----------|---------|
+| `{{WISH}}` | Descricao do que o usuario quer construir | "sistema de notificacoes push com preferencias por canal" |
+
+## Gates de Aprovacao
+
+O autopilot para APENAS nestes 3 momentos:
+
+1. **GATE 1 — PRD**: Apresenta o PRD gerado e aguarda aprovacao do usuario antes de gerar techspec/tasks
+2. **GATE 2 — Tasks**: Apresenta a lista de tasks e aguarda aprovacao antes de iniciar a execucao
+3. **GATE 3 — PR**: Apos commit automatico, pergunta se o usuario quer gerar o Pull Request
+
+## Retomada de Sessao
+
+Se este comando for invocado para retomar um autopilot interrompido (via `/dw-resume`):
+
+<critical>Leia o arquivo `autopilot-state.json` no diretorio do PRD. Pule TODAS as etapas listadas em `completed_steps`. Retome a execucao a partir de `current_step`. Gates ja passados (listados em `gates_passed`) NAO devem ser reapresentados.</critical>
+
+1. Leia `.dw/spec/prd-[nome]/autopilot-state.json`
+2. Reporte: "Retomando autopilot da etapa [N] ([nome]). Etapas 1-[N-1] ja completadas."
+3. Continue a execucao normalmente a partir da etapa indicada
+
+## Pipeline Completo
+
+### Etapa 1: Inteligencia do Codebase
+
+<critical>Se `.planning/intel/` existir, a consulta e OBRIGATORIA antes de iniciar.</critical>
+
+- Consulte `.planning/intel/` via `/gsd-intel` (se disponivel) ou `.dw/rules/` para entender o contexto do projeto
+- Identifique: stack tecnologica, padroes existentes, features relacionadas
+
+### Etapa 2: Pesquisa (Condicional)
+
+Avalie se o topico necessita de pesquisa profunda:
+- **SIM** (execute `/dw-deep-research`): tecnologia nova para o projeto, dominio desconhecido, integracoes com APIs externas, decisoes arquiteturais criticas
+- **NAO** (pule para etapa 3): feature simples no dominio ja mapeado, refatoracao de algo existente, CRUD basico
+
+Se executar, use modo `standard` por padrao. Incorpore os findings nas etapas seguintes.
+
+### Etapa 3: Brainstorm
+
+Execute `/dw-brainstorm` com o contexto acumulado (intel + pesquisa).
+- Gere 3 direcoes
+- Convirja automaticamente na opcao mais pragmatica para o contexto do projeto
+- NAO aguarde aprovacao do usuario (brainstorm e automatico no autopilot)
+
+### Etapa 4: PRD
+
+Execute `/dw-create-prd` usando os findings do brainstorm.
+- Siga todas as instrucoes do comando (perguntas de esclarecimento respondidas com base no contexto acumulado)
+- Gere o PRD completo em `.dw/spec/prd-[nome]/prd.md`
+
+### ═══ GATE 1: Aprovacao do PRD ═══
+
+Apresente ao usuario:
+- Resumo dos requisitos funcionais
+- Decisoes tomadas automaticamente
+- Questoes em aberto (se houver)
+
+**Aguarde aprovacao explicita.** Se o usuario pedir mudancas, ajuste e reapresente.
+
+### Etapa 5: TechSpec
+
+Execute `/dw-create-techspec` a partir do PRD aprovado.
+- Siga todas as instrucoes do comando
+- Gere em `.dw/spec/prd-[nome]/techspec.md`
+
+### Etapa 6: Tasks
+
+Execute `/dw-create-tasks` a partir do PRD + TechSpec.
+- Siga todas as instrucoes do comando
+- Gere tasks individuais em `.dw/spec/prd-[nome]/`
+
+### ═══ GATE 2: Aprovacao das Tasks ═══
+
+Apresente ao usuario:
+- Lista de tasks com descricao resumida
+- Dependencias entre tasks
+- Estimativa de esforco total
+
+**Aguarde aprovacao explicita.** Se o usuario pedir mudancas, ajuste e reapresente.
+
+### Etapa 7: Design Contract (Condicional)
+
+Avalie se as tasks envolvem frontend:
+- **SIM** (execute `/dw-redesign-ui`): se houver tasks com componentes visuais E a skill `ui-ux-pro-max` estiver disponivel
+  - Gere o design contract em `.dw/spec/prd-[nome]/design-contract.md`
+  - NAO aguarde aprovacao (o contract e automatico no autopilot, baseado nos requisitos do PRD)
+- **NAO** (pule para etapa 8): tasks puramente backend/infra
+
+### Etapa 8: Execucao
+
+Execute `/dw-run-plan` com o path do PRD.
+- Siga TODAS as instrucoes do comando, incluindo integracao GSD (verificacao de plano, execucao paralela)
+- Cada task segue `/dw-run-task` com validacao Level 1
+
+### Etapa 9: Review de Implementacao (Loop)
+
+Execute `/dw-review-implementation` para verificar PRD compliance (Level 2).
+- Se encontrar gaps: corrija automaticamente e re-execute o review
+- Maximo 3 ciclos de correcao
+- NAO avance para QA ate que o review passe
+
+### Etapa 10: QA Visual
+
+Execute `/dw-run-qa` com Playwright MCP.
+- Teste happy paths, edge cases, fluxos negativos, acessibilidade
+- Documente bugs com screenshots
+
+### Etapa 11: Fix QA (Condicional)
+
+Se o QA encontrou bugs:
+- Execute `/dw-fix-qa` para corrigir e retestar
+- Loop ate estabilizar
+
+### Etapa 12: Review de Implementacao (Pos-QA)
+
+Execute `/dw-review-implementation` novamente para confirmar que as correcoes do QA nao quebraram PRD compliance.
+- Se encontrar gaps: corrija e re-execute
+- Maximo 3 ciclos
+
+### Etapa 13: Code Review
+
+Execute `/dw-code-review` (Level 3) para review formal.
+- Gere relatorio persistido
+
+### Etapa 14: Commit
+
+Execute `/dw-commit` automaticamente.
+- Commits semanticos seguindo Conventional Commits
+- NAO aguarde aprovacao
+
+### ═══ GATE 3: Pull Request ═══
+
+Pergunte ao usuario: **"Commits realizados. Deseja gerar o Pull Request?"**
+
+- **SIM**: execute `/dw-generate-pr` com o branch alvo
+- **NAO**: informe que os commits estao prontos e o usuario pode gerar o PR manualmente depois
+
+## Integracao GSD
+
+<critical>Quando o GSD estiver instalado, TODAS as integracoes GSD de cada comando individual DEVEM ser executadas. O autopilot nao e desculpa para pular passos do GSD.</critical>
+
+Se o GSD (get-shit-done-cc) estiver instalado:
+- Etapa 1: use `/gsd-intel` para consulta
+- Etapa 8: use verificacao de plano + execucao paralela
+- Todos os comandos: sigam suas secoes GSD individuais
+
+Se o GSD NAO estiver instalado:
+- Todos os comandos funcionam normalmente sem GSD
+
+## Persistencia de Estado
+
+<critical>O autopilot DEVE salvar seu estado apos cada etapa completada para permitir retomada via `/dw-resume` em caso de interrupcao.</critical>
+
+Salve o arquivo `.dw/spec/prd-[nome]/autopilot-state.json` com o seguinte formato:
+
+```json
+{
+  "mode": "autopilot",
+  "wish": "descricao original do usuario",
+  "prd_path": ".dw/spec/prd-[nome]",
+  "current_step": 8,
+  "completed_steps": [1, 2, 3, 4, 5, 6, 7],
+  "skipped_steps": [2],
+  "gates_passed": ["prd", "tasks"],
+  "started_at": "2026-04-10T14:30:00Z",
+  "last_updated": "2026-04-10T15:45:00Z"
+}
+```
+
+- Atualize `current_step` e `completed_steps` ANTES de iniciar cada etapa
+- Se a sessao cair, o `/dw-resume` lera este arquivo e continuara da etapa correta
+- Ao finalizar o pipeline (apos commit ou PR), remova o arquivo ou marque `"status": "completed"`
+
+## Formato de Progresso
+
+Durante a execucao, reporte progresso no formato:
+
+```
+═══ AUTOPILOT ═══════════════════════════════
+  ✅ [1/14] Inteligencia do Codebase
+  ✅ [2/14] Pesquisa (pulada — dominio conhecido)
+  ✅ [3/14] Brainstorm
+  ✅ [4/14] PRD
+  ⏸️ [GATE 1] Aguardando aprovacao do PRD...
+═════════════════════════════════════════════
+```
+
+## Encerramento
+
+Ao final, apresente:
+- Link do PR (se gerado)
+- Resumo: etapas executadas, etapas puladas, tempo estimado economizado
+- Proximos passos sugeridos (merge, deploy, etc.)
+
+</system_instructions>

package/scaffold/pt-br/commands/dw-code-review.md

@@ -26,7 +26,7 @@ Quando disponíveis no projeto em `./.agents/skills/`, use estas skills como apo
 
 ## Inteligência do Codebase
 
-Se `.planning/intel/` existir, consulte antes da análise:
+<critical>Se `.planning/intel/` existir, a consulta é OBRIGATÓRIA antes de redigir os requisitos. NÃO pule este passo.</critical>
 - Execute internamente: `/gsd-intel "convenções, anti-patterns e decision spaces documentados"`
 - Priorize findings que violem convenções documentadas
 - Verifique se decisões arquiteturais questionáveis são intencionais (documentadas como decision spaces)

package/scaffold/pt-br/commands/dw-create-prd.md

@@ -34,7 +34,7 @@
 
     ## Inteligência do Codebase
 
-    Se `.planning/intel/` existir, consulte antes de redigir os requisitos:
+    <critical>Se `.planning/intel/` existir, a consulta é OBRIGATÓRIA antes de redigir os requisitos. NÃO pule este passo.</critical>
     - Execute internamente: `/gsd-intel "features existentes no domínio de [tópico do PRD]"`
     - Use os findings para evitar duplicar funcionalidade existente e referenciar padrões já estabelecidos
 

package/scaffold/pt-br/commands/dw-create-techspec.md

@@ -23,7 +23,7 @@
 
     ## Inteligência do Codebase
 
-    Se `.planning/intel/` existir, consulte antes de propor arquitetura:
+    <critical>Se `.planning/intel/` existir, a consulta é OBRIGATÓRIA antes de redigir os requisitos. NÃO pule este passo.</critical>
     - Execute internamente: `/gsd-intel "padrões arquiteturais e decisões técnicas do projeto"`
     - Alinhe propostas com padrões existentes; sinalize desvios explicitamente
 

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

@@ -92,6 +92,7 @@ Este workspace utiliza um sistema de comandos AI que automatiza o ciclo completo
 | `/dw-quick` | Executa task pontual com garantias do workflow sem PRD | Descrição da mudança | Código + commit |
 | `/dw-resume` | Restaura contexto da sessão e sugere próximo passo | (nenhum) | Resumo + sugestão |
 | `/dw-intel` | Consulta inteligência do codebase sobre padrões e arquitetura | Pergunta | Resposta com fontes |
+| `/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
 
@@ -189,6 +190,11 @@ Este workspace utiliza um sistema de comandos AI que automatiza o ciclo completo
 /dw-generate-pr main                               # 5. PR
 ```
 
+### Autopilot (Pipeline Completo)
+```bash
+/dw-autopilot "descrição do que quer construir"    # Pesquisa → PRD → Tasks → Código → QA → PR
+```
+
 ### Task Rápida
 ```bash
 /dw-quick "descrição da mudança"                   # Implementa + valida + commit
@@ -218,6 +224,7 @@ workspace/
 │   ├── 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
@@ -287,4 +294,7 @@ workspace/
 **Q: O `/dw-quick` substitui o `/dw-run-task`?**
 - Não. `/dw-quick` é para mudanças pontuais sem PRD. `/dw-run-task` executa tasks de um plano estruturado com PRD e TechSpec.
 
+**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.
+
 </system_instructions>

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

@@ -31,6 +31,8 @@ Voce e um assistente de inteligencia do codebase. Este comando existe para respo
 
 ## Integracao GSD
 
+<critical>Quando .planning/intel/ existir, a consulta via /gsd-intel é OBRIGATÓRIA como fonte primária. NÃO pule esta consulta.</critical>
+
 Se o GSD (get-shit-done-cc) estiver instalado e `.planning/intel/` existir:
 - Delegue para `/gsd-intel "{{QUERY}}"` para consulta indexada
 - O GSD retorna informacoes de: architectural assumptions, decision spaces, behavioral references, UI patterns

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

@@ -31,6 +31,8 @@ Voce e um executor de tasks rapidas. Este comando existe para implementar mudanc
 
 ## Integracao GSD
 
+<critical>Quando o GSD estiver instalado, a delegação para /gsd-quick é OBRIGATÓRIA para tracking.</critical>
+
 Se o GSD (get-shit-done-cc) estiver instalado no projeto:
 - Delegue para `/gsd-quick` para tracking em `.planning/quick/`
 - A task fica registrada no historico para consulta futura via `/dw-intel`

package/scaffold/pt-br/commands/dw-redesign-ui.md

@@ -65,6 +65,8 @@ Utilize ferramentas de diagnóstico conforme o framework do projeto:
 
 ## Integração GSD
 
+<critical>Quando o GSD estiver instalado, o registro do design contract em .planning/ e a consulta de .planning/intel/ são OBRIGATÓRIOS.</critical>
+
 Se o GSD (get-shit-done-cc) estiver instalado no projeto:
 - Após gerar o design contract, registre em `.planning/` para persistência cross-sessão
 - Consulte `.planning/intel/` na fase de auditoria para UI patterns existentes

package/scaffold/pt-br/commands/dw-refactoring-analysis.md

@@ -30,7 +30,7 @@ Para projetos Angular, use `ng lint` como complemento analítico.
 
 ## Inteligência do Codebase
 
-Se `.planning/intel/` existir, consulte antes da auditoria:
+<critical>Se `.planning/intel/` existir, a consulta é OBRIGATÓRIA antes de redigir os requisitos. NÃO pule este passo.</critical>
 - Execute internamente: `/gsd-intel "tech debt, decision spaces e dívida técnica conhecida"`
 - Contextualize findings com decisões já documentadas
 - Evite sinalizar como smell algo que é uma decisão intencional registrada

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

@@ -13,6 +13,19 @@ Voce e um assistente de continuidade de sessao. Este comando existe para restaur
 
 ## Comportamento Obrigatorio
 
+<critical>ANTES de qualquer analise, verifique se existe um autopilot interrompido. Procure por `autopilot-state.json` em TODOS os diretorios dentro de `.dw/spec/`. Se encontrar um com status diferente de "completed", a retomada do autopilot tem PRIORIDADE sobre qualquer outra sugestao.</critical>
+
+### Deteccao de Autopilot Interrompido
+
+1. Procure por `.dw/spec/*/autopilot-state.json`
+2. Se encontrar um arquivo com `"mode": "autopilot"` e sem `"status": "completed"`:
+   - Apresente: desejo original, etapa em que parou, etapas ja completadas
+   - Pergunte: **"Encontrei um autopilot interrompido na etapa [N] ([nome da etapa]). Deseja continuar de onde parou?"**
+   - Se **SIM**: execute `/dw-autopilot` informando que deve retomar a partir da etapa `current_step` usando o state file. O autopilot deve ler o state e pular as etapas ja completadas.
+   - Se **NAO**: continue com o fluxo normal de resume abaixo
+
+### Fluxo Normal (sem autopilot pendente)
+
 1. Leia `.dw/spec/` e identifique PRDs com tasks pendentes (checkboxes `- [ ]` em tasks.md)
 2. Leia `git log --oneline -10` para identificar o ultimo trabalho realizado
 3. Identifique a branch ativa e se ha mudancas nao commitadas
@@ -22,6 +35,8 @@ Voce e um assistente de continuidade de sessao. Este comando existe para restaur
 
 ## Integracao GSD
 
+<critical>Quando o GSD estiver instalado, a delegação para /gsd-resume-work é OBRIGATÓRIA, não opcional.</critical>
+
 Se o GSD (get-shit-done-cc) estiver instalado no projeto:
 - Delegue para `/gsd-resume-work` para restaurar estado cross-sessao de `.planning/STATE.md`
 - Incorpore contexto adicional: threads persistentes, backlog, notas

package/scaffold/pt-br/commands/dw-run-plan.md

@@ -136,6 +136,8 @@ Se uma tarefa FALHAR durante a execução:
 
 ## Integração GSD
 
+<critical>Quando o GSD estiver instalado, a verificação de plano e a execução paralela são OBRIGATÓRIAS, não opcionais. O comando NÃO pode pular estes passos.</critical>
+
 ### Verificação de Plano (Pré-Execução)
 
 Se o GSD (get-shit-done-cc) estiver instalado no projeto:

package/scaffold/pt-br/commands/dw-run-task.md

@@ -23,7 +23,7 @@ Quando disponíveis no projeto em `./.agents/skills/`, use estas skills como sup
 
 ## Inteligência do Codebase
 
-Se `.planning/intel/` existir, consulte antes de implementar:
+<critical>Se `.planning/intel/` existir, a consulta é OBRIGATÓRIA antes de redigir os requisitos. NÃO pule este passo.</critical>
 - Execute internamente: `/gsd-intel "padrões de implementação em [área alvo da task]"`
 - Siga convenções encontradas para estrutura de arquivos, nomenclatura e tratamento de erros