@brunosps00/dev-workflow 0.2.1 → 0.4.0

package/README.md

@@ -10,11 +10,17 @@ npx @brunosps00/dev-workflow init
 
 This will:
 1. Ask you to select a language (English or Portuguese)
-2. Create `.dw/commands/` with 17 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. Generate skill wrappers for Claude Code, Codex, Copilot, and OpenCode
-6. Configure MCP servers (Context7 + Playwright)
+5. Install bundled skills (ui-ux-pro-max, security-review, etc.) to `.agents/skills/`
+6. Generate skill wrappers for Claude Code, Codex, Copilot, and OpenCode
+7. Configure MCP servers (Context7 + Playwright)
+
+Optional dependencies (Playwright browsers, react-doctor, GSD):
+```bash
+npx @brunosps00/dev-workflow install-deps
+```
 
 ## Commands
 
@@ -23,6 +29,9 @@ This will:
 #### `/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`.
 
@@ -38,18 +47,24 @@ Breaks down the PRD and TechSpec into implementable tasks with a target of ~6 ta
 Executes a single task from the task list, implementing code that follows project patterns and includes mandatory unit tests. Performs Level 1 validation (acceptance criteria + tests + standards check) and creates a commit upon completion.
 
 #### `/dw-run-plan`
-Executes all pending tasks sequentially and automatically, with Level 1 validation after each task. After all tasks are complete, performs a final Level 2 review (PRD compliance) with an interactive corrections cycle until no gaps remain or the user accepts pending items.
+Executes all pending tasks sequentially and automatically, with Level 1 validation after each task. After all tasks are complete, performs a final Level 2 review (PRD compliance) with an interactive corrections cycle until no gaps remain or the user accepts pending items. With GSD installed, supports plan verification gates and wave-based parallel execution for independent tasks.
 
 #### `/dw-bugfix`
 Analyzes and fixes bugs with automatic triage that distinguishes between bugs, feature requests, and excessive scope. Asks exactly 3 clarification questions before proposing a solution. Supports Direct mode (executes fix immediately) and Analysis mode (`--analysis`) that generates a document for the techspec/tasks pipeline.
 
+#### `/dw-redesign-ui`
+Audits existing frontend pages or components, proposes 2-3 design directions using `ui-ux-pro-max` (colors, typography, layout), waits for user approval, then implements the redesign following the project's CSS methodology. Framework-agnostic (React, Angular, Vue). Generates a design contract persisted for consistency across tasks.
+
+#### `/dw-quick`
+Executes a one-off change with workflow guarantees (validation, atomic commit) without requiring a full PRD. For hotfixes, config adjustments, dependency updates, and small refactors. Warns and redirects to `/dw-create-prd` if the change is too large.
+
 ### Quality
 
 #### `/dw-run-qa`
 Validates the implementation against PRD, TechSpec, and Tasks using Playwright MCP for E2E browser automation. Tests happy paths, edge cases, negative flows, and regressions while verifying WCAG 2.2 accessibility compliance. Generates a QA report, documents bugs with screenshot evidence, and detects stub/placeholder pages.
 
 #### `/dw-fix-qa`
-Fixes bugs found during QA testing with evidence-driven retesting via Playwright MCP. Runs iterative cycles of identify → fix → retest, updating `QA/bugs.md` and `QA/qa-report.md` with status and retest evidence including screenshots and logs.
+Fixes bugs found during QA testing with evidence-driven retesting via Playwright MCP. Runs iterative cycles of identify, fix, retest, updating `QA/bugs.md` and `QA/qa-report.md` with status and retest evidence including screenshots and logs.
 
 #### `/dw-review-implementation`
 Compares documented requirements (PRD + TechSpec + Tasks) against actual code as a Level 2 review. Maps each requirement to endpoints and tasks with evidence, identifies gaps, partial implementations, and extra undocumented code. Does not execute fixes — waits for user instruction.
