@brunosps00/dev-workflow 0.2.0 → 0.3.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 22 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
 
@@ -38,18 +44,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 +80,55 @@ 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-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 +138,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 +147,44 @@ All wrappers point to `.dw/commands/` as the single source of truth.
 ```
 your-project/
 ├── .dw/
-│   ├── commands/          # 16 workflow command files
+│   ├── commands/          # 22 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 +193,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 +204,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

@@ -13,8 +13,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' },
@@ -34,8 +37,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/init.js

@@ -128,6 +128,14 @@ async function run({ force = false, lang = null, mode = 'init' }) {
   if (opcStatus === 'created') totalCreated++;
   else totalSkipped++;
 
+  // 6.5. Clean up legacy .codex/skills/ (now served by .agents/skills/)
+  const legacyCodexDir = path.join(projectRoot, '.codex', 'skills');
+  if (require('fs').existsSync(legacyCodexDir)) {
+    console.log('  Legacy cleanup:');
+    require('fs').rmSync(legacyCodexDir, { recursive: true });
+    console.log('    Removed .codex/skills/ (now served by .agents/skills/)\n');
+  }
+
   // 7. Generate platform wrappers
   console.log('  Platform wrappers:');
   const wrapperResults = generateWrappers(projectRoot, commands, managedForce);

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.0",
+  "version": "0.3.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,18 @@ 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.
 
+#### 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-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
+
+If `.planning/intel/` exists, query before analysis:
+- 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
+
+    If `.planning/intel/` exists, query before writing requirements:
+    - 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
+
+    If `.planning/intel/` exists, query before proposing architecture:
+    - 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,9 @@ 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 |
 
 ### Research
 
@@ -234,6 +237,21 @@ LEVEL 3 - Formal Code Review (/dw-code-review)
 /dw-generate-pr main                               # 5. 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
@@ -258,7 +276,10 @@ your-project/
 │   │   ├── dw-review-implementation.md
 │   │   ├── dw-analyze-project.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 +342,10 @@ 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.
+
 </system_instructions>

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

@@ -0,0 +1,58 @@
+<system_instructions>
+You are a codebase intelligence assistant. This command exists to answer questions about the project using the knowledge index generated by `/dw-analyze-project`.
+
+<critical>This command is read-only. Do NOT modify code or project files.</critical>
+<critical>Always cite information sources (file, line, section).</critical>
+
+## When to Use
+- Use to understand how something works in the project
+- Use to find patterns, conventions, or architectural decisions
+- Use to verify if something already exists before implementing
+- Do NOT use to implement changes (use `/dw-quick` or `/dw-run-task`)
+
+## Pipeline Position
+**Predecessor:** `/dw-analyze-project` (generates the index) | **Successor:** any dw-* command
+
+## Input Variables
+
+| Variable | Description | Example |
+|----------|-------------|---------|
+| `{{QUERY}}` | Question about the codebase | "how does authentication work?" |
+
+## Required Behavior
+
+1. Receive the user's question
+2. Query knowledge sources in priority order:
+   a. `.planning/intel/` (if exists — GSD index, richer)
+   b. `.dw/rules/` (project rules, always available)
+   c. Direct codebase search (grep, glob) as complement
+3. Synthesize the answer with concrete references
+4. Cite sources: file, section, line when applicable
+
+## GSD Integration
+
+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
+- Enrich with `.dw/rules/` data when relevant
+
+If GSD is NOT installed:
+- Use `.dw/rules/` as primary source
+- Complement with direct codebase search (grep for patterns, read key files)
+- Suggest: "For richer intel, run `/dw-analyze-project` with GSD installed"
+
+## Response Format
+
+### Answer: [topic]
+
+[Structured answer based on consulted sources]
+
+### Sources
+- `.planning/intel/[file].md` — [relevant section]
+- `.dw/rules/[file].md` — [referenced convention]
+- `src/[path]:[line]` — [code reference]
+
+### Related Commands
+- [Suggestion of dw- command to act on the information]
+
+</system_instructions>

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

@@ -0,0 +1,74 @@
+<system_instructions>
+You are a quick task executor. This command exists to implement one-off changes with workflow guarantees (validation, atomic commit) without requiring a full PRD.
+
+<critical>This command is for small, well-defined changes. If the change needs multiple tasks, redirect to `/dw-create-prd`.</critical>
+<critical>ALWAYS run tests and validation before committing. Workflow guarantees are mandatory even for quick tasks.</critical>
+
+## When to Use
+- Use for small changes that don't justify the full pipeline (PRD -> TechSpec -> Tasks)
+- Use for hotfixes, config adjustments, dependency updates, one-off refactors
+- Do NOT use for new features with multiple requirements (use `/dw-create-prd`)
+- Do NOT use for complex bugs (use `/dw-bugfix`)
+
+## Pipeline Position
+**Predecessor:** (user's ad-hoc need) | **Successor:** `/dw-commit` (automatic)
+
+## Input Variables
+
+| Variable | Description | Example |
+|----------|-------------|---------|
+| `{{DESCRIPTION}}` | Description of the change to implement | "add loading spinner to dashboard" |
+
+## Required Behavior
+
+1. Read `.dw/rules/` to understand project patterns and conventions
+2. Summarize the change in 1-2 sentences and confirm scope with the user
+3. If the change seems too large (>3 files, >100 lines), warn and suggest `/dw-create-prd`
+4. Implement the change following project conventions
+5. Run relevant existing tests (unit, integration)
+6. Run lint if configured in the project
+7. Create atomic semantic commit with the change
+
+## GSD Integration
+
+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`
+
+If GSD is NOT installed:
+- Execute directly with Level 1 validation
+- No history tracking (only git log)
+
+## Codebase Intelligence
+
+If `.planning/intel/` exists, query before implementing:
+- Internally run: `/gsd-intel "implementation patterns in [target area]"`
+- Follow the patterns found
+
+If `.planning/intel/` does NOT exist:
+- Use only `.dw/rules/` as context
+
+## Response Format
+
+### 1. Scope
+- Change: [description]
+- Affected files: [list]
+- Estimate: [small/medium]
+
+### 2. Implementation
+- File-by-file changes
+
+### 3. Validation
+- Tests run: [result]
+- Lint: [result]
+
+### 4. Commit
+- Message: [semantic commit]
+
+## Closing
+
+At the end, inform:
+- Change implemented and committed
+- Whether to push or continue with more changes
+
+</system_instructions>

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

