@brunosps00/dev-workflow 0.9.0 → 0.10.0

package/README.md

@@ -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 (`/dw-map-codebase` + `/dw-intel`), research (conditional), brainstorm, PRD, techspec, tasks, execution (with `/dw-plan-checker` gate and `/dw-execute-phase` wave-based parallel dispatch), QA, review, and commit. Stops at 3 gates: PRD approval, tasks approval, and PR confirmation.
+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 via `/dw-execute-phase`, which gates on `/dw-plan-checker` (6-dimension goal-backward verification) before any code is touched. Wave-based parallel dispatch 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.
+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,9 +108,6 @@ Records an Architecture Decision Record (ADR) for a non-trivial decision during
 
 ### Intelligence
 
-#### `/dw-resume`
-Restores context from the last session by reading `.dw/spec/active-session.md` (written by `/dw-execute-phase` at checkpoint), pending tasks, recent git history, and active branches. Suggests the next command to execute.
-
 #### `/dw-intel`
 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.
 
@@ -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 ---
@@ -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
@@ -206,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
 
@@ -258,7 +255,9 @@ After running `npx @brunosps00/dev-workflow init`:
 
 ## Acknowledgements
 
-Codebase intelligence (`/dw-intel`, `/dw-map-codebase`, the `dw-codebase-intel` bundled skill) and phase execution patterns (`/dw-execute-phase`, `/dw-plan-checker`, the `dw-execute-phase` bundled skill) 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.
+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/lib/constants.js