@@ -68,41 +83,59 @@ Analyzes pending changes, groups them by feature or logical context, and creates
 #### `/dw-generate-pr`
 Pushes the branch to remote and creates a Pull Request on GitHub with a structured description. Collects information from the PRD and modified files, runs tests, then generates a PR body with summary, changes grouped by module, test plan, and deploy notes.
 
-### Utilities
+### Intelligence
+
+#### `/dw-resume`
+Restores context from the last session by reading pending tasks, recent git history, and active branches. Suggests the next command to execute. With GSD installed, also restores cross-session state from `.planning/STATE.md`.
+
+#### `/dw-intel`
+Queries codebase intelligence to answer questions about patterns, conventions, and architecture. Uses `.planning/intel/` (if GSD) or `.dw/rules/` as knowledge sources, complemented with direct codebase search. Always cites sources with file paths and line numbers.
 
 #### `/dw-analyze-project`
-Scans the repository to identify tech stack, architectural patterns, naming conventions, and anti-patterns. Generates structured documentation in `.dw/rules/` with a project overview (`index.md`) and per-module rule files containing real code examples, which are consumed by other workflow commands.
+Scans the repository to identify tech stack, architectural patterns, naming conventions, and anti-patterns. Generates structured documentation in `.dw/rules/` with a project overview (`index.md`) and per-module rule files containing real code examples. With GSD installed, also creates a queryable index in `.planning/intel/`.
 
 #### `/dw-deep-research`
 Conducts multi-source research with citation tracking and verification across quick, standard, deep, and ultradeep modes. Executes parallel information gathering, triangulation, and cross-reference verification through 8+ phases, producing a professional report with complete bibliography.
 
+#### `/dw-functional-doc`
+Generates a functional documentation dossier with screen mapping, E2E flows, and Playwright validation. Maps routes, components, and user journeys into structured documentation with evidence.
+
 #### `/dw-help`
-Displays the complete guide of available commands, integration flows, and when to use each one. Can be invoked without arguments for the full guide or with a specific command name (e.g., `/dw-help create-prd`) for a detailed section.
+Displays the complete guide of available commands, integration flows, and when to use each one. Can be invoked without arguments for the full guide or with a specific command name for a detailed section.
 
 ## Workflow
 
 ```
-/dw-brainstorm
-    |
-/dw-create-prd  -->  .dw/spec/prd-{name}/prd.md
-    |
-/dw-create-techspec  -->  .dw/spec/prd-{name}/techspec.md
-    |
-/dw-create-tasks  -->  .dw/spec/prd-{name}/tasks.md + {N}_task.md
-    |
-/dw-run-task (or /dw-run-plan for all)
-    |
-/dw-run-qa  -->  .dw/spec/prd-{name}/QA/
-    |
-/dw-fix-qa (if bugs found)
-    |
-/dw-review-implementation  -->  PRD compliance check
-    |
-/dw-refactoring-analysis  -->  .dw/spec/prd-{name}/dw-refactoring-analysis.md (optional)
-    |
-/dw-code-review  -->  .dw/spec/prd-{name}/QA/dw-code-review.md
-    |
-/dw-commit + /dw-generate-pr
+                        /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
+                            |
+                        /dw-create-tasks  -->  .dw/spec/prd-{name}/tasks.md + {N}_task.md
+                            |
+                        /dw-run-task (one at a time)
+                            |       or
+                        /dw-run-plan (all tasks — parallel with GSD)
+                            |
+                        /dw-run-qa  -->  .dw/spec/prd-{name}/QA/
+                            |
+                        /dw-fix-qa (if bugs found)
+                            |
+                        /dw-review-implementation  -->  PRD compliance check
+                            |
+                        /dw-code-review  -->  .dw/spec/prd-{name}/QA/dw-code-review.md
+                            |
+                        /dw-commit + /dw-generate-pr
+
+Shortcuts:
+  /dw-quick "description"      One-off change with workflow guarantees
+  /dw-intel "question"         Query codebase intelligence
+  /dw-redesign-ui "target"     Visual redesign of a page or component
 ```
 
 ## Platform Support