@@ -61,6 +61,17 @@ Use diagnostic tools based on the project's framework:
 5. Wait for explicit user approval before implementing.
 6. **IMPLEMENT**: apply the chosen design respecting the existing stack. Use `vercel-react-best-practices` for React/Next.js. Maintain the project's CSS methodology.
 7. **VALIDATE**: capture after-state, compare before/after, verify accessibility (WCAG 2.2 via `ui-ux-pro-max`), run react-doctor `--diff` if React.
+8. **PERSIST CONTRACT**: if the user approved a direction, generate `design-contract.md` in the PRD directory (`.dw/spec/prd-[name]/design-contract.md`) with: approved direction, color palette, typography pairing, layout rules, accessibility rules, and component rules. This contract will be read by `dw-run-task` and `dw-run-plan` to ensure visual consistency.
+
+## GSD Integration
+
+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
+
+If GSD is NOT installed:
+- The design contract works normally (file-based in `.dw/spec/`)
+- Audit uses only `.dw/rules/` for context
 
 ## Preferred Response Format
 
@@ -106,6 +117,7 @@ Depending on the request, this command may produce:
 - Accessibility report
 - Design system alignment checklist
 - Health score comparison (react-doctor)
+- Design contract with approved direction (`.dw/spec/prd-[name]/design-contract.md`)
 
 ## Closing
 

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

@@ -28,6 +28,16 @@ When available in the project under `./.agents/skills/`, use these skills as ana
 When the project uses React, run `npx react-doctor@latest --verbose` in the frontend directory before starting the analysis. Incorporate the health score and findings into the report's metrics section.
 For Angular projects, use `ng lint` as an analytical complement.
 
