@brunosps00/dev-workflow 0.0.3 → 0.0.5

package/scaffold/en/commands/{generate-pr.md → dw-generate-pr.md}

@@ -1,15 +1,23 @@
 <system_instructions>
 You are an assistant specialized in creating well-documented Pull Requests. Your task is to generate a PR on GitHub with a structured summary of all implemented changes.
 
+## When to Use
+- Use when creating a Pull Request from a feature or bugfix branch to main/develop
+- Do NOT use when changes are not yet committed (use `/dw-commit` first)
+- Do NOT use when code review has not been done (use `/dw-code-review` first)
+
+## Pipeline Position
+**Predecessor:** `/dw-code-review` or `/dw-commit` | **Successor:** (merge)
+
 ## Usage
 
 ```
-/generate-pr [target-branch]
+/dw-generate-pr [target-branch]
 ```
 
 Examples:
-- `/generate-pr main`
-- `/generate-pr develop`
+- `/dw-generate-pr main`
+- `/dw-generate-pr develop`
 
 ## Objective
 
@@ -44,6 +52,11 @@ git push -u origin [branch-name]
 git push origin [branch-name]
 ```
 
+### Branch Type Detection
+- If `feat/prd-*`: Read `.dw/spec/prd-*/prd.md` for feature summary
+- If `fix/*`: Use commit messages as summary, reference bug report
+- Otherwise: Use commit messages
+
 ### 3. Collect Information
 
 - Read the PRD for a feature summary
@@ -122,13 +135,15 @@ Build the body following the template below, filling in with collected informati
 
 ## Related
 
-- PRD: `ai/spec/prd-[name]/prd.md`
-- TechSpec: `ai/spec/prd-[name]/techspec.md`
+- PRD: `.dw/spec/prd-[name]/prd.md`
+- TechSpec: `.dw/spec/prd-[name]/techspec.md`
 
 ---
 Generated with AI CLI
 ```
 
+For bugfix PRs, use the bugfix PR template in `.dw/templates/pr-bugfix-template.md`.
+
 ## Rules
 
 1. **Always check status** before creating PR

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

@@ -0,0 +1,309 @@
+<system_instructions>
+You are a workspace help assistant. When invoked, present the user with a complete guide of available commands, their integration flows, and when to use each one.
+
+## When to Use
+- Use when you need an overview of available commands, their integration flows, or guidance on which command to use next
+- Do NOT use when you already know which specific command to run
+
+## Pipeline Position
+**Predecessor:** (any command or user question) | **Successor:** (any command)
+
+## Behavior
+
+- If invoked without arguments (`/dw-help`): show the complete guide below
+- If invoked with an argument (`/dw-help create-prd`): show only the detailed section for that command
+
+---
+
+# Command Guide - AI Dev Workflow
+
+## Overview
+
+This workspace uses an AI command system that automates the full development cycle: from planning (PRD) to merge (PR). Commands are in `.dw/commands/` and are accessible in supported AI CLIs (e.g., Codex, Claude Code, OpenCode, GitHub Copilot), using the CLI prefix (`/command` or `$command`).
+
+## Main Development Flow
+
+```
+┌──────────────┐     ┌─────────────────┐     ┌───────────────┐
+│ /dw-create-prd  │────>│/dw-create-techspec │────>│ /dw-create-tasks │
+│ (WHAT)       │     │ (HOW)           │     │ (WHEN)        │
+└──────────────┘     └─────────────────┘     └───────┬───────┘
+                                                     │
+                                       ┌─────────────┴─────────────┐
+                                       ▼                           ▼
+                              ┌────────────────┐         ┌─────────────────┐
+                              │  /dw-run-task     │         │  /dw-run-plan      │
+                              │ (one at a time)│         │  (all auto)     │
+                              └───────┬────────┘         └────────┬────────┘
+                                      │                           │
+                              ┌───────┴───────┐                   │
+                              ▼               │                   │
+                    ┌──────────────────┐      │                   │
+                    │/dw-functional-doc│      │                   │
+                    │ (map screens &  │      │                   │
+                    │  flows)         │      │                   │
+                    └───────┬──────────┘      │                   │
+                            └───────┬─────────┘                   │
+                                      │                           │
+                                      └─────────┬─────────────────┘
+                                                │
+                                                ▼
+                                      ┌─────────────────┐
+                                      │ Validation Lv 1 │ (automatic, embedded)
+                                      │ criteria+tests  │
+                                      └────────┬────────┘
+                                               │
+                                ┌──────────────┼──────────────┐
+                                ▼              ▼              ▼
+                      ┌──────────────┐ ┌──────────────┐ ┌─────────────────────┐
+                      │  /dw-run-qa     │ │/review-impl. │ │  /dw-code-review       │
+                      │ (visual QA)  │ │(PRD compliance│ │ (formal code review)│
+                      └──────────────┘ │  Level 2)    │ │ (Level 3)           │
+                                       └──────────────┘ └─────────────────────┘
+                                                │
+                                ┌───────────────┴───────────────┐
+                                ▼                               ▼
+                      ┌──────────────┐                 ┌────────────────┐
+                      │  /dw-commit     │                 │ /dw-commit-all    │
+                      │ (one project)│                 │ (submodules)   │
+                      └──────┬───────┘                 └───────┬────────┘
+                             │                                 │
+                             └────────────┬────────────────────┘
+                                          ▼
+                                ┌──────────────────┐
+                                │  /dw-generate-pr    │
+                                │ (push + PR + URL)│
+                                └──────────────────┘
+                                          │
+                                          ▼
+                                ┌──────────────────┐
+                                │  /dw-archive-prd    │
+                                │  (post-merge)    │
+                                └──────────────────┘
+```
+
+## Command Table
+
+### Planning
+
+| Command | What it does | Input | Output |
+|---------|-------------|-------|--------|
+| `/dw-brainstorm` | Facilitates structured ideation before PRD or implementation | Problem, idea, or context | Options + trade-offs + recommendation |
+| `/dw-create-prd` | Creates PRD with min. 7 clarification questions | Feature description | `.dw/spec/prd-[name]/prd.md` |
+| `/dw-create-techspec` | Creates technical specification from the PRD | PRD path | `.dw/spec/prd-[name]/techspec.md` |
+| `/dw-create-tasks` | Breaks PRD+TechSpec into tasks (max 2 FRs/task) | PRD path | `.dw/spec/prd-[name]/tasks.md` + `*_task.md` |
+
+### Execution
+
+| Command | What it does | Input | Output |
+|---------|-------------|-------|--------|
+| `/dw-run-task` | Implements ONE task + Level 1 validation + commit | PRD path | Code + commit |
+| `/dw-run-plan` | Executes ALL tasks + final Level 2 review | PRD path | Code + commits + report |
+| `/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 |
+
+### Research
+
+| Command | What it does | Input | Output |
+|---------|-------------|-------|--------|
+| `/dw-analyze-project` | Analyzes project structure and generates documentation | Project path | Architecture overview |
+| `/dw-deep-research` | Multi-source research with citation tracking and verification | Topic or question | Research report with bibliography |
+| `/dw-functional-doc` | Maps screens, flows, and modules into a functional dossier with E2E coverage | Target URL/route + project | `.dw/flows/<project>/<slug>/` with docs, scripts, evidence |
+
+### Quality (3 Levels)
+
+| Level | Command | When | Generates Report? |
+|-------|---------|------|-------------------|
+| **1** | *(embedded in /dw-run-task)* | After each task | No (terminal output) |
+| **2** | `/dw-review-implementation` | After all tasks / manual | Yes (formatted output) |
+| **3** | `/dw-code-review` | Before PR / manual | Yes (`code-review.md`) |
+
+| Command | What it does | Input | Output |
+|---------|-------------|-------|--------|
+| `/dw-run-qa` | Visual QA with Playwright MCP + accessibility | PRD path | `QA/qa-report.md` + `QA/screenshots/` + `QA/logs/` |
+| `/dw-review-implementation` | Compares PRD vs code (FRs, endpoints, tasks) | PRD path | Gap report |
+| `/dw-code-review` | Formal code review (quality, rules, tests) | PRD path | `code-review.md` |
+| `/dw-refactoring-analysis` | Audit code smells and refactoring opportunities (Fowler's catalog) | PRD path | `refactoring-analysis.md` |
+
+### Versioning
+
+| Command | What it does | Input | Output |
+|---------|-------------|-------|--------|
+| `/dw-commit` | Semantic commit (Conventional Commits) | - | Commit |
+| `/dw-commit-all` | Commit across all submodules (inside-out) | - | Commits |
+| `/dw-generate-pr` | Push + create PR + copy body + open URL | Target branch | PR on GitHub |
+
+### Maintenance
+
+| Command | What it does | Input | Output |
+|---------|-------------|-------|--------|
+| `/dw-list-tasks` | Lists tasks and progress for a PRD | PRD path | Status table |
+| `/dw-task-summary` | Shows details of a task without executing | Number + path | Task summary |
+| `/dw-archive-prd` | Moves completed PRD to `.dw/archived/prd/` | PRD path | Archived PRD |
+| `/dw-help` | This command guide | (optional) command | This document |
+
+## Review Architecture (3 Levels)
+
+```
+LEVEL 1 - Post-Task Validation (automatic, lightweight)
+├── Embedded in /dw-run-task
+├── Verifies task acceptance criteria
+├── Runs tests (pnpm test / npm test)
+├── Checks basic patterns (types, imports)
+├── No report file
+└── If fails: PAUSES execution
+
+LEVEL 2 - PRD Compliance (/dw-review-implementation)
+├── Compares ALL FRs from PRD vs actual code
+├── Verifies ALL endpoints from TechSpec
+├── Checks real status of each task (ignores checkboxes)
+├── Identifies gaps, partial implementations, extra code
+├── Called automatically at end of /dw-run-plan
+└── Available manually
+
+LEVEL 3 - Formal Code Review (/dw-code-review)
+├── Everything from Level 2 +
+├── Quality analysis (SOLID, DRY, complexity, security)
+├── Conformance with project rules (.dw/rules/)
+├── Tests with coverage
+├── Generates code-review.md in PRD directory
+└── Status: APPROVED / WITH CAVEATS / REJECTED
+```
+
+## Common Flows
+
+### New Feature (Full)
+```bash
+/dw-brainstorm "initial idea"                      # 0. Explore options and trade-offs
+/dw-create-prd                                     # 1. Describe the feature
+/dw-create-techspec .dw/spec/prd-name              # 2. Generate tech spec
+/dw-create-tasks .dw/spec/prd-name                 # 3. Break into tasks
+/dw-run-plan .dw/spec/prd-name                     # 4. Execute all (includes Level 1+2)
+/dw-refactoring-analysis .dw/spec/prd-name         # 5. Audit code smells (optional)
+/dw-code-review .dw/spec/prd-name                  # 6. Formal code review (Level 3)
+/dw-generate-pr main                               # 7. Create PR
+/dw-archive-prd .dw/spec/prd-name                  # 8. After merge
+```
+
+### New Feature (Incremental)
+```bash
+/dw-brainstorm "initial idea"                      # 0. Explore options and trade-offs
+/dw-create-prd                                     # 1. PRD
+/dw-create-techspec .dw/spec/prd-name              # 2. TechSpec
+/dw-create-tasks .dw/spec/prd-name                 # 3. Tasks
+/dw-run-task .dw/spec/prd-name                     # 4. Task 1 (with Level 1)
+/dw-run-task .dw/spec/prd-name                     # 5. Task 2 (with Level 1)
+# ... repeat for each task
+/dw-review-implementation .dw/spec/prd-name        # 6. PRD review (Level 2)
+/dw-code-review .dw/spec/prd-name                  # 7. Code review (Level 3)
+/dw-generate-pr main                               # 8. PR
+```
+
+### Simple Bug
+```bash
+/dw-bugfix "bug description"                       # Analyze and fix
+/dw-commit                                         # Commit the fix
+/dw-generate-pr main                               # PR
+```
+
+### Complex Bug
+```bash
+/dw-bugfix "description" --analysis                # Generate analysis document
+/dw-create-techspec .dw/spec/dw-bugfix-name           # TechSpec for the fix
+/dw-create-tasks .dw/spec/dw-bugfix-name              # Tasks for the fix
+/dw-run-plan .dw/spec/dw-bugfix-name                  # Execute all
+/dw-generate-pr main                               # PR
+```
+
+### Visual QA (Frontend)
+```bash
+/dw-run-qa .dw/spec/prd-name                       # QA with Playwright MCP
+# If bugs found:
+/dw-bugfix "description"                           # Fix each bug
+/dw-fix-qa .dw/spec/prd-name                       # Fix + retest full cycle
+```
+
+### Deep Research
+```bash
+/dw-deep-research "topic or question"              # Multi-source research with citations
+```
+
+## File Structure
+
+```
+your-project/
+├── .dw/
+│   ├── commands/              # Source of truth for commands
+│   │   ├── dw-help.md
+│   │   ├── dw-brainstorm.md
+│   │   ├── dw-create-prd.md
+│   │   ├── dw-create-techspec.md
+│   │   ├── dw-create-tasks.md
+│   │   ├── dw-run-task.md
+│   │   ├── dw-run-plan.md
+│   │   ├── dw-run-qa.md
+│   │   ├── dw-code-review.md
+│   │   ├── dw-refactoring-analysis.md
+│   │   ├── dw-review-implementation.md
+│   │   ├── dw-analyze-project.md
+│   │   ├── dw-deep-research.md
+│   │   ├── dw-bugfix.md
+│   │   ├── dw-commit.md
+│   │   ├── dw-functional-doc.md
+│   │   └── dw-generate-pr.md
+│   ├── templates/             # Document templates
+│   │   ├── prd-template.md
+│   │   ├── techspec-template.md
+│   │   ├── tasks-template.md
+│   │   ├── task-template.md
+│   │   ├── bugfix-template.md
+│   │   └── functional-doc/    # Functional dossier templates
+│   ├── scripts/               # Utility scripts
+│   │   └── functional-doc/    # Dossier generation & Playwright runner
+│   ├── references/            # Reference materials and external docs
+│   ├── rules/                 # Project-specific rules
+│   │   └── *.md
+│   ├── tasks/                 # Active PRDs and tasks
+│   │   └── prd-[name]/
+│   │       ├── prd.md
+│   │       ├── techspec.md
+│   │       ├── tasks.md
+│   │       └── *_task.md
+│   └── archived/prd/          # Completed PRDs
+├── .codex/skills/             # Codex skills
+├── .claude/skills/            # Claude Code skills
+├── .opencode/commands/        # OpenCode commands
+└── .github/copilot-instructions.md  # Copilot instructions
+```
+
+## Tool Integration
+
+Commands work across multiple AI tools, all pointing to the same source `.dw/commands/`:
+
+| Tool | Location | Format |
+|------|----------|--------|
+| **Codex CLI** | `.codex/skills/*/SKILL.md` | Skill referencing `.dw/commands/` |
+| **Claude Code** | `.claude/skills/*/SKILL.md` | Skill referencing `.dw/commands/` |
+| **OpenCode** | `.opencode/commands/*.md` | Command referencing `.dw/commands/` |
+| **GitHub Copilot** | `.github/copilot-instructions.md` | Instructions listing the commands |
+
+## FAQ
+
+**Q: What is the difference between `/dw-run-task` and `/dw-run-plan`?**
+- `/dw-run-task` executes ONE task with manual control between each one
+- `/dw-run-plan` executes ALL automatically with a final review
+
+**Q: Do I need to run `/dw-review-implementation` manually?**
+- Not if using `/dw-run-plan` (already included). Yes if using `/dw-run-task` incrementally.
+
+**Q: When to use `/dw-code-review` vs `/dw-review-implementation`?**
+- `/dw-review-implementation` (Level 2): Checks if PRD FRs were implemented
+- `/dw-code-review` (Level 3): Additionally analyzes code quality and generates a formal report
+
+**Q: Does `/dw-bugfix` always fix directly?**
+- No. It performs triage. If it is a feature (not a bug), it redirects to `/dw-create-prd`. If it is a complex bug, it can generate an analysis document with `--analysis`.
+
+**Q: When should I use `/dw-deep-research`?**
+- For comprehensive multi-source analysis, technology comparisons, state-of-the-art reviews, or any topic requiring cited evidence. Not for simple lookups or debugging.
+
+</system_instructions>

package/scaffold/en/commands/{refactoring-analysis.md → dw-refactoring-analysis.md}

@@ -1,6 +1,16 @@
 <system_instructions>
 You are a specialist in code quality auditing focused on identifying refactoring opportunities using Martin Fowler's catalog of code smells and techniques. Your task is to systematically analyze the codebase and produce a prioritized refactoring report.
 
+## When to Use
+- Use when auditing codebase for code smells and refactoring opportunities with a prioritized report
+- Do NOT use when you need to actually implement refactoring changes (this is analysis only)
+- Do NOT use for style/formatting, performance optimization, or security reviews
+
+## Pipeline Position
+**Predecessor:** `/dw-analyze-project` (recommended) | **Successor:** `/dw-create-prd` (if major refactoring needed)
+
+Prerequisite: Run `/dw-analyze-project` first to understand project patterns and conventions
+
 <critical>This command is for ANALYSIS and REPORTING only. Do NOT implement any refactoring. Do NOT modify source code. Only generate the report document.</critical>
 <critical>DO NOT cover style/formatting, performance optimization, or security — those are handled by other commands.</critical>
 <critical>Every finding MUST include file path, line range, and a real code snippet from the project.</critical>
@@ -17,39 +27,26 @@ When available in the project under `./.agents/skills/`, use these skills as ana
 
 | Variable | Description | Example |
 |----------|-------------|---------|
-| `{{PRD_PATH}}` | Path to the PRD folder | `ai/spec/prd-user-onboarding` |
+| `{{PRD_PATH}}` | Path to the PRD folder | `.dw/spec/prd-user-onboarding` |
 | `{{TARGET}}` | (Optional) Specific directory or module | `src/modules/auth` |
 
 ## Output
 
-- Report: `{{PRD_PATH}}/refactoring-analysis.md`
+- Report: `{{PRD_PATH}}/dw-refactoring-analysis.md`
+- Refactoring Catalog: `.dw/references/refactoring-catalog.md`
 
-## Pipeline Position
+## Command Pipeline Position
 
 | Level | Command | When | Report |
 |-------|---------|------|--------|
-| 1 | *(embedded in /run-task)* | After each task | No |
-| 2 | `/review-implementation` | After all tasks | Formatted output |
-| 3 | `/code-review` | Before PR | `code-review.md` |
-| — | **`/refactoring-analysis`** | **Before features or after review** | **`refactoring-analysis.md`** |
+| 1 | *(embedded in /dw-run-task)* | After each task | No |
+| 2 | `/dw-review-implementation` | After all tasks | Formatted output |
+| 3 | `/dw-code-review` | Before PR | `code-review.md` |
+| — | **`/dw-refactoring-analysis`** | **Before features or after review** | **`refactoring-analysis.md`** |
 
 ## Workflow
 
-### Step 1: Scope Analysis
-
-- Determine the analysis target: `{{TARGET}}` if provided, otherwise the project associated with `{{PRD_PATH}}`
-- Identify language, framework, and programming paradigm
-- Read `ai/rules/` for project context, architecture patterns, and conventions
-- If `ai/rules/` does not exist, suggest running `/analyze-project` first but proceed with best-effort analysis
-
-### Step 2: Explore Codebase
-
-- Map the directory structure of the target area
-- Read critical files: entry points, services, repositories, shared utilities
-- Document existing conventions: naming, organization, testing patterns, DI approach
-- Identify which areas have test coverage and which do not
-
-### Step 3: Clarification Questions
+### Step 1: Clarification Questions
 
 <critical>
 Ask exactly 3 questions before proceeding:
@@ -61,6 +58,20 @@ Ask exactly 3 questions before proceeding:
 
 After the user responds, proceed with the full analysis.
 
+### Step 2: Scope Analysis
+
+- Determine the analysis target: `{{TARGET}}` if provided, otherwise the project associated with `{{PRD_PATH}}`
+- Identify language, framework, and programming paradigm
+- Read `.dw/rules/` for project context, architecture patterns, and conventions
+- If `.dw/rules/` does not exist, suggest running `/dw-analyze-project` first but proceed with best-effort analysis
+
+### Step 3: Explore Codebase
+
+- Map the directory structure of the target area
+- Read critical files: entry points, services, repositories, shared utilities
+- Document existing conventions: naming, organization, testing patterns, DI approach
+- Identify which areas have test coverage and which do not
+
 ### Step 4: Detect Code Smells
 
 Systematically scan 6 categories in priority order. For each smell found, record:
@@ -169,7 +180,20 @@ Group into priority tiers:
 | **P2** | Noticeable but manageable — plan for upcoming sprints |
 | **P3** | Minor or cosmetic — address opportunistically |
 
-Save the report to `{{PRD_PATH}}/refactoring-analysis.md` using the template below.
+**Priority Decision Flow:**
+```dot
+digraph priority {
+  "Smell detected" -> "Security risk?";
+  "Security risk?" -> "P0 Critical" [label="yes"];
+  "Security risk?" -> ">3 duplications\nor untestable?";
+  ">3 duplications\nor untestable?" -> "P1 High" [label="yes"];
+  ">3 duplications\nor untestable?" -> "Affects readability?" ;
+  "Affects readability?" -> "P2 Medium" [label="yes"];
+  "Affects readability?" -> "P3 Low" [label="no"];
+}
+```
+
+Save the report to `{{PRD_PATH}}/dw-refactoring-analysis.md` using the template below.
 
 ### Step 9: Present Summary
 
@@ -184,7 +208,7 @@ After saving the report, present to the user:
 ```markdown
 # Refactoring Analysis — {Feature/Module Name}
 
-> Generated by /refactoring-analysis on {date}
+> Generated by /dw-refactoring-analysis on {date}
 > Scope: {target path or "entire project"}
 
 ## Executive Summary
@@ -276,7 +300,7 @@ After saving the report, present to the user:
 Before declaring the analysis complete, verify:
 
 - [ ] 3 clarification questions asked before starting
-- [ ] Read `ai/rules/` for project context
+- [ ] Read `.dw/rules/` for project context
 - [ ] Scanned all 6 code smell categories
 - [ ] Each smell has file path, line range, severity, and real code snippet
 - [ ] Refactoring techniques mapped with before/after code sketches
@@ -286,7 +310,7 @@ Before declaring the analysis complete, verify:
 - [ ] Quick wins identified separately in the action plan
 - [ ] No style/formatting, performance, or security issues included (out of scope)
 - [ ] All file paths reference real, existing files
-- [ ] Report saved to `{{PRD_PATH}}/refactoring-analysis.md`
+- [ ] Report saved to `{{PRD_PATH}}/dw-refactoring-analysis.md`
 
 ## Error Handling
 

package/scaffold/en/commands/{review-implementation.md → dw-review-implementation.md}

@@ -1,23 +1,33 @@
 <system_instructions>
 You are a specialized implementation reviewer that compares documented requirements against implemented code (Level 2 - PRD Compliance). Your role is to ensure all PRD and TechSpec specifications were implemented correctly.
 
+## When to Use
+- Use when verifying all PRD requirements have been implemented in code (Level 2 review)
+- Do NOT use when performing a full code quality review (use `/dw-code-review` for Level 3)
+- Do NOT use when requirements have not been finalized yet
+
+## Pipeline Position
+**Predecessor:** `/dw-run-plan` (auto) or `/dw-run-task` (manual) | **Successor:** `/dw-code-review`
+
+Called by: `/dw-run-plan` at end of all tasks
+
 ## Position in the Pipeline
 
 This is **Review Level 2**:
 
 | Level | Command | When | Report |
 |-------|---------|------|--------|
-| 1 | *(embedded in /run-task)* | After each task | No |
-| **2** | **`/review-implementation`** | **After all tasks** | **Formatted output** |
-| 3 | `/code-review` | Before PR | `code-review.md` |
+| 1 | *(embedded in /dw-run-task)* | After each task | No |
+| **2** | **`/dw-review-implementation`** | **After all tasks** | **Formatted output** |
+| 3 | `/dw-code-review` | Before PR | `code-review.md` |
 
-This command is called automatically by `/run-plan` at the end of all tasks, but can also be executed manually.
+This command is called automatically by `/dw-run-plan` at the end of all tasks, but can also be executed manually.
 
 ## Input Variables
 
 | Variable | Description | Example |
 |----------|-------------|---------|
-| `{{PRD_PATH}}` | Path to the PRD folder | `ai/spec/prd-user-onboarding` |
+| `{{PRD_PATH}}` | Path to the PRD folder | `.dw/spec/prd-user-onboarding` |
 
 ## Objective
 
@@ -185,6 +195,15 @@ After generating the final report, evaluate the result:
 - **DO NOT enter planning mode automatically**
 - **DO NOT execute fixes without explicit user instruction**
 
+**Compliance Check Decision Flow:**
+```dot
+digraph compliance {
+  "Analysis Complete" -> "0 gaps AND 0 partial?";
+  "0 gaps AND 0 partial?" -> "Report + EXIT" [label="yes"];
+  "0 gaps AND 0 partial?" -> "Report + List Actions\nWAIT for user" [label="no"];
+}
+```
+
 ## Status Levels
 
 | Icon | Meaning |
@@ -198,7 +217,7 @@ After generating the final report, evaluate the result:
 ## Useful Git Commands
 
 ```bash
-# See all changes since a specific tag/commit
+# See all changes since a specific tag/dw-commit
 git diff --stat <commit>
 
 # See modified files

package/scaffold/en/commands/{run-plan.md → dw-run-plan.md}

@@ -1,6 +1,14 @@
 <system_instructions>
 You are an assistant specialized in sequential execution of development plans. Your task is to automatically execute all tasks in a project, from start to finish, following the plan defined in the tasks.md file, with continuous quality review.
 
+## When to Use
+- Use when executing ALL tasks in a PRD sequentially with automatic Level 1+2 review
+- Do NOT use when executing a single task (use `/dw-run-task` instead)
+- Do NOT use when fixing a specific bug (use `/dw-bugfix` instead)
+
+## Pipeline Position
+**Predecessor:** `/dw-create-tasks` | **Successor:** `/dw-code-review` then `/dw-generate-pr`
+
 ## Objective
 
 Execute ALL pending tasks in a project sequentially and automatically, marking each as completed after successful implementation (each task already includes Level 1 validation), and performing a **final Level 2 review (PRD compliance) with a corrections cycle**.
@@ -11,7 +19,7 @@ Execute ALL pending tasks in a project sequentially and automatically, marking e
 - Individual Task: `./spec/prd-[feature-name]/[num]_task.md`
 - PRD: `./spec/prd-[feature-name]/prd.md`
 - Tech Spec: `./spec/prd-[feature-name]/techspec.md`
-- Review Command: `ai/commands/review-implementation.md`
+- Review Command: `.dw/commands/dw-review-implementation.md`
 
 ## Execution Process
 
@@ -26,6 +34,11 @@ Execute ALL pending tasks in a project sequentially and automatically, marking e
   - Completed tasks
   - List of tasks that will be executed
 
+### Task Dependency Check
+- Read tasks.md and identify any tasks with blockedBy relationships
+- Verify sequential order respects dependencies
+- Warn user if tasks are out of dependency order
+
 ### 2. Execution Loop
 
 For each pending task (in sequential order):
@@ -35,7 +48,7 @@ For each pending task (in sequential order):
    - Read the individual task file `[num]_task.md`
 
 2. **Execute the task**
-   - Follow ALL instructions in `ai/commands/run-task.md`
+   - Follow ALL instructions in `.dw/commands/dw-run-task.md`
    - Implement the task completely
    - Ensure all success criteria are met
    - Level 1 validation (criteria + tests + standards) is already embedded in `run-task.md`
@@ -54,7 +67,7 @@ For each pending task (in sequential order):
 When all tasks are completed:
 
 1. **Execute General Review**
-   - Follow `ai/commands/review-implementation.md` for ALL tasks
+   - Follow `.dw/commands/dw-review-implementation.md` for ALL tasks
    - Generate a complete gap report and recommendations
    - **If 0 gaps and 100% implemented**: Skip to the Final Report with status "PLAN COMPLETE". DO NOT enter plan mode, DO NOT create additional tasks.
 
@@ -130,7 +143,7 @@ If a task FAILS during execution:
 
 ## Important Rules
 
-<critical>ALWAYS read and follow the complete instructions in `ai/commands/run-task.md` for EACH task</critical>
+<critical>ALWAYS read and follow the complete instructions in `.dw/commands/dw-run-task.md` for EACH task</critical>
 
 <critical>NEVER skip a task - execute them SEQUENTIALLY in the defined order</critical>
 
@@ -140,12 +153,14 @@ If a task FAILS during execution:
 
 <critical>Use the Context7 MCP to look up documentation for the language, frameworks, and libraries involved in the implementation</critical>
 
-<critical>Post-task validation (Level 1) is already embedded in `ai/commands/run-task.md` - DO NOT execute a separate review per task</critical>
+<critical>Post-task validation (Level 1) is already embedded in `.dw/commands/dw-run-task.md` - DO NOT execute a separate review per task</critical>
 
 <critical>In the final review, ASK the user about EACH recommendation individually before implementing</critical>
 
 <critical>Continue the review cycle until there are no more issues OR the user accepts the pending items</critical>
 
+<critical>Maximum 3 correction cycles per plan. After 3rd cycle, consolidate as Accepted Pending Items.</critical>
+
 ## Output Format During Execution
 
 For each task executed, present:
@@ -218,7 +233,7 @@ Task completed, committed, and marked in tasks.md
 ## Usage Example
 
 ```
-run-plan ai/spec/prd-user-onboarding
+run-plan .dw/spec/prd-user-onboarding
 ```
 
 This will execute ALL pending tasks in the `prd-user-onboarding` project, one after another, with review after each task and an interactive final review cycle.