@@ -112,7 +145,7 @@ Displays the complete guide of available commands, integration flows, and when t
 | Claude Code | `.claude/skills/` | Full support |
 | Codex CLI | `.agents/skills/` | Full support |
 | Copilot | `.agents/skills/` | Full support |
-| OpenCode | `.agents/skills/` | Full support |
+| OpenCode | `.opencode/commands/` | Full support |
 
 All wrappers point to `.dw/commands/` as the single source of truth.
 
@@ -121,16 +154,44 @@ All wrappers point to `.dw/commands/` as the single source of truth.
 ```
 your-project/
 ├── .dw/
-│   ├── commands/          # 16 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
+│   ├── scripts/           # Utility scripts
 │   └── spec/              # PRD directories created by commands
 ├── .claude/
 │   ├── skills/            # Claude Code wrappers
 │   └── settings.json      # MCP servers (Context7, Playwright)
-└── .agents/skills/        # Codex/Copilot/OpenCode wrappers
+├── .agents/skills/        # Codex/Copilot wrappers + bundled skills
+├── .opencode/commands/    # OpenCode wrappers
+└── .planning/             # GSD state (if installed via install-deps)
 ```
 
+## Bundled Skills
+
+Skills installed to `.agents/skills/` for use by all commands:
+
+| Skill | Description | Source | License |
+|-------|-------------|--------|---------|
+| **ui-ux-pro-max** | Design intelligence: 50+ styles, 161 color palettes, 57 font pairings, 99 UX guidelines across 10 stacks | [Next Level Builder](https://github.com/skills-sh) | MIT |
+| **vercel-react-best-practices** | 67 React/Next.js performance optimization rules across 8 priority categories | [Vercel Labs](https://github.com/vercel-labs/agent-skills) | MIT |
+| **security-review** | Systematic vulnerability review based on OWASP with confidence-based reporting | [OWASP Cheat Sheet Series](https://cheatsheetseries.owasp.org/) | CC BY-SA 4.0 |
+| **humanizer** | Detects and removes 24 AI writing patterns based on Wikipedia's "Signs of AI Writing" guide | [Wikipedia AI Writing Guide](https://en.wikipedia.org/wiki/Wikipedia:Signs_of_AI_writing) | -- |
+| **remotion-best-practices** | 25+ rules for video creation in React with Remotion | [Remotion](https://www.remotion.dev/) | -- |
+| **webapp-testing** | Playwright-based browser testing toolkit for E2E validation and screenshots | [Playwright](https://playwright.dev/) | -- |
+
+## Dependencies
+
+Installed via `npx @brunosps00/dev-workflow install-deps`:
+
+| Dependency | Purpose | Link |
+|------------|---------|------|
+| **Playwright** | Browser automation for QA, E2E tests, and visual validation | [playwright.dev](https://playwright.dev/) |
+| **Context7 MCP** | Contextual documentation lookup for AI assistants | [upstash/context7-mcp](https://github.com/upstash/context7-mcp) |
+| **react-doctor** | Health score and diagnostics for React projects | [react.doctor](https://www.react.doctor/) |
+| **GSD (get-shit-done-cc)** | Optional engine: parallel execution, plan verification, codebase intelligence, cross-session persistence | [gsd-build/get-shit-done](https://github.com/gsd-build/get-shit-done) |
+
 ## Options
 
 ```bash
@@ -139,6 +200,7 @@ npx @brunosps00/dev-workflow init --lang=en        # English, skip prompt
 npx @brunosps00/dev-workflow init --lang=pt-br     # Portuguese, skip prompt
 npx @brunosps00/dev-workflow init --force          # Overwrite existing files
 npx @brunosps00/dev-workflow update                # Update commands/templates only
+npx @brunosps00/dev-workflow install-deps          # Install Playwright, react-doctor, GSD
 npx @brunosps00/dev-workflow help                  # Show help
 ```
 
@@ -149,6 +211,7 @@ After running `npx @brunosps00/dev-workflow init`:
 1. **Run `/dw-analyze-project`** in your AI assistant to generate project rules
 2. **Run `/dw-brainstorm`** to start planning a new feature
 3. **Run `/dw-help`** to see all available commands and workflows
+4. **(Optional) Run `npx @brunosps00/dev-workflow install-deps`** for Playwright, react-doctor, and GSD
 
 ## License
 

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' },
@@ -13,8 +14,11 @@ const COMMANDS = {
     { name: 'dw-functional-doc', description: 'Generate functional documentation dossier with screen mapping, E2E flows, and Playwright validation' },
     { name: 'dw-generate-pr', description: 'Generate a Pull Request with structured description' },
     { name: 'dw-help', description: 'Show complete guide of available commands and workflows' },
+    { name: 'dw-intel', description: 'Query codebase intelligence to understand patterns, conventions, and architecture' },
+    { name: 'dw-quick', description: 'Execute a one-off task with workflow guarantees without requiring a full PRD' },
     { name: 'dw-redesign-ui', description: 'Analyze, propose, and implement frontend page/component redesigns with design system integration' },
     { name: 'dw-refactoring-analysis', description: 'Audit codebase for code smells and refactoring opportunities with prioritized report' },
+    { name: 'dw-resume', description: 'Restore session context and suggest the next workflow step' },
     { name: 'dw-review-implementation', description: 'Review if all PRD requirements were correctly implemented' },
     { name: 'dw-run-plan', description: 'Execute ALL tasks sequentially until the plan is complete' },
     { name: 'dw-run-qa', description: 'Run visual QA with browser automation, E2E tests, and accessibility' },
@@ -22,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' },
@@ -34,8 +39,11 @@ const COMMANDS = {
     { name: 'dw-functional-doc', description: 'Gerar dossie funcional com mapeamento de telas, fluxos E2E e validacao com Playwright' },
     { name: 'dw-generate-pr', description: 'Gerar um Pull Request com descricao estruturada' },
     { name: 'dw-help', description: 'Mostrar guia completo dos comandos e fluxos disponiveis' },
+    { name: 'dw-intel', description: 'Consultar inteligencia do codebase para entender padroes, convencoes e arquitetura' },
+    { name: 'dw-quick', description: 'Executar uma task pontual com garantias do workflow sem precisar de PRD completo' },
     { name: 'dw-redesign-ui', description: 'Analisar, propor e implementar redesign de paginas/componentes frontend com integracao de design system' },
     { name: 'dw-refactoring-analysis', description: 'Auditar codebase para code smells e oportunidades de refatoracao com relatorio priorizado' },
+    { name: 'dw-resume', description: 'Restaurar contexto da sessao e sugerir o proximo passo do workflow' },
     { name: 'dw-review-implementation', description: 'Revisar se todos os requisitos do PRD foram implementados corretamente' },
     { name: 'dw-run-plan', description: 'Executar TODAS as tasks sequencialmente ate completar o plano' },
     { name: 'dw-run-qa', description: 'Executar QA visual com automacao de browser, testes E2E e acessibilidade' },

package/lib/install-deps.js

@@ -20,6 +20,11 @@ function run() {
       check: null,
       install: 'npx react-doctor@latest --help',
     },
+    {
+      name: 'GSD (Get Shit Done)',
+      check: null,
+      install: 'npx get-shit-done-cc@latest --claude --codex --copilot --opencode --local -y',
+    },
   ];
 
   let installed = 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brunosps00/dev-workflow",
-  "version": "0.2.1",
+  "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,20 @@ 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:
+- After generating rules in `.dw/rules/`, delegate to `/gsd-map-codebase` to create a rich index in `.planning/intel/`
+- The index includes: architectural assumptions, decision spaces, behavioral references, UI patterns
+- The index is incremental — re-running adds to the existing index, does not replace
+- Other dw-* commands can query the index via `/gsd-intel` internally
+
+If GSD is NOT installed:
+- Generate only `.dw/rules/` (current behavior)
+- Suggest: "For queryable codebase intelligence, install GSD via `npx dev-workflow install-deps`"
+
 ### Step 4: Detect Code Patterns and Conventions
 
 Read **10-20 representative source files** per module to identify actual patterns in use. For large projects, increase coverage proportionally.

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

@@ -24,6 +24,16 @@ When available in the project under `./.agents/skills/`, use these skills as ana
 - `security-review`: use when auth, authorization, external input, upload, SQL, external integration, secrets, SSRF, XSS, or sensitive surfaces are present
 - `vercel-react-best-practices`: use when the diff touches React/Next.js to review rendering, fetching, bundle, hydration, and performance patterns
 
+## Codebase Intelligence
+
+<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)
+
+If `.planning/intel/` does NOT exist:
+- Use `.dw/rules/` as context (current behavior)
+
 ## Input Variables
 
 | Variable | Description | Example |

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

@@ -32,6 +32,15 @@
     - Final directory: `.dw/spec/prd-[feature-name]/` (relative to workspace root, name in kebab-case)
     - **IMPORTANT**: PRDs must be saved in `.dw/spec/` at the workspace root, NEVER inside subprojects
 
+    ## Codebase Intelligence
+
+    <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
+
+    If `.planning/intel/` does NOT exist:
+    - Use `.dw/rules/` as context (current behavior)
+
     ## Multi-Project Features
 
     Many features may involve more than one project in the workspace (e.g., a feature may impact both frontend and backend, or multiple services).

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

@@ -21,6 +21,15 @@
     - `ui-ux-pro-max`: use when defining design system decisions, color palettes, typography, and UI style for the TechSpec
     - `security-review`: use when the feature touches auth, authorization, or sensitive data handling
 
+    ## Codebase Intelligence
+
+    <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
+
+    If `.planning/intel/` does NOT exist:
+    - Use `.dw/rules/` as context (current behavior)
+
     ## Multi-Project Decision Flowchart
 
     ```dot

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

@@ -102,6 +102,10 @@ This workspace uses an AI command system that automates the full development cyc
 | `/dw-bugfix` | Analyzes and fixes bugs (bug vs feature triage) | Target + description | Fix + commit OR PRD (if feature) |
 | `/dw-fix-qa` | Fixes documented QA bugs and retests with evidence | PRD path | Code + `QA/bugs.md` + `QA/qa-report.md` updated |
 | `/dw-redesign-ui` | Audits, proposes, and implements visual redesign of pages/components | Target page/component | Redesign brief + code |
+| `/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
 
@@ -234,6 +238,26 @@ 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
+```
+
+### Resume Session
+```bash
+/dw-resume                                         # Restore context + suggest next step
+```
+
+### Query Codebase
+```bash
+/dw-intel "how does X work in this project?"       # Answer with sources
+```
+
 ### Deep Research
 ```bash
 /dw-deep-research "topic or question"              # Multi-source research with citations
@@ -257,8 +281,12 @@ 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
 │   │   ├── dw-redesign-ui.md
+│   │   ├── dw-resume.md
 │   │   ├── dw-bugfix.md
 │   │   ├── dw-commit.md
 │   │   ├── dw-functional-doc.md
@@ -321,4 +349,13 @@ Commands work across multiple AI tools, all pointing to the same source `.dw/com
 **Q: Does `/dw-redesign-ui` work with Angular?**
 - Yes. The command is framework-agnostic. For React it uses react-doctor and `vercel-react-best-practices`; for Angular it uses `ng lint` and Angular DevTools. Visual design (`ui-ux-pro-max`) works with any framework.
 
+**Q: What is GSD and do I need to install it?**
+- GSD (get-shit-done-cc) is an optional engine that enables advanced features: parallel execution, plan verification, codebase intelligence, and cross-session persistence. Install with `npx dev-workflow install-deps`. Without GSD, all commands work normally.
+
+**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>