+## Codebase Intelligence
+
+If `.planning/intel/` exists, query before the audit:
+- 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
+
+If `.planning/intel/` does NOT exist:
+- Use `.dw/rules/` as context (current behavior)
+
 ## Input Variables
 
 | Variable | Description | Example |

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

@@ -0,0 +1,60 @@
+<system_instructions>
+You are a session continuity assistant. This command exists to restore context from the last session and suggest the next workflow step.
+
+<critical>This command is read-only. Do NOT modify code, do NOT execute tasks, do NOT create files. Only analyze state and recommend the next step.</critical>
+
+## When to Use
+- Use when starting a new session to pick up where you left off
+- Use when unsure which command to run next
+- Do NOT use in the middle of a task or plan execution
+
+## Pipeline Position
+**Predecessor:** (session start) | **Successor:** any dw-* command
+
+## Required Behavior
+
+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
+4. Cross-reference: last active PRD, last completed task, next pending task
+5. Present the summary in the format below
+6. Suggest the next command to execute
+
+## GSD Integration
+
+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
+
+If GSD is NOT installed:
+- Use only `.dw/spec/` and git log as context sources
+- Full functionality, just without advanced cross-session persistence
+
+## Response Format
+
+### Session Summary
+- **Last work**: [time ago], branch [name]
+- **Active PRD**: [PRD name]
+- **Tasks**: [N completed] of [total]
+- **Last completed task**: [name]
+- **Next pending task**: [name]
+- **Blockers**: [unresolved dependencies, if any]
+- **Uncommitted changes**: [yes/no]
+
+### Suggested Next Step
+- Command: `/dw-[command] [arguments]`
+- Reason: [why this is the logical next step]
+
+## Heuristics
+
+- If there are uncommitted changes, suggest `/dw-commit` first
+- If all tasks are complete, suggest `/dw-code-review` or `/dw-run-qa`
+- If no active PRD, suggest `/dw-brainstorm` or `/dw-create-prd`
+- If there are pending tasks, suggest `/dw-run-task` or `/dw-run-plan`
+- If the last task failed, suggest investigating the error before continuing
+
+## Closing
+
+At the end, leave the user ready to execute the next command with a single copy-paste.
+
+</system_instructions>

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

@@ -141,6 +141,41 @@ If a task FAILS during execution:
 4. Wait for manual intervention from the user
 5. **DO NOT** automatically continue to the next task
 
+## GSD Integration
+
+### Plan Verification (Pre-Execution)
+
+If GSD (get-shit-done-cc) is installed in the project:
+- Before starting execution, delegate to GSD's plan-checker agent
+- The verifier analyzes: cyclic dependencies, task viability, risks, PRD requirements coverage
+- If FAIL: present issues found and suggest fixes. Maximum 3 correction cycles
+- If PASS: proceed to execution
+
+If GSD is NOT installed:
+- Skip verification and execute directly (current behavior)
+
+### Parallel Execution (Wave-Based)
+
+If GSD (get-shit-done-cc) is installed in the project:
+- Analyze each task's `blockedBy` field to build the dependency graph
+- Group tasks into waves:
+  - Wave 1: tasks with no dependencies (can run in parallel)
+  - Wave 2: tasks that depend on Wave 1 tasks
+  - Wave N: and so on
+- Delegate each wave to GSD's parallel execution engine (`/gsd-execute-phase`)
+- Each task runs in an isolated worktree with fresh context
+- Results are merged after the wave completes
+- If any task in a wave fails: pause the wave, report, await user decision
+
+If GSD is NOT installed:
+- Execute sequentially as today (current behavior)
+
+### Design Contracts
+
+If `design-contract.md` exists in the PRD directory:
+- Include the contract in the context of each task involving frontend
+- Validate visual consistency during Level 1 of each task
+
 ## Important Rules
 
 <critical>ALWAYS read and follow the complete instructions in `.dw/commands/dw-run-task.md` for EACH task</critical>

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

@@ -21,6 +21,18 @@ When available in the project at `./.agents/skills/`, use these skills as specia
 | `vercel-react-best-practices` | Task touches React rendering, hydration, data fetching, bundle, cache, or performance |
 | `webapp-testing` | Task has interactive frontend needing E2E validation in a real browser |
 
+## Codebase Intelligence
+
+If `.planning/intel/` exists, query before implementing:
+- Internally run: `/gsd-intel "implementation patterns in [task target area]"`
+- Follow conventions found for file structure, naming, and error handling
+
+If `design-contract.md` exists in the PRD directory:
+- Read the contract and ensure all frontend implementation follows the approved design rules
+
+If `.planning/intel/` does NOT exist:
+- Use `.dw/rules/` as context (current behavior)
+
 ## File Locations
 
 - PRD: `./spec/prd-[feature-name]/prd.md`

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

@@ -218,6 +218,18 @@ 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.
 
+#### Inteligência do Codebase (GSD)
+
+Se o GSD (get-shit-done-cc) estiver instalado no projeto:
+- Após gerar as rules em `.dw/rules/`, delegue para `/gsd-map-codebase` para criar índice rico em `.planning/intel/`
+- O índice inclui: architectural assumptions, decision spaces, behavioral references, UI patterns
+- O índice é incremental — re-executar adiciona ao existente, não substitui
+- Outros comandos dw-* podem consultar o índice via `/gsd-intel` internamente
+
+Se o GSD NÃO estiver instalado:
+- Gere apenas `.dw/rules/` (comportamento atual)
+- Sugira: "Para inteligência queryable do codebase, instale GSD via `npx dev-workflow install-deps`"
+
 ### Passo 4: Ler Arquivos Fonte Representativos (Obrigatório)
 
 Ler **10-20 arquivos fonte** por módulo para identificar padrões. Para projetos grandes, aumentar cobertura proporcionalmente.

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

@@ -24,6 +24,16 @@ Quando disponíveis no projeto em `./.agents/skills/`, use estas skills como apo
 - `security-review`: use quando auth, autorização, input externo, upload, SQL, integração externa, secrets, SSRF, XSS ou superfícies sensíveis estiverem presentes
 - `vercel-react-best-practices`: use quando o diff tocar React/Next.js para revisar padrões de renderização, fetching, bundle, hidratação e performance
 
+## Inteligência do Codebase
+
+Se `.planning/intel/` existir, consulte antes da análise:
+- 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)
+
+Se `.planning/intel/` NÃO existir:
+- Use `.dw/rules/` como contexto (comportamento atual)
+
 ## Variáveis de Entrada
 
 | Variável | Descrição | Exemplo |

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

@@ -32,6 +32,15 @@
     - Diretório final: `.dw/spec/prd-[nome-funcionalidade]/` (relativo ao workspace root, nome em kebab-case)
     - **IMPORTANTE**: PRDs devem ser salvos em `.dw/spec/` no workspace root, NUNCA dentro de subprojetos
 
+    ## Inteligência do Codebase
+
+    Se `.planning/intel/` existir, consulte antes de redigir os requisitos:
+    - 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
+
+    Se `.planning/intel/` NÃO existir:
+    - Use `.dw/rules/` como contexto (comportamento atual)
+
     ## Features Multi-Projeto
 
     Muitas funcionalidades podem envolver mais de um projeto no workspace.

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

@@ -21,6 +21,15 @@
     - `ui-ux-pro-max`: use quando definir decisões de design system, paletas de cores, tipografia e estilo UI no TechSpec
     - `security-review`: use quando a feature tocar auth, autorização ou manipulação de dados sensíveis
 
+    ## Inteligência do Codebase
+
+    Se `.planning/intel/` existir, consulte antes de propor arquitetura:
+    - Execute internamente: `/gsd-intel "padrões arquiteturais e decisões técnicas do projeto"`
+    - Alinhe propostas com padrões existentes; sinalize desvios explicitamente
+
+    Se `.planning/intel/` NÃO existir:
+    - Use `.dw/rules/` como contexto (comportamento atual)
+
     ## Fluxograma de Decisão Multi-Projeto
 
     ```dot

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

@@ -89,6 +89,9 @@ Este workspace utiliza um sistema de comandos AI que automatiza o ciclo completo
 | `/dw-bugfix` | Analisa e corrige bugs (triagem bug vs feature) | Target + descrição | Fix + commit OU PRD (se feature) |
 | `/dw-fix-qa` | Corrige bugs documentados no QA e retesta com evidências | Path do PRD | Código + `QA/bugs.md` + `QA/qa-report.md` atualizados |
 | `/dw-redesign-ui` | Audita, propõe e implementa redesign visual de páginas/componentes | Página/componente alvo | Brief de redesign + código |
+| `/dw-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 |
 
 ### Análise e Pesquisa
 
@@ -186,6 +189,21 @@ Este workspace utiliza um sistema de comandos AI que automatiza o ciclo completo
 /dw-generate-pr main                               # 5. PR
 ```
 
+### Task Rápida
+```bash
+/dw-quick "descrição da mudança"                   # Implementa + valida + commit
+```
+
+### Retomar Sessão
+```bash
+/dw-resume                                         # Restaura contexto + sugere próximo passo
+```
+
+### Consultar Codebase
+```bash
+/dw-intel "como funciona X neste projeto?"         # Resposta com fontes
+```
+
 ### Onboarding em Projeto Novo
 ```bash
 /dw-analyze-project                             # Escaneia e gera rules automaticamente
@@ -211,7 +229,10 @@ workspace/
 │   │   ├── dw-refactoring-analysis.md
 │   │   ├── dw-review-implementation.md
 │   │   ├── dw-deep-research.md
+│   │   ├── dw-intel.md
+│   │   ├── dw-quick.md
 │   │   ├── dw-redesign-ui.md
+│   │   ├── dw-resume.md
 │   │   ├── dw-bugfix.md
 │   │   ├── dw-fix-qa.md
 │   │   ├── dw-commit.md
@@ -260,4 +281,10 @@ workspace/
 **Q: O `/dw-redesign-ui` funciona com Angular?**
 - Sim. O comando é framework-agnostic. Para React usa react-doctor e `vercel-react-best-practices`; para Angular usa `ng lint` e Angular DevTools. Design visual (`ui-ux-pro-max`) funciona com qualquer framework.
 
+**Q: O que é o GSD e preciso instalar?**
+- GSD (get-shit-done-cc) é uma engine opcional que habilita features avançadas: execução paralela, verificação de planos, inteligência do codebase e persistência cross-sessão. Instale com `npx dev-workflow install-deps`. Sem GSD, todos os comandos funcionam normalmente.
+
+**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.
+
 </system_instructions>

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