@@ -13,7 +13,6 @@ const COMMANDS = {
     { name: 'dw-deep-research', description: 'Researches a topic across sources, tracks citations, and flags claims that don\'t check out.' },
     { name: 'dw-deps-audit', description: 'Finds outdated and supply-chain-compromised packages, drafts a per-package update plan, and runs scoped QA after each upgrade.' },
     { name: 'dw-dockerize', description: 'Reads a project, detects the stack and runtime deps, then proposes Dockerfile and docker-compose for dev and prod with explicit trade-offs.' },
-    { name: 'dw-execute-phase', description: 'Executes a PRD phase in waves with atomic commits per task, deviation handling, and a hard plan-checker gate before any code is touched.' },
     { name: 'dw-find-skills', description: 'Searches the npx skills ecosystem for a skill matching what you need, vets it, and installs it where you choose.' },
     { name: 'dw-fix-qa', description: 'Fixes bugs found in QA and retests them with screenshot evidence until they stay fixed.' },
     { name: 'dw-functional-doc', description: 'Maps screens and user flows into a functional doc, validated end-to-end with Playwright.' },
@@ -22,12 +21,9 @@ const COMMANDS = {
     { 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-plan-checker', description: 'Goal-backward verification of a phase tasks.md before execution. Returns PASS, REVISE, or BLOCK across 6 dimensions.' },
-    { 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.' },
@@ -49,7 +45,6 @@ const COMMANDS = {
     { name: 'dw-deep-research', description: 'Pesquisa um topico em varias fontes, rastreia citacoes e marca o que nao confere.' },
     { name: 'dw-deps-audit', description: 'Encontra pacotes desatualizados e comprometidos por supply-chain, monta plano de update por pacote e roda QA do que foi afetado.' },
     { name: 'dw-dockerize', description: 'Le um projeto, detecta stack e deps de runtime, e propoe Dockerfile e docker-compose para dev e prod com trade-offs explicitos.' },
-    { name: 'dw-execute-phase', description: 'Executa uma fase de PRD em waves com commits atomicos por task, deviation handling e gate hard de plan-checker antes de tocar codigo.' },
     { name: 'dw-find-skills', description: 'Busca no ecossistema npx skills uma skill que resolva o que voce precisa, valida e instala onde voce escolher.' },
     { name: 'dw-fix-qa', description: 'Corrige bugs do QA e retesta com evidencia em screenshot ate ficarem estaveis.' },
     { name: 'dw-functional-doc', description: 'Mapeia telas e fluxos em um dossie funcional, validado E2E com Playwright.' },
@@ -58,12 +53,9 @@ const COMMANDS = {
     { 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-plan-checker', description: 'Verificacao goal-backward de tasks.md de uma fase antes da execucao. Retorna PASS, REVISE ou BLOCK em 6 dimensoes.' },
-    { 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/migrate-gsd.js

@@ -124,7 +124,7 @@ function migrate(projectRoot) {
   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-execute-phase, /dw-plan-checker, /dw-resume now provide what GSD provided.');
+  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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brunosps00/dev-workflow",
-  "version": "0.9.0",
+  "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-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>
 
@@ -149,7 +149,7 @@ Evaluate whether tasks involve frontend:
 ### Step 8: Execution
 
 Run `/dw-run-plan` with the PRD path.
-- Follow ALL command instructions, including the native plan-checker gate (PASS required) and wave-based parallel execution via `/dw-execute-phase`
+- 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)
@@ -250,11 +250,11 @@ Ask the user: **"Commits completed. Do you want to generate the Pull Request?"**
 
 ## Native Engine
 
-The autopilot relies on dev-workflow-native infrastructure for codebase intelligence (`/dw-map-codebase` + `/dw-intel`), plan verification (`/dw-plan-checker`), and parallel execution (`/dw-execute-phase`). All four are bundled and require no external dependencies. See the `dw-codebase-intel` and `dw-execute-phase` bundled skills under `.agents/skills/` for details.
+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:
 
@@ -286,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

@@ -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

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

@@ -24,6 +24,7 @@ When available in the project under `./.agents/skills/`, use these skills as ana
 - `dw-review-rigor`: **ALWAYS** — applies de-duplication (same pattern in N files = 1 finding), severity ordering (critical → high → medium → low), verify-before-flag, skip-what-linter-catches, and signal-over-volume. The report's "Issues Found" table follows this discipline.
 - `dw-verify`: **ALWAYS** — invoked before emitting an `APPROVED` or `APPROVED WITH CAVEATS` verdict. Without a VERIFICATION REPORT PASS (test + lint + build), the verdict cannot be APPROVED.
 - `/dw-security-check`: **ALWAYS for TS/Python/C#/Rust projects** — invoked as step 6.7 (Security Layer) before emitting a verdict. If the project uses a supported language and `security-check.md` is missing OR has REJECTED status, the verdict is **REJECTED** — no exception.
+- `dw-simplification`: use when the diff touches dense or twisty code — applies Chesterton's Fence (understand WHY before flagging removal), behavior-preserving refactor protocol (test gate before/after), and complexity metrics (cyclomatic, cognitive, depth, fan-out) so that "simplify this" findings are concrete, not vibes-based.
 - `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
 

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

@@ -9,6 +9,12 @@
     ## Pipeline Position
     **Predecessor:** `/dw-run-task` or `/dw-bugfix` | **Successor:** `/dw-generate-pr`
 
+    ## Complementary Skills
+
+    When available in the project under `./.agents/skills/`, use these skills as operational support without replacing this command:
+
+    - `dw-git-discipline`: **ALWAYS** — enforces atomic commits (one logical intent per commit; refactor separate from feature), Conventional Commits format, lint+tests+build green BEFORE the commit, and bans bypassing pre-commit hooks (`--no-verify`) or amending pushed commits. When mixed changes are detected, splits via `git add -p`.
+
     ## Input Variables
 
     | Variable | Description | Example |

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

@@ -23,6 +23,7 @@
     When available in the project under `./.agents/skills/`, use these skills as support:
 
     - `dw-council` (opt-in via `--council`): multi-advisor debate on the primary architectural decision with steel-manning. **DO NOT invoke by default**.
+    - `dw-source-grounding` (**ALWAYS**): every framework/library decision must follow Detect → Fetch → Implement → Cite. The techspec emits inline citations `[source: <url>, version: X.Y, retrieved: YYYY-MM-DD]` next to each architectural decision.
     - `vercel-react-best-practices`: use when defining frontend architecture for React/Next.js projects
     - `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
@@ -32,6 +33,7 @@
     <critical>If `.dw/intel/` exists, querying it via `/dw-intel` is MANDATORY before writing the techspec. Do NOT skip this step.</critical>
     - Internally run: `/dw-intel "architectural patterns and technical decisions in the project"`
     - Align proposals with existing patterns; flag deviations explicitly
+    - When the techspec defines API endpoints, ALSO consult `dw-codebase-intel/references/api-design-discipline.md` (Hyrum's Law, contract-first, error semantics, boundary validation, versioning) — the new endpoint must match conventions surfaced in `apis.json`, not impose external "best practices" that conflict with existing patterns.
 
     If `.dw/intel/` does NOT exist:
     - Use `.dw/rules/` as context, falling back to grep

package/scaffold/en/commands/dw-deep-research.md

@@ -13,6 +13,12 @@ You are an AI assistant specialized in conducting enterprise-grade research with
 <critical>Bibliography must be COMPLETE -- every citation, no placeholders, no ranges</critical>
 <critical>Operate independently -- infer assumptions from context, only stop for critical errors</critical>
 
+## Complementary Skills
+
+| Skill | Trigger |
+|-------|---------|
+| `dw-source-grounding` | **ALWAYS** — applies the Detect → Fetch → Implement → Cite protocol with the strict source-priority hierarchy (official versioned docs > changelogs > web standards > compatibility tables; Stack Overflow / blogs / training data are discovery only). Each finding ends with `[source: <url>, version: X.Y, retrieved: YYYY-MM-DD]`; the bibliography is built from these citations. |
+
 ## Input Variables
 
 | Variable | Description | Example |

package/scaffold/en/commands/dw-deps-audit.md

@@ -29,6 +29,7 @@ This command is **distinct** from `/dw-security-check`:
 | `dw-verify` | **ALWAYS** — every phase emits a VERIFICATION REPORT (commands run, exit codes, artifacts) before the next phase starts |
 | `dw-review-rigor` | **ALWAYS** — applies de-duplication (same advisory across N packages = 1 finding with affected list), severity ordering, and signal-over-volume on the OUTDATED-MINOR list |
 | `security-review` (`references/supply-chain.md`) | **ALWAYS** when classifying findings — gives OWASP A06 (Vulnerable & Outdated Components) framing for the brainstorm trade-offs |
+| `dw-source-grounding` | **ALWAYS** in the brainstorm phase — each per-package update option (Conservative/Balanced/Bold) cites the official changelog/release notes for the target version: `[source: <url>, version: X.Y, retrieved: YYYY-MM-DD]`. Catches "agent recommends v5 because it sounds modern, but v5 dropped Node 18 support" errors. |
 | `dw-council` | Auto opt-in when ≥3 packages land in tier COMPROMISED — multi-advisor stress-test on remediation order and scope |
 | `webapp-testing` | Optional — when the project is frontend and the scoped test phase needs Playwright-aware test selection |
 

package/scaffold/en/commands/dw-find-skills.md

@@ -15,7 +15,7 @@ You are an agent skills discovery helper for this workspace. Your job is to help
 
 ## Pipeline Position
 
-**Predecessor:** any exploratory question | **Successor:** none (independent flow). If no skill is found, fall back to `/dw-brainstorm` (idea exploration) or `/dw-quick` (small one-off task) when applicable.
+**Predecessor:** any exploratory question | **Successor:** none (independent flow). If no skill is found, fall back to `/dw-brainstorm` (idea exploration) or `/dw-run-task` (small one-off task) when applicable.
 
 ## Complementary Skills
 
@@ -81,7 +81,7 @@ Browse skills at: https://skills.sh/
    - Acknowledge no match was found, no fabrication
    - Offer to help directly with general capabilities
    - Suggest `/dw-brainstorm` if the user wants to explore options before building it themselves
-   - Suggest `/dw-quick` if the request fits a small one-off change (≤ 3 files, no PRD)
+   - Suggest `/dw-run-task` if the request fits a small one-off change (≤ 3 files, no PRD)
    - Mention `npx skills init <name>` as a path to author the missing skill
 
 ## Common Skill Categories
@@ -128,7 +128,7 @@ I searched for skills related to "<query>" and didn't find a strong match
 
 I can still help directly with general capabilities. Or:
   /dw-brainstorm "<your idea>"   — if you want to explore approaches first
-  /dw-quick "<small change>"     — if it's a tiny change that fits one task
+  /dw-run-task "<small change>"  — if it's a tiny change that fits one task (write quick PRD first)
   npx skills init <name>         — if this would be valuable as a reusable skill
 ```
 
@@ -150,7 +150,7 @@ I can still help directly with general capabilities. Or:
 `dw-find-skills` ports the `find-skills` skill (from the Claude superpowers bundle, `~/.agents/skills/find-skills/SKILL.md`) into a `dw-*` workflow command so every supported platform (Claude Code, Codex, Copilot, OpenCode) gets the same discovery on-ramp. Adaptations for dev-workflow:
 
 - Pipeline integration: `/dw-help <keyword>` routes here when the keyword matches `skill`/`find skill`/`install skill`/`extend agent`.
-- Fallback to `/dw-brainstorm` or `/dw-quick` when no skill matches — keeps the user inside the workflow instead of dumping them empty-handed.
+- Fallback to `/dw-brainstorm` or `/dw-run-task` when no skill matches — keeps the user inside the workflow instead of dumping them empty-handed.
 - Explicit scope question (`-g` vs local) before installing, instead of always installing globally.
 
 Credit: the `find-skills` skill from the Claude superpowers ecosystem and the `npx skills` / [skills.sh](https://skills.sh/) project.

package/scaffold/en/commands/dw-fix-qa.md

@@ -18,6 +18,7 @@ You are an AI assistant specialized in post-QA bug fixing with evidence-driven r
 
 When available in the project under `./.agents/skills/`, use these skills as operational support without replacing this command:
 
+- `dw-debug-protocol`: **ALWAYS** — every bug-shaped finding (failing scenario, not missing feature) flows through the six-step triage. The retest evidence is the step-6 verification artifact; the regression test added in step 5 is what allows `Fixed` status to stick.
 - `dw-verify`: **ALWAYS** — invoked before marking any bug as `Fixed` or `Closed` in `QA/bugs.md`. Without a VERIFICATION REPORT PASS (test + lint + build) **and** retest evidence (screenshot in UI mode OR JSONL log line in API mode), status stays `Reopened` or `Under review`.
 - `webapp-testing`: (UI mode) support for structuring retests, captures, and scripts when complementary to Playwright MCP
 - `vercel-react-best-practices`: (UI mode) use only if the fix affects React/Next.js frontend and there is risk of rendering, hydration, fetching, or performance regression

package/scaffold/en/commands/dw-generate-pr.md

@@ -14,6 +14,7 @@ You are an assistant specialized in creating well-documented Pull Requests. Your
 | Skill | Trigger |
 |-------|---------|
 | `dw-verify` | **ALWAYS** — invoked before `git push`. Without a VERIFICATION REPORT PASS in the current session AFTER the last code edit, the PR **CANNOT** be created. |
+| `dw-git-discipline` | **ALWAYS** — validates branch naming (`<type>/<scope>` kebab-case), atomic-commit history (each commit single-intent, conventional message), branch lifetime (flag if >7 days old), and PR scope (suggest split if diff > ~400 lines). PR description follows summary + test plan structure, not a `git log` dump. |
 | `/dw-security-check` | **ALWAYS for TS/Python/C#/Rust projects** — `security-check.md` with status ≠ REJECTED is required for supported-language projects. |
 
 <critical>Hard gate 1 (verify): if the current session has no VERIFICATION REPORT PASS from `dw-verify` produced AFTER the last edit/commit, STOP and invoke `dw-verify` before proceeding. A PR is a permanent artifact — it demands the highest verification standard.</critical>

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

@@ -23,20 +23,14 @@ You are a workspace help assistant. When invoked, present the user with a comple
 | qa, visual test, playwright | `/dw-run-qa` | E2E QA with browser automation |
 | refactor, smell, fowler | `/dw-refactoring-analysis` | Prioritized code-smell audit |
 | design, ui, redesign | `/dw-redesign-ui` | Audit + propose + implement visual |
-| decision, adr, architecture | `/dw-adr` | Record an Architecture Decision Record |
 | debate, council, stress-test, opinions | `/dw-brainstorm --council` or `/dw-create-techspec --council` | Invokes `dw-council` for a multi-advisor debate |
 | security, vulnerability, owasp, trivy, cve | `/dw-security-check` | Rigid multi-layer check (OWASP static + Trivy SCA/IaC + native audit) for TS/Python/C#/Rust |
 | supply chain, outdated, compromised, malicious package, deps update, package upgrade, npm audit, pip-audit | `/dw-deps-audit` | Detect + classify + per-package update plan with scoped QA. Goes beyond `/dw-security-check` by adding remediation. |
 | skill, find skill, install skill, ecosystem, capability, extend agent | `/dw-find-skills` | Discover skills from skills.sh / `npx skills` and install them globally or locally |
 | new project, scaffold, bootstrap, start, kickoff, init project, fullstack, monorepo | `/dw-new-project` | Stack interview + create-* tools + docker-compose for dev. Runs after `npx dev-workflow init`. |
 | dockerize, docker, dockerfile, compose, container, prod image, multi-stage | `/dw-dockerize` | Reads existing project, brainstorms base image, generates Dockerfile + docker-compose for dev/prod/both, or audits existing artifacts. |
-| map codebase, intel index, code map, knowledge graph, queryable index | `/dw-map-codebase` | Builds .dw/intel/ (stack/files/apis/deps/arch) so /dw-intel and other commands stop re-exploring the codebase. |
-| execute phase, parallel tasks, wave, dispatch, atomic commits | `/dw-execute-phase` | Runs a PRD phase in waves with atomic commits per task, deviation handling, and a hard plan-checker gate before any code is touched. |
-| plan check, verify plan, plan validation, goal backward | `/dw-plan-checker` | Goal-backward verification of tasks.md before execution. PASS / REVISE / BLOCK across 6 dimensions. |
 | refine, refinement, idea, one-pager | `/dw-brainstorm --onepager` | Idea refinement with Product Inventory + classification (IMPROVES/CONSOLIDATES/NEW) + durable one-pager |
 | revert, rollback task | `/dw-revert-task` | Safe revert with dependency checks |
-| hotfix, quick change | `/dw-quick` | One-off task with guarantees, no PRD |
-| resume, where I left off | `/dw-resume` | Restore previous session context |
 | research | `/dw-deep-research` | Multi-source research with citations |
 | idea, brainstorm | `/dw-brainstorm` | Structured ideation with trade-offs |
 | update dev-workflow | `/dw-update` | Update to latest npm version |
@@ -130,9 +124,6 @@ This workspace uses an AI command system that automates the full development cyc
 | `/dw-bugfix` | Analyzes and fixes bugs (bug vs feature triage) | Target + description | Fix + commit OR PRD (if feature) |
 | `/dw-fix-qa` | Fixes documented QA bugs and retests with evidence | PRD path | Code + `QA/bugs.md` + `QA/qa-report.md` updated |
 | `/dw-redesign-ui` | Audits, proposes, and implements visual redesign of pages/components | Target page/component | Redesign brief + code |
-| `/dw-quick` | Execute a one-off task with workflow guarantees without PRD | Change description | Code + commit |
-| `/dw-resume` | Restore session context and suggest next step | (none) | Summary + suggestion |
-| `/dw-intel` | Query codebase intelligence about patterns and architecture | Question | Answer with sources |
 | `/dw-autopilot` | Full pipeline orchestrator: from a wish to a PR with minimal intervention | Wish description | PRD + code + commits + PR |
 
 ### Research
@@ -168,11 +159,15 @@ This workspace uses an AI command system that automates the full development cyc
 | `/dw-generate-pr` | Push + create PR + copy body + open URL | Target branch | PR on GitHub |
 | `/dw-revert-task` | Safely revert a specific task's commits (dependency checks + confirmation) | PRD path + task number | Reverted commits + updated `tasks.md` |
 
-### Architectural Decisions
+### Internal commands (used by other dw-* commands; rarely invoked directly)
 
-| Command | What it does | Input | Output |
-|---------|-------------|-------|--------|
-| `/dw-adr` | Record an Architecture Decision Record (ADR) for a non-trivial decision during a PRD | PRD path + title | `.dw/spec/<prd>/adrs/adr-NNN.md` + cross-refs updated |
+| Command | What it does | Typically invoked by |
+|---------|-------------|----------------------|
+| `/dw-adr` | Record an Architecture Decision Record during PRD execution | `/dw-create-techspec`, `/dw-run-task` when a non-trivial decision arises |
+| `/dw-intel` | Query the codebase index built in `.dw/intel/` | `/dw-create-prd`, `/dw-create-techspec`, `/dw-code-review`, etc. |
+| `/dw-map-codebase` | Build/refresh the queryable codebase index in `.dw/intel/` | `/dw-analyze-project` (auto-runs after rules generation) |
+
+These are exposed as slash commands for occasional manual use (e.g., quickly recording an ADR mid-session, ad-hoc codebase queries) but most users never invoke them directly — they're called by the higher-level commands above.
 
 ### Maintenance
 
@@ -293,16 +288,6 @@ LEVEL 3 - Formal Code Review (/dw-code-review)
 /dw-autopilot "description of what you want to build"  # Research → PRD → Tasks → Code → QA → PR
 ```
 
-### Quick Task
-```bash
-/dw-quick "change description"                     # Implement + validate + commit
-```
-
-### Resume Session
-```bash
-/dw-resume                                         # Restore context + suggest next step
-```
-
 ### Query Codebase
 ```bash
 /dw-intel "how does X work in this project?"       # Answer with sources
@@ -334,9 +319,7 @@ your-project/
 │   │   ├── dw-autopilot.md
 │   │   ├── dw-deep-research.md
 │   │   ├── dw-intel.md
-│   │   ├── dw-quick.md
 │   │   ├── dw-redesign-ui.md
-│   │   ├── dw-resume.md
 │   │   ├── dw-bugfix.md
 │   │   ├── dw-commit.md
 │   │   ├── dw-functional-doc.md
@@ -400,10 +383,7 @@ Commands work across multiple AI tools, all pointing to the same source `.dw/com
 - 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: How do I get codebase intelligence and parallel execution?**
-- Both are native to dev-workflow as of v0.9.0. Run `/dw-map-codebase` to build the queryable index in `.dw/intel/`, then `/dw-intel "<question>"` to query it. For parallel execution, `/dw-execute-phase` dispatches tasks in waves with atomic commits per task. No external dependency needed.
-
-**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.
+- Both are native to dev-workflow. Run `/dw-map-codebase` to build the queryable index in `.dw/intel/`, then `/dw-intel "<question>"` to query it. For parallel execution, `/dw-run-plan` invokes the bundled phase-execution agents (executor + plan-checker) directly to dispatch tasks in waves with atomic commits per task. No external dependency needed.
 
 **Q: Does `/dw-autopilot` replace all other commands?**
 - No. It orchestrates existing commands in sequence. You can still use each command individually for manual control. Autopilot is for when you want to go from a wish to a PR with minimal intervention.

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

@@ -10,7 +10,7 @@ You are a codebase intelligence assistant. This command answers questions about
 - Use to understand how something works in the project (auth flow, data model, route surface)
 - 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`)
+- Do NOT use to implement changes (use `/dw-run-task`)
 
 ## Pipeline Position
 

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

@@ -21,8 +21,9 @@ Prerequisite: Run `/dw-analyze-project` first to understand project patterns and
 When available in the project under `./.agents/skills/`, use these skills as analytical support without replacing this command:
 
 - `dw-review-rigor`: **ALWAYS** — when cataloging code smells, apply de-duplication (same smell in N files = 1 entry with affected list), severity ordering across P0-P3, signal-over-volume (max ~20 findings; keep criticals, prune marginal ones). A smell with a justifying ADR drops to `low` at most.
+- `dw-simplification`: **ALWAYS** — every flagged smell is filtered through Chesterton's Fence (what does the construct DO, why was it added, what breaks if removed). Smells with no clear "why-was-it-there" answer get downgraded to `info` and a research note instead of a refactor proposal. Complexity metrics back the severity (cognitive complexity ≥16 or nesting depth ≥4 = `high` candidate; <10 = `low` at most).
 - `security-review`: defer security concerns to this skill — do not duplicate
-- `vercel-react-best-practices`: defer React/Next.js performance patterns to this skill
+- `vercel-react-best-practices`: defer React/Next.js performance patterns to this skill — when flagging perf-related smells, follow its `references/perf-discipline.md` (measure → identify → fix → verify → guard) and cite the metric + tool, not vibes
 
 ## Analysis Tools
 

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

@@ -318,6 +318,32 @@ git diff <commit> -- path/to/file
 
 <critical>DO NOT APPROVE requirements without concrete evidence in the code</critical>
 <critical>ANALYZE the actual code, do not trust only the checkboxes in tasks.md</critical>
-<critical>If 100% of requirements were implemented and there are NO gaps: DO NOT enter plan mode, DO NOT create tasks, DO NOT dispatch agents. Just present the report and END.</critical>
-<critical>If gaps are found, enter the fix-review loop automatically. Do NOT wait for user instructions to fix gaps. Maximum 3 cycles before marking as BLOCKED.</critical>
+<critical>If 100% of requirements were implemented and there are NO gaps: DO NOT enter plan mode, DO NOT create tasks, DO NOT dispatch agents. Just present the Level 2 report, then proceed to Level 3 (next section).</critical>
+<critical>If gaps are found, enter the fix-review loop automatically. Do NOT wait for user instructions to fix gaps. Maximum 3 cycles before marking as BLOCKED. Level 3 only runs after the loop reaches APPROVED on Level 2.</critical>
+
+## Level 3 — Quality Layer (auto-invoked at the end)
+
+After Level 2 (PRD coverage) reaches APPROVED, **automatically invoke `/dw-code-review`** to add the formal quality layer (best practices, SOLID, DRY, complexity, security, conventions). Addresses the user expectation that a single review covers both "did we deliver everything?" (Level 2) and "is what we delivered well-built?" (Level 3).
+
+Pipeline:
+
+1. After Level 2 APPROVED, run `/dw-code-review {{PRD_PATH}}` with the same PRD scope.
+2. Wait for `/dw-code-review` to produce its verdict (APPROVED / APPROVED WITH CAVEATS / REJECTED).
+3. Write a consolidated summary at `{{PRD_PATH}}/QA/review-consolidated.md` referencing both:
+   - Level 2: `{{PRD_PATH}}/QA/review-coverage.md` (PRD compliance map)
+   - Level 3: `{{PRD_PATH}}/QA/dw-code-review.md` (formal review)
+4. Final status combines both verdicts:
+   - Level 2 APPROVED + Level 3 APPROVED → consolidated APPROVED
+   - Level 2 APPROVED + Level 3 APPROVED WITH CAVEATS → consolidated APPROVED WITH CAVEATS
+   - Level 2 APPROVED + Level 3 REJECTED → consolidated REJECTED (Level 3 wins)
+   - Level 2 REJECTED → never reaches Level 3 (loop fixes coverage first)
+
+### Flag to skip Level 3
+
+If the user runs `/dw-review-implementation --no-code-review`, skip Level 3 and emit only the Level 2 report. Use case: re-running coverage after a small targeted gap fix when a full Level 3 sweep was just done.
+
+### Why this auto-chain exists
+
+`dw-review-implementation` historically returned only Level 2 (coverage). Users expected a single review to also cover quality. Splitting the natural intent into two separate commands created friction. The auto-chain restores the natural "review the implementation" semantics: cover + quality, by default, in one invocation. Standalone `/dw-code-review` remains available for cases where only Level 3 is wanted (e.g., reviewing a cherry-picked refactor branch with no PRD).
+
 </system_instructions>

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

@@ -165,7 +165,7 @@ If a task FAILS during execution:
 
 ### Plan Verification (Pre-Execution)
 
-Before starting execution, delegate to `/dw-plan-checker {{PRD_PATH}}`:
+Before starting execution, spawn the **plan-checker agent** from `.agents/skills/dw-execute-phase/agents/plan-checker.md`:
 - The plan-checker agent verifies the 6 dimensions (requirement coverage, task completeness, dependency soundness, artifact wiring, context budget, constraint compliance)
 - If REVISE: present issues found and suggest fixes. Maximum 3 correction cycles via `/dw-create-tasks --revise`
 - If BLOCK: surface conflict to user, do NOT auto-replan
@@ -173,7 +173,7 @@ Before starting execution, delegate to `/dw-plan-checker {{PRD_PATH}}`:
 
 ### Parallel Execution (Wave-Based)
 
-After plan-checker PASS, delegate to `/dw-execute-phase {{PRD_PATH}}`:
+After plan-checker PASS, spawn the **executor agent** from `.agents/skills/dw-execute-phase/agents/executor.md`:
 - The executor agent analyzes each task's `Depends on:` field to build the dependency graph
 - Groups tasks into waves:
   - Wave 1: tasks with no dependencies (run in parallel)

package/scaffold/en/templates/idea-onepager.md

@@ -86,5 +86,5 @@ Ideally 2-4 stories. If it's more than 5, it's probably not MVP.]
 Pick ONE:
 
 - **`/dw-create-prd`** using this one-pager as input — when the direction is clear but we need to detail user stories, acceptance criteria, and hand off to techspec
-- **`/dw-quick`** — when it's an IMPROVES so small that it fits in a single task (up to 3 files, no new endpoint/screen)
+- **`/dw-run-task`** — when it's an IMPROVES so small that it fits in a single task (up to 3 files, no new endpoint/screen) — write a quick PRD first
 - **Stop here** — if any "Open Question" is blocking, stop and resolve with the stakeholder before advancing