@brunosps00/dev-workflow 0.8.1 → 0.10.0

package/README.md

@@ -19,7 +19,7 @@ This will:
 
 > **Compozy-inspired disciplines.** Since 0.5.0, dev-workflow bundles three primitives — `dw-verify`, `dw-memory`, `dw-review-rigor` — adapted from the [Compozy](https://github.com/compozy/compozy) project and invoked internally by existing commands. See [docs/compozy-integration.md](docs/compozy-integration.md) for what was ported and what was not.
 
-Optional dependencies (Playwright browsers, react-doctor, GSD):
+Optional dependencies (Playwright browsers, react-doctor, Trivy, Docker):
 ```bash
 npx @brunosps00/dev-workflow install-deps
 ```
@@ -32,7 +32,7 @@ npx @brunosps00/dev-workflow install-deps
 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. **Product-aware**: when PRDs or rules exist, automatically reads them to produce a Feature Inventory and tags each option as `[IMPROVES: <feature>]`, `[CONSOLIDATES: <A>+<B>]`, or `[NEW]`. With optional `--onepager` flag, generates a durable one-pager at `.dw/spec/ideas/<slug>.md` that `/dw-create-prd` can consume to reduce clarification questions. Inspired by [`addyosmani/agent-skills@idea-refine`](https://skills.sh/addyosmani/agent-skills/idea-refine), adapted to product-level (features) rather than code-level grounding. No code is written or project files modified by the brainstorm itself.
 
 #### `/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.
+Full pipeline orchestrator that takes a wish and automatically runs the entire development flow: codebase intelligence (`/dw-map-codebase` + `/dw-intel`), research (conditional), brainstorm, PRD, techspec, tasks, execution (gated by goal-backward plan verification, then wave-based parallel dispatch from the `dw-execute-phase` bundled skill), QA, review, and commit. Stops at 3 gates: PRD approval, tasks approval, and PR confirmation.
 
 #### `/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`.
@@ -49,7 +49,7 @@ 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. With GSD installed, supports plan verification gates and wave-based parallel execution for independent tasks.
+Executes all pending tasks via the `dw-execute-phase` bundled skill — gated by 6-dimension goal-backward verification (`plan-checker` agent) before any code is touched. Wave-based parallel dispatch (`executor` agent) for independent tasks; atomic commit per task; deviation handling. After all tasks complete, performs a final Level 2 review (PRD compliance) with an interactive corrections cycle until no gaps remain or the user accepts pending items.
 
 #### `/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.
@@ -57,9 +57,6 @@ Analyzes and fixes bugs with automatic triage that distinguishes between bugs, f
 #### `/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`
@@ -69,7 +66,7 @@ Validates the implementation against PRD, TechSpec, and Tasks. **Mode-aware**: i
 Fixes bugs found during QA testing with evidence-driven retesting. **Mode-aware**: in UI mode replays the failing flow via Playwright MCP and saves a retest screenshot; in API mode replays the failing `.http`/recipe and appends a `verdict: PASS|FAIL` JSONL line to `QA/logs/api/BUG-NN-retest.log`. Runs iterative cycles of identify, fix, retest, updating `QA/bugs.md` and `QA/qa-report.md` with status and mode-correct evidence.
 
 #### `/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.
+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. After the coverage map is complete, automatically chains `/dw-code-review` (Level 3 quality layer) so a single invocation produces a consolidated coverage + quality report — pass `--no-code-review` if you want only Level 2.
 
 #### `/dw-code-review`
 Performs a formal Level 3 code review before PR creation, verifying PRD compliance, code quality (SOLID, DRY, complexity, security), and conformance with project rules in `.dw/rules/`. Runs tests, verifies coverage targets, and generates a persistent report with APPROVED, APPROVED WITH CAVEATS, or REJECTED status.
@@ -111,14 +108,11 @@ Records an Architecture Decision Record (ADR) for a non-trivial decision during
 
 ### 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.
+Queries codebase intelligence to answer questions about patterns, conventions, and architecture. Reads `.dw/intel/` (built by `/dw-map-codebase`) as primary source, falls back to `.dw/rules/` and direct grep when absent. Surfaces stale-index warnings (>7 days). 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. With GSD installed, also creates a queryable index in `.planning/intel/`.
+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. Also invokes `/dw-map-codebase` to build the queryable index in `.dw/intel/` (the two are complementary — rules are human-readable, intel is machine-queryable).
 
 #### `/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.
@@ -130,13 +124,11 @@ Generates a functional documentation dossier with screen mapping, E2E flows, and
 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.
 
 #### `/dw-find-skills`
-Discovers skills from the open agent skills ecosystem (`npx skills` / [skills.sh](https://skills.sh/)) when no `dw-*` already covers the request. Checks the leaderboard first, then runs `npx skills find <query>` if needed, vets each candidate (install count, source reputation, GitHub stars), and presents 1–3 options with the install commands. Asks whether to install globally (`-g`, lands in `~/.agents/skills/`) or locally (this repo) before running `npx skills add`. Falls back to `/dw-brainstorm` or `/dw-quick` when no skill matches. Ports the `find-skills` Claude superpowers skill into a `dw-*` command so every supported platform gets the same discovery on-ramp.
+Discovers skills from the open agent skills ecosystem (`npx skills` / [skills.sh](https://skills.sh/)) when no `dw-*` already covers the request. Checks the leaderboard first, then runs `npx skills find <query>` if needed, vets each candidate (install count, source reputation, GitHub stars), and presents 1–3 options with the install commands. Asks whether to install globally (`-g`, lands in `~/.agents/skills/`) or locally (this repo) before running `npx skills add`. Falls back to `/dw-brainstorm` or `/dw-run-task` when no skill matches. Ports the `find-skills` Claude superpowers skill into a `dw-*` command so every supported platform gets the same discovery on-ramp.
 
 ## Workflow
 
 ```
-                        /dw-resume (pick up where you left off)
-                            |
 /dw-autopilot "wish"  ------>  Runs entire pipeline automatically
                                 (gates: PRD approval, Tasks approval, PR confirmation)
     --- OR ---
@@ -149,7 +141,7 @@ Discovers skills from the open agent skills ecosystem (`npx skills` / [skills.sh
                             |
                         /dw-run-task (one at a time)
                             |       or
-                        /dw-run-plan (all tasks — parallel with GSD)
+                        /dw-run-plan (all tasks — wave-based parallel native)
                             |
                         /dw-run-qa  -->  .dw/spec/prd-{name}/QA/
                             |
@@ -162,7 +154,6 @@ Discovers skills from the open agent skills ecosystem (`npx skills` / [skills.sh
                         /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
 ```
@@ -183,7 +174,7 @@ All wrappers point to `.dw/commands/` as the single source of truth.
 ```
 your-project/
 ├── .dw/
-│   ├── commands/          # 31 workflow command files
+│   ├── commands/          # 30 workflow command files
 │   ├── templates/         # Document templates (PRD, TechSpec, etc.)
 │   ├── rules/             # Project-specific rules (run /dw-analyze-project)
 │   ├── references/        # Reference documentation
@@ -193,8 +184,7 @@ your-project/
 │   ├── skills/            # Claude Code wrappers
 │   └── settings.json      # MCP servers (Context7, Playwright)
 ├── .agents/skills/        # Codex/Copilot wrappers + bundled skills
-├── .opencode/commands/    # OpenCode wrappers
-└── .planning/             # GSD state (if installed via install-deps)
+└── .opencode/commands/    # OpenCode wrappers
 ```
 
 ## Bundled Skills
@@ -207,21 +197,27 @@ These are not slash commands — they are primitives other commands call to enfo
 
 | Skill | Description | Invoked by | Inspired by |
 |-------|-------------|------------|-------------|
-| **dw-verify** | Enforces fresh verification evidence before any completion, commit, or PR claim — with Iron Law, gate function, and Verification Report template | `dw-run-task`, `dw-run-plan`, `dw-fix-qa`, `dw-bugfix`, `dw-code-review`, `dw-generate-pr`, `dw-quick` | [Compozy](https://github.com/compozy/compozy) `cy-final-verify` |
-| **dw-memory** | Two-tier workflow memory (shared `MEMORY.md` + per-task `<N>_memory.md`) with promotion test and compaction rules, so cross-task context persists cleanly | `dw-run-task`, `dw-run-plan`, `dw-autopilot`, `dw-resume` | [Compozy](https://github.com/compozy/compozy) `cy-workflow-memory` |
+| **dw-verify** | Enforces fresh verification evidence before any completion, commit, or PR claim — with Iron Law, gate function, and Verification Report template | `dw-run-task`, `dw-run-plan`, `dw-fix-qa`, `dw-bugfix`, `dw-code-review`, `dw-generate-pr` | [Compozy](https://github.com/compozy/compozy) `cy-final-verify` |
+| **dw-memory** | Two-tier workflow memory (shared `MEMORY.md` + per-task `<N>_memory.md`) with promotion test and compaction rules, so cross-task context persists cleanly | `dw-run-task`, `dw-run-plan`, `dw-autopilot` | [Compozy](https://github.com/compozy/compozy) `cy-workflow-memory` |
 | **dw-review-rigor** | Review discipline: de-duplication, severity ordering, verify-intent-before-flagging, skip-linter-issues, signal-over-volume | `dw-code-review`, `dw-review-implementation`, `dw-refactoring-analysis` | [Compozy](https://github.com/compozy/compozy) `cy-review-round` |
 | **dw-council** | Multi-advisor debate (3-5 archetypes) with steel-manning, concession tracking, and dissent-preserving synthesis. Opt-in only. | `dw-brainstorm --council`, `dw-create-techspec --council` | [Compozy](https://github.com/compozy/compozy) `cy-idea-factory` |
+| **dw-codebase-intel** | Codebase intelligence (`stack.json`, `files.json`, `apis.json`, `deps.json`, `arch.md`) with incremental updates and query patterns. Cross-cutting reference: `api-design-discipline` (Hyrum's Law, contract-first, error semantics) used when techspecs design API endpoints. | `/dw-intel`, `/dw-map-codebase`, `dw-create-techspec` | [`get-shit-done-cc`](https://github.com/gsd-build/get-shit-done) (MIT) + [`addyosmani/agent-skills`](https://github.com/addyosmani/agent-skills) (MIT) |
+| **dw-execute-phase** | Goal-backward 6-dimension plan verification (`plan-checker`) and wave-based parallel task execution (`executor`) with atomic commit, deviation handling, and checkpoint recovery | `dw-run-plan`, `dw-autopilot` | [`get-shit-done-cc`](https://github.com/gsd-build/get-shit-done) (MIT) |
+| **dw-source-grounding** | Detect → Fetch → Implement → Cite protocol with `[source: <url>, version: X.Y, retrieved: YYYY-MM-DD]` citations. Strict source-priority hierarchy (Tier 1 official docs > Tier 2 maintainer blogs > Tier 3 Stack Overflow as discovery only). | `dw-create-techspec`, `dw-deps-audit`, `dw-deep-research` | [`addyosmani/agent-skills`](https://github.com/addyosmani/agent-skills) (MIT) |
+| **dw-simplification** | Chesterton's Fence (understand WHY before changing), behavior-preserving refactor protocol (test gate before/after), complexity metrics (cyclomatic, cognitive, depth, fan-out), Rule of 500 for large refactors | `dw-code-review`, `dw-refactoring-analysis` | [`addyosmani/agent-skills`](https://github.com/addyosmani/agent-skills) (MIT) |
+| **dw-debug-protocol** | Stop-the-line discipline plus six-step triage (Reproduce → Localize → Reduce → Fix Root Cause → Guard → Verify End-to-End). Error categorization matrix; instrument-first non-reproducible-bug strategy. | `dw-bugfix`, `dw-fix-qa` | [`addyosmani/agent-skills`](https://github.com/addyosmani/agent-skills) (MIT) |
+| **dw-git-discipline** | Trunk-based pattern (1-3 day branches, daily rebase, feature flags), atomic commit discipline (one intent per commit; refactor separate from feature), Conventional Commits, branch hygiene | `dw-commit`, `dw-generate-pr` | [`addyosmani/agent-skills`](https://github.com/addyosmani/agent-skills) (MIT) |
 
 ### Domain expertise
 
 | 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 |
+| **vercel-react-best-practices** | 67 React/Next.js performance optimization rules across 8 priority categories. Wraps the rules with `references/perf-discipline.md` (measure → identify → fix → verify → guard) so perf work is data-driven, not vibes-based | [Vercel Labs](https://github.com/vercel-labs/agent-skills) + [`addyosmani/agent-skills`](https://github.com/addyosmani/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/) | -- |
+| **webapp-testing** | Playwright-based browser testing toolkit for E2E validation and screenshots. Cross-cutting references: `security-boundary` (every byte from a browser is potentially attacker-controlled) and `three-workflow-patterns` (UI bugs vs network issues vs perf — distinct workflows, don't conflate) | [Playwright](https://playwright.dev/) + [`addyosmani/agent-skills`](https://github.com/addyosmani/agent-skills) | -- |
 
 ## Dependencies
 
@@ -232,8 +228,8 @@ Installed via `npx @brunosps00/dev-workflow install-deps`:
 | **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) |
 | **Trivy** | Native binary scanner used by `/dw-security-check` for CVE, secret, and IaC scanning. `install-deps` detects presence and prints OS-specific install instructions (brew / curl script / choco / Docker) — does not install automatically. | [aquasecurity.github.io/trivy](https://aquasecurity.github.io/trivy/) |
+| **Docker + Docker Compose** | Required by `/dw-new-project` and `/dw-dockerize` for dev dependency seeding and image generation. `install-deps` detects presence and prints OS-specific install instructions — does not install automatically. | [docs.docker.com](https://docs.docker.com/engine/install/) |
 
 ## Options
 
@@ -243,7 +239,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 install-deps          # Install Playwright, react-doctor; check Trivy, Docker
 npx @brunosps00/dev-workflow help                  # Show help
 ```
 
@@ -254,7 +250,14 @@ 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
+4. **(Optional) Run `npx @brunosps00/dev-workflow install-deps`** to install Playwright + react-doctor and check Trivy + Docker
+5. **Run `/dw-map-codebase`** once your project has source files to build the queryable index in `.dw/intel/`
+
+## Acknowledgements
+
+Codebase intelligence (`/dw-intel`, `/dw-map-codebase`, the `dw-codebase-intel` bundled skill) and phase execution patterns (the `dw-execute-phase` bundled skill, with its `plan-checker` and `executor` agents) were adapted from [`get-shit-done-cc`](https://github.com/gsd-build/get-shit-done) by gsd-build (MIT). Schemas (`stack.json`, `files.json`, `apis.json`, `deps.json`, `arch.md`), the goal-backward verification protocol, and the wave-based parallel execution pattern come from there. dev-workflow specifics: `.dw/` namespace instead of `.planning/`, agent-driven runtime instead of `gsd-sdk` CLI, integration with the rest of the `dw-*` command surface.
+
+Source-driven development, code simplification, debugging discipline, and git workflow patterns adapted from [`addyosmani/agent-skills`](https://github.com/addyosmani/agent-skills) by Addy Osmani (MIT) into the bundled `dw-source-grounding`, `dw-simplification`, `dw-debug-protocol`, and `dw-git-discipline` skills. Performance-optimization workflow (`vercel-react-best-practices/references/perf-discipline.md`), API-design discipline (`dw-codebase-intel/references/api-design-discipline.md`), and browser-DevTools patterns (`webapp-testing/references/{security-boundary, three-workflow-patterns}`) also incorporated as enhancements to existing bundled skills.
 
 ## License
 

package/bin/dev-workflow.js

@@ -30,7 +30,7 @@ const HELP_TEXT = `
                    Preserves: .dw/rules/, .dw/spec/, user data
     install-deps   Install system dependencies (Playwright browsers, MCP servers)
     uninstall      Remove all managed files (commands, templates, wrappers, skills, MCPs)
-                   Preserves: .dw/rules/, .dw/spec/, .planning/ (user data)
+                   Preserves: .dw/rules/, .dw/spec/, .dw/intel/ (user data)
     help           Show this help message
 
   Options:

package/lib/constants.js

@@ -18,13 +18,12 @@ const COMMANDS = {
     { name: 'dw-functional-doc', description: 'Maps screens and user flows into a functional doc, validated end-to-end with Playwright.' },
     { name: 'dw-generate-pr', description: 'Pushes the branch and opens a PR with a body that explains what changed and how to test it.' },
     { name: 'dw-help', description: 'Lists every command and the flows that connect them. Pass a keyword for a contextual shortcut.' },
-    { name: 'dw-intel', description: 'Answers questions about the codebase using its own rules and intel as the source of truth.' },
+    { name: 'dw-intel', description: 'Answers questions about the codebase by querying .dw/intel/ (built by /dw-map-codebase) with .dw/rules/ and grep as fallbacks.' },
+    { name: 'dw-map-codebase', description: 'Builds a queryable index in .dw/intel/ (stack, files, apis, deps, arch) so other commands stop re-exploring the codebase.' },
     { name: 'dw-new-project', description: 'Interviews you about stack and infra, then scaffolds a working monorepo with docker-compose for dev, .env, scripts, CI, and seeded rules.' },
-    { name: 'dw-quick', description: 'Runs a small, well-defined change with workflow guarantees, no PRD needed.' },
     { name: 'dw-redesign-ui', description: 'Audits a frontend page, proposes design directions you choose from, then ships the redesign.' },
     { name: 'dw-refactoring-analysis', description: 'Catalogs code smells in Fowler\'s vocabulary and ranks them by impact, P0 to P3.' },
-    { name: 'dw-resume', description: 'Picks up where you left off — reads the active PRD, the last task, and tells you what\'s next.' },
-    { name: 'dw-review-implementation', description: 'Maps every PRD requirement to the code that delivers it, and lists what is still missing.' },
+    { name: 'dw-review-implementation', description: 'Maps every PRD requirement to the code that delivers it, then runs /dw-code-review for the Level 3 quality layer.' },
     { name: 'dw-revert-task', description: 'Reverts the commits of one task, but only after checking nothing downstream depends on it.' },
     { name: 'dw-run-plan', description: 'Runs every pending task in order, with PRD-compliance review at the end.' },
     { name: 'dw-run-qa', description: 'Drives the browser to test happy paths, edge cases, and accessibility, with screenshot proof.' },
@@ -51,13 +50,12 @@ const COMMANDS = {
     { name: 'dw-functional-doc', description: 'Mapeia telas e fluxos em um dossie funcional, validado E2E com Playwright.' },
     { name: 'dw-generate-pr', description: 'Faz push da branch e abre um PR com corpo explicando o que mudou e como testar.' },
     { name: 'dw-help', description: 'Lista todos os commands e os fluxos que os conectam. Passe uma keyword para atalho contextual.' },
-    { name: 'dw-intel', description: 'Responde perguntas sobre o codebase usando suas proprias rules e intel como fonte.' },
+    { name: 'dw-intel', description: 'Responde perguntas sobre o codebase consultando .dw/intel/ (do /dw-map-codebase) com .dw/rules/ e grep como fallback.' },
+    { name: 'dw-map-codebase', description: 'Constroi um indice queryable em .dw/intel/ (stack, files, apis, deps, arch) para outros comandos pararem de re-explorar o codebase.' },
     { name: 'dw-new-project', description: 'Entrevista voce sobre stack e infra, depois faz scaffold de um monorepo com docker-compose para dev, .env, scripts, CI e rules seed.' },
-    { name: 'dw-quick', description: 'Roda uma mudanca pequena e bem definida com garantias do workflow, sem precisar de PRD.' },
     { name: 'dw-redesign-ui', description: 'Audita uma pagina frontend, propoe direcoes de design que voce escolhe, e entrega o redesign.' },
     { name: 'dw-refactoring-analysis', description: 'Cataloga code smells no vocabulario de Fowler e ranqueia por impacto, P0 a P3.' },
-    { name: 'dw-resume', description: 'Retoma de onde voce parou — le o PRD ativo, a ultima task, e diz qual o proximo passo.' },
-    { name: 'dw-review-implementation', description: 'Mapeia cada requisito do PRD ao codigo que o entrega, e lista o que ainda falta.' },
+    { name: 'dw-review-implementation', description: 'Mapeia cada requisito do PRD ao codigo que o entrega, e roda /dw-code-review para a camada de qualidade Nivel 3.' },
     { name: 'dw-revert-task', description: 'Reverte os commits de uma task, mas so depois de checar que nada a frente depende dela.' },
     { name: 'dw-run-plan', description: 'Roda todas as tasks pendentes em ordem, com review de PRD compliance no final.' },
     { name: 'dw-run-qa', description: 'Pilota o browser para testar fluxo feliz, edge cases e acessibilidade, com screenshot.' },

package/lib/init.js

@@ -4,6 +4,7 @@ const { ensureDir, copyDir, writeFile, log } = require('./utils');
 const { selectLanguage } = require('./prompts');
 const { generateWrappers } = require('./wrappers');
 const { installMCPs } = require('./mcp');
+const { migrate: migrateGsd } = require('./migrate-gsd');
 
 const SCAFFOLD_DIR = path.join(__dirname, '..', 'scaffold');
 
@@ -18,6 +19,11 @@ async function run({ force = false, lang = null, mode = 'init' }) {
   console.log(`\n  dev-workflow ${isUpdate ? 'update' : 'init'}`);
   console.log(`  ${'='.repeat(40)}\n`);
 
+  // 0. GSD migration (idempotent; only runs if legacy GSD artifacts are detected)
+  if (isUpdate) {
+    migrateGsd(projectRoot);
+  }
+
   // 1. Select language
   const selectedLang = await selectLanguage(lang);
   console.log(`\n  Language: ${selectedLang}\n`);

package/lib/install-deps.js

@@ -20,11 +20,6 @@ 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',
-    },
     {
       name: 'Trivy (security scanner)',
       check: 'trivy --version',

package/lib/migrate-gsd.js

@@ -0,0 +1,164 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * One-shot GSD migration. Detects legacy GSD artifacts in a project,
+ * migrates the parts dev-workflow now provides natively, and removes
+ * the rest.
+ *
+ * Idempotent: returns silently when nothing to do.
+ *
+ * Run automatically from lib/init.js when mode === 'update'.
+ */
+function migrate(projectRoot) {
+  const planning = path.join(projectRoot, '.planning');
+  const dotClaude = path.join(projectRoot, '.claude');
+  const claudeCmdsGsd = path.join(dotClaude, 'commands', 'gsd');
+  const claudeManifest = path.join(dotClaude, 'gsd-file-manifest.json');
+
+  const hasPlanning = fs.existsSync(planning);
+  const hasGsdCmds = fs.existsSync(claudeCmdsGsd);
+  const hasGsdManifest = fs.existsSync(claudeManifest);
+
+  // Detect any gsd-* file in .claude/agents/ or .claude/hooks/
+  const gsdAgents = listMatching(path.join(dotClaude, 'agents'), /^gsd-.*\.md$/);
+  const gsdHooks = listMatching(path.join(dotClaude, 'hooks'), /^gsd-.*\.(js|cjs|mjs)$/);
+
+  const detected =
+    hasPlanning || hasGsdCmds || hasGsdManifest || gsdAgents.length > 0 || gsdHooks.length > 0;
+
+  if (!detected) return null; // nothing to migrate
+
+  console.log('\n  GSD legacy artifacts detected — migrating to dev-workflow native namespace.');
+
+  const stats = {
+    intel_files: 0,
+    state_migrated: false,
+    quick_files: 0,
+    threads_files: 0,
+    planning_archived: false,
+    cmds_removed: false,
+    agents_removed: 0,
+    hooks_removed: 0,
+    manifest_removed: false,
+  };
+
+  // 1. Migrate .planning/intel/* → .dw/intel/*
+  if (hasPlanning) {
+    const planningIntel = path.join(planning, 'intel');
+    if (fs.existsSync(planningIntel)) {
+      const dwIntel = path.join(projectRoot, '.dw', 'intel');
+      stats.intel_files = copyDirRecursive(planningIntel, dwIntel);
+    }
+
+    // 2. Migrate .planning/STATE.md → .dw/spec/active-session.md
+    const stateFile = path.join(planning, 'STATE.md');
+    if (fs.existsSync(stateFile)) {
+      const target = path.join(projectRoot, '.dw', 'spec', 'active-session.md');
+      ensureDir(path.dirname(target));
+      fs.copyFileSync(stateFile, target);
+      stats.state_migrated = true;
+    }
+
+    // 3. Migrate .planning/quick/* → .dw/spec/quick/*
+    const planningQuick = path.join(planning, 'quick');
+    if (fs.existsSync(planningQuick)) {
+      const dwQuick = path.join(projectRoot, '.dw', 'spec', 'quick');
+      stats.quick_files = copyDirRecursive(planningQuick, dwQuick);
+    }
+
+    // 4. Migrate .planning/threads/* → .dw/threads/*
+    const planningThreads = path.join(planning, 'threads');
+    if (fs.existsSync(planningThreads)) {
+      const dwThreads = path.join(projectRoot, '.dw', 'threads');
+      stats.threads_files = copyDirRecursive(planningThreads, dwThreads);
+    }
+
+    // 5. Rename .planning/ → .planning.gsd-archive-<DATE>/ (preserve for inspection)
+    const date = new Date().toISOString().split('T')[0];
+    const archive = path.join(projectRoot, `.planning.gsd-archive-${date}`);
+    if (!fs.existsSync(archive)) {
+      try {
+        fs.renameSync(planning, archive);
+        stats.planning_archived = true;
+      } catch (err) {
+        console.log(`    \x1b[33m! Could not rename .planning → ${path.basename(archive)}: ${err.message}\x1b[0m`);
+      }
+    } else {
+      console.log(`    \x1b[33m! Archive ${path.basename(archive)} already exists; leaving .planning/ in place\x1b[0m`);
+    }
+  }
+
+  // 6. Remove .claude/commands/gsd/
+  if (hasGsdCmds) {
+    rmRecursive(claudeCmdsGsd);
+    stats.cmds_removed = true;
+  }
+
+  // 7. Remove .claude/agents/gsd-*.md
+  for (const file of gsdAgents) {
+    fs.unlinkSync(path.join(dotClaude, 'agents', file));
+    stats.agents_removed++;
+  }
+
+  // 8. Remove .claude/hooks/gsd-*.js
+  for (const file of gsdHooks) {
+    fs.unlinkSync(path.join(dotClaude, 'hooks', file));
+    stats.hooks_removed++;
+  }
+
+  // 9. Remove .claude/gsd-file-manifest.json
+  if (hasGsdManifest) {
+    fs.unlinkSync(claudeManifest);
+    stats.manifest_removed = true;
+  }
+
+  // 10. Print summary
+  console.log('  Migration summary:');
+  if (stats.intel_files) console.log(`    + .dw/intel/                   (${stats.intel_files} files migrated from .planning/intel/)`);
+  if (stats.state_migrated) console.log('    + .dw/spec/active-session.md   (migrated from .planning/STATE.md)');
+  if (stats.quick_files) console.log(`    + .dw/spec/quick/              (${stats.quick_files} files migrated from .planning/quick/)`);
+  if (stats.threads_files) console.log(`    + .dw/threads/                 (${stats.threads_files} files migrated from .planning/threads/)`);
+  if (stats.planning_archived) console.log(`    ~ .planning/                   (renamed to .planning.gsd-archive-${new Date().toISOString().split('T')[0]}/ — review and delete when ready)`);
+  if (stats.cmds_removed) console.log('    - .claude/commands/gsd/        (removed; native /dw-* commands cover the use cases)');
+  if (stats.agents_removed) console.log(`    - .claude/agents/gsd-*.md      (${stats.agents_removed} files removed; native dw-* agents bundled in skills)`);
+  if (stats.hooks_removed) console.log(`    - .claude/hooks/gsd-*.js       (${stats.hooks_removed} files removed; not used by dev-workflow)`);
+  if (stats.manifest_removed) console.log('    - .claude/gsd-file-manifest.json (removed)');
+  console.log('  Done. Native /dw-intel, /dw-map-codebase, /dw-run-plan (with bundled phase-execution agents) now provide what GSD provided.');
+  console.log();
+
+  return stats;
+}
+
+function listMatching(dir, regex) {
+  if (!fs.existsSync(dir)) return [];
+  return fs.readdirSync(dir).filter((name) => regex.test(name));
+}
+
+function ensureDir(dir) {
+  fs.mkdirSync(dir, { recursive: true });
+}
+
+function copyDirRecursive(src, dst) {
+  if (!fs.existsSync(src)) return 0;
+  ensureDir(dst);
+  let count = 0;
+  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    const srcPath = path.join(src, entry.name);
+    const dstPath = path.join(dst, entry.name);
+    if (entry.isDirectory()) {
+      count += copyDirRecursive(srcPath, dstPath);
+    } else if (entry.isFile()) {
+      fs.copyFileSync(srcPath, dstPath);
+      count++;
+    }
+  }
+  return count;
+}
+
+function rmRecursive(target) {
+  if (!fs.existsSync(target)) return;
+  fs.rmSync(target, { recursive: true, force: true });
+}
+
+module.exports = { migrate };

package/lib/uninstall.js

@@ -97,14 +97,14 @@ function run() {
   // 6. Remove legacy .codex/skills/
   removeDir(path.join(projectRoot, '.codex', 'skills'));
 
-  // Note: .dw/rules/, .dw/spec/, .planning/ are USER DATA — never removed
+  // Note: .dw/rules/, .dw/spec/, .dw/intel/ are USER DATA — never removed
   console.log(`\n  ${'='.repeat(40)}`);
   console.log(`  Done! ${removed} removed, ${skipped} already absent`);
   console.log();
   console.log('  Preserved (user data):');
   console.log('    .dw/rules/    (project rules)');
   console.log('    .dw/spec/     (PRDs and specs)');
-  console.log('    .planning/    (GSD state)');
+  console.log('    .dw/intel/    (codebase index from /dw-map-codebase)');
   console.log();
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brunosps00/dev-workflow",
-  "version": "0.8.1",
+  "version": "0.10.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,19 +230,14 @@ 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>
+<critical>Running /dw-map-codebase to generate the queryable index in .dw/intel/ is MANDATORY. The command CANNOT be considered complete without it.</critical>
 
-#### Codebase Intelligence (GSD)
+#### Codebase Intelligence (native)
 
-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`"
+After generating rules in `.dw/rules/`, delegate to `/dw-map-codebase` to create the queryable index in `.dw/intel/`:
+- The index includes: stack (`stack.json`), file graph (`files.json`), API surface (`apis.json`), dependencies (`deps.json`), architecture overview (`arch.md`)
+- The index is incremental — `/dw-map-codebase --files <list>` updates only the touched entries; full scan only when needed
+- Other dw-* commands query the index via `/dw-intel` (see the `dw-codebase-intel` bundled skill for schemas)
 
 ### Step 4: Detect Code Patterns and Conventions
 

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

@@ -26,7 +26,7 @@ A step that invokes a `/dw-xxx` command is ONLY considered complete when the art
 ## 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 for small, well-scoped one-off tasks — use `/dw-run-task` directly with a quick PRD instead
 - Do NOT use to fix bugs (use `/dw-bugfix`)
 - Do NOT use when you want manual control between each phase (use individual commands)
 
@@ -56,7 +56,7 @@ The autopilot stops ONLY at these 3 moments:
 
 ## Session Resumption
 
-If this command is invoked to resume an interrupted autopilot (via `/dw-resume`):
+If this command is re-invoked on the same PRD after interruption:
 
 <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>
 
@@ -68,10 +68,11 @@ If this command is invoked to resume an interrupted autopilot (via `/dw-resume`)
 
 ### Step 1: Codebase Intelligence
 
-<critical>If `.planning/intel/` exists, querying it is MANDATORY before starting.</critical>
+<critical>If `.dw/intel/` exists, querying it via `/dw-intel` is MANDATORY before starting. Falls back to `.dw/rules/` and direct grep if absent.</critical>
 
-- Query `.planning/intel/` via `/gsd-intel` (if available) or `.dw/rules/` to understand project context
+- Query `.dw/intel/` via `/dw-intel` to understand project context
 - Identify: tech stack, existing patterns, related features
+- If `.dw/intel/` is absent, suggest running `/dw-map-codebase` first for richer downstream context
 
 ### Step 2: Research (Conditional)
 
@@ -148,7 +149,7 @@ Evaluate whether tasks involve frontend:
 ### Step 8: Execution
 
 Run `/dw-run-plan` with the PRD path.
-- Follow ALL command instructions, including GSD integration (plan verification, parallel execution)
+- Follow ALL command instructions, including the native plan-checker gate (PASS required) and wave-based parallel execution via the bundled `dw-execute-phase` skill agents
 - Each task follows `/dw-run-task` with Level 1 validation
 
 ### Step 9: Implementation Review (Loop)
@@ -247,21 +248,13 @@ 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
+## Native Engine
 
-<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
+The autopilot relies on dev-workflow-native infrastructure for codebase intelligence (`/dw-map-codebase` + `/dw-intel`) and bundled phase execution agents (plan-checker + executor in `.agents/skills/dw-execute-phase/agents/`). All bundled and require no external dependencies. See the `dw-codebase-intel` and `dw-execute-phase` bundled skills under `.agents/skills/` for details.
 
 ## State Persistence
 
-<critical>The autopilot MUST save its state after each completed step to allow resumption via `/dw-resume` in case of interruption.</critical>
+<critical>The autopilot MUST save its state after each completed step to allow re-invocation on the same PRD after interruption.</critical>
 
 Save the file `.dw/spec/prd-[name]/autopilot-state.json` with the following format:
 
@@ -293,7 +286,7 @@ Save the file `.dw/spec/prd-[name]/autopilot-state.json` with the following form
 
 - Update `current_step`, `completed_steps`, and `step_artifacts` BEFORE moving to the next step
 - A step ONLY moves to `completed_steps` after verifying its artifacts exist on disk
-- If the session drops, `/dw-resume` will read this file and continue from the correct step — and revalidate artifacts before trusting `completed_steps`
+- If the session drops, re-invoke `/dw-autopilot` on the same PRD; the command reads `autopilot-state.json` and continues from the correct step, revalidating artifacts before trusting `completed_steps`
 - When the pipeline finishes (after commit or PR), remove the file or mark `"status": "completed"`
 
 <critical>After EACH completed step, display the updated progress block to the user. This is MANDATORY — the user MUST see what was done and what comes next. If a step was skipped, the reason MUST appear in the progress block.</critical>

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

@@ -65,7 +65,7 @@ Use this command when the user wants to:
 2. **Reframe as "How Might We"**: turn the raw idea into `How might we [verb] for [user] so that [outcome]?`. This pulls the team out of premature "solution mode".
 3. **Product Inventory (required if the product exists)**:
    - If `.dw/spec/prd-*/` has PRDs OR `.dw/rules/index.md` exists, read these artifacts to map the **current product's feature inventory** (product level, not code level).
-   - Sources to consult: `.dw/spec/prd-*/prd.md` (Overview / Main Features / User Stories sections), `.dw/rules/index.md` and `.dw/rules/<module>.md`, `.planning/intel/` if present.
+   - Sources to consult: `.dw/spec/prd-*/prd.md` (Overview / Main Features / User Stories sections), `.dw/rules/index.md` and `.dw/rules/<module>.md`, `.dw/intel/` if present (queryable via `/dw-intel`).
    - Produce a **short Feature Inventory (5-12 bullets)** before diverging: "the product today does X, Y, Z".
    - If the project is greenfield (no PRDs or rules), record: "Feature Inventory: greenfield — no product artifacts yet".
 4. If essential context is missing for the user (problem, persona, expected value), ask short and objective questions before expanding.
@@ -109,7 +109,7 @@ Use this command when the user wants to:
 - Short and actionable list
 - If appropriate, suggest which command to use next:
   - `/dw-create-prd` (main successor; accepts the one-pager as input, reducing clarification questions)
-  - `/dw-quick` (if it's a small IMPROVES that fits in a single task, ≤3 files)
+  - `/dw-run-task` (if it's a small IMPROVES that fits in a single task with a quick PRD)
   - `/dw-create-techspec`
   - `/dw-create-tasks`
   - `/dw-bugfix`

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

@@ -15,6 +15,7 @@
 
     When available in the project at `./.agents/skills/`, use these skills as contextual support without replacing this command:
 
+    - `dw-debug-protocol`: **ALWAYS** — runs the bug through the six-step triage (Reproduce → Localize → Reduce → Fix Root Cause → Guard → Verify End-to-End). Stop-the-line discipline; root-cause over symptom; regression test committed in the same atomic commit. Non-reproducible bugs follow the instrument-first sub-protocol — no guess fixes without explicit acknowledgement.
     - `dw-verify`: **ALWAYS** — in Direct mode, invoked before committing the fix. The VERIFICATION REPORT must show the original bug symptom no longer reproduces (not just that tests pass).
     - `vercel-react-best-practices`: use when the bug affects React/Next.js and there is suspicion of render, hydration, fetching, waterfall, bundle, or re-render issues
     - `webapp-testing`: use when the fix requires a reproducible E2E/retest flow in a web app