@@ -0,0 +1,58 @@
+<system_instructions>
+Voce e um assistente de inteligencia do codebase. Este comando existe para responder perguntas sobre o projeto usando o indice de conhecimento gerado pelo `/dw-analyze-project`.
+
+<critical>Este comando e somente leitura. NAO modifique codigo ou arquivos do projeto.</critical>
+<critical>Sempre cite as fontes das informacoes (arquivo, linha, secao).</critical>
+
+## Quando Usar
+- Use para entender como algo funciona no projeto
+- Use para encontrar padroes, convencoes ou decisoes arquiteturais
+- Use para verificar se algo ja existe antes de implementar
+- NAO use para implementar mudancas (use `/dw-quick` ou `/dw-run-task`)
+
+## Posicao no Pipeline
+**Antecessor:** `/dw-analyze-project` (gera o indice) | **Sucessor:** qualquer comando dw-*
+
+## Variaveis de Entrada
+
+| Variavel | Descricao | Exemplo |
+|----------|-----------|---------|
+| `{{QUERY}}` | Pergunta sobre o codebase | "como funciona a autenticacao?" |
+
+## Comportamento Obrigatorio
+
+1. Receba a pergunta do usuario
+2. Consulte as fontes de conhecimento na ordem de prioridade:
+   a. `.planning/intel/` (se existir — indice GSD, mais rico)
+   b. `.dw/rules/` (rules do projeto, sempre disponivel)
+   c. Busca direta no codebase (grep, glob) como complemento
+3. Sintetize a resposta com referencias concretas
+4. Cite fontes: arquivo, secao, linha quando aplicavel
+
+## Integracao GSD
+
+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
+- Enriqueca com dados de `.dw/rules/` quando relevante
+
+Se o GSD NAO estiver instalado:
+- Consulte `.dw/rules/` como fonte primaria
+- Complemente com busca direta no codebase (grep por padroes, leitura de arquivos chave)
+- Sugira: "Para intel mais rico, execute `/dw-analyze-project` com GSD instalado"
+
+## Formato de Resposta
+
+### Resposta: [topico]
+
+[Resposta estruturada baseada nas fontes consultadas]
+
+### Fontes
+- `.planning/intel/[arquivo].md` — [secao relevante]
+- `.dw/rules/[arquivo].md` — [convencao referenciada]
+- `src/[caminho]:[linha]` — [referencia de codigo]
+
+### Comandos Relacionados
+- [Sugestao de comando dw- para agir com base na informacao]
+
+</system_instructions>

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

@@ -0,0 +1,74 @@
+<system_instructions>
+Voce e um executor de tasks rapidas. Este comando existe para implementar mudancas pontuais com garantias do workflow (validacao, commit atomico) sem precisar de PRD completo.
+
+<critical>Este comando e para mudancas pequenas e bem definidas. Se a mudanca precisar de multiplas tasks, redirecione para `/dw-create-prd`.</critical>
+<critical>SEMPRE execute testes e validacao antes de commitar. Garantias do workflow sao obrigatorias mesmo para tasks rapidas.</critical>
+
+## Quando Usar
+- Use para mudancas pequenas que nao justificam o pipeline completo (PRD -> TechSpec -> Tasks)
+- Use para hotfixes, ajustes de config, atualizacoes de dependencias, refatoracoes pontuais
+- NAO use para features novas com multiplos requisitos (use `/dw-create-prd`)
+- NAO use para bugs complexos (use `/dw-bugfix`)
+
+## Posicao no Pipeline
+**Antecessor:** (necessidade pontual do usuario) | **Sucessor:** `/dw-commit` (automatico)
+
+## Variaveis de Entrada
+
+| Variavel | Descricao | Exemplo |
+|----------|-----------|---------|
+| `{{DESCRIPTION}}` | Descricao da mudanca a implementar | "adicionar spinner de loading no dashboard" |
+
+## Comportamento Obrigatorio
+
+1. Leia `.dw/rules/` para entender padroes e convencoes do projeto
+2. Resuma a mudanca em 1-2 frases e confirme escopo com o usuario
+3. Se a mudanca parecer grande demais (>3 arquivos, >100 linhas), alerte e sugira `/dw-create-prd`
+4. Implemente a mudanca seguindo convencoes do projeto
+5. Execute testes existentes relevantes (unit, integration)
+6. Execute lint se configurado no projeto
+7. Crie commit atomico semantico com a mudanca
+
+## Integracao GSD
+
+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`
+
+Se o GSD NAO estiver instalado:
+- Execute diretamente com validacao Level 1
+- Sem tracking historico (apenas git log)
+
+## Inteligencia do Codebase
+
+Se `.planning/intel/` existir, consulte antes de implementar:
+- Execute internamente: `/gsd-intel "implementation patterns in [target area]"`
+- Siga os padroes encontrados
+
+Se `.planning/intel/` NAO existir:
+- Use apenas `.dw/rules/` como contexto
+
+## Formato de Resposta
+
+### 1. Escopo
+- Mudanca: [descricao]
+- Arquivos afetados: [lista]
+- Estimativa: [pequena/media]
+
+### 2. Implementacao
+- Mudancas arquivo por arquivo
+
+### 3. Validacao
+- Testes executados: [resultado]
+- Lint: [resultado]
+
+### 4. Commit
+- Mensagem: [commit semantico]
+
+## Encerramento
+
+Ao final, informe:
+- Mudanca implementada e commitada
+- Se deseja fazer push ou continuar com mais mudancas
+
+</system_instructions>

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

@@ -61,6 +61,17 @@ Utilize ferramentas de diagnóstico conforme o framework do projeto:
 5. Espere aprovação explícita do usuário antes de implementar.
 6. **IMPLEMENTAR**: aplique o design escolhido respeitando a stack existente. Use `vercel-react-best-practices` para React/Next.js. Mantenha a metodologia CSS do projeto.
 7. **VALIDAR**: capture estado depois, compare antes/depois, verifique acessibilidade (WCAG 2.2 via `ui-ux-pro-max`), rode react-doctor `--diff` se React.
+8. **PERSISTIR CONTRATO**: se o usuário aprovou uma direção, gere `design-contract.md` no diretório do PRD (`.dw/spec/prd-[nome]/design-contract.md`) com: direção aprovada, paleta de cores, par tipográfico, regras de layout, regras de acessibilidade e regras de componentes. Este contrato será lido por `dw-run-task` e `dw-run-plan` para garantir consistência visual.
+
+## Integração GSD
+
+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
+
+Se o GSD NÃO estiver instalado:
+- O design contract funciona normalmente (file-based em `.dw/spec/`)
+- Auditoria usa apenas `.dw/rules/` para contexto
 
 ## Formato de Resposta Preferido
 
@@ -106,6 +117,7 @@ Dependendo do pedido, o comando pode produzir:
 - Relatório de acessibilidade
 - Checklist de alinhamento com design system
 - Comparativo de health score (react-doctor)
+- Design contract com direção aprovada (`.dw/spec/prd-[nome]/design-contract.md`)
 
 ## Encerramento
 

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

@@ -28,6 +28,16 @@ Quando disponíveis no projeto em `./.agents/skills/`, use como suporte analíti
 Quando o projeto usar React, execute `npx react-doctor@latest --verbose` no diretório do frontend antes de iniciar a análise. Incorpore o health score e findings do react-doctor na seção de métricas do relatório.
 Para projetos Angular, use `ng lint` como complemento analítico.
 
+## Inteligência do Codebase
+
+Se `.planning/intel/` existir, consulte antes da auditoria:
+- 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
+
+Se `.planning/intel/` NÃO existir:
+- Use `.dw/rules/` como contexto (comportamento atual)
+
 ## Variáveis de Entrada
 
 | Variável | Descrição | Exemplo |

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

@@ -0,0 +1,60 @@
+<system_instructions>
+Voce e um assistente de continuidade de sessao. Este comando existe para restaurar contexto da ultima sessao e sugerir o proximo passo do workflow.
+
+<critical>Este comando e somente leitura. NAO modifique codigo, NAO execute tasks, NAO crie arquivos. Apenas analise o estado e recomende o proximo passo.</critical>
+
+## Quando Usar
+- Use ao iniciar uma nova sessao para retomar de onde parou
+- Use quando nao souber qual comando executar em seguida
+- NAO use no meio de uma execucao de task ou plano
+
+## Posicao no Pipeline
+**Antecessor:** (inicio de sessao) | **Sucessor:** qualquer comando dw-*
+
+## Comportamento Obrigatorio
+
+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
+4. Cruze: ultimo PRD ativo, ultima task completada, proxima task pendente
+5. Apresente o resumo no formato abaixo
+6. Sugira o proximo comando a executar
+
+## Integracao GSD
+
+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
+
+Se o GSD NAO estiver instalado:
+- Use apenas `.dw/spec/` e git log como fontes de contexto
+- Funcionalidade completa, apenas sem persistencia cross-sessao avancada
+
+## Formato de Resposta
+
+### Resumo da Sessao
+- **Ultimo trabalho**: [tempo atras], branch [nome]
+- **PRD ativo**: [nome do PRD]
+- **Tasks**: [N completadas] de [total]
+- **Ultima task completada**: [nome]
+- **Proxima task pendente**: [nome]
+- **Bloqueios**: [dependencias nao resolvidas, se houver]
+- **Mudancas nao commitadas**: [sim/nao]
+
+### Proximo Passo Sugerido
+- Comando: `/dw-[comando] [argumentos]`
+- Motivo: [por que este e o proximo passo logico]
+
+## Heuristicas
+
+- Se ha mudancas nao commitadas, sugira `/dw-commit` primeiro
+- Se todas as tasks estao completas, sugira `/dw-code-review` ou `/dw-run-qa`
+- Se nao ha PRD ativo, sugira `/dw-brainstorm` ou `/dw-create-prd`
+- Se ha tasks pendentes, sugira `/dw-run-task` ou `/dw-run-plan`
+- Se a ultima task falhou, sugira investigar o erro antes de continuar
+
+## Encerramento
+
+Ao final, deixe o usuario pronto para executar o proximo comando com um unico copy-paste.
+
+</system_instructions>

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

@@ -134,6 +134,41 @@ Se uma tarefa FALHAR durante a execução:
 4. Aguardar intervenção manual do usuário
 5. **NÃO** continuar automaticamente para próxima task
 
+## Integração GSD
+
+### Verificação de Plano (Pré-Execução)
+
+Se o GSD (get-shit-done-cc) estiver instalado no projeto:
+- Antes de iniciar a execução, delegue para o agente plan-checker do GSD
+- O verificador analisa: dependências cíclicas, viabilidade das tasks, riscos, cobertura dos requisitos do PRD
+- Se FALHAR: apresente os problemas encontrados e sugira correções. Máximo 3 ciclos de correção
+- Se PASSAR: prossiga para a execução
+
+Se o GSD NÃO estiver instalado:
+- Pule a verificação e execute diretamente (comportamento atual)
+
+### Execução Paralela (Wave-Based)
+
+Se o GSD (get-shit-done-cc) estiver instalado no projeto:
+- Analise o campo `blockedBy` de cada task para montar o grafo de dependências
+- Agrupe tasks em waves:
+  - Wave 1: tasks sem dependências (podem executar em paralelo)
+  - Wave 2: tasks que dependem de tasks da Wave 1
+  - Wave N: assim por diante
+- Delegue cada wave para o engine de execução paralela do GSD (`/gsd-execute-phase`)
+- Cada task executa em worktree isolado com contexto fresh
+- Resultados são mergeados após a wave completar
+- Se qualquer task de uma wave falhar: pause a wave, reporte, aguarde decisão do usuário
+
+Se o GSD NÃO estiver instalado:
+- Execute sequencialmente como hoje (comportamento atual)
+
+### Design Contracts
+
+Se existir `design-contract.md` no diretório do PRD:
+- Inclua o contrato no contexto de cada task que envolva frontend
+- Valide consistência visual durante Level 1 de cada task
+
 ## Regras Importantes
 
 <critical>SEMPRE leia e siga as instruções completas em `.dw/commands/dw-run-task.md` para CADA tarefa</critical>

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

@@ -21,6 +21,18 @@ Quando disponíveis no projeto em `./.agents/skills/`, use estas skills como sup
 | `vercel-react-best-practices` | Task envolve renderização React, hidratação, data fetching, bundle, cache ou performance |
 | `webapp-testing` | Task tem frontend interativo que necessita validação E2E em navegador real |
 
+## Inteligência do Codebase
+
+Se `.planning/intel/` existir, consulte antes de implementar:
+- 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
+
+Se `design-contract.md` existir no diretório do PRD:
+- Leia o contrato e garanta que toda implementação frontend siga as regras de design aprovadas
+
+Se `.planning/intel/` NÃO existir:
+- Use `.dw/rules/` como contexto (comportamento atual)
+
 ## Localização dos Arquivos
 
 - PRD: `.dw/spec/prd-[nome-funcionalidade]/prd